Same Forecasts, Different Portfolios: Factor Normalization and Regularization

Why two versions of one factor model with the same forecasts can hold different portfolios when a penalty on factor exposures is written in each version’s own units, and what using the model’s estimated intercept adds.

Author

Affiliation

Mingyang Liu

Imperial Business School, Imperial College London

Version

October 2026

Paper (PDF) · BibTeX

Working paper, October 2026 · 116 pages: a 46-page main text and a 70-page Internet Appendix (cited as pages IA-1 to IA-70) · not yet posted to SSRN, no DOI · page numbers refer to the paper above

Two versions of one factor model can forecast the same stock returns and still hold different portfolios. The portfolio rule adds a small constant (a ridge; the paper calls it the factor penalty) to each factor’s variance. That constant penalises how much the portfolio bets on each factor, in the units each version happens to use, so one number is two different penalties (eq. 6, p. 11). Over 594 months, the two versions’ stock forecasts differ by a median of 4.8 parts in a million (Table II, p. 24). Yet at the same penalty number their Sharpe ratios (average excess return per unit of volatility) before trading costs are 0.69 and 1.07 (Table I, p. 19). Written in one set of units, the penalty gives one portfolio; without it, both versions are at 1.62.

A portfolio needs a return forecast as well as a risk penalty, and the second result turns to the forecast. The same kind of model can also estimate an intercept, the part of expected return that none of its factors explains. Using the full fitted mean, intercept included, gives a Sharpe ratio of 2.51 before trading costs that barely moves with the penalty. Its gain over the best portfolio without an intercept is 0.89, with a 95% interval of [0.59, 1.26], and 0.57 [0.29, 0.89] net of 25 basis points per dollar traded (Table III, p. 30). Since October 2007 the net advantage has an interval that includes zero (pp. 7, 39).

1 The question

In the agenda, this paper asks: same forecast, different portfolio? Interpreting Pricing Errors asks what a model’s alpha means; this paper moves from reading the model to acting on it. The Ruler Matters then holds the target fixed and asks: same target, different stocks?

If two versions of one factor model make the same forecasts but measure factor exposure with different rulers, do they tell the investor to hold the same stocks? And what does using the intercept the model already estimates add?

To say how much of a stock’s expected return each driver explains, a model must first decide when two combinations of characteristics are really different, and how large each one is. The rule it uses for that is the ruler: technically, a metric (an inner product) on characteristic space. Give each characteristic a weight and add them up: every stock gets a score. Such a weighted combination is called a direction (it is not a portfolio). The plain ruler (the Euclidean or identity metric) judges a direction by its weights alone. The characteristic ruler (the Gram metric, built from the Gram matrix of the characteristics: their average products across stocks) judges it by the scores it gives real stocks: how large they typically are, and whether two directions’ scores line up across stocks, high on the same stocks and low on the same stocks. So the ruler is the convention a model uses to measure how large a direction is and how much two directions overlap. Two value signals that pick out the same cheap stocks count as overlapping under the characteristic ruler but as unrelated under the plain ruler.

The paper compares two separately estimated versions of one factor model that differ only in the ruler. IPCA (instrumented principal component analysis) is a standard conditional factor model in which characteristics determine each stock’s factor loadings, that is, how strongly the stock moves with the common drivers (Kelly et al. 2019). Its hidden (latent) factors have no units of their own, so a model must fix them; the paper calls this choice the normalisation. Fixing them with the plain ruler gives the Euclidean normalisation, IPCA’s usual restriction; fixing them with the characteristic ruler, the metric of Characteristic-Space Metrics (Liu 2026b), gives the Gram normalisation (eqs. 2–3 and footnote 3, p. 10). A third fit adds an intercept: the part of expected return that no factor in this model explains (the home page’s “alpha” is a close relative, measured against a stated benchmark model). It is the NA-IPCA (No-Arbitrage IPCA) of Geometric Framework (Liu 2026a), whose “no-arbitrage” is a cap on how much the intercept may carry; the cap never binds in this paper (footnote 3, p. 10).

2 Why it matters

Factor models are compared by the Sharpe ratios of their portfolios, but a portfolio is a forecast passed through a risk matrix, and that matrix carries settings written in the model’s own units. If a setting moves holdings, a manager who switches or re-estimates a risk model may read the new positions as a new signal when nothing in the forecast has changed.

Economic. The same penalty number decides a comparison across model families. At the reference penalty, risk-premium PCA (RP-PCA, a competing way of extracting factors) has a Sharpe ratio before trading costs of 1.49 against 0.69 for IPCA with the plain ruler. Without the penalty, the gap of 0.80 becomes −0.08, with an interval of [−0.44, 0.26] (Table I, p. 19; Table II, p. 24).
Practical. A constant added to factor variances for numerical stability is a penalty on factor exposures. Written in one set of units, or directly on stock positions, it cannot move the portfolio when the normalisation changes (Proposition 1, p. 12). The paper’s design rule: state the penalty, the units it is written in, and which part of the fitted mean the portfolio uses (p. 43).
Statistical. The reference penalty is about 11 times the median factor variance in plain-ruler units and 27 times in characteristic-ruler units. The factor covariances are invertible without it (smallest eigenvalue 3.1 × 10⁻⁵), so it is not needed for that purpose (Internet Appendix IA.E.2, p. IA-22).

3 The argument at a glance

Question. Investors hold portfolios, not forecasts, so a fair comparison follows the forecast to the holdings. → The question
Framework. A hidden factor’s units are a convention: doubling a factor and halving its loadings leaves every fitted return unchanged (p. 11). The two separately estimated versions forecast alike, a median gap of 4.8 parts in a million. → The framework
Mechanism. The rule’s constant on factor variances penalises factor exposures in each version’s own units, so the same number holds back different stock positions. → A simple example
Evidence. At the reference penalty the two versions hold different stocks, with Sharpe ratios of 0.69 and 1.07 before trading costs. → Figure 2
Remedy. Written in one set of units, the penalty gives one portfolio (one minus weight similarity 1.0 × 10⁻¹¹ in the median month); without it, both versions are at 1.62 before trading costs. → Table 1
Second result. Within one fit, using the full fitted mean, intercept included, gives a Sharpe ratio of 2.51 before trading costs, flat along the penalty and 0.89 above the best portfolio without an intercept. → Figure 3
Boundary. State the penalty, its units and the mean input. The limits: returns are before trading costs unless stated, costs are proportional, the intercept is not shown to be mispricing, the net advantage after 2007 is not resolved, and no ruler or penalty strength is shown to be best. → Scope

4 The framework

The portfolio rule holds more of a factor when its forecast is high relative to its estimated risk. Before inverting the factor risk, it adds a small constant (0.01, a ridge; the paper calls it the factor penalty) to each factor’s variance, which makes the rule hold a little less of every factor. That constant charges the portfolio’s exposure to each factor in the units in which the factor loadings are reported, so changing the ruler changes how strongly each stock position is held back (eq. 6, p. 11).

Changing the ruler is a matched change of units: every fitted return and residual stays the same, the loadings are rescaled, and overlap moves among the hidden factors, the observed Fama–French factors and the intercept (Proposition 1, p. 12). Of the portfolio rule’s inputs, only the penalty changes: doubling a factor and halving its loadings turns the same penalty into a quarter of itself on that factor (pp. 11, 13). Proposition 1 gives the map between the two versions and shows that their penalised portfolios coincide if and only if the penalty is written in one set of units: chosen under one ruler and carried to the other, or set directly on stock positions. Neither choice says what the penalty should be, because the fit is the same under every normalisation and cannot select it (Proposition 1, p. 12; p. 13).

The intercept enters through the expected-return input. The penalty acts on a portfolio only through its factor exposures. A portfolio built from the factor means alone carries its whole forecast through those exposures; adding the intercept adds positions whose expected return the factor block does not carry, so the penalty barely reaches them (Lemma 1, pp. 14–15).

Note: this paper’s characteristic ruler, month by month. The characteristic ruler used here is an exponentially weighted moving average (EWMA) of each window’s Gram matrices, with a half-life of 60 months (p. 17). It is re-estimated in each of the paper’s 618 formation months. The main text uses the 594 months from June 1975. Its participation dimension (how many equally large directions of variation the characteristics behave like) runs from 17.36 to 22.63. Its median is 19.83. The largest direction’s share of the spread (the leading eigenvalue’s share of the trace) runs from 11.76% to 15.21%. Both ranges are reported in Table IA.L.1 (p. IA-62). Neither statistic counts priced risks, and the ruler affects portfolios only through the factor penalty (p. IA-61). Data: rolling_geometry.csv from the paper’s research files (not public). The home page’s Figure 1 is a separate, descriptive exhibit on the 153-characteristic library and is not drawn from this paper. Files and pipeline: Data & Code.

Technical details

The model writes stock i’s next-month excess return as (eq. 1, p. 9)

r_{i,s+1} = z_{i,s}'\Gamma_\beta f_{s+1} + z_{i,s}'\Gamma_\delta g_{s+1} + z_{i,s}'\Gamma_\alpha + \varepsilon_{i,s+1}.

Here z_{i,s} lists the 132 characteristics, f the three hidden factors and g the five Fama–French factors; each \Gamma turns characteristics into loadings, and IPCA sets \Gamma_\alpha = 0. A normalisation with metric Q imposes \Gamma_\beta' Q \Gamma_\beta = I_K and \Gamma_\beta' Q [\Gamma_\delta, \Gamma_\alpha] = 0: the plain ruler sets Q = I_L, the characteristic ruler an average of the window’s Gram matrices W_s = Z_s'Z_s/N_s (eqs. 2–3, p. 10). The intercept fit also bounds the average squared stock-level intercept by 0.035; the bound is slack at every date, with a largest value of 1.5 × 10⁻⁴ across the 618 rolling fits (footnote 3, p. 10).

