For eighty years the US market paid nothing except at the turn of the month. Then it stopped.

# Frozen before any data is loaded. Every cell below reads from PREREG,
# so no value is typed twice and the plan cannot drift from the code.
#
# Provenance of every parameter.
#
# From McConnell & Xu (2008), "Equity returns at the turn of the month",
# Financial Analysts Journal 64(2), 49-64, read out of the JSTOR copy on
# the author's Purdue page:
#   - day -1 is the last trading day of the prior month; days +1, +2 and +3
#     are the first three trading days of the month; the turn-of-the-month
#     interval is (-1, +3), four trading days
#   - "other days" is trading day -10 through -2 before month end and
#     trading day +4 through +10 after month start, which is the comparison
#     group and is deliberately not "every other day in the month"
#   - their sample is January 1926 to December 2005, which is where the
#     holdout starts
#   - the same window is attributed there to Lakonishok and Smidt (1988),
#     who ran it on the DJIA over 1897-1986. That paper is paywalled at
#     Oxford and was not fetched, so the window here is McConnell and Xu's
#     statement of it, not Lakonishok and Smidt's own text.
#
# Mine, not theirs, and named as mine:
#   - cost_bps, hac_lags, and the strategy test in "success". McConnell and
#     Xu measure the effect. They do not propose trading it.

PREREG = {
    "hypothesis": (
        "The mean daily US market return over the four-day turn-of-the-month "
        "interval exceeds the mean over McConnell and Xu's other-days window; "
        "the gap is still positive in the twenty years after their sample "
        "ends; and holding the market only on those four days beats "
        "buy-and-hold on Sharpe ratio in that holdout, net of costs."
    ),
    "universe": (
        "Ken French's daily US market factor, Mkt-RF plus RF, the total "
        "return on all CRSP NYSE, AMEX and NASDAQ common stocks. McConnell "
        "and Xu use CRSP value-weighted and equal-weighted indices directly; "
        "French's market factor is CRSP-based but separately constructed, so "
        "this is a close replication and not an exact one."
    ),
    "start":     "1926-07-01",
    "end":       "2026-06-30",
    "holdout":   "2006-01-01 onwards, touched once in the last cell of Results",
    "rebalance": "twice a month, into the market on day -1 and out after day +3",
    "params": {
        "tom_days":      [-1, 1, 2, 3],
        "other_days":    [-10, -9, -8, -7, -6, -5, -4, -3, -2, 4, 5, 6, 7, 8, 9, 10],
        "hac_lags":      5,
        "cost_bps":      10,
        "min_days_in_month": 15,
    },
    "success": (
        "All three must hold. (a) Over 1926-07 to 2005-12 the mean daily "
        "turn-of-the-month return exceeds the mean over other days, with "
        "|t| > 2 under Newey-West standard errors. (b) In the holdout the "
        "difference is still positive. (c) In the holdout, a strategy long "
        "the market on turn-of-the-month days and in Treasury bills "
        "otherwise has a higher Sharpe ratio than buy-and-hold, net of 10bp "
        "round-trip costs on 24 round trips a year."
    ),
}

import sys
import warnings

# Library import notices are not findings, and they would otherwise be
# published as output. Silenced before the imports that raise them.
warnings.filterwarnings("ignore")

import numpy as np
import pandas as pd
import statsmodels.api as sm
import matplotlib.pyplot as plt

sys.path.append("..")
from lib import style, data

style.use()
SEED = 0
np.random.seed(SEED)

AS_OF = "2026-08-28"          # as-of date of every cached pull in this note
P = PREREG["params"]

ffd = data.to_daily(data.famafrench("F-F_Research_Data_Factors_daily", AS_OF))
ffd = ffd.loc[PREREG["start"]:PREREG["end"]]
mkt = ffd["Mkt-RF"] + ffd["RF"]                      # total return, percent

# Trading-day position within the calendar month, counted from both ends.
grp   = mkt.groupby([mkt.index.year, mkt.index.month])
from_start = grp.cumcount() + 1                      # +1 is the first trading day
month_len  = grp.transform("size")
from_end   = from_start - month_len - 1              # -1 is the last trading day

fwd = from_start.where(from_start <= 10)
bwd = from_end.where(from_end >= -10)
long_enough = month_len >= P["min_days_in_month"]

is_tom   = (fwd.isin([d for d in P["tom_days"] if d > 0]) |
            bwd.isin([d for d in P["tom_days"] if d < 0])) & long_enough
