# Original paper

**Abstract**

We show the number of stocks contributing to the overall performance of an actively managed mutual fund is related to the persistency of the fund performance. Among the funds that have similar risk-adjusted returns, the funds that rely on a few high return stocks underperform the funds that hold many above-median return stocks. The difference between two groups is as large as 8% annual risk-adjusted return empirically. This result holds throughout our sample period, and is not generated by survivorship bias, look-back bias, or fund expenses.

**Keywords:**Â Mutual Fund, Holdings Data, Luck vs. Skill, Performance evaluation, Skewness

# Trading rules

- Pick stocks from NYSE, AMEX, and NASDAQ, leaving out those with low trade volume.
- Evaluate the alpha value of each stock from NYSE, AMEX, and NASDAQ using the Carhart 4-factor approach, considering the past 125 days of performance.
- Categorize these stocks into different groups based on their alpha score.
- Target growth equity funds for your investment considerations.
- Assess funds either quarterly or semi-annually to determine their skewness value.
- Derive the skewness value (S) for every fund with the equation: S = n/((n-1)*(n-2))
*SUM(Wi^1.5*(Xi-Average(X)/sigma)^3). - Opt for the top 20% of funds showcasing superior performance over the last year.
- Prioritize the top 20% of funds that exhibit the most pronounced negative skewness for your investments.

# Python code

## Backtrader

```
import backtrader as bt
import numpy as np
import pandas as pd
from scipy.stats import skew
class CarhartFourFactorModel(bt.Strategy):
params = (
('alpha_period', 125),
('rebalance_freq', 63), # Quarterly rebalancing (approx. 3 months)
('past_perf_period', 252), # 12-month performance
)
def __init__(self):
self.alphas = {}
def next(self):
if len(self.data) % self.params.rebalance_freq == 0:
self.calculate_alpha()
self.rebalance()
def calculate_alpha(self):
for d in self.datas:
returns = d.close.get(size=self.params.alpha_period)
# Calculate alpha using Carhart 4-factor model and past 125-day performance
# ... implement the alpha calculation ...
self.alphas[d._name] = alpha_value
def rebalance(self):
# Calculate stock percentiles based on alpha measure
alphas_df = pd.DataFrame(list(self.alphas.items()), columns=['Ticker', 'Alpha'])
alphas_df['Percentile'] = alphas_df['Alpha'].rank(pct=True)
# Filter growth equity funds as the investment universe
# ... implement growth equity funds filtering ...
# Calculate skewness measure for each fund
skewness_measures = {}
for fund in growth_equity_funds:
# Use quarterly or 6-month holding statements to calculate skewness measure
# ... implement the holding statements calculation ...
# Calculate skewness measure (S) for each fund
n = len(holding_statements)
weights = np.array([statement['Weight'] for statement in holding_statements])
alpha_rankings = np.array([statement['AlphaRanking'] for statement in holding_statements])
avg_alpha_ranking = np.mean(alpha_rankings)
sigma = np.std(alpha_rankings)
s = n / ((n - 1) * (n - 2)) * np.sum(weights ** 1.5 * (alpha_rankings - (avg_alpha_ranking / sigma)) ** 3)
skewness_measures[fund] = s
# Choose top quintile of funds with the best past performance
top_quintile_past_perf = alphas_df.nlargest(int(len(alphas_df) * 0.2), 'Alpha')
# Select top quintile of funds with the most negative skewness for investment
skewness_df = pd.DataFrame(list(skewness_measures.items()), columns=['Ticker', 'Skewness'])
top_quintile_negative_skew = skewness_df.nsmallest(int(len(skewness_df) * 0.2), 'Skewness')
# Rebalance the portfolio with the selected funds
# ... implement the rebalancing logic ...
```

Note: This code is a starting point and not fully functional. You will need to fill in the calculations for the Carhart 4-factor model, filter the growth equity funds, and implement the rebalancing logic.