With B_t the stocks’ factor exposures, \hat\mu_t the forecast and A_{0,t} the risk matrix without the factor penalty (it keeps a position penalty \lambda_\Sigma = 0.01 written directly on stock positions), the portfolio solves (eq. 6, p. 11)

\max_w \; w'\hat\mu_t \;-\; \tfrac12\, w'A_{0,t}\, w \;-\; \tfrac{\lambda}{2}\,\lVert B_t'w\rVert^2 .

A change of normalisation maps B \to BJ^{-1}. Adjustments R and R^Q added to the two factor covariances give the same stock risk matrix, and the same portfolio for every expected-return vector, if and only if R^Q = JRJ'; for R = R^Q = \lambda I with \lambda > 0 this holds if and only if J is orthogonal, which the map from the plain to the characteristic ruler is only when the two metrics already agree on the hidden loadings (Proposition 1, p. 12; p. 13). For any expected-return vector, the penalty shrinks the portfolio’s factor exposures as B'w_\lambda = (I+\lambda M)^{-1}B'w_0 with M = B'A_0^{-1}B, and without the penalty the intercept portfolio is the same under every normalisation (Lemma 1, pp. 14–15).

5 A simple example

Try this. Here k sets the unit of the ruler: k = 2 doubles the factor and halves its stock loadings, which leaves the forecast unchanged (pp. 11, 13). (1) At k = 1 the portfolio is 50/50. (2) Drag k to 2. Rows 1 and 2 of the table do not move; only row 3, the ridge charge, falls from 0.0100 to 0.0025, because the loading is halved and the charge depends on its square. Stock 1’s share rises to 54%. (3) Drag k to 0.25. The charge grows sixteen-fold and stock 1 falls to 20%. (4) Choose “Convert the ridge with the units” (the paper calls this writing the penalty in one set of units): the dot moves to the dashed line, flat at 50% for every k. “Remove the factor ridge” also gives 50% here. What to notice: nothing about the stocks changed, only the units in which a fixed constant was charged. The toy has two independent factors; in the paper’s two-factor example the penalty tilts the portfolio toward the factor whose variance is larger in the units in which the penalty is written (p. 13).

Figure 1: Same forecast, same risk, different ridge charge. Two stocks; the units of factor 1 change and nothing else does.

palette = ({
  naipca_iab: "#18557f", complete: "#18557f",
  qz_ipca: "#8a6a1a",
  ipca: "#6f9cc0", rp_pca: "#7a7a7a", ff5: "#b3b3b3",
  naipca_beta_only: "#8a8378", beta_only: "#8a8378",
  band: "rgba(0,0,0,0.06)", muted: "rgba(0,0,0,0.6)", rule: "rgba(0,0,0,0.1)"
})
LANG = (document.documentElement.lang || "en").startsWith("zh") ? "zh" : "en"
STR = ({ en: { view: "View", cost: "Cost (bp per traded dollar)", universe: "Universe", sample: "Sample (months)", log: "Log scale", models: "Models", statistic: "Statistic", theme: "Theme", sort: "Sort by", method: "Method", scenario: "Scenario", block: "Block (months)", metric: "Metric", intervals: "Intervals", cost_bp: "One-way cost (bp)", failed: "Interactive data failed to load. The static figure is shown instead." },
        zh: { view: "视图", cost: "成本（每交易一美元，基点）", universe: "股票池", sample: "样本（月）", log: "对数坐标", models: "模型", statistic: "统计量", theme: "主题", sort: "排序", method: "方法", scenario: "情景", block: "块长（月）", metric: "指标", intervals: "区间", cost_bp: "单边成本（基点）", failed: "交互数据加载失败，改为显示静态图。" } })
t = (k) => STR[LANG][k] ?? STR.en[k] ?? k
fmt2 = (x) => (x == null || Number.isNaN(x)) ? "n/a" : x.toFixed(2)
fmt1 = (x) => (x == null || Number.isNaN(x)) ? "n/a" : x.toFixed(1)
fmtBp = (x) => (x == null || Number.isNaN(x)) ? "> 500" : `${Math.round(x)} bp`
parseMonth = (s) => new Date(`${s}-01T00:00:00Z`)
// Sharpe, annualised, sample std (ddof = 1): matches the release convention
sharpe = (r) => {
  const n = r.length, m = r.reduce((a, b) => a + b, 0) / n
  const v = r.reduce((a, b) => a + (b - m) ** 2, 0) / (n - 1)
  const vol = Math.sqrt(v) * Math.sqrt(12)
  return vol > 1e-12 ? (m * 12) / vol : NaN
}
netSeries = (r, to, bp) => r.map((x, i) => x - to[i] * bp / 1e4)
wealthPath = (r) => { let w = 1; return r.map((x) => (w *= 1 + x)) }
nberMarks = (nber) => Plot.rectX(nber, { x1: (d) => parseMonth(d.start), x2: (d) => parseMonth(d.end), fill: palette.band })

cg_toy_S = LANG === "zh" ? ({
  k: "尺子的单位 k",
  mode: "因子岭项",
  fixed: "固定为 0.01（现行规则）",
  convert: "让岭项随单位换算",
  remove: "去掉因子岭项",
  lineFixed: "现行规则的结果（实线）",
  lineRemedy: "论文提出的补救（虚线）",
  xLabel: "尺子的单位 k（对数坐标）",
  yLabel: "股票 1 在组合中的占比（%）",
  aria: "示意图：因子 1 的单位改变时，股票 1 在两只股票组合中的占比",
  ariaDesc: "岭项固定时，k 从 0.25 增至 8，股票 1 的占比从 20% 升至约 55%；岭项随单位换算或被去掉时，占比始终为 50%。",
  qty: "项目", base: "原始单位（k = 1）", now: (k) => `当前（k = ${k}）`,
  r1: "股票 1 的预测收益（载荷 × 因子均值）",
  r2: "股票 1 的因子风险（载荷² × 因子方差）",
  r3: "岭项收费（载荷² × 岭项）",
  r4: "股票 1 的未缩放权重",
  r5: "股票 2 的未缩放权重（单位不变）",
  r6: "股票 1 的占比（头寸缩放至多空头寸总规模为 1 后）"
}) : ({
  k: "Ruler's unit k",
  mode: "Factor ridge",
  fixed: "Fixed at 0.01 (implemented rule)",
  convert: "Convert the ridge with the units",
  remove: "Remove the factor ridge",
  lineFixed: "What the implemented rule does (solid)",
  lineRemedy: "The paper's remedy (dashed)",
  xLabel: "Ruler's unit k (log axis)",
  yLabel: "Stock 1's share of the portfolio (%)",
  aria: "Illustrative example: share of stock 1 in a two-stock portfolio as the units of factor 1 change",
  ariaDesc: "With the ridge fixed, stock 1's share rises from 20% to about 55% as k grows from 0.25 to 8. With the ridge converted with the units, or removed, the share stays at 50%.",
  qty: "Toy quantity", base: "Original units (k = 1)", now: (k) => `Now (k = ${k})`,
  r1: "Stock 1's forecast (loading × factor mean)",
  r2: "Stock 1's factor risk (loading² × factor variance)",
  r3: "Ridge charge (loading² × ridge)",
  r4: "Stock 1's unscaled weight",
  r5: "Stock 2's unscaled weight (units unchanged)",
  r6: "Stock 1's share (positions scaled to a total size of one)"
})
viewof cg_toy_k = Inputs.range([0.25, 8], { value: 1, step: 0.05, label: cg_toy_S.k })

viewof cg_toy_transport = Inputs.radio(new Map([[cg_toy_S.fixed, "fixed"], [cg_toy_S.convert, "convert"], [cg_toy_S.remove, "remove"]]), { label: cg_toy_S.mode, value: "fixed" })

cg_toy_calc = (k, mode) => {
  const loading = 1 / k, mean = 0.01 * k, varf = 0.02 * k * k
  const ridge = mode === "convert" ? 0.01 * k * k : mode === "remove" ? 0 : 0.01
  const ridge2 = mode === "remove" ? 0 : 0.01
  const forecast = loading * mean, risk = loading * loading * varf, charge = loading * loading * ridge
  const w1 = forecast / (risk + charge + 0.01 + 0.01)
  const w2 = 0.01 / (0.02 + ridge2 + 0.01 + 0.01)
  return { k, loading, mean, varf, ridge, forecast, risk, charge, w1, w2, share: w1 / (w1 + w2) }
}
cg_toy_now = cg_toy_calc(cg_toy_k, cg_toy_transport)
cg_toy_grid = d3.range(0, 1.0001, 0.01).map((u) => 0.25 * Math.pow(32, u))
cg_toy_lines = ["fixed", "convert"].flatMap((mode) => cg_toy_grid.map((k) => ({
  k, share: 100 * cg_toy_calc(k, mode).share, mode,
  rule: mode === "fixed" ? cg_toy_S.lineFixed : cg_toy_S.lineRemedy
})))

cg_toy_chart = Plot.plot({
  width: Math.min(width, 640), height: 280, marginLeft: 52, marginBottom: 40, style: { fontFamily: "inherit", fontSize: 12 },
  ariaLabel: cg_toy_S.aria,
  ariaDescription: cg_toy_S.ariaDesc,
  x: { type: "log", domain: [0.25, 8], ticks: [0.25, 0.5, 1, 2, 4, 8], tickFormat: (d) => `${d}`, label: cg_toy_S.xLabel },
  y: { domain: [15, 60], grid: true, label: cg_toy_S.yLabel },
  color: { domain: [cg_toy_S.lineFixed, cg_toy_S.lineRemedy], range: [palette.complete, palette.qz_ipca], legend: true },
  marks: [
    Plot.ruleY([50], { stroke: palette.rule }),
    Plot.ruleX([1], { stroke: palette.rule }),
    Plot.lineY(cg_toy_lines.filter((d) => d.mode === "fixed"), { x: "k", y: "share", stroke: "rule", strokeWidth: 2 }),
    Plot.lineY(cg_toy_lines.filter((d) => d.mode === "convert"), { x: "k", y: "share", stroke: "rule", strokeWidth: 2, strokeDasharray: "5 4" }),
    Plot.dot([cg_toy_now], { x: "k", y: (d) => 100 * d.share, r: 6, fill: cg_toy_transport === "fixed" ? palette.complete : palette.qz_ipca, stroke: "white" }),
    Plot.text([cg_toy_now], { x: "k", y: (d) => 100 * d.share, text: (d) => `${(100 * d.share).toFixed(1)}%`, dy: -14, fontWeight: 600 })
  ]
})

