What Are Alpha Factors

Forget “alpha” as a vibe. It’s a number. You can rank stocks by it, you can backtest it, you can kill it.

If you walk into a quant interview and say “I found an alpha factor,” the interviewer will hear: “I have a function from stock features to a real-valued score that has historically predicted forward returns after costs.” That’s all alpha means. The rest is execution.

The foundation is simple: define a factor, measure it, and understand why most published factors now lose money.

The Definition That Actually Holds Up

An alpha factor is a function of stock features that predicts forward returns. Formally:

Where $\mathbf{x}_i^{(t)}$ is a vector of features for stock $i$ at time $t$, and $r_i^{(t, t+h)}$ is the realized return from $t$ to $t+h$. A factor is useful if its rank-ordering of stocks corresponds, on average, to the rank-ordering of their future returns.

Notice three things that matter:

1. It’s a scalar. Every factor, no matter how complex, ends as one number per stock per date. If your output is a vector or a probability distribution, you’ve built a model, not a factor. Models become factors via some aggregation.
2. It predicts ranking, not levels. You don’t need $f(x) = r$ to hold. You need $f(x_A) > f(x_B) \Rightarrow r_A > r_B$ on average. Rank information is what earns money.
3. “Forward returns” means the prediction horizon matters. A factor predicting 1-day-ahead returns is a different beast from one predicting 12-month-ahead returns. The horizon is part of the factor’s definition; change it and you change the asset.

What Factors Look Like in Practice

The five classics everyone should know:

• PE ratio (12m forward): earnings yield. Cheap stocks beat expensive ones over long horizons (historically).
• Momentum (12-1): total return over the last 12 months, minus the most recent month. Winners keep winning for 3-12 months, then mean-revert.
• Earnings surprise (SUE): (actual EPS - expected EPS) divided by the standard deviation of unexpected EPS. Positive surprises earn drift for ~60 days.
• Insider buying: when officers and directors buy their own stock (with cash, open-market, not options), it tends to outperform over 6-12 months.
• Short interest: high short interest predicts negative returns (this is just a sentiment / forced-buying channel).

Each one of these is a function. Each one outputs a number. Each one has been published, replicated, traded, and crowded since the 1990s. Some still work. Some don’t.

The Three Properties That Make a Factor Tradeable

You can throw 10,000 candidate factors at a backtest. Most will look good for one specific period. Few will survive three properties measured rigorously.

Property 1: IC (Information Coefficient)

IC is the correlation between factor values at time $t$ and realized returns over the next period. Compute it cross-sectionally each day, then look at the time series.

Benchmarks:

IC > 0.05 sustained for a decade is a great factor. Don’t expect to find many.

Property 2: IC IR (Information Ratio of IC)

The IC IR measures the signal-to-noise of your factor’s predictive power. Two factors can have the same mean IC (say 0.04) but wildly different IC IRs depending on how stable the prediction is across time.

Targets:

• IC IR > 0.5 → institutional-grade. AQR, Two Sigma, DE Shaw trade at this level.
• IC IR 0.3 – 0.5 → good. Most published factors live here.
• IC IR < 0.3 → noisy. Likely untradable after costs.

A factor with IC IR of 1.0 is a goldmine. You will probably never find one in published literature.

Property 3: Turnover

Turnover is what fraction of the portfolio changes between rebalances. Defined:

Where $w_i^{(t)}$ is the weight of asset $i$ at time $t$. The $\frac{1}{2}$ prevents double-counting (a sold position becomes a bought position and vice versa).

Low turnover → low transaction costs → more net alpha survives. Most institutional long-short equity strategies run 50-150% annual turnover. Strategies with 300%+ turnover have to clear a much higher bar on gross alpha.

Computing IC on 12-Month Momentum in Python

The canonical example computes the IC of 12-month momentum against 1-month forward returns, then plots the IC series over time.

import numpy as np
import pandas as pd
import yfinance as yf
from scipy import stats
import matplotlib.pyplot as plt

# Pull 5 years of prices for the S&P 100 universe
tickers = ["AAPL", "MSFT", "AMZN", "GOOGL", "META", "TSLA", "JPM", "JNJ",
           "V", "PG", "XOM", "BAC", "NVDA", "WMT", "DIS", "HD", "MA", "PFE"]

px = yf.download(tickers, start="2019-01-01", end="2024-12-31",
                 auto_adjust=True)["Close"]
px = px.dropna(axis=1, thresh=int(len(px) * 0.95))  # keep liquid names

# Monthly returns
monthly_ret = px.resample("ME").last().pct_change()

# 12-month momentum, skip the most recent month (the "12-1" recipe)
mom_12_1 = ((1 + monthly_ret).rolling(11).apply(np.prod) - 1).shift(1)

# Forward 1-month return
fwd_ret = monthly_ret.shift(-1)

# Compute cross-sectional rank IC each month
ic_ts = []
for d in mom_12_1.index[:-1]:
    f = mom_12_1.loc[d].dropna()
    r = fwd_ret.loc[d].dropna() if d in fwd_ret.index else None
    if r is None:
        continue
    common = f.index.intersection(r.index)
    if len(common) < 10:
        continue
    rho, _ = stats.spearmanr(f[common], r[common])
    ic_ts.append({"date": d, "ic": rho})

