Original paper
Abstract
We exploit a novel setting in which the same piece of information affects two sets of firms: one set of firms requires straightforward processing to update prices, while the other set requires more complicated analyses to incorporate the same piece of information into prices. We document substantial return predictability from the set of easy-to-analyze firms to their more complicated peers. Specifically, a simple portfolio strategy that takes advantage of this straightforward vs. complicated information processing classification yields returns of 118 basis points per month. Consistent with processing complexity driving the return relation, we further show that the more complicated the firm, the more pronounced the return predictability. In addition, we find that sell-side analysts are subject to these same information processing constraints, as their forecast revisions of easy-to-analyze firms predict their future revisions of more complicated firms.
Keywords:Â Complicated trades, return predictability, stand alone, conglomerate, market frictions
Trading rules
- Target stocks: Companies on NYSE, Amex, and Nasdaq.
- Avoid stocks valued under $5 and those with market capitalizations in the lowest 10% of NYSE-listed entities.
- Divide businesses into two classifications: standalone companies and conglomerates.
- Standalone firms: operate in one industry (80%+ of total sales)
- Conglomerates: operate in multiple industries (80%+ of total sales from all segments)
- Each year at June's close, construct a pseudo-conglomerate corresponding to each diversified company.
- Pseudo-conglomerate: portfolio of standalone firms from each industry segment, weighted by sales contribution.
- On a monthly basis, rank conglomerate firms into ten segments according to the prior month's returns of their pseudo-conglomerate.
- Every month, invest in the highest-yielding conglomerate firms and short on worst-performing firms.
- Use equal weight for conglomerate stocks and rebalance portfolio monthly
Python code
Backtrader
import backtrader as bt
import datetime
import pandas as pd
class ComplexityEffect(bt.Strategy):
params = dict(
stock_price_threshold=5,
nyse_percentile=0.1,
industry_segment_weight=0.8,
rebalance_annual_month=6,
rebalance_annual_day=30,
rebalance_monthly_day=1,
)
def __init__(self):
self.inds = dict()
self.date_annual_rebalance = None
self.date_monthly_rebalance = None
def next(self):
if not self.position:
if self.data.datetime.date(0) == self.date_annual_rebalance:
self.create_pseudo_conglomerates()
self.date_annual_rebalance = self.calculate_next_annual_rebalance()
if self.data.datetime.date(0) == self.date_monthly_rebalance:
self.rank_conglomerates()
self.rebalance_portfolio()
self.date_monthly_rebalance = self.calculate_next_monthly_rebalance()
def create_pseudo_conglomerates(self):
# Implement logic for creating pseudo-conglomerates
pass
def rank_conglomerates(self):
# Implement logic for ranking conglomerates based on pseudo-conglomerate returns
pass
def rebalance_portfolio(self):
# Implement logic for rebalancing the portfolio (long/short)
pass
def calculate_next_annual_rebalance(self):
return (self.data.datetime.date(0) + datetime.timedelta(days=365)).replace(
month=self.p.rebalance_annual_month, day=self.p.rebalance_annual_day
)
def calculate_next_monthly_rebalance(self):
return (self.data.datetime.date(0) + datetime.timedelta(days=31)).replace(day=self.p.rebalance_monthly_day)
def get_data_feed():
# Implement logic for fetching stock data (NYSE, Amex, and Nasdaq traded companies)
pass
def run_strategy():
cerebro = bt.Cerebro()
cerebro.addstrategy(ComplexityEffect)
data_feed = get_data_feed()
cerebro.adddata(data_feed)
cerebro.run()
if __name__ == '__main__':
run_strategy()Please note that the provided code is a starting point for your strategy implementation using the Backtrader framework. The get_data_feed() function should be implemented to fetch stock data for NYSE, Amex, and Nasdaq traded companies. You will also need to implement the logic for creating pseudo-conglomerates, ranking conglomerates, and rebalancing the portfolio in the respective functions: create_pseudo_conglomerates(), rank_conglomerates(), and rebalance_portfolio().