cg_toy_table = {
  const base = cg_toy_calc(1, "fixed"), now = cg_toy_now
  const f = (x, d = 4) => x.toFixed(d)
  const S = cg_toy_S
  const rows = [
    [S.r1, f(base.forecast), f(now.forecast)],
    [S.r2, f(base.risk), f(now.risk)],
    [S.r3, f(base.charge), f(now.charge)],
    [S.r4, f(base.w1, 3), f(now.w1, 3)],
    [S.r5, f(base.w2, 3), f(now.w2, 3)],
    [S.r6, `${(100 * base.share).toFixed(1)}%`, `${(100 * now.share).toFixed(1)}%`]
  ]
  return html`<table class="tbl-num"><thead><tr><th>${S.qty}</th><th>${S.base}</th><th>${S.now(now.k.toFixed(2))}</th></tr></thead>
  <tbody>${rows.map((r) => html`<tr><td>${r[0]}</td><td>${r[1]}</td><td>${r[2]}</td></tr>`)}</tbody></table>`
}

How to read it. Stock 1 loads on factor 1 (mean 0.01, variance 0.02, loading 1); stock 2 loads on an independent factor whose units never change. Each stock has residual variance 0.01 plus its own penalty of 0.01 on stock positions. Converting the ridge with the units is the paper’s remedy, which it calls writing the penalty in one set of units; removing the penalty is the paper’s other benchmark (Proposition 1, p. 12; Table IA.A.1, p. IA-4). Source: illustrative arithmetic on the portfolio rule in the paper (eq. 6, p. 11); no data files.

Two cooks follow the same recipe. One measures flour in cups, the other in half-cups. The recipe also says “add a pinch of salt per unit of flour”, so the half-cup cook adds more salt, although the flour is the same. The difference lies in how the rule is written, not in the ingredients. There are two fixes: drop the rule, or convert it with the units. In the paper, the flour is the forecast, the unit is set by the ruler, and the pinch is the penalty of 0.01 added to each factor’s variance. Unlike salt, the penalty is a charge that makes the rule hold less of each factor; it grows with the square of the exposure, and a real change of ruler also mixes exposures.

6 Design and main results

The data are monthly U.S. stock returns and 132 characteristics from Jensen et al. (2023), for mega-, large- and small-capitalisation stocks (microcaps excluded), ranked each month (Section III.A, p. 16). Each month every model is refitted on the previous 120 months and its portfolio is held for one month, over 594 formation months from June 1975 to November 2024 (pp. 16–17). Each IPCA fit has three hidden factors and the five Fama–French factors as observed factors (Fama and French 2015). One mean–variance rule sets every model’s weights on individual stocks, and positions are scaled each month to a total size of one, long plus short; the paper calls this unit gross exposure (pp. 17–18). The factor penalty takes six values from 0 to 0.1, with 0.01 as the reference (p. 17). Intervals are pointwise 95% intervals from a paired moving-block bootstrap with 12-month blocks and 10,000 draws that holds the fitted models fixed (Section III.D, p. 20). Sharpe ratios are annualised and before trading costs unless stated. Costs are quoted in basis points (bp; 1 bp = 0.01 percentage point) per dollar traded.

1. Same forecasts, different holdings. If the units did not matter, the two versions would hold the same stocks. They do not: at the reference penalty, written in each version’s own units, one minus the similarity of their weights has a median of 0.17, and the typical distance between their weights is more than half of the total position (p. 21; Table II, p. 24).

Table 1: Forecasts agree; holdings agree only when the penalty is written in one set of units. The two versions of IPCA, plain and characteristic ruler, 594 months.

Comparison	One minus weight similarity, median (maximum)	Distance between the two, median (maximum)
Stock forecasts (relative gap)	—	4.8 × 10⁻⁶ (1.4 × 10⁻⁴)
Reference penalty, each version’s own units	0.17 (0.55)	0.58 (1.04)
Characteristic-ruler fit, penalty written in plain-ruler units	1.0 × 10⁻¹¹ (1.4 × 10⁻⁹)	4.5 × 10⁻⁶ (5.2 × 10⁻⁵)
Plain-ruler fit, penalty written in characteristic-ruler units	4.8 × 10⁻¹² (2.6 × 10⁻⁹)	3.1 × 10⁻⁶ (6.9 × 10⁻⁵)
Both without the penalty	6.2 × 10⁻¹² (4.6 × 10⁻⁹)	3.5 × 10⁻⁶ (9.4 × 10⁻⁵)

Weight similarity is the cosine of the two weight vectors: 1 minus it is 0 for identical proportions. The distance is the sum of absolute differences between the two portfolios’ weights, each scaled to a total position of one, so it runs from 0 to 2. The forecast gap is the size of the forecast difference relative to the plain-ruler forecast (Table II, Panel A, p. 24).

The two versions are estimated separately, so this agreement is measured, not built in. Written in one set of units, the reference penalty gives one portfolio, and the returns follow the weights: the characteristic-ruler fit with its penalty written in plain-ruler units has the plain-ruler fit’s Sharpe ratio, 0.69 (p. 22; Table I, p. 19). The holdings gap therefore comes from writing the penalty in two sets of units.

2. The penalty along its scale, and across model families. Figure 2 moves the penalty from 0 to ten times the reference value.

Figure 2: One model, two rulers, one penalty number. Sharpe ratio before trading costs along the factor penalty, 594 months, June 1975 to November 2024 (Figures 1 and 3, pp. 4, 26).

sfpc_data = FileAttachment("/data/sf_penalty_curves.json").json().catch(() => null)
sfpc_S = LANG === "zh" ? ({
  unitsLabel: "惩罚写在",
  own: "各自尺子的单位里（论文的参考设定）",
  oneSet: "同一套单位里（论文的补救）",
  moreLabel: "加上其他模型族",
  names: { euclid: "普通尺子（欧氏单位）", gram: "特征尺子（格拉姆单位）", both: "两把尺子，惩罚写在同一套单位里", rppca: "风险溢价主成分分析（RP-PCA）", ff5: "FF5（法玛–弗伦奇五因子）" },
  xLabel: "因子惩罚 λ（对数坐标；0 为单独刻度）",
  yLabel: "夏普比率（年化，未计交易成本）",
  aria: "图 2：沿因子惩罚变化的夏普比率",
  ariaDesc: "同一 IPCA 模型两个版本的年化夏普比率（未计交易成本），因子惩罚取 0 至 0.1 六个值，带状区域为逐点 95% 区间；594 个月。",
  byIdentity: "由命题 1 得出（第 12 页）",
  check: "论文计算值：λ = 0.01 时为 0.69（表 I，第 19 页）",
  thSeries: "组合", thLambda: "λ =",
  refLabel: "参考惩罚",
  fallbackAlt: "两幅图：左图为普通尺子与特征尺子下 IPCA 的夏普比率随因子惩罚的变化，无惩罚时均为 1.62，参考惩罚 0.01 处分别为 0.69 和 1.07；右图为两者之差，参考惩罚处为 0.38。594 个月，未计交易成本。"
}) : ({
  unitsLabel: "Penalty written in",
  own: "each ruler's own units (the paper's reference setting)",
  oneSet: "one set of units (the paper's remedy)",
  moreLabel: "Add other model families",
  names: { euclid: "Plain ruler (Euclidean units)", gram: "Characteristic ruler (Gram units)", both: "Both rulers, penalty in one set of units", rppca: "RP-PCA (risk-premium PCA)", ff5: "FF5 (Fama–French five factors)" },
  xLabel: "Factor penalty λ (log scale; 0 is a separate tick)",
  yLabel: "Sharpe ratio (annualised, before trading costs)",
  aria: "Figure 2: The Sharpe ratio along the factor penalty",
  ariaDesc: "Annualised Sharpe ratios before trading costs of two versions of one IPCA model as the factor penalty takes six values from 0 to 0.1, with pointwise 95% bands; 594 months.",
  byIdentity: "by Proposition 1 (p. 12)",
  check: "computed in the paper: 0.69 at λ = 0.01 (Table I, p. 19)",
  thSeries: "Portfolio", thLambda: "λ =",
  refLabel: "reference penalty",
  fallbackAlt: "Two panels: left, the Sharpe ratio of IPCA under the plain and the characteristic ruler along the factor penalty, both 1.62 without the penalty and 0.69 and 1.07 at the reference penalty 0.01; right, their difference, 0.38 at the reference penalty. 594 months, before trading costs."
})
sfpc_fallback = sfpc_data === null ? html`<p class="figcaption"><strong>${t("failed")}</strong></p><img src="/assets/img/sf_penalty_curves.png" alt="${sfpc_S.fallbackAlt}" style="width:100%">` : html``

viewof sfpc_units = Inputs.radio(new Map([[sfpc_S.own, "own"], [sfpc_S.oneSet, "one_set"]]), { value: "own", label: sfpc_S.unitsLabel })
viewof sfpc_more = Inputs.checkbox(new Map([[sfpc_S.names.rppca, "rppca"], [sfpc_S.names.ff5, "ff5"]]), { value: [], label: sfpc_S.moreLabel })
viewof sfpc_block = Inputs.radio(sfpc_data ? sfpc_data.blocks : [12, 24, 60], { value: sfpc_data ? sfpc_data.default_block : 12, label: t("block") })

