Reference
Clock ablation methods
This benchmark runs one 8-K strategy three times across 88 filings and twelve issuers using the same daily price bars. Only the timestamp rule changes between runs. The performance difference between the runs isolates the effect of the timestamp choice.
All data on this page comes from ablation.json, regenerated on 2026-08-27 over the corpus described on coverage.
The measurement
Backtests that join SEC filings to prices using only the calendar date trade on filings hours before publication. The top curve shows the result of that lookahead over five months across twelve large-cap stocks. The two lower curves show returns when trades wait until filings become public.
These curves measure the effect of timing lookahead. The return levels reflect this specific basket and time window. You can recompute every value on this page from the source data file.
The three clocks
The strategy uses one trade rule: buy at the first open at or after the timestamp assigned to the filing, hold for five trading sessions, and sell at the close of the fifth session. Each arm uses a different timestamp rule.
| Curve | Moment it treats the filing as known | First auction it can reach | Reachable |
|---|---|---|---|
leaky |
The filing's index date at 00:00:00Z, the instant a join on the filed date implicitly anchors to. |
The morning of the filing's own index day. | No |
dump |
published_at, the day-end bound at 23:59:59Z on the index day. See timestamps. |
The next morning. | Yes |
pit |
acceptance_at, the receipt EDGAR wrote when it took the submission, where the corpus carries one. Rows without a stamp use published_at. |
Whichever session opens after that receipt. | Yes |
Midnight UTC occurs at 19:00 or 20:00 the previous evening in New
York. The leaky timestamp always falls before the
market open on the filing date, so leaky buys at that
open. The day-end bound is 18:59:59 in New York after market
close, so dump buys at the next morning's open. The
acceptance receipt provides the exact time of day. A filing
accepted at 07:12 ET trades that morning, while a filing accepted
at 17:22 ET waits for the next session.
The two realistic curves only diverge when an acceptance timestamp
changes the trading session. In this test, pit and
dump enter on different sessions for 17 of the 88
filings. They enter on the same session for the other 71 filings,
either because the receipt arrived after market close or because
the record has no acceptance receipt yet.
Two worked filings
3M filed 0000066740-22-000080 with an
EDGAR acceptance receipt at 2022-11-14 17:22:43 ET. The
leaky arm bought at the 2022-11-14 open at 09:30 ET,
which was 7.88 hours before EDGAR received the filing. This is the
largest timing error in the test. Across the 47 filings with this
error, the average lead time is 6.05 hours.
Boeing filed 0000012927-22-000077 with
a receipt of 2022-11-28 17:53:20 ET. EDGAR indexed the filing the
next day, setting its published_at to 2022-11-29 at
23:59:59Z. The pit arm reads the receipt time and
buys at the 2022-11-29 open for +7.07%. The dump arm
waits for the daily index cutoff and buys at the 2022-11-30 open
for +0.24%. Both arms trade the same filing one session apart.
The basket
The universe is the Dow Jones Industrial Average. Its membership did not change between 2020-08-31 and 2024-02-26, so the same 30 members cover the test window from 2022-11-01 through 2023-03-31 without substitutions.
To select twelve stocks from the thirty: keep members with available price data, rank them by number of 8-Ks filed during the window, select the top twelve, and break ties by ticker. This selection uses filing counts rather than price returns. The twelve tickers are AMGN, AXP, BA, CRM, CSCO, GS, HON, JPM, MMM, PG, V, and WMT. Filing counts appear in ablation.json.
All three arms use the same twelve stocks. Stock selection changes absolute return levels, but it does not cause the differences between arms. The reported returns apply only to this basket.
Filing records contain CIK numbers rather than tickers. Tickers
are mapped using a curated CIK table valid during the test window,
joined at each row's published_at timestamp. The
SEC's current company_tickers.json file omits SVB
Financial and Walgreens Boots Alliance, so joining against current
data would drop those 2023 filers.
The strategy
- Long only, with one position per 8-K. Exclude amendments (
8-K/A). - Buy at the opening auction allowed by the arm's timestamp. Hold for five sessions. Sell at the close of the fifth session.
- Equal weight across all open positions, rebalanced at market close. Sessions with no open positions earn 0% return. Idle cash earns no interest.
- The entry session return is close divided by open. Subsequent session returns are close divided by previous close.
- Two filings from the same issuer inside one hold window open separate positions, resulting in double weight while they overlap.
- No transaction costs, slippage, borrow fees, dividends, taxes, or short positions.
- All curves start indexed to 100 at the close on 2022-10-31, the session immediately before the window.
The holding period is fixed at five sessions.
Prices
Daily open and close prices come from Yahoo Finance's daily bar endpoint, fetched once at build time on 2026-08-27 and cached outside the repository. Prices are split-adjusted. None of the twelve stocks split during the window. Dividends are omitted.
The published data file contains only derived values: curve levels indexed to 100 and per-filing percentage returns. Raw price rows are not redistributed.
The benchmark originally used Stooq end-of-day CSV files. Stooq now requires a JavaScript challenge, so the build pipeline uses Yahoo Finance instead.
Exclusions
- SIVB: SVB Financial Group filed 10 8-Ks during the window and was attempted outside the index universe for that reason, but the price source provides no price bars. It is excluded from all curves.
- WBA: Walgreens Boots Alliance was an index member during the window, but the price source is missing data. It is excluded from all curves.
- If any arm cannot trade a filing (due to no remaining entry sessions or a hold extending past available price data), the filing is excluded from all three arms and recorded in
exclusions. This ensures all arms evaluate the exact same filings.
The test scanned 287,929 corpus rows for the window and traded 88
filings. 64 filings include an EDGAR acceptance receipt. The
remaining 24 fall back to the day-end bound. The pit
and dump curves will diverge further as missing
acceptance receipts are backfilled.
The measured result
| Curve | Total return | Max drawdown |
|---|---|---|
leaky | +5.13% | −13.83% |
dump | −2.02% | −17.58% |
pit | +0.18% | −16.91% |
The test covers 88 filings across 12 issuers over 105 sessions
from 2022-10-31 to 2023-03-31. The difference between
leaky and pit is 4.95 points, labeled
lookahead_inflation in the data file. The difference
between leaky and dump is 7.15 points.
The difference between pit and dump is
2.20 points.
Reading the numbers
The leaky performance gap is caused by lookahead
bias. The leaky arm trades one session before
dump on all 88 filings. On 47 of the 64 filings with
receipts, it trades hours before EDGAR received the filing. The
timing lead occurs on every filing in the sample.
The 2.20-point difference between pit and
dump occurs on the 17 filings where the arms entered
on different sessions. Across those 17 filings, the per-filing
return difference averages +0.95% with a standard deviation of
2.92%. The pit arm outperformed on 9 of the 17
filings. The mean is approximately 1.3 standard errors from zero.
The sample measures the size of the effect without establishing
its sign. The 2.20 points describe this basket over this window.
The sample covers one filing type, twelve issuers, and five months. The data file includes all per-filing details: accession number, both timestamps, entry sessions for each arm, and per-arm returns. You can recompute all summary statistics from the file.
Reproducing it
$ go run ./cmd/ablation
events 88 rows scanned 287929 sessions 105
acceptance stamped 64 fallback to published_at 24
leaky total_return +5.1287% max_drawdown -13.8255% trades 88
dump total_return -2.0185% max_drawdown -17.5796% trades 88
pit total_return +0.1779% max_drawdown -16.9131% trades 88
The generation script reads the corpus files, fetches prices into an external cache, and writes ablation.json. Object keys are alphabetical, arrays are sorted, floating-point numbers use fixed width, and the pull date comes from the price cache. Running the script with the same inputs produces identical output bytes.