Implementing Sector-Based Pairs Trading

To understand how this strategy works, we first need to get through some background theoretical knowledge. First, let’s start with what pairs trading even is.

Background #

Pairs Trading is a market-neutral trading strategy that allows the trader to profit from the divergence in returns of correlated assets. The most familiar example of this is the Coca-Cola & Pepsi pairs trade. Both Coca-Cola & Pepsi operate in the same industry and are exposed to similar risks/upsides, so generally, the performance of these 2 stocks tend to be similar.

When the performance of these 2 stocks diverge by a significant amount (e.g. Coca-Cola stock goes up 5%, Pepsi only goes up by 1%), the trader profits by buying the underperforming shares (in the above example, this would be Pepsi since the % return is lower than that of Coca-Cola) and they would go short the overperforming shares (in this case, Coca-Cola since the % return is higher).

A profit is realized when the spread between the two stocks decreases. It isn’t necessary for both legs to converge in opposing directions, often times profit is made when one leg of the trade “catches up” and closes the spread. In that scenario, you would lose money on one leg, but you would make more than you lost through the leg that “catches up”.

That is the meat and bones of how pairs trading works, but this strategy has been used/studied for decades by now, so while opportunities in stocks like Coke and Pepsi exist, they aren’t significant enough to be worth the effort. However, there are a few other areas of the market where this strategy can be extraordinarily effective.

Sector-Based Pairs Trading #

Pairs trading works because the stocks involved often have valid economic reasons for being correlated (e.g., similar industry, different securities for the same underlying company, similar macroeconomic exposure, etc.). As you expand the scope of stocks looked at, you will notice that while the correlations remain strong, they become imperfect — but this is where the largest opportunities lie.

Let’s look at this from a sector-based perspective. We first ask the question, how correlated are the top 10 stocks of the Technology sector (by market cap)? To answer that, we pulled about a year of data and ran a correlation matrix for those stocks and this was the output:

As demonstrated, the top stocks of the given sector are strongly, positively correlated. Does this relationship work for other sectors? Let’s try the same thing, but for the Financial sector:

While the correlations aren’t as high as the Technology sector, it is clear that there are still strong, positive correlations between the 10 largest components.

Implementation

Since we know that the top n<10 stocks of a given sector will have strong correlations, we can use it as the basis for a pairs trading strategy. This strategy will take the top 10 stocks of a sector, then it will split the basket in 2. Considering the high correlation, the performance of these 2 baskets should be very similar, so when the performance of the baskets diverge (the “spread”), we can buy the underperforming basket, then short the overperforming basket.

Thankfully, the QuantGlobal API handles the bulk work of the calculations and we can get our universe with just a few lines of code.

For this example, we’ll use the Financials sector:

# First, import the necessary packages
import pandas as pd
import QuantGlobal as qg
# This variable will store the underlying basket data which includes
# the ticker symbols, prices, and performance.
underlying_data = qg.download(key = "authenticated_user@email.com",
                             strategy = 'pt_extended',
                             underlying = 'financials',
                             from_date = '2022-11-29',
                             end_date = '2022-11-30')
# This variable will store the spread index values to act as a trade signal.
index_data = qg.download(key = 'authenticated_user@email.com',
                         strategy = 'pt',
                         underlying = 'financials',
                         from_date = '2022-11-29',
                         end_date = '2022-11-30')

The underlying_data variable will return a dataframe structured as follows:

The index_data variable will return a dataframe structured as follows:

Trading #

Now that the data is stored, we can focus on building the actual strategy that will be traded.

We will put on a pairs trade when the index spread increases above our designated threshold. Just to clarify, the spread represents the absolute difference between the two equal-weighted baskets. To better understand this, consider the below scenario:

• Basket A: BRK/B, V, JPM, MA, BAC
• Basket B: WFC, MS, SCHW, GS, HSBC
• Both baskets are equal-weighted
• If Basket A returns 2%, but Basket B returns 1%; the index spread will be 1 (abs(Basket A Performance — Basket B performance)).
• If we buy Basket B and short Basket A; we make money when the index spread drops to a number lower than 1 (or whatever the number was when we entered the trade)

It might be a bit tricky to navigate buying/selling 10 different stocks at once, so for this example, we’ll trade using just 2 stocks out of the 10. The two stocks will be the highest performing share and the lowest performing share. This pair will have the largest effect on the spread as they are the “outliers”, and as such, they offer the largest profit opportunity.

Every broker’s API looks different, but here is the general code flow of how we would put on this trade:

# When the index spread crosses to/above this level, we want to put on a trade
opening_threshold = 0.75
# When the spread crosses to/below this level, we close the trade
closing_threshold = 0.25
# We check the most recent value of the spread to see if it is at the threshold
if index_data['Spread'].iloc[-1] >= opening_threshold:
  # If the index is indeed above/at our threshold, we get the symbols we need.
  # This line gets the ticker with the smallest/largest cumulative return
    most_recent_underlying_data = underlying_data[underlying_data.index == underlying_data.index[-1]]
    lowest_performer = most_recent_underlying_data['Ticker'][most_recent_underlying_data['Cumulative Returns'] == most_recent_underlying_data['Cumulative Returns'].min()].iloc[0]
    highest_performer = most_recent_underlying_data['Ticker'][most_recent_underlying_data['Cumulative Returns'] == most_recent_underlying_data['Cumulative Returns'].max()].iloc[0]
  # Now, we submit the pairs trade order
  # "broker_api" is a placeholder for the api used to submit your orders
  # Any broker capable of buying/selling stocks is compatible with this strategy.
    long_order = broker_api.buy(lowest_performer)
    short_order = broker_api.short(highest_performer)
else:
  # If the most recent value isn't above our threshold, do nothing.
  pass

Using the logic above, the first condition would be triggered at around 11:21 on that day:

Considering that the index is above the threshold, the script would buy the weakest performing share (V) and sell-short the strongest performing share (MS).

Now that the position is on, the program needs to wait for the index to duck back down below/to the closing threshold. Again, each broker’s API works differently, so here’s just a boilerplate version of how that would flow:

# When the spread crosses to/below this level, we close the trade
closing_threshold = 0.25
# We check the most recent value of the spread to see if it is at the threshold
if index_data['Spread'].iloc[-1] <= closing_threshold:
  # If the index is indeed below/at our threshold, we close the open orders.
  close_long_position = broker_api.sell(lowest_performer)
  close_short_position = broker_api.buy(highest_performer)
else:
  # If the most recent value isn't below/at our threshold, do nothing.
  pass

The closing condition would be triggered at 3:07 on that day:

As demonstrated, this trade yielded a profit of ~1.72%. You can intuitively calculate PnL by tracking the Cumulative Returns column. In this example, we bought V at 98.88, then sold it for 99.27. Since the index starts each day at 100 and tracks returns, this means a 0.39% profit on the V leg. Then, we were short MS at 101.04, and bought it back at 99.71 for a 1.33% profit. So when tallied, the net profit on the position was 1.72% (0.39% + 1.33%).

Further Steps #

While this was just one implementation of the strategy, there is essentially an infinite degree of flexibility in how it can be further optimized. For example, while trading all 10 stocks in the baskets may be difficult to mentally manage, it can significantly reduce the overall volatility of the strategy. Trading the full baskets also allows for maximal scalability. Another possible optimization of this is continuing the pattern of taking just the 2 outlier stocks, but instead of just those in the financials sector, how about 2 from all the sectors? Our API provides unlimted access to all the data you need to explore and implement these ideas and we make it easy for you to get started.

Ready to try our data? Start your free trial