sfpc_x = (l) => l === 0 ? 0.001 / Math.sqrt(10) : l
sfpc_ticks = sfpc_data ? sfpc_data.lambdas.map(sfpc_x) : []
sfpc_tick = (d) => { const i = sfpc_ticks.findIndex((v) => Math.abs(v / d - 1) < 1e-9); return i >= 0 ? sfpc_data.lambda_labels[i] : "" }
sfpc_ref = sfpc_data ? sfpc_data.lambdas.indexOf(sfpc_data.reference_lambda) : 3
sfpc_ids = sfpc_units === "own" ? ["euclid", "gram", ...sfpc_more] : ["euclid", ...sfpc_more]
sfpc_name = (id) => sfpc_units === "one_set" && id === "euclid" ? sfpc_S.names.both : sfpc_S.names[id]
sfpc_series = sfpc_data ? sfpc_ids.map((id) => {
  const s = sfpc_data.series.find((d) => d.id === id)
  return { id, name: sfpc_name(id), color: palette[s.palette_key], s }
}) : []
sfpc_pts = sfpc_series.flatMap(({ id, name, s }) => sfpc_data.lambdas.map((l, i) => ({
  id, name, i, x: sfpc_x(l), y: s.sharpe[i], printed: s.printed[i], label: sfpc_data.lambda_labels[i],
  lo: s.band[String(sfpc_block)].lo[i], hi: s.band[String(sfpc_block)].hi[i],
  identity: sfpc_units === "one_set" && id === "euclid" && sfpc_data.units.one_set.status[i] === "by_identity"
})))

sfpc_readout = {
  if (!sfpc_data) return html``
  const h = sfpc_data.headline, zh = LANG === "zh", i = sfpc_ref
  const dr = sfpc_data.diffs.find((d) => d.id === "rppca_minus_euclid")
  const ff = sfpc_data.series.find((d) => d.id === "ff5")
  const main = sfpc_units === "own"
    ? (zh ? html`λ = 0.01（参考惩罚）时，普通尺子为 <strong>${h.euclid_ref}</strong>，特征尺子为 <strong>${h.gram_ref}</strong>，差值 ${h.diff_ref} [${h.diff_ref_ci.join(", ")}]。去掉惩罚，两者都是 ${h.unpenalised}。`
          : html`At the reference penalty (λ = 0.01) the Sharpe ratio is <strong>${h.euclid_ref}</strong> under the plain ruler and <strong>${h.gram_ref}</strong> under the characteristic ruler: a difference of ${h.diff_ref} [${h.diff_ref_ci.join(", ")}]. Without the penalty both are at ${h.unpenalised}.`)
    : (zh ? html`惩罚写在同一套单位里，两把尺子持有同一个组合：“1 减权重相似度”的中位数为 ${h.weights_one_set_median}，λ = 0.01 时两者都是 <strong>${h.unit_consistent_ref}</strong>。去掉惩罚，两者都是 ${h.unpenalised}。`
          : html`Written in one set of units, the two rulers hold one portfolio: one minus their weight similarity has a median of ${h.weights_one_set_median}, and both have a Sharpe ratio of <strong>${h.unit_consistent_ref}</strong> at λ = 0.01. Without the penalty both are at ${h.unpenalised}.`)
  const rp = sfpc_more.includes("rppca")
    ? (zh ? html`RP-PCA 减普通尺子：λ = 0.01 时 ${dr.printed[i]} [${dr.printed_ci[i].join(", ")}]，去掉惩罚时 ${dr.printed[0]} [${dr.printed_ci[0].join(", ")}]。`
          : html`RP-PCA minus the plain ruler: ${dr.printed[i]} [${dr.printed_ci[i].join(", ")}] at λ = 0.01 and ${dr.printed[0]} [${dr.printed_ci[0].join(", ")}] without the penalty.`)
    : ""
  const f5 = sfpc_more.includes("ff5")
    ? (zh ? html`FF5：λ = 0.01 时 ${ff.printed[i]}，去掉惩罚时 ${ff.printed[0]}。` : html`FF5: ${ff.printed[i]} at λ = 0.01 and ${ff.printed[0]} without the penalty.`)
    : ""
  const loc = zh ? "（表 I，第 19 页；表 II，第 24 页）" : "(Table I, p. 19; Table II, p. 24)"
  const parts = [main, rp, f5, html`<span class="loc">${loc}</span>`].filter((x) => x !== "")
  return html`<p class="figcaption" style="font-size:14px;margin:.2rem 0 .4rem">${parts.flatMap((x, k) => k > 0 && !zh ? [" ", x] : [x])}</p>`
}

sfpc_chart = {
  if (!sfpc_data) return html``
  const c = sfpc_data.units.one_set.check
  return Plot.plot({
    width: Math.min(width, 720), height: 340, marginLeft: 52, marginRight: 16, marginBottom: 44,
    style: { fontFamily: "inherit", fontSize: 12 },
    ariaLabel: sfpc_S.aria,
    ariaDescription: sfpc_S.ariaDesc,
    x: { type: "log", domain: [sfpc_x(0) / 1.6, 0.16], ticks: sfpc_ticks, tickFormat: sfpc_tick, label: sfpc_S.xLabel, labelAnchor: "center", labelArrow: "none" },
    y: { domain: [-0.5, 2.5], grid: true, label: sfpc_S.yLabel },
    color: { domain: sfpc_series.map((d) => d.name), range: sfpc_series.map((d) => d.color), legend: true },
    marks: [
      Plot.ruleY([0], { stroke: palette.muted }),
      Plot.ruleX([sfpc_data.reference_lambda], { stroke: palette.muted, strokeDasharray: "2 3" }),
      Plot.text([{ x: sfpc_data.reference_lambda, y: 2.45 }], { x: "x", y: "y", text: () => sfpc_S.refLabel, dx: 4, textAnchor: "start", fill: palette.muted, fontSize: 11 }),
      Plot.areaY(sfpc_pts, { x: "x", y1: "lo", y2: "hi", fill: "name", fillOpacity: 0.12, z: "name" }),
      Plot.line(sfpc_pts, { x: "x", y: "y", stroke: "name", z: "name", strokeWidth: 2 }),
      Plot.dot(sfpc_pts.filter((d) => !d.identity), { x: "x", y: "y", fill: "name", r: 3.5 }),
      Plot.dot(sfpc_pts.filter((d) => d.identity), { x: "x", y: "y", stroke: "name", fill: "white", r: 3.5, strokeWidth: 1.5 }),
      sfpc_units === "one_set" ? Plot.dot([{ x: sfpc_x(c.lambda), y: c.sharpe }], { x: "x", y: "y", r: 8, stroke: "currentColor", fill: "none", strokeWidth: 1.5 }) : null,
      Plot.tip(sfpc_pts, Plot.pointer({ x: "x", y: "y", title: (d) => `${d.name}\nλ = ${d.label}: ${d.printed}${d.identity ? `\n${sfpc_S.byIdentity}` : ""}${sfpc_units === "one_set" && d.id === "euclid" && d.i === sfpc_ref ? `\n${sfpc_S.check}` : ""}` }))
    ]
  })
}

sfpc_table = {
  if (!sfpc_data) return html``
  const L = sfpc_data.lambda_labels
  return html`<table class="tbl-num"><thead><tr><th>${sfpc_S.thSeries}</th>${L.map((l) => html`<th>${sfpc_S.thLambda} ${l}</th>`)}</tr></thead>
    <tbody>${sfpc_series.map(({ id, name, s }) => html`<tr><td>${name}</td>${s.printed.map((p, i) => {
      const ident = sfpc_units === "one_set" && id === "euclid" && sfpc_data.units.one_set.status[i] === "by_identity"
      return html`<td>${p}${ident ? html`<sup title="${sfpc_S.byIdentity}">†</sup>` : ""}</td>`
    })}</tr>`)}</tbody></table>
    ${sfpc_units === "one_set" ? html`<p class="note">† ${sfpc_S.byIdentity}.</p>` : ""}`
}

How to read it. Each line is one portfolio’s Sharpe ratio at six values of the factor penalty λ; the leftmost tick, λ = 0, is drawn apart on the log axis, and the dotted line marks the reference penalty, 0.01. Bands are pointwise 95% intervals that hold the fitted models fixed; the block menu changes only the bands, and the readout quotes the paper’s 12-month intervals. “One set of units” draws the single portfolio both rulers hold when the penalty is written in plain-ruler units; the paper computes it at λ = 0 and at the reference penalty (circled), and Proposition 1 gives the other points (†). RP-PCA and FF5 (the five Fama–French factors with loadings instrumented by the characteristics) are re-solved under the same rule (Table I, p. 19; Section IV.D, p. 25). Source: Same Forecasts, Different Portfolios, working paper (October 2026), Figure 1 (p. 4), Figure 3 (p. 26) and Tables I–II (pp. 19, 24); replication files 10_sharpe_by_lambda_594.csv, 10_contrasts_594.csv, 13_ladder_594.csv, 13_holdings_594.json. Data · PNG

What this shows. The scale of the penalty moves the Sharpe ratio by more than its units do: both versions fall from 1.62 without the penalty, the plain ruler to 0.30 and the characteristic ruler to 1.00 at λ = 0.1 (Table I, p. 19). Removing the reference penalty raises the plain ruler’s Sharpe ratio by 0.93 [0.61, 1.25] and the characteristic ruler’s by 0.55 [0.35, 0.77] (Table II, Panel C, p. 24). A ranking at one penalty number measures the penalty: RP-PCA’s lead over the plain ruler grows from −0.08 without the penalty to 1.03 at λ = 0.1, while RP-PCA’s own Sharpe ratio changes little (Table II, p. 24; p. 25). A data-driven shrinkage does not remove the dependence: Ledoit–Wolf shrinkage (Ledoit and Wolf 2004), applied in each version’s own units, gives 1.17 and 1.54 (Table II, p. 24).

3. The intercept the model already estimates. The second result holds one fit of IPCA with an intercept fixed and changes only the expected-return input: the factor means alone (the factor-mean portfolio) or the complete fitted mean, intercept included (the intercept portfolio). Both use the same risk matrix, penalty included, and no model is re-estimated (Section V.A, pp. 27–28). The benchmark that does not depend on the ruler is the best portfolio without an intercept: IPCA without the penalty, the same under both rulers, at 1.62 (pp. 14, 28).