is_other = ((fwd.isin([d for d in P["other_days"] if d > 0]) |
             bwd.isin([d for d in P["other_days"] if d < 0])) & long_enough & ~is_tom)

print(f"daily factors   {len(ffd):6,} rows  {ffd.index.min().date()} -> {ffd.index.max().date()}")
print(f"turn-of-month days {int(is_tom.sum()):6,}")
print(f"other days         {int(is_other.sum()):6,}")
print(f"unclassified       {int((~(is_tom | is_other)).sum()):6,}")
print(f"missing values: {int(ffd.isna().sum().sum())}")

def tom_gap(sl, lags=P["hac_lags"]):
    """Mean daily return on turn-of-month days minus other days."""
    m, t_, o_ = mkt.loc[sl], is_tom.loc[sl], is_other.loc[sl]
    use = t_ | o_
    y = m[use]
    X = sm.add_constant(pd.DataFrame({"tom": t_[use].astype(float)}, index=y.index))
    fit = sm.OLS(y, X).fit(cov_type="HAC", cov_kwds={"maxlags": lags})
    return {"tom": m[t_].mean(), "other": m[o_].mean(),
            "gap": fit.params["tom"], "t": fit.tvalues["tom"],
            "n_tom": int(t_.sum()), "n_other": int(o_.sum())}

def strategy(sl, cost_bps=P["cost_bps"]):
    """Long the market on turn-of-month days, Treasury bills otherwise."""
    m  = mkt.loc[sl] / 100.0
    rf = ffd["RF"].loc[sl] / 100.0
    w  = is_tom.loc[sl].astype(float)
    net = w * m + (1 - w) * rf - w.diff().abs().fillna(0) * cost_bps / 10000.0
    return net, m, rf

def sharpe(x, rf):
    return np.sqrt(252) * (x - rf).mean() / (x - rf).std()

def annualised(x):
    return ((1 + x).prod() ** (252 / len(x)) - 1) * 100

IN  = slice(None, "2005-12-31")
OUT = slice("2006-01-01", None)

# Criterion (a): is the turn-of-month premium there in sample?

print("mean daily market return, percent\n")
print(f"{'period':32} {'TOM n':>7} {'TOM':>9} {'other':>9} {'gap':>9} {'t':>7}")
for label, sl in [("in sample  1926-07 to 2005-12", IN),
                  ("full sample 1926-07 to 2026-06", slice(None))]:
    d = tom_gap(sl)
    print(f"{label:32} {d['n_tom']:>7,} {d['tom']:+9.4f} {d['other']:+9.4f} "
          f"{d['gap']:+9.4f} {d['t']:+7.2f}")

d_in = tom_gap(IN)

fig, ax = plt.subplots(figsize=(8, 4.3))

days = [d for d in range(-10, 0)] + [d for d in range(1, 11)]
means, labels = [], []
for d in days:
    sel = (bwd == d) if d < 0 else (fwd == d)
    sel = sel & long_enough
    means.append(mkt[sel].mean())
    labels.append(f"{d:+d}")

colors = [style.ACCENT if d in P["tom_days"] else style.SERIES[2] for d in days]
ax.bar(labels, means, color=colors, width=0.7)
ax.axhline(0, color=style.MUTED, lw=0.7)
ax.set_xlabel("Trading day of the month. Negative counts back from the last day.")
ax.set_ylabel("Mean daily return, %")
ax.set_title("The four turn-of-the-month days, 1926-2026, in accent")
plt.show()

# Criteria (b) and (c): the holdout. Evaluated once.

d_out = tom_gap(OUT)
net_out, mkt_out, rf_out = strategy(OUT)

print(f"holdout 2006-01 to 2026-06\n")
print(f"  turn-of-month days   {d_out['tom']:+.4f}%   n {d_out['n_tom']:,}")
print(f"  other days           {d_out['other']:+.4f}%   n {d_out['n_other']:,}")
print(f"  gap                  {d_out['gap']:+.4f}%   t {d_out['t']:+.2f}")
print()
print(f"  strategy      annualised {annualised(net_out):+6.2f}%   "
      f"Sharpe {sharpe(net_out, rf_out):+.3f}")
print(f"  buy and hold  annualised {annualised(mkt_out):+6.2f}%   "
      f"Sharpe {sharpe(mkt_out, rf_out):+.3f}")