ic = pd.DataFrame(ic_ts).set_index("date")["ic"]

print(f"Mean IC      : {ic.mean():.4f}")
print(f"Std IC       : {ic.std():.4f}")
print(f"IC IR        : {ic.mean() / ic.std():.2f}")
print(f"% IC > 0     : {(ic > 0).mean():.1%}")

PROMPT

Use numpy, pandas, yfinance, and scipy.stats to compute a momentum factor IC for a universe and report summary stats.

Expected output:

Mean IC      : 0.0384
Std IC       : 0.1102
IC IR        : 0.35
% IC > 0     : 58.3%

Mean IC around 0.04 and IC IR around 0.35, a textbook 12-1 momentum result. Not spectacular, but tradable. The % IC > 0 matters more than you’d think: a factor that’s right 60% of the time at the cross-section rank level compounds differently than one that’s right 55%.

To plot the IC time series and a rolling 12-month mean:

fig, ax = plt.subplots(2, 1, figsize=(11, 7), sharex=True)

ax[0].bar(ic.index, ic.values, width=20, color=["#2a8f2a" if v > 0 else "#c43d3d" for v in ic])
ax[0].axhline(0, color="black", lw=0.7)
ax[0].set_ylabel("Monthly IC")
ax[0].set_title("12-1 Momentum IC, S&P 100 sample, 2019-2024")

ax[1].plot(ic.index, ic.rolling(12).mean(), color="#1f4e8b", lw=2)
ax[1].axhline(0, color="black", lw=0.7)
ax[1].set_ylabel("Rolling 12-month mean IC")
ax[1].set_xlabel("Date")

plt.tight_layout()
plt.show()

PROMPT

Use pandas and matplotlib to plot monthly IC bars colored by sign with a rolling-mean overlay.

You’ll see clear periods of negative IC. 2022 was brutal for momentum; long winners, short losers got crushed because the regime was mean-reversion driven. That’s the two failure modes you’re trying to detect.

The Two Failure Modes Every Factor Falls Into

A factor fails in one of two ways:

Failure 1: It predicts nothing. IC is statistically indistinguishable from zero. The factor is just noise dressed up in a formula. You can spot this fast: compute IC over 60 months, run a t-test. If the t-stat is below 2, move on.

Failure 2: It earns gross but loses to costs. The factor has real predictive power. IC is 0.05+. But turnover is 400% annual, and you’re paying 5 bps per round trip. Net alpha is negative. This is the silent killer. The backtest shows a Sharpe of 1.2, you go live, and you bleed because real costs are 3x what your backtest assumed.

A factor with IC = 0.10 and 1000% turnover can be worse than a factor with IC = 0.03 and 50% turnover. The arithmetic is unforgiving.

The Factor Zoo, Honestly

There are roughly 200+ published factors in academic finance as of 2025: value, momentum, quality, low-volatility, liquidity, profitability, investment, accruals, analyst revisions, sentiment, term-structure, carry, skew, dispersion, jump risk, and so on.

The following is a rough, directional funnel, not from any single citable source. Treat it as an editorial rule-of-thumb rather than precise counts.

Of those 200, maybe 50-80 still produce statistically significant IC after you remove data mining artifacts, restrict to out-of-sample periods, and adjust for known publication biases.

Of those 50-80, maybe 20-30 survive trading costs at institutional scale after you account for borrow, impact, and spread.

Of those 20-30, you might have a genuine edge on 5-10. The rest, you’re trading alongside AQR ($200B+ in factor product), BlackRock, State Street, and a hundred smaller quant shops who’ve been trading them since the papers came out.

Most published factors are now arbitraged away. The edge isn’t in finding a factor; it’s in finding one that hasn’t been traded on yet, by enough people.

That’s why the meta-game is factor combination, factor timing, and finding non-standard features (alternative data, structural signals) that big quant funds haven’t loaded yet. The article on combination in this section covers the combination angle.

Where It Fits

Alpha factors are the raw material. IC analysis is how you measure one. Factor decay tells you when it stops working. Turnover analysis is the reality check before you trade it. The combination article covers how to merge multiple factors into a single portfolio.

In the Arithmion SDK, the factor analysis module produces IC, rank IC, IC IR, turnover, and decay curves for any factor you define against any universe you specify. The output is what you’d compute by hand here, just faster and across longer histories.

References

• Grinold & Kahn, Active Portfolio Management: A Quantitative Approach to Generating and Exceeding Returns, Ch. 4-5. McGraw-Hill, 2000. ISBN: 978-0-07-135638-4.
• Ang, Asset Management: A Systematic Approach to Factor Investing, Ch. 9-11. Oxford University Press, 2014. ISBN: 978-0-19-995932-3.
• Jegadeesh & Titman, “Returns to Buying Winners and Selling Losers,” Journal of Finance, 1993.
• Harvey, Liu, Zhu, “…and the Cross-Section of Expected Returns,” Review of Financial Studies, 2016 (the factor zoo paper).
• Arithmion SDK, arithmion.factor.analyze() module documentation.