Figure 3: One fit, two mean inputs. Sharpe ratio along the factor penalty of the intercept portfolio and the factor-mean portfolio of the same fit, 594 months (Figure 4, p. 29; Table III, p. 30).

sfmi_data = FileAttachment("/data/sf_mean_input.json").json().catch(() => null)
sfmi_S = LANG === "zh" ? ({
  inputLabel: "均值输入",
  inputs: { full_mean: "完整拟合均值，含截距（截距组合）", factor_means: "仅用因子均值（同一拟合的因子均值组合）" },
  short: { full_mean: "完整拟合均值（截距组合）", factor_means: "仅用因子均值（因子均值组合）" },
  costLabel: "交易成本",
  gross: "未计交易成本", net: "每交易一美元扣 25 个基点",
  bench: (v) => `最佳零截距组合，${v}`,
  xLabel: "因子惩罚 λ（对数坐标；0 为单独刻度）",
  yLabel: (c) => c === "gross" ? "夏普比率（年化，未计交易成本）" : "夏普比率（年化，扣除 25 个基点成本后）",
  aria: "图 3：同一拟合的两种均值输入",
  ariaDesc: "同一个含截距的 IPCA 拟合，分别只用因子均值或用完整拟合均值构建组合，年化夏普比率随因子惩罚的变化；虚线为最佳零截距组合；594 个月。",
  thSeries: "组合", thLambda: "λ =", thCost: { gross: "未计交易成本", net25: "扣除 25 个基点成本后" },
  netNote: "按每交易一美元（买入加卖出）收取 25 个基点的比例成本；不含价格冲击、融资、融券费用与容量限制，并非可实现的扣费后收益（脚注 23，第 40 页）。",
  fallbackAlt: "两幅图：左图为同一拟合的截距组合与因子均值组合的夏普比率随因子惩罚的变化，截距组合约为 2.50 至 2.51，因子均值组合由 0.56 降至 0.37，虚线为最佳零截距组合 1.62；右图为参考惩罚处的柱状图，未计交易成本与扣除 25 个基点成本后分别为 0.39 与 −0.04、1.62 与 1.03、2.51 与 1.60。594 个月。"
}) : ({
  inputLabel: "Mean input",
  inputs: { full_mean: "Complete fitted mean, including the intercept (intercept portfolio)", factor_means: "Factor means only (factor-mean portfolio of the same fit)" },
  short: { full_mean: "Complete fitted mean (intercept portfolio)", factor_means: "Factor means only (factor-mean portfolio)" },
  costLabel: "Trading costs",
  gross: "Before trading costs", net: "Net of 25 bp per dollar traded",
  bench: (v) => `Best zero-intercept portfolio, ${v}`,
  xLabel: "Factor penalty λ (log scale; 0 is a separate tick)",
  yLabel: (c) => c === "gross" ? "Sharpe ratio (annualised, before trading costs)" : "Sharpe ratio (annualised, net of 25 bp)",
  aria: "Figure 3: Two mean inputs, one fit",
  ariaDesc: "Annualised Sharpe ratios along the factor penalty of two portfolios of one IPCA fit with an intercept, one using the factor means only and one the complete fitted mean; the dashed line is the best zero-intercept portfolio; 594 months.",
  thSeries: "Portfolio", thLambda: "λ =", thCost: { gross: "before trading costs", net25: "net of 25 bp" },
  netNote: "A proportional cost of 25 basis points per dollar traded, on purchases plus sales; it omits price impact, financing, short-sale fees and capacity, and is not an implementable net return (footnote 23, p. 40).",
  fallbackAlt: "Two panels: left, the Sharpe ratio of the intercept portfolio (about 2.50 to 2.51) and of the factor-mean portfolio of the same fit (0.56 falling to 0.37) along the factor penalty, with the best zero-intercept portfolio at 1.62 as a dashed line; right, bars at the reference penalty, gross and net of 25 bp: 0.39 and −0.04, 1.62 and 1.03, 2.51 and 1.60. 594 months."
})
sfmi_fallback = sfmi_data === null ? html`<p class="figcaption"><strong>${t("failed")}</strong></p><img src="/assets/img/sf_mean_input.png" alt="${sfmi_S.fallbackAlt}" style="width:100%">` : html``

viewof sfmi_input = Inputs.radio(new Map([[sfmi_S.inputs.full_mean, "full_mean"], [sfmi_S.inputs.factor_means, "factor_means"]]), { value: "full_mean", label: sfmi_S.inputLabel })
viewof sfmi_cost = Inputs.radio(new Map([[sfmi_S.gross, "gross"], [sfmi_S.net, "net25"]]), { value: "gross", label: sfmi_S.costLabel })

sfmi_x = (l) => l === 0 ? 0.001 / Math.sqrt(10) : l
sfmi_ticks = sfmi_data ? sfmi_data.lambdas.map(sfmi_x) : []
sfmi_tick = (d) => { const i = sfmi_ticks.findIndex((v) => Math.abs(v / d - 1) < 1e-9); return i >= 0 ? sfmi_data.lambda_labels[i] : "" }
sfmi_ref = sfmi_data ? sfmi_data.lambdas.indexOf(sfmi_data.reference_lambda) : 3
sfmi_pts = sfmi_data ? sfmi_data.inputs.flatMap((inp) => sfmi_data.lambdas.map((l, k) => ({
  id: inp.id, name: sfmi_S.short[inp.id], x: sfmi_x(l), label: sfmi_data.lambda_labels[k],
  y: inp[sfmi_cost].sharpe[k], printed: inp[sfmi_cost].printed[k],
  lo: inp.gross.band[String(sfmi_data.default_block)].lo[k], hi: inp.gross.band[String(sfmi_data.default_block)].hi[k]
}))) : []

sfmi_readout = {
  if (!sfmi_data) return html``
  const zh = LANG === "zh", i = sfmi_ref, c = sfmi_cost
  const sel = sfmi_data.inputs.find((d) => d.id === sfmi_input)
  const bench = sfmi_data.benchmark[c].printed
  const zp = sfmi_data.contrasts.full_minus_best_zp.rows.find((r) => r.ip_lambda === sfmi_data.reference_lambda)[c].printed
  const fm = sfmi_data.contrasts.full_minus_factor[c][i].printed
  const v = sel[c].printed
  const mv = c === "gross"
    ? (zh ? `；年化均值 ${sel.gross.printed_mean[i]}%，年化波动率 ${sel.gross.printed_vol[i]}%` : `; annualised mean ${sel.gross.printed_mean[i]}% and volatility ${sel.gross.printed_vol[i]}%`)
    : ""
  const body = sfmi_input === "full_mean"
    ? (zh ? html`${sfmi_S.short.full_mean}：λ = 0.01 时为 <strong>${v[i]}</strong>，去掉惩罚时为 ${v[0]}${mv}。相对最佳零截距组合（${bench}），增益为 ${zp.diff} [${zp.lo}, ${zp.hi}]。`
          : html`${sfmi_S.short.full_mean}: <strong>${v[i]}</strong> at λ = 0.01 and ${v[0]} without the penalty${mv}. Against the best zero-intercept portfolio's ${bench}, the gain is ${zp.diff} [${zp.lo}, ${zp.hi}].`)
    : (zh ? html`${sfmi_S.short.factor_means}：λ = 0.01 时为 <strong>${v[i]}</strong>，去掉惩罚时为 ${v[0]}${mv}。同一惩罚下，截距组合比它高 ${fm.diff} [${fm.lo}, ${fm.hi}]。`
          : html`${sfmi_S.short.factor_means}: <strong>${v[i]}</strong> at λ = 0.01 and ${v[0]} without the penalty${mv}. At the same penalty the intercept portfolio exceeds it by ${fm.diff} [${fm.lo}, ${fm.hi}].`)
  const loc = zh ? "（表 III，第 30 页；表 I，第 19 页）" : "(Table III, p. 30; Table I, p. 19)"
  return html`<p class="figcaption" style="font-size:14px;margin:.2rem 0 .4rem">${body}${zh ? "" : " "}<span class="loc">${loc}</span>${c === "net25" ? html`<br>${sfmi_S.netNote}` : ""}</p>`
}

sfmi_chart = {
  if (!sfmi_data) return html``
  const b = sfmi_data.benchmark[sfmi_cost]
  const names = sfmi_data.inputs.map((d) => sfmi_S.short[d.id])
  const colors = sfmi_data.inputs.map((d) => palette[d.palette_key])
  const sel = sfmi_pts.filter((d) => d.id === sfmi_input), other = sfmi_pts.filter((d) => d.id !== sfmi_input)
  return Plot.plot({
    width: Math.min(width, 720), height: 340, marginLeft: 52, marginRight: 16, marginBottom: 44,
    style: { fontFamily: "inherit", fontSize: 12 },
    ariaLabel: sfmi_S.aria,
    ariaDescription: sfmi_S.ariaDesc,
    x: { type: "log", domain: [sfmi_x(0) / 1.6, 0.16], ticks: sfmi_ticks, tickFormat: sfmi_tick, label: sfmi_S.xLabel, labelAnchor: "center", labelArrow: "none" },
    y: { domain: [-0.5, 3.25], grid: true, label: sfmi_S.yLabel(sfmi_cost) },
    color: { domain: names, range: colors, legend: true },
    marks: [
      Plot.ruleY([0], { stroke: palette.muted }),
      Plot.ruleX([sfmi_data.reference_lambda], { stroke: palette.muted, strokeDasharray: "2 3" }),
      sfmi_cost === "gross" ? Plot.areaY(sfmi_pts, { x: "x", y1: "lo", y2: "hi", fill: "name", fillOpacity: 0.1, z: "name" }) : null,
      Plot.ruleY([b.sharpe], { stroke: palette[sfmi_data.benchmark.palette_key], strokeDasharray: "5 4", strokeWidth: 1.5 }),
      Plot.text([{ x: sfmi_x(0), y: b.sharpe }], { x: "x", y: "y", text: () => sfmi_S.bench(b.printed), dy: -8, textAnchor: "start", fill: palette.muted, fontSize: 11 }),
      Plot.line(other, { x: "x", y: "y", stroke: "name", strokeWidth: 1.2, strokeOpacity: 0.7 }),
      Plot.line(sel, { x: "x", y: "y", stroke: "name", strokeWidth: 2.6 }),
      Plot.dot(sfmi_pts, { x: "x", y: "y", fill: "name", r: (d) => d.id === sfmi_input ? 4 : 2.5 }),
      Plot.tip(sfmi_pts, Plot.pointer({ x: "x", y: "y", title: (d) => `${d.name}\nλ = ${d.label}: ${d.printed}` }))
    ]
  })
}