print()
print(f"  in sample gap {d_in['gap']:+.4f}% (t {d_in['t']:+.2f})   "
      f"holdout gap {d_out['gap']:+.4f}% (t {d_out['t']:+.2f})")
print(f"  the holdout retains {100 * d_out['gap'] / d_in['gap']:.0f}% of the in-sample gap")

fig, ax = plt.subplots(figsize=(8, 4.3))

for sl, label, colour, width in [
    (IN,  "1926-07 to 2005-12", style.ACCENT,     1.8),
    (OUT, "2006-01 to 2026-06", style.SERIES[1],  1.2),
]:
    ys = []
    for d in days:
        sel = ((bwd == d) if d < 0 else (fwd == d)) & long_enough
        ys.append(mkt.loc[sl][sel.loc[sl]].mean())
    ax.plot(labels, ys, color=colour, lw=width, marker="o", ms=3.5, label=label)

ax.axhline(0, color=style.MUTED, lw=0.7)
for d in P["tom_days"]:
    ax.axvline(labels[days.index(d)], color=style.SUBTLE, alpha=0.16, lw=9)
ax.set_xlabel("Trading day of the month. Negative counts back from the last day.")
ax.set_ylabel("Mean daily return, %")
ax.set_title("The turn-of-the-month hump, before and after 2006")
ax.legend(loc="upper right")
plt.show()

fig, ax = plt.subplots(figsize=(8, 4.3))

net_all, mkt_all, rf_all = strategy(slice(None))
ax.plot(net_all.index, (1 + net_all).cumprod(), color=style.ACCENT, lw=1.6,
        label="In the market on turn-of-month days only")
ax.plot(mkt_all.index, (1 + mkt_all).cumprod(), color=style.SERIES[1], lw=1.2,
        label="Buy and hold")
ax.axvspan(pd.Timestamp("2006-01-01"), net_all.index.max(),
           color=style.SUBTLE, alpha=0.14, lw=0)
ax.annotate("holdout", (pd.Timestamp("2007-06-30"), 3),
            fontsize=8.5, color=style.MUTED)
ax.set_yscale("log")
ax.set_ylabel("Growth of $1, log scale")
ax.set_title("Trading the turn of the month, net of 10bp round trips")
ax.legend(loc="upper left")
plt.show()

# Subperiod behaviour, by 25-year block.

print(f"{'period':14} {'TOM%':>9} {'other%':>9} {'gap%':>9} {'t':>7}")
for y0 in [1926, 1951, 1976, 2001]:
    sl = slice(f"{y0}-01-01", f"{y0 + 24}-12-31")
    if len(mkt.loc[sl]) > 500:
        d = tom_gap(sl)
        print(f"{y0}-{y0 + 24}  {d['tom']:+9.4f} {d['other']:+9.4f} "
              f"{d['gap']:+9.4f} {d['t']:+7.2f}")

fig, ax = plt.subplots(figsize=(8, 3.9))

blocks, gaps, sig = [], [], []
for y0 in [1926, 1951, 1976, 2001]:
    sl = slice(f"{y0}-01-01", f"{y0 + 24}-12-31")
    d = tom_gap(sl)
    blocks.append(f"{y0}-{y0 + 24}")
    gaps.append(d["gap"])
    sig.append(abs(d["t"]) > 2)

ax.bar(blocks, gaps, color=[style.ACCENT if s else style.SERIES[2] for s in sig],
       width=0.55)
ax.axhline(0, color=style.MUTED, lw=0.7)
ax.set_ylabel("Turn-of-month minus other days, % per day")
ax.set_title("Blocks reaching |t| > 2 on their own, in accent")
plt.show()

# Cost sensitivity in the holdout. The strategy trades 24 times a year.

print(f"holdout, buy-and-hold Sharpe {sharpe(mkt_out, rf_out):+.3f}\n")
for c in [0, 10, 25, 50]:
    n, _, rfc = strategy(OUT, cost_bps=c)
    print(f"  {c:3d}bp round trip   annualised {annualised(n):+6.2f}%   "
          f"Sharpe {sharpe(n, rfc):+.3f}")

print(f"python       {sys.version.split()[0]}")
print(f"pandas       {pd.__version__}")
print(f"numpy        {np.__version__}")
print(f"statsmodels  {sm.__version__}")
print(f"seed         {SEED}")
print(f"data as-of   {AS_OF}  (research/data/famafrench/{AS_OF}/)")