To backtest an option strategy on multiple underlying assets and see the returns from each underlier separately without running separate backtests for each, you can utilize the concept of Universes in QuantConnect to dynamically select the underlying assets you're interested in. Then, within your algorithm, you can track the performance of options strategies for each underlying asset separately. Here's a simplified approach to achieve this:

1. Define Universes: Use the Universe selection feature to dynamically select the underlying assets for your options strategies. This could be based on criteria like market cap, volume, or membership in an index.

2. Subscribe to Option Chains: For each underlying asset selected by your Universe, subscribe to its option chain.

3. Implement the Strategy: Implement your options trading strategy within the OnData method. This is where you'll decide when to enter or exit positions based on your criteria.

4. Track Performance Separately: Create a dictionary or a custom class to track the performance of the options strategy for each underlying asset separately. You can update this tracking mechanism whenever you make trades.

5. Logging and Analysis: Use logging to record the performance of each underlying asset. Alternatively, you can use custom charts or insights to analyze the performance during or after the backtest.

Here's a very basic example to illustrate the concept:

class MyOptionStrategy(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2020, 12, 31)
        self.SetCash(100000)
        # Define a universe of underlying assets (e.g., top 5 stocks by dollar volume)
        self.AddUniverse(self.CoarseSelectionFunction, self.FineSelectionFunction)
        # Dictionary to track performance
        self.performanceTracker = {}
    def CoarseSelectionFunction(self, coarse):
        # Placeholder for coarse selection logic
        return [x.Symbol for x in coarse if x.DollarVolume > 10000000][:5]
    def FineSelectionFunction(self, fine):
        # Placeholder for fine selection logic
        return [x.Symbol for x in fine if x.Price > 10][:5]
    def OnSecuritiesChanged(self, changes):
        for added in changes.AddedSecurities:
            if added.Symbol.SecurityType == SecurityType.Equity:
                # Subscribe to option chain for the underlying asset
                option = self.AddOption(added.Symbol)
                # More option filter settings here
                option.SetFilter(-2, +2, timedelta(0), timedelta(180))
                # Initialize performance tracking
                self.performanceTracker[added.Symbol] = 0
        for removed in changes.RemovedSecurities:
            if removed.Symbol in self.performanceTracker:
                del self.performanceTracker[removed.Symbol]
    def OnData(self, slice):
        for optionChain in slice.OptionChains.values():
            underlyingSymbol = optionChain.Underlying
            if underlyingSymbol not in self.performanceTracker:
                continue
            # Implement your option strategy logic here
            # Update self.performanceTracker[underlyingSymbol] based on the strategy's performance
    # Additional methods to log or analyze performance
+ Expand
- Collapse

This example is quite basic and needs to be adapted to your specific strategy, including how you select universes, filter options, and define your entry/exit criteria. The key takeaway is to use the universe selection to manage multiple underliers and track their performance individually within the same backtest.

Thank you. The most complex part of your suggestion is left for the user, where you comment:

# Update self.performanceTracker[underlyingSymbol] based on the strategy's performance

Do I need to do all of the accounting to calculate strategy performance myself, or are there already functions that I can use to do that for each symbol?

In QuantConnect, while there are built-in functions to manage portfolio and security transactions, tracking the performance of individual strategies or symbols, especially in a complex scenario like options trading across multiple underliers, often requires custom implementation. However, you can leverage some of the platform's features and data structures to simplify this process. Here's how you can approach it:

1. Profit and Loss Tracking: Use the SecurityHolding.Profit and SecurityHolding.TotalFees properties to track the profit and loss (P&L) and fees for individual positions. This can help you calculate net performance for trades on each symbol.

2. Portfolio Contribution: To understand the contribution of each symbol to the overall portfolio, you can use the Portfolio object, which contains information about all holdings. By comparing the value of individual holdings (SecurityHolding) against the total portfolio value, you can gauge the relative performance.

3. Custom Data Structure for Performance Tracking: While you need to manually update your performance tracking, you can structure it to minimize effort. For example, you could track realized and unrealized P&L, fees, and entry/exit points for each trade.

4. Transactions and Orders: Leverage the Transactions object to track when orders are filled. This allows you to capture the exact points of entry and exit for trades, which is crucial for performance analysis.

Here's an example of how you might extend the performance tracking for each symbol:

class MyOptionStrategy(QCAlgorithm):
    def Initialize(self):
        # Initialization code...
        self.performanceTracker = {}
    # Other methods...
    def OnOrderEvent(self, orderEvent):
        if orderEvent.Status == OrderStatus.Filled:
            symbol = orderEvent.Symbol
            fillPrice = orderEvent.FillPrice
            quantity = orderEvent.FillQuantity
            orderFee = orderEvent.OrderFee.Value
            # Initialize tracking for the symbol if not already present
            if symbol not in self.performanceTracker:
                self.performanceTracker[symbol] = {
                    "entries": [],
                    "exits": [],
                    "netProfit": 0,
                    "totalFees": 0
                }
            # Determine if the order is an entry or exit based on quantity
            if quantity > 0:
                self.performanceTracker[symbol]["entries"].append((fillPrice, quantity))
            else:
                self.performanceTracker[symbol]["exits"].append((fillPrice, quantity))
                # Assuming this is a simple close position for simplicity
                # Calculate profit for the trade
                entryPrice, entryQuantity = self.performanceTracker[symbol]["entries"].pop()
                tradeProfit = (fillPrice - entryPrice) * abs(quantity) - orderFee
                self.performanceTracker[symbol]["netProfit"] += tradeProfit
                self.performanceTracker[symbol]["totalFees"] += orderFee
    # At any point, you can log or analyze the performanceTracker dictionary
    # to understand the performance of each symbol.
+ Expand
- Collapse

This example is simplified and assumes each exit corresponds to the last entry (FIFO). Depending on your strategy, you might need a more sophisticated method to match entries and exits, especially for strategies that open multiple positions in the same symbol over time.

Remember, this custom tracking is necessary because QuantConnect's built-in performance metrics are generally portfolio-wide and don't automatically break down performance by individual symbols or strategies. By implementing a custom solution, you gain flexibility in how you analyze and interpret the performance data.