sfmi_table = {
  if (!sfmi_data) return html``
  const L = sfmi_data.lambda_labels
  return html`<table class="tbl-num"><thead><tr><th>${sfmi_S.thSeries}${LANG === "zh" ? `（${sfmi_S.thCost[sfmi_cost]}）` : ` (${sfmi_S.thCost[sfmi_cost]})`}</th>${L.map((l) => html`<th>${sfmi_S.thLambda} ${l}</th>`)}</tr></thead>
    <tbody>${sfmi_data.inputs.map((inp) => html`<tr><td>${sfmi_S.short[inp.id]}</td>${inp[sfmi_cost].printed.map((p) => html`<td>${p}</td>`)}</tr>`)}</tbody></table>`
}

How to read it. The thick line is the selected mean input; the dashed line is the best portfolio without an intercept (IPCA without the penalty, λ = 0). Gross bands are pointwise 95% intervals from 12-month blocks. The net view charges 25 bp per dollar traded on purchases plus sales, a proportional cost that omits price impact, financing, short-sale fees and capacity, and is not an implementable net return (Table III, p. 30; footnote 23, p. 40). Source: Same Forecasts, Different Portfolios, working paper (October 2026), Table III (p. 30), Figure 4 (p. 29) and Table I (p. 19); replication files 14_table3_594.csv, 14_intercept_curve_594.csv, 15_net_by_lambda_594.csv, 15_contrasts_594.csv, 13_ladder_594.csv. Data · PNG

What this shows. The factor-mean portfolio behaves like the portfolios of Figure 2: 0.56 without the penalty, 0.39 at the reference. The intercept portfolio barely moves: 2.50 without the penalty and 2.51 at every positive value (Table III, p. 30). It exceeds the best portfolio without an intercept by 0.89 [0.59, 1.26], the smallest of its gains over the portfolios compared; net of 25 bp its Sharpe ratio is 1.60 against 1.03 (Table III, p. 30; Table I, p. 19). The gain needs the fitted intercept’s assignment to stocks: shuffling it across stocks within each month leaves a Sharpe ratio of 0.04 on average, never above 0.30 in 1,000 draws (p. 29; Table IA.M.1, p. IA-65).

4. Where the gain comes from, and how long it lasts. The gain over the best portfolio without an intercept comes mainly through lower volatility per dollar of position, not a reliably higher mean: the intercept portfolio’s annualised mean is 7.6% against 6.6%, a difference within sampling error, and its volatility 3.0% against 4.1% (pp. 33–35). Of the 0.89, 0.66 arrives through volatility and 0.23 through the mean, a descriptive split that depends on its order (footnote 21, p. 35). Regressed on that benchmark and the five Fama–French factors, the intercept portfolio loads 0.45 on the benchmark and keeps an annualised alpha of 4.9% (Table V, p. 38). Its break-even cost, at which the mean net return falls to zero, is 68 bp, equal to the benchmark’s (Table IV, p. 35). Trading one month late lowers its Sharpe ratio from 2.51 to 1.52, against 1.62 to 1.07 for the benchmark (Table III, Panel C, p. 30). Its Sharpe ratio falls from 3.95 in the first third of the sample to 1.11 in the last, a decline matched by the benchmark (p. 39). From October 2007 (206 months), its advantage over the benchmark net of 25 bp is 0.19 with an interval of [−0.41, 0.75]: the data cannot tell a gain from a loss (p. 39; Table IA.I.2, p. IA-44). Much of the gain is a short-horizon premium: setting to zero the intercept’s loadings on a group of short-horizon return and trading-activity characteristics leaves 1.81 before trading costs, and a gain of only 0.19 [−0.17, 0.53] (p. 41).

Internet Appendix comparison. Figure 4 keeps an exhibit this site built from the paper’s research release of September 2026. Its numbers belong to the Internet Appendix, and its labels predate the paper’s names: QZ-IPCA is IPCA under the characteristic ruler and NA-IPCA is IPCA with an intercept (footnote 3, p. 10); “intercept off” is the factor-mean portfolio, “mean only” the intercept portfolio, and the “complete intercept rule” the stabilised intercept portfolio, which also charges for how much the intercept loadings varied over the 24 previous estimates (p. IA-33). “Core” is the paper’s full universe: U.S. stocks excluding microcaps (p. 16).

Figure 4: Internet Appendix comparison: a holdings difference is not yet a reliable return gain. Compounded cumulative return, positions scaled to a total size of one, June 1973 to November 2024; the intercept views use 594 months from June 1975.

pf_data = FileAttachment("/data/portfolio_formation.json").json().catch(() => null)
pf_loadFailed = pf_data === null ? html`<p class="figcaption"><strong>${t("failed")}</strong></p><img src="/assets/img/portfolio_formation.png" alt="${pf_S.fallbackAlt}" style="width:100%">` : html``
// Visible strings, localised through LANG (the model labels in the data file are English).
pf_S = LANG === "zh" ? ({
  views: [["跨模型比较", "cross"], ["关闭截距与完整截距规则", "iab"], ["同一拟合，三种输入", "ablation"]],
  models: { ff5: "FF5（法玛–弗伦奇五因子）", rp_pca: "RP-PCA", ipca: "IPCA", qz_ipca: "QZ-IPCA（滚动 60 个月版本）", naipca_beta_only: "NA-IPCA，关闭截距", naipca_iab: "NA-IPCA，完整截距规则" },
  legs: { beta_only: "NA-IPCA，关闭截距", complete: "NA-IPCA，完整截距规则" },
  universes: { CORE: "核心股票池", MEGA: "超大盘股", LARGE: "大盘股", SMALL: "小盘股" },
  ablation: { intercept_off: "关闭截距", mean_only: "仅均值", complete_iab: "完整截距规则" },
  selectOne: "请至少选择一个模型以绘制图表。",
  sharpeGross: "夏普比率（未计交易成本）",
  wealth: (bp) => `累计收益（起点为 1；代理成本 ${bp} 个基点）`,
  wealthWord: "累计收益",
  ariaCross: "图 3：持仓不同，还不等于可靠的收益优势",
  ariaCrossDesc: "所选组合规则按月复利的累计收益，阴影为 NBER 衰退期。",
  ariaAbl: "图 3：同一拟合，三种输入",
  ariaAblDesc: "同一拟合模型三种输入规则（关闭截距、仅均值、完整截距规则）的夏普比率柱状图，未计交易成本。",
  thModel: "模型（618 个月）", thGross: "夏普比率（未计交易成本）", thProxy: (bp) => `代理成本调整后的夏普比率（${bp} 个基点）`,
  thRet: "年化均值（%）", thVol: "年化波动率（%）", thDD: "最大回撤（%）", thTO: "换手率", thBE: "盈亏平衡成本（代理成本，向上取整到基点）",
  pcaNote: "主成分分析（PCA）未列入：论文研究发布包把它的组合标为退化，在论文的设定下多空头寸总规模接近零。",
  thRule: "规则（594 个月共同样本）",
  thPaired: "配对月均收益差：完整截距规则 − 关闭截距", thMonths: "月数", thDiff: "月均差", thCI: "95% 区间", thHolm: "Holm 调整 p 值",
  full: "完整共同样本", recent: "2007 年 10 月以来",
  iabNote: "区间来自配对月收益的 12 个月区块自助法；夏普比率仅作描述。",
  thInput: "输入规则",
  ablNote: "全程使用同一个拟合模型：未计交易成本时，增量主要来自把截距纳入预期收益输入；针对截距载荷不稳定的额外风险收费作用很小。",
  fallbackAlt: "六种因子模型组合的累计收益，核心股票池，1973 年至 2024 年，对数坐标，阴影为 NBER 衰退期"
}) : ({
  views: [["Across models", "cross"], ["Intercept off vs complete intercept rule", "iab"], ["One fit, three inputs", "ablation"]],
  models: { ff5: "FF5 (Fama–French five factors)", rp_pca: "RP-PCA", ipca: "IPCA", qz_ipca: "QZ-IPCA (rolling-60 version)", naipca_beta_only: "NA-IPCA, intercept off", naipca_iab: "NA-IPCA, complete intercept rule" },
  legs: { beta_only: "NA-IPCA, intercept off", complete: "NA-IPCA, complete intercept rule" },
  universes: { CORE: "Core", MEGA: "Mega", LARGE: "Large", SMALL: "Small" },
  ablation: { intercept_off: "Intercept off", mean_only: "Mean only", complete_iab: "Complete intercept rule" },
  selectOne: "Select at least one model to draw the chart.",
  sharpeGross: "Sharpe ratio (before trading costs)",
  wealth: (bp) => `Cumulative return (start = 1; proxy cost ${bp} bp)`,
  wealthWord: "cumulative return",
  ariaCross: "Figure 3: A holdings difference is not yet a reliable return gain",
  ariaCrossDesc: "Compounded cumulative return of the selected portfolio rules, with NBER recessions shaded.",
  ariaAbl: "Figure 3: One fit, three inputs",
  ariaAblDesc: "Bar chart of Sharpe ratios before trading costs for three input rules of one fitted model: intercept off, mean only and the complete intercept rule.",
  thModel: "Model (618 months)", thGross: "Sharpe ratio (before trading costs)", thProxy: (bp) => `Proxy-adjusted Sharpe (${bp} bp)`,
  thRet: "Annualised mean (%)", thVol: "Annualised volatility (%)", thDD: "Maximum drawdown (%)", thTO: "Turnover", thBE: "Break-even cost (proxy, rounded up to whole bp)",
  pcaNote: "PCA (principal component analysis) is not shown: the paper's research release flags its portfolio as degenerate, with a total position size near zero under the paper's settings.",
  thRule: "Rule (594-month common sample)",
  thPaired: "Paired mean difference, complete − intercept off", thMonths: "Months", thDiff: "Monthly difference", thCI: "95% interval", thHolm: "Holm-adjusted p-value",
  full: "Full common sample", recent: "October 2007 onward",
  iabNote: "Intervals come from a 12-month block bootstrap of paired monthly returns; the Sharpe ratios are descriptive.",
  thInput: "Input rule",
  ablNote: "Same fitted model throughout: adding the intercept to the expected-return input accounts for most of the increase before trading costs; the extra risk charge for unstable intercept loadings adds little.",
  fallbackAlt: "Cumulative return of six factor-model portfolios, Core stocks, 1973 to 2024, log scale, NBER recessions shaded"
})
pf_fmtBp = (x) => LANG === "zh" ? ((x == null || Number.isNaN(x)) ? "> 500" : `${Math.round(x)} 个基点`) : fmtBp(x)
pf_label = (id) => pf_S.models[id] ?? (pf_data ? pf_data.cross_model.models.find((m) => m.id === id).label : id)

viewof pf_view = Inputs.radio(new Map(pf_S.views), { value: "cross", label: t("view") })

pf_investable = pf_data ? pf_data.cross_model.models.filter((m) => m.status === "OK") : []
viewof pf_chosen = Inputs.checkbox(pf_investable.map((m) => m.id), {
  label: t("models"), value: this?.value ?? ["ipca", "qz_ipca"],
  format: (id) => pf_label(id), disabled: pf_view !== "cross"
})
viewof pf_cost = Inputs.radio([0, 10, 50], { label: t("cost"), value: this?.value ?? 0, format: (x) => LANG === "zh" ? `${x} 个基点` : `${x} bp`, disabled: pf_view === "ablation" })
viewof pf_universe = Inputs.radio(pf_data ? pf_data.iab.universes : ["CORE"], { label: t("universe"), value: this?.value ?? "CORE", format: (u) => pf_S.universes[u] ?? u, disabled: pf_view !== "iab" })
viewof pf_logScale = Inputs.toggle({ label: t("log"), value: this?.value ?? true, disabled: pf_view === "ablation" })
viewof pf_sample = Inputs.radio([618, 594], { label: t("sample"), value: this?.value ?? 594, disabled: pf_view !== "ablation" })

pf_months = pf_data ? pf_data.months.map(parseMonth) : []
pf_series = {
  if (!pf_data) return []
  if (pf_view === "cross") {
    return pf_chosen.map((id) => ({ id, label: pf_label(id),
      r: netSeries(pf_data.cross_model.r[id], pf_data.cross_model.turnover[id], pf_cost) }))
  }
  if (pf_view === "iab") {
    const k = pf_data.iab.strict24_start_index
    return ["beta_only", "complete"].map((leg) => ({ id: leg, label: pf_S.legs[leg], start: k,
      r: netSeries(pf_data.iab.r[pf_universe][leg].slice(k), pf_data.iab.turnover[pf_universe][leg].slice(k), pf_cost) }))
  }
  return []
}
pf_rows = pf_series.flatMap((s) => wealthPath(s.r).map((w, i) => ({ date: pf_months[i + (s.start ?? 0)], wealth: w, label: s.label, id: s.id })))

pf_ablationNames = pf_S.ablation
pf_ablationOrder = ["intercept_off", "mean_only", "complete_iab"]

pf_chart = {
  if (!pf_data) return html``
  if (pf_view === "cross" && pf_chosen.length === 0) return html`<p class="note">${pf_S.selectOne}</p>`
  if (pf_view === "ablation") {
    const data = pf_data.ablation.filter((d) => d.sample_months === pf_sample)
    return Plot.plot({
      width: Math.min(width, 640), height: 260, marginLeft: 50, style: { fontFamily: "inherit", fontSize: 12 },
      ariaLabel: pf_S.ariaAbl,
      ariaDescription: pf_S.ariaAblDesc,
      x: { domain: pf_ablationOrder, tickFormat: (d) => pf_ablationNames[d], label: null },
      y: { label: pf_S.sharpeGross, grid: true },
      marks: [
        Plot.barY(data, { x: "model", y: "gross_sharpe", fill: (d) => d.model === "complete_iab" ? palette.complete : palette.rp_pca }),
        Plot.text(data, { x: "model", y: "gross_sharpe", text: (d) => fmt2(d.gross_sharpe), dy: -8, fontFamily: "inherit" }),
        Plot.ruleY([0])
      ]
    })
  }
  const color = { domain: pf_series.map((s) => s.label), range: pf_series.map((s) => palette[s.id]) }
  return Plot.plot({
    width: Math.min(width, 640), height: 360, marginLeft: 52, style: { fontFamily: "inherit", fontSize: 12 },
    ariaLabel: pf_S.ariaCross,
    ariaDescription: pf_S.ariaCrossDesc,
    x: { label: null }, y: { type: pf_logScale ? "log" : "linear", grid: true, label: pf_S.wealth(pf_cost) },
    color: { ...color, legend: true },
    marks: [
      nberMarks(pf_data.nber),
      Plot.lineY(pf_rows, { x: "date", y: "wealth", stroke: "label", strokeWidth: (d) => d.id === "naipca_iab" || d.id === "complete" ? 2 : 1.4 }),
      Plot.tip(pf_rows, Plot.pointerX({ x: "date", y: "wealth", stroke: "label", title: (d) => `${d.label}\n${d.date.toISOString().slice(0, 7)} · ${pf_S.wealthWord} ${fmt2(d.wealth)}` }))
    ]
  })
}

pf_table = {
  if (!pf_data) return html``
  const S = pf_S
  if (pf_view === "cross") {
    if (pf_chosen.length === 0) return html`<p class="note">${S.selectOne}</p>`
    const t = pf_data.cross_model.table.filter((d) => pf_chosen.includes(d.id))
    return html`<table><thead><tr><th>${S.thModel}</th><th>${S.thGross}</th>${pf_cost > 0 ? html`<th>${S.thProxy(pf_cost)}</th>` : ""}<th>${S.thRet}</th><th>${S.thVol}</th><th>${S.thDD}</th><th>${S.thTO}</th><th>${S.thBE}</th></tr></thead>
      <tbody>${t.map((d) => { const r = pf_data.cross_model.r[d.id], to = pf_data.cross_model.turnover[d.id]; const net = sharpe(netSeries(r, to, pf_cost));
        return html`<tr><td>${pf_label(d.id)}</td><td>${fmt2(d.gross_sharpe)}</td>${pf_cost > 0 ? html`<td>${fmt2(net)}</td>` : ""}<td>${fmt1(d.annual_return_pct)}</td><td>${fmt1(d.annual_vol_pct)}</td><td>${fmt1(d.max_drawdown_pct)}</td><td>${fmt2(d.turnover)}</td><td>${pf_fmtBp(d.break_even_cost_bp)}</td></tr>` })}</tbody></table>
      <p class="note">${S.pcaNote}</p>`
  }
  if (pf_view === "iab") {
    const t = pf_data.iab.table.filter((d) => d.universe === pf_universe)
    const p = pf_data.iab.paired.filter((d) => d.universe === pf_universe)
    return html`<table><thead><tr><th>${S.thRule}</th><th>${S.thGross}</th><th>${S.thProxy(10)}</th><th>${S.thProxy(50)}</th><th>${S.thRet}</th><th>${S.thDD}</th><th>${S.thTO}</th><th>${S.thBE}</th></tr></thead>
      <tbody>${t.map((d) => html`<tr><td>${S.legs[d.leg] ?? d.label}</td><td>${fmt2(d.gross_sharpe)}</td><td>${fmt2(d.net_sharpe_10bp)}</td><td>${fmt2(d.net_sharpe_50bp)}</td><td>${fmt1(d.annual_return_pct)}</td><td>${fmt1(d.max_drawdown_pct)}</td><td>${fmt2(d.turnover)}</td><td>${pf_fmtBp(d.break_even_cost_bp)}</td></tr>`)}</tbody></table>
      <table><thead><tr><th>${S.thPaired}</th><th>${S.thMonths}</th><th>${S.thDiff}</th><th>${S.thCI}</th><th>${S.thHolm}</th></tr></thead>
      <tbody>${p.map((d) => html`<tr><td>${d.sample === "STRICT24_FULL" ? S.full : S.recent}</td><td>${d.n_months}</td><td>${(d.mean_diff_monthly * 100).toFixed(2)}%</td><td>[${(d.ci_low * 100).toFixed(2)}%, ${(d.ci_high * 100).toFixed(2)}%]</td><td>${d.p_holm < 1e-3 ? "< 0.001" : d.p_holm.toFixed(d.p_holm < 0.01 ? 3 : 2)}</td></tr>`)}</tbody></table>
      <p class="note">${S.iabNote}</p>`
  }
  const d = pf_data.ablation.filter((x) => x.sample_months === pf_sample)
  return html`<table><thead><tr><th>${S.thInput}</th><th>${S.thGross}</th><th>${S.thRet}</th><th>${S.thVol}</th><th>${S.thDD}</th></tr></thead>
    <tbody>${d.map((x) => html`<tr><td>${pf_ablationNames[x.model]}</td><td>${fmt2(x.gross_sharpe)}</td><td>${fmt1(x.annual_return_pct)}</td><td>${fmt1(x.annual_vol_pct)}</td><td>${fmt1(x.max_drawdown_pct)}</td></tr>`)}</tbody></table>
    <p class="note">${S.ablNote}</p>`
}

How to read it. Across models: 618 months at the reference penalty; IPCA is at 0.64, RP-PCA at 1.48 and FF5 at 0.68 (Table IA.E.3, p. IA-25), the rolling-60 version of the characteristic ruler 1.00 (Table IA.E.6, p. IA-29), the stabilised intercept portfolio 2.4926 and the factor-mean portfolio 0.32 (Table IA.G.4, p. IA-36). Intercept off vs complete intercept rule: by stock-size group over 594 months (Tables IA.I.3–IA.I.4, pp. IA-46–IA-47). One fit, three inputs: 594 months, 0.3917, 2.5126 and 2.5347, with the intercept portfolio’s monthly mean 48.69 bp [34.66, 63.36] above the factor-mean portfolio’s (Table IA.G.1, p. IA-35); the 618-month bars are in Table IA.G.4 (p. IA-36). Before trading costs by default; the 10 and 50 bp views and the break-even column charge a cost on one-way turnover computed by this site, not the paper’s cost model, and are not implementable net returns. Source: Same Forecasts, Different Portfolios, working paper (October 2026), Internet Appendix; research release 2026-09-09, core_monthly_unitgross_returns_source.csv, core_model_performance_618.csv, iab_ra_monthly.csv, beta_only_monthly.csv, Strict24_Main_Performance.csv, Strict24_Paired_Inference.csv, ablation_summary.csv, nber_monthly.csv; release not public; paths compounded by this site, descriptive only. Data · PNG

What this shows. On all 618 months the ordering is the main text’s: the intercept portfolios first, the factor-mean portfolio last. The characteristic ruler’s lead over the plain ruler at the reference penalty is smaller there, 0.27 [−0.02, 0.58] for the EWMA version, an interval that includes zero (Table IA.E.6, p. IA-29; footnote 1, p. 4). Over the 594 months, the stabilising term adds 0.0222 [0.0100, 0.0355] to the Sharpe ratio and leaves the mean unchanged (Table IA.G.1, p. IA-35). From October 2007 (206 months), the stabilised intercept portfolio’s mean return exceeds the factor-mean portfolio’s by 0.202 percentage points a month, with an interval of [−0.071, 0.409]: the data cannot tell a gain from a loss (Table IA.I.3, p. IA-46).

7 How it relates to prior work

One literature estimates factor models from many characteristics; another regularises risk estimates for portfolio choice. This paper studies the step between, where a factor model’s forecast and risk become a portfolio.

Prior work	What it established	What this paper adds
Kelly et al. (2019)	Characteristics instrument time-varying factor loadings (IPCA); a zero intercept is not rejected once several hidden factors are included	The normalisation IPCA leaves free sets the units of any factor-covariance penalty; the intercept is used as a portfolio input, a different question from their test (Section V.C, p. 31)
Jagannathan and Ma (2003); Ledoit and Wolf (2004); Ledoit and Wolf (2017)	Portfolio constraints and shrinkage act as covariance regularisation and can improve portfolio selection	A constant on factor variances is a stock-level penalty whose size depends on the normalisation unless it is written in one set of units; shrinkage toward the identity inherits the dependence
Lettau and Pelger (2020)	Risk-premium PCA extracts factors that also fit average returns	Under one rule, its 0.80 lead over plain-ruler IPCA at the reference penalty is −0.08 without the penalty: the comparison measures the penalty (Table II, p. 24)
Kelly et al. (2023)	Portfolios built from signals can separate alpha from factor exposure	The intercept portfolio draws most of its return from outside the factor block without an explicit hedge, and is not factor-neutral (loading 0.45; Table V, p. 38)

A Sharpe ratio of 2.5 sits beside Kelly, Pruitt and Su’s finding that this model’s intercept cannot be distinguished from zero, and the two answer different questions. Their test asks whether the intercept loadings, one per characteristic, are jointly large; the portfolio asks whether the intercept summed across some two thousand stocks, weighted by the inverse risk matrix, has a mean per unit of risk. The second can be large when the first is not (Section V.C, p. 31).

Geometric Framework and Characteristic-Space Metrics show that the ruler decides how a fit is split without changing the fit. This paper takes its characteristic ruler from Characteristic-Space Metrics and its intercept fit, NA-IPCA, from Geometric Framework (footnote 3, p. 10), and follows a change of the ruler’s units into a portfolio: it matters only through a penalty written in those units. The Ruler Matters measures the same ruler on the stocks, and asks which familiar positions a model’s factors represent and what hedging them requires.

Interpreting Pricing Errors and Same Forecasts, Different Portfolios both ask what the model’s leftover is worth, but in different settings. The first shrinks one characteristic-based model’s alpha component (keeps an estimated fraction of it) to make forecasts more accurate under squared-error loss. The second adds the NA-IPCA intercept to expected returns inside one fitted model and measures a portfolio Sharpe ratio before trading costs. The models, objectives and samples differ, so neither result confirms or contradicts the other.

The tools are known. What is new is a check and a measurement: whether holdings move when only the units of a fixed factor penalty change, with the map that removes the dependence, and how using the full fitted mean changes a portfolio’s sensitivity to the same penalty (p. 8). It is a check, not a new estimator.

8 Scope

Before trading costs unless stated. The net figures charge 25 bp per dollar traded on purchases plus sales, a proportional cost that omits price impact, financing, short-sale fees and capacity (footnote 23, p. 40). The results are conditional evidence on model-based allocation, not a verified implementable trading strategy: a stock enters a month only when its next-month return is recorded, and the point-in-time availability of the characteristics is not independently verified (p. 7; footnote 7, p. 16).
Pointwise intervals. Intervals hold the rolling fits fixed and are not joint across penalties or portfolios. The 594-month sample and the plain intercept portfolio as the main-text rule were chosen after both samples and both rules were computed, and the intervals do not adjust for that (footnote 2, p. 6; footnote 12, p. 20). On all 618 months, the corresponding difference between the rulers, 0.27, has an interval that includes zero (footnote 1, p. 4; Table IA.E.6, p. IA-29).
One model, not model families. Proposition 1 maps two normalisations of one model; it says how to carry a penalty across them, not what its strength should be, and it does not equate model families, whose forecasts differ (pp. 4, 13).
The intercept is not shown to be mispricing. It is the part of the fitted mean that the factor block does not absorb; whether it reflects pricing errors, omitted factors or conditional dynamics is not imposed, and its alpha is a residual relative to the stated regressors (pp. 5–7; footnote 18, p. 27).
No best ruler or penalty. The ranking of the two rulers is a function of the penalty, and the fit cannot select the penalty (pp. 13, 23). In this sample no shrinkage of the factor covariance is needed; the design rule that does not depend on the sample is to write any penalty in stock units (p. 26).

References

Fama, Eugene F., and Kenneth R. French. 2015. “A Five-Factor Asset Pricing Model.” Journal of Financial Economics 116 (1): 1–22. https://doi.org/10.1016/j.jfineco.2014.10.010.

Jagannathan, Ravi, and Tongshu Ma. 2003. “Risk Reduction in Large Portfolios: Why Imposing the Wrong Constraints Helps.” Journal of Finance 58 (4): 1651–83. https://onlinelibrary.wiley.com/doi/10.1111/1540-6261.00580.

Jensen, Theis Ingerslev, Bryan Kelly, and Lasse Heje Pedersen. 2023. “Is There a Replication Crisis in Finance?” Journal of Finance 78 (5): 2465–518. https://onlinelibrary.wiley.com/doi/full/10.1111/jofi.13249.

Kelly, Bryan T., Seth Pruitt, and Yinan Su. 2019. “Characteristics Are Covariances: A Unified Model of Risk and Return.” Journal of Financial Economics 134 (3): 501–24. https://www.sciencedirect.com/science/article/abs/pii/S0304405X19301151.

Kelly, Bryan, Semyon Malamud, and Lasse Heje Pedersen. 2023. “Principal Portfolios.” Journal of Finance 78 (1): 347–87. https://doi.org/10.1111/jofi.13199.

Ledoit, Olivier, and Michael Wolf. 2004. “A Well-Conditioned Estimator for Large-Dimensional Covariance Matrices.” Journal of Multivariate Analysis 88 (2): 365–411. https://doi.org/10.1016/S0047-259X(03)00096-4.

Ledoit, Olivier, and Michael Wolf. 2017. “Nonlinear Shrinkage of the Covariance Matrix for Portfolio Selection: Markowitz Meets Goldilocks.” Review of Financial Studies 30 (12): 4349–88. https://academic.oup.com/rfs/article-abstract/30/12/4349/3863121.

Lettau, Martin, and Markus Pelger. 2020. “Estimating Latent Asset-Pricing Factors.” Journal of Econometrics 218 (1): 1–31. https://www.sciencedirect.com/science/article/abs/pii/S0304407620300051.

Liu, Mingyang. 2026a. A Geometric Framework for Identification in Characteristic-Based Factor Models. https://doi.org/10.2139/ssrn.7013178.

Liu, Mingyang. 2026b. Characteristic-Space Metrics in Factor Models: Identification and Inference. https://doi.org/10.2139/ssrn.7445120.

Citation

BibTeX citation:

@report{liu2026forecasts,
  author = {Liu, Mingyang},
  publisher = {Imperial Business School, Imperial College London},
  title = {Same {Forecasts,} {Different} {Portfolios:} {Factor}
    {Normalization} and {Regularization}},
  date = {2026-10},
  url = {https://mingyangliu.org/research/same-forecasts-different-portfolios.html},
  langid = {en}
}

For attribution, please cite this work as:

Liu, Mingyang. 2026. Same Forecasts, Different Portfolios: Factor Normalization and Regularization. Working paper. Imperial Business School, Imperial College London. https://mingyangliu.org/research/same-forecasts-different-portfolios.html.