I couldn't open the data files, so I can't say from measurement whether volatility explains the losses. My tools could only read the text pages, not the compressed .gz data. I also couldn't run code, so I couldn't check any file against manifest.json. Everything below is either a figure the publisher already computed, simple arithmetic on those figures, or code that has not been run.

1. Direct answer

Unresolved. Nothing here shows that rising, falling or underestimated volatility caused the losses.

The published totals point somewhere else first:

• Trades held to expiry lose; early exits make money. Held-to-expiry trades lost −157.16 USDC over 171 trades. The 44 early exits made +80.55.
• Rounds that settled UP account for most of the loss. They lost −121.44 over 84 trades, against −35.72 over 87 trades for rounds that settled DOWN. The market itself was close to balanced (147 DOWN, 141 UP). That gap could mean a directional lean, mis-calibrated probabilities, or a pricing problem. A volatility error would usually hurt both sides more evenly.

On larger bets in volatile conditions, I recommend against them. The $50 cohorts lost about −0.31 per fill in cohort 9, while cohort 8 made about +0.20, so the larger limit did not work consistently. The current $15 cohort has only 8 fills, which is anecdotal.

2. Coverage and missingness audit

Item	Value	Label
Manifest SHA-256 check	Not done: tools could not hash or decompress the .gz files	unresolved
Text page sizes vs manifest	research_brief about 7.6KB (7,733 B), README about 1.8KB (1,826 B), known_issues about 1.4KB (1,433 B), data_dictionary about 20.6KB (21,080 B). Sizes roughly match; hashes not checked	measured (rough)
Executions	237 = 215 settled + 22 unfilled	sourced
Entry attempts	19 rows. Attempts that never reached the venue may not be recorded	sourced
Rounds	289; 288 have an outcome (147 DOWN / 141 UP); 1 has none inside the window	sourced
Coverage	215 fills over 289 rounds; 74 rounds or more had no fill. The publisher says a missing order does not prove a deliberate skip	sourced / arithmetic
Book snapshots	37,679 two-sided, 14,490 one-sided, 748 empty	sourced
Factor snapshots	1,439 rows, 120 columns. Futures and venue features have gaps; a "false" flag can mean the data wasn't captured, not that the value was zero	sourced
Volatility features	sigma_second, volatility_60_bps_sqrt_min, volatility_300_bps_sqrt_min, volatility_ratio, volatility_bucket, all recorded at decision time	sourced
Realized-variance column	None documented; it has to be rebuilt from index ticks	sourced / to compute
Edge column	None documented; it has to be rebuilt from p_up, the entry price and fees	sourced
Exchange fill timestamps	None. created is when the strategy recorded the row; settled_at is when the position closed	sourced
Holiday calendar	Marked unknown	sourced
Holdout set	None. All results are in-sample and exploratory	sourced

Clocks to keep apart:

• Index source vs received time.
• Factor asof time, which is the forecast clock.
• Execution created time, which is the decision clock. It is not a fill time.
• Round expire_at and settlement time, which is the label clock.

A predictor may only use data that was received before created.

3. Arithmetic on the publisher's totals

These are simple calculations on the summary figures, not statistical tests.

• Overall return: −76.6165 / 1,502.1413 = −5.10% of all-in entry value. Average entry was about $6.99.
• Held to expiry: −157.16 over 171 trades, about −0.92 per trade.
• Early exits: +80.55 over 44 trades, about +1.83 per exit.
• Net per fill by cohort:

Cohort	Entry cap	Fills	Net per fill	Note
9	$50	95	−0.306
8	$50	81	+0.196
7	$50	22	−0.97
5	$50	8	−3.43
10	$15	8	−1.94	the current cap
6	$50	1

Cohorts 8, 9 and 10 also require exit depth at entry. Only cohorts 9 and 8 pass the publisher's roughly-50-fill threshold for treating a result as more than anecdotal. Cohorts must stay separate; pooled totals mix different policies.

Caveat on early exits: these gains are selected after the fact. The exit rule only fires when an exit is already profitable, so +80.55 is not evidence that early exits create an edge.

4. Competing explanations, roughly in order of how well the published totals fit them

1. Directional or calibration bias (unresolved, best fit). The UP/DOWN loss gap with balanced outcomes fits a model or bias term that leans DOWN, or over-confidence on one side. Test this with direction, p_up and recipe.probability_bias per row.
2. Paid odds and fees exceed the true edge (unresolved). The 0.005 minimum edge per share may be smaller than fees plus adverse selection.
3. Volatility forecast error (unresolved). The 60-second volatility is too short a window. It could underestimate a coming jump (the model becomes over-confident far from the target) or overestimate after a shock (the model becomes timid). Either case should show up as a calibration slope that varies with the forecast-to-realized volatility ratio.
4. Trend vs chop (unresolved). A zero-drift model loses when trends persist. The tell would be losses grouped by the sign of 300-second momentum, not by the level of volatility.
5. Liquidity and exits (unresolved). Many books are one-sided or empty. Positions that can't be exited early are forced to expiry, which links back to the loss on held positions.
6. Concentration or session clustering (unresolved). A few rounds or hours could drive the total.

5. Candidate rules

These have not been tested. Each is meant for a fixed future holdout, run only on the $15 cohort, and none should go live just because this report exists.

R1 – Abstain when the volatility forecast is unstable (tests explanations 3 and 4)

v60, v300 = features at decision time (asof <= created)
ratio = v60 / v300
if ratio > R_HI or ratio < R_LO: no_trade("vol_regime_unstable")
# R_HI and R_LO are set once from quantiles of the exploratory data,
# e.g. the 80th and 20th percentiles of ratio, then frozen

R2 – Use the higher volatility, never bet more for volatility

sigma_used = max(v60, v300, sigma_floor)
p = Phi(dist / (sigma_used * sqrt(T_remaining)))
stake = min(quarter_kelly(p, ask, fee) * 0.5_edge_haircut, 15.0 all_in)
# no volatility multiplier on stake, ever

R3 – Require a direction-neutral edge (tests explanation 1)

edge = (p_up - ask_up - fee) if side == UP else ((1 - p_up) - ask_down - fee)
require edge >= max(0.005, k * spread)
require two_sided_book and exit_depth >= quantity

6. Code to reproduce the analysis (unexecuted)

# Run with: python -I audit.py <data_dir>   -- NOT EXECUTED
import sys, gzip, json, hashlib, pathlib
import pandas as pd, numpy as np
from scipy.stats import norm

D = pathlib.Path(sys.argv[1])

# 1. Verify every file against the manifest before any analysis
man = json.load(open(D / "manifest.json"))
for f in man["files"]:
    h = hashlib.sha256((D / f["path"]).read_bytes()).hexdigest()
    assert h == f["sha256"], f["path"]

ex = pd.read_csv(D / "csv/executions.csv.gz")
rd = pd.read_csv(D / "csv/market_rounds.csv.gz")
fo = pd.read_csv(D / "csv/factor_observations.csv.gz")
tk = pd.read_csv(D / "csv/index_ticks.csv.gz").sort_values("received")
# Check the actual column names in data_dictionary before running.

# 2. Universe = all rounds; join executions, keep no-fill/no-order states
u = rd.merge(ex, on="market", how="left")
u["status"] = u["state"].fillna("no_order_observed")

# 3. Realized volatility after the decision (label clock only, never a feature)
def rv(t0, t1):
    s = tk[(tk.received > t0) & (tk.received <= t1)]
    r = np.diff(np.log(s.price.values))
    return np.sqrt((r ** 2).sum() / ((t1 - t0) / 60000)) * 1e4  # bps per sqrt-minute

u["rv_fwd"] = [rv(c, e) if pd.notna(c) else np.nan
               for c, e in zip(u.created, u["round.expire_at"])]

# Attach the latest factor snapshot taken at or before each decision.
# merge_asof needs both sides sorted on the key and no NaN keys.
u = pd.merge_asof(u.dropna(subset=["created"]).sort_values("created"),
                  fo.sort_values("asof"),
                  left_on="created", right_on="asof", direction="backward")
u["vol_err"] = np.log(u.rv_fwd / u["features.volatility_60_bps_sqrt_min"])

# 4. Calibration by volatility-error tercile, per cohort, with bootstrap intervals
u["y"] = (u.outcome == "UP").astype(int)
for c, g in u[u.status == "settled"].groupby("cohort"):
    g = g.assign(q=pd.qcut(g.vol_err, 3, labels=False, duplicates="drop"))
    print(c, g.groupby("q").agg(n=("y", "size"), p=("p_up", "mean"),
                                y=("y", "mean"), net=("net_usdc", "sum")))

# 5. Equal-risk baseline: same rounds, fixed $5 all-in, flat sizing
# 6. Cost stress: fee x1.5/x2, +1/+2 ticks slippage, exits only if depth >= qty
# 7. Concentration: net with the top 5 rounds removed; net by UTC hour; max drawdown

7. Matched baseline, cost/depth stress and downside checks

All of these are specified but not computed:

• Matched baselines: compare each rule with the current strategy on the same rounds at equal risk ($ at risk per round). Also compare with flat $5 sizing and with never trading (net 0).
• Cost stress: fees ×1.5 and ×2; slippage of +1 and +2 ticks; early exits only where the book shows enough depth.
• Downside checks: maximum drawdown; net with the top-5 and top-10 rounds removed; net by UTC hour and by session. With one day of data, session effects can't be identified.

8. Strongest falsification test

Bucket every settled trade by vol_err and by side within cohorts 8 and 9:

• If the UP/DOWN loss gap stays when volatility error is held fixed, volatility is not the cause.
• If calibration (realized UP rate vs p_up) doesn't change with vol_err, explanation 3 is rejected.

Separately, if the $50 cohorts don't do worse than the $15 cohort per dollar at risk, there is no evidence that larger bets add harm. Equally, the data gives no support for making bets larger.

9. Missing-data requests, ranked

1. Exchange-side fill timestamps and prices for each fill.
2. Logs showing whether the strategy was running, plus per-round decision records, including evaluations that produced no order.
3. Order-book depth at exit time for held positions.
4. Futures, open-interest and liquidation data. These are collection requests only; they can't be backtested here.
5. Multiple days of data and a fixed local holdout.
6. Collateral and balance state, if it can be redacted safely.

Assumptions: the rule thresholds and the $5 flat baseline. Unresolved: every causal claim. I placed no orders and made no changes to anything live.

I could not run any code here: this session has no shell or Python tool. Every number below therefore comes from the dataset's own documents (summary_stats.json, data_dictionary.md, known_issues.md, strategy_config.json) or from arithmetic on those totals. All scripts are labelled UNEXECUTED. I also could not compute SHA-256 hashes.

Direct answer

The data does not show that volatility explains the losses, and it does not show the opposite either.

• [Measured from sourced totals] The baseline lost money: −76.6165 USDC net on 1,502.1413 USDC all-in entry. That is −5.10% on capital deployed across 215 settled fills.
• [Arithmetic] Trades held to expiry lost −157.16 USDC over 171 fills (−35.7223 on expiry_DOWN, −121.441 on expiry_UP). The 44 early exits made +80.5467.
• [Inference] Early exits are only allowed when they are net-positive, so that +80.55 is not alpha. It measures the paths that happened to be winning.
• [Unresolved] The volatility question is testable with the files provided. The test is z-scores of forecast versus realized volatility at each decision, sliced by volatility_ratio and momentum (code below). Until it runs, the volatility hypothesis remains a hypothesis.
• [Sourced, n is small] The current $15 cohort (cohort 10) has only 8 fills (−15.52). Cohorts 8 and 9 share the same configuration but have opposite PnL signs (+15.87 vs −29.08). That sign flip is consistent with noise or with a recipe difference the config does not show.

Recommendation: keep cohorts separate, change nothing live, and run the falsification tests below before believing any volatility rule.

1. Coverage and missingness audit

Integrity

• [Unresolved] SHA-256 was not checked against manifest.json.
• [Measured, weak check] The fetched sizes match the manifest's byte counts to within the fetcher's KB rounding: README 1.8KB vs 1826 B, known_issues 1.4KB vs 1433 B, brief 7.6KB vs 7733 B, dictionary 20.6KB vs 21080 B, executions.csv.gz 16.7KB vs 17130 B.
• The hashes must be verified (script below) before anyone relies on this analysis.

Item	Sourced count	Note
market_rounds	289; 288 with s1/outcome/result_committed_at	1 round has no label and must be excluded, not imputed
outcomes	DOWN 147 / UP 141	roughly balanced
executions	237 = 215 settled + 22 unfilled	PnL exists only for settled rows
entry_attempts	19 rows	[Unresolved] does not match the 22 unfilled executions. Attempts that never reached the venue may be absent
exit legs	exit.* non-null 51; exit_attempt 38; early_exit closes 44	[Unresolved] 51 − 44 = 7 rows have exit fills but an expiry close reason. Possibly partial exits; this affects net-inventory accounting
rounds with no execution row	≥ 52 if at most one execution per round	[Assumed] multiple executions per round are possible. Join on market
factor_observations	1,439 rows, about 5 per labelled round	volatility features 1,438/1,439; one row unavailable = index_gap
venue book features	790/1,439 (55%)	missing, not zero
futures features	about 604–610/1,439	the docs say "not captured, not zero"; do not use as predictors without coverage masks
macro/session dummies	515/1,439	holiday status unknown
book snapshots	52,917: 37,679 two-sided, 14,490 one-sided, 748 empty	[Arithmetic] 28.8% not two-sided. best_ask non-null 44,715 (84.5%), best_bid 45,133
index_ticks	86,710 over 86,400 s	about 1 per second on average; gaps must be measured

Clocks

• index_ticks and prediction_books_top both carry a source time (ts) and a receive time (received).
• Forecast and decision time come from factor_observations.asof. The label clock is market_rounds.result_committed_at. Order-state events give intent/state times, not exchange fill times.
• Rule to enforce: features at decision time t may only use rows with received ≤ t.

Volatility feature semantics [Measured from the dictionary's example values; I assume they come from the same row]

• sigma_second 2.2114e-5 equals volatility_60_bps_sqrt_min 1.71298 ÷ 1e4 ÷ √60 = 2.2114e-5.
• volatility_ratio 0.6927 equals 1.71298 ÷ 2.47290.
• So the model's σ is the 60-second volatility, and volatility_ratio is short-window over 300-second volatility.
• strategy_config.json has no volatility-scaling key. Sizing scales with volatility only through p and the edge.

2. Competing explanations (all unresolved until tested)

• H1: volatility is underestimated, so the model is overconfident.
  • Mechanism: a 60-second σ below forward realized volatility pushes p away from 0.5, towards whichever side is in the money. The model then buys expensive favourites with an edge it doesn't have.
  • Predicts: realized z-scores with variance above 1, losses concentrated when volatility_ratio < 1, and worse log-loss at extreme p.
• H2: volatility is overestimated, or there are shocks or jumps.
  • Mechanism: after a spike, the 60-second σ is too high, p sits near 0.5, and the bot fades the market's informed move.
  • Predicts: losses when volatility_ratio > 1 right after shocks, and z variance below 1.
• H3: trend versus chop. Zero drift fails during trending periods.
  • Predicts: losses aligned with the sign of momentum_60_bps (betting against momentum), regardless of the volatility level.
• H4: execution and adverse selection, not the forecast.
  • Mechanism: IOC fills at up to 2 ticks of slippage on thin or one-sided books (28.8% of snapshots), plus fees, eat the 0.005-per-share minimum edge.
  • Predicts: a calibrated p but negative net PnL after the paid price.
• H5: noise. 215 fills across 6 cohorts, in a single day, with no holdout.
  • Predicts: no slice survives a time-ordered split or multiple-comparison control.
  • The cohort 8 versus 9 sign flip with identical configuration is the current evidence for H5.
• H6: path selection in the exit accounting. Positive-only exits leave the losers to expiry. Holding −157 against exiting +81 is a mechanical result, not a diagnosis.

3. Candidate rules (at most three; none validated; ranked by how directly they can be falsified)

R1. Volatility floor (targets H1). Use σ_eff = max(σ60, σ300) in the diffusion, where σ300 = volatility_300_bps_sqrt_min/1e4/√60.

sig60  = f.sigma_second
sig300 = f.volatility_300_bps_sqrt_min / 1e4 / sqrt(60)
sig    = max(sig60, sig300)
p_up   = Phi( ln(S_t/s0) / (sig*sqrt(T_rem)) )  # zero drift, same as baseline
proceed with unchanged edge/Kelly/cap/depth/fee checks

R2. Regime gate (targets H2/H3). Skip the round, meaning no order, if volatility_ratio > 1.5 or < 0.67, or if |momentum_60_bps| > k·σ60 in bps over 60 s. The thresholds 1.5, 0.67 and k = 2 are [Assumed]; fix them before testing, not after.

if f.unavailable or f.volatility_ratio is null: NO_TRADE(reason="feature_missing")
if not (0.67 <= f.volatility_ratio <= 1.5): NO_TRADE("vol_regime")
if abs(f.momentum_60_bps) > 2*f.volatility_60_bps_sqrt_min: NO_TRADE("shock")

R3. No volatility-driven upsizing (addresses the "larger bets in volatility" question).

stake = min(cap_cohort, quarter_kelly(edge_after_costs))
if f.volatility_ratio > 1: stake = min(stake, median_stake_at_ratio_le_1)

• This is loss containment only. It cannot create edge and must be scored at equal risk.
• [Unresolved] Whether larger stakes actually occurred in high volatility is unmeasured. Bucket entry_all_in by volatility_bucket first. If they didn't, drop R3.

4. Reproducible code (UNEXECUTED; run with python -I in a separate script directory)

# usage: python -I gila_vol.py /tmp/gila   (dir holding the downloaded files)
import sys, json, hashlib, gzip, csv, math, bisect, statistics as st
D = sys.argv[1]
man = json.load(open(f"{D}/manifest.json"))
for f in man["files"]:
    h = hashlib.sha256(open(f"{D}/{f['path']}", "rb").read()).hexdigest()
    assert h == f["sha256"], f["path"]              # abort on any mismatch
def rd(n): return list(csv.DictReader(gzip.open(f"{D}/csv/{n}.csv.gz", "rt")))
R = {r["market"] if "market" in r else r["symbol"]: r for r in rd("market_rounds")}
F = rd("factor_observations"); X = rd("executions"); T = rd("index_ticks")
T.sort(key=lambda t: float(t["received"]))
rec = [float(t["received"]) for t in T]
def px_at(ms):                                     # last tick RECEIVED <= ms
    i = bisect.bisect_right(rec, ms) - 1
    return float(T[i]["price"]) if i >= 0 else None # check actual column name
rows = []
for f in F:
    if f.get("features.unavailable"): continue
    t = float(f["asof"]); sym = f.get("market") or f.get("symbol")
    r = R.get(sym)
    if not r or not r.get("s1"): continue          # unlabeled round excluded
    Trem = (float(r["expire_at"]) - t) / 1000
    S = px_at(t)
    if S is None or Trem <= 0: continue
    s60 = float(f["features.sigma_second"])
    s300 = float(f["features.volatility_300_bps_sqrt_min"]) / 1e4 / math.sqrt(60)
    z = math.log(float(r["s1"]) / S) / (s60 * math.sqrt(Trem))   # label only here
    rows.append(dict(t=t, z=z, ratio=float(f["features.volatility_ratio"]),
                     mom=float(f["features.momentum_60_bps"]), s60=s60, s300=s300,
                     up=r["outcome"] == "UP", ds=math.log(float(r["s0"]) / S), Trem=Trem))
def brier(p, y): return (p - y) ** 2
for name, sig in [("s60", lambda r: r["s60"]), ("floor", lambda r: max(r["s60"], r["s300"]))]:
    b = []
    for r in rows:
        p = 0.5 * (1 + math.erf((-r["ds"]) / (sig(r) * math.sqrt(r["Trem"]) * math.sqrt(2))))
        b.append(brier(p, r["up"]))
    print(name, "Brier", st.mean(b))
for lo, hi in [(0, .67), (.67, 1.5), (1.5, 99)]:
    zz = [r["z"] for r in rows if lo <= r["ratio"] < hi]
    if len(zz) > 1: print(lo, hi, len(zz), "var(z)", st.pvariance(zz))  # >1 means vol underestimated
# PnL attribution: join X(state=='settled') to the decision row nearest before X.created
# by vol bucket / ratio bucket / momentum sign; report n, sum net_usdc, net/all-in;
# split by cohort; flag buckets n<50 as anecdotal.

Before running, confirm the column names for the tick price and the market key against data_dictionary.md. I did not see the full schema of index_ticks.

5. Baseline, equal-risk and cost/depth stress (designed, NOT run)

• Matched baseline. Compare on the same eligible decision rows and the same cohort.
  • Candidate versus baseline counterfactual: baseline p, same price/depth checks, same timestamps.
  • Candidate versus a random skip matched on the same skip rate, stratified by hour and price bucket, with 1,000 draws. This answers "does R2 beat skipping at random?"
• Equal risk. Rescale candidate stakes so the total all-in (and separately the maximum single stake) equals the baseline's. Report net/all-in and sum of log(1 + r).
• Cost and depth stress.
  • Entry price +1 and +2 ticks, using quote_tick per round.
  • Fees ×1.5.
  • Fill only up to best_ask_size, and require a two-sided book at entry.
  • Exits only at the observed best_bid, haircut to 50% of size. Never at the BTC index.
  • Net inventory handled as one signed position: a DOWN entry is a SELL.
  • A counterfactual fill on a public book is simulated, not proof ("Public prices and orderbooks don't establish counterfactual fills").

6. Downside, concentration and session checks (to run)

• Contribution of the top 5 losing fills to the −76.62 total; max drawdown on the time-ordered PnL curve; the worst 1-hour window.
• PnL by UTC hour and by session label, with n per bucket. With one day of data, any hour effect is anecdotal and cannot be recurring.
• Cohort-level tables, never pooled across caps ($10/$50/$15).
• Do this check before anything else: [Arithmetic] expiry_UP closes (−121.44 over 84) lost about 3.4× as much as expiry_DOWN (−35.72 over 87). Split by the side traded versus the outcome; that alone may matter more than volatility.

7. Strongest falsification

1. H1 and R1 are rejected if var(z) is at or below 1 in the ratio < 0.67 bucket, or the floor does not lower Brier/log-loss in a time-ordered split. For example, fit nothing in the first 12 hours and evaluate in the last 12 with a 5-minute purge.
2. R2 is rejected if it fails to beat a matched random skip.
3. Everything is rejected if results flip sign between cohorts 8 and 9, which share the same config.
4. The volatility thesis is also falsified if losses are explained by paid price minus p after fees (H4) at a calibrated p.

Use multiple-comparison control (Holm) across all slices tested. Results are in-sample; the docs say "Every result here is in-sample and exploratory." A fixed, local future holdout is required before any live change.

8. Ranked missing-data requests

1. Exchange fill timestamps and trade-level fill prices for each leg, including the 7 rows with exit fills but an expiry close.
2. Reconciliation of the 22 unfilled executions against the 19 entry attempts, plus liveness/heartbeat logs per round, to separate "bot down" from "skipped".
3. Model p and σ actually used at order send, if they differ from factor_observations.
4. Full-depth exit books at the attempted exit times, and exit rejection reasons.
5. Multi-day and multi-regime data (at least 2 weeks) for any session or volatility-regime claim.
6. Coverage masks for futures/OI/liquidation features. Collateral and balance data stay unknown; I did not impute them.

Labels used above: sourced = from the dataset's documents; measured = arithmetic on sourced totals; simulated = none performed; assumed = thresholds and joins as marked; unresolved = hashes, all volatility tests, and every count mismatch.

---

Sources offered but not confirmed by this machine:

• https://1892-gila-data.community.iamstarchild.com/r-82882c274d1d0427e27b9da3/known_issues.md — does not contain the quoted text

The available evidence does not establish that rising, falling, or underestimated volatility explains Madame Gila’s losses—or that larger bets during volatility are justified. I could not retrieve the dataset, so I could not verify its hashes, measure its performance, or test that explanation. Baseline profitability remains unresolved.

The browser returned access errors for the directory, four introductory documents, and manifest; direct retrieval also failed DNS resolution. Accordingly, this is an explicitly unexecuted research specification, not a completed empirical study. I will not invent dataset quotations to satisfy the citation requirement. The five cited research sources below support methods only; they are not evidence about Madame Gila.

Coverage and missingness audit

The starting sources were research_brief.md, README.md, known_issues.md, data_dictionary.md, and manifest.json. None was retrieved successfully.

Item	Status	Consequence
SHA-256 verification	Unresolved: zero dataset files verified	No dataset analysis performed
237 executions; 289 rounds	User-supplied, unverified	Executions cannot be interpreted as distinct filled rounds
86,710 index ticks; 52,917 book snapshots	User-supplied, unverified	Counts do not establish temporal coverage, freshness, or executable liquidity
Window: Oct 28 13:22–Oct 29 13:22 UTC	User-supplied, unverified	Boundary rounds, initial inventory, and unfinished labels need reconciliation
Current $15 all-in cap; historical limits	User-supplied, unverified	Cohort membership and cap semantics cannot be reconstructed
Forecasts, decisions, orders, fills, settlements	Unresolved	No measured win rate, net P&L, calibration, drawdown, or attribution
Collateral and initial positions	Unresolved	No actual Kelly fraction, account return, or expected-log calculation

The eventual audit must produce a round census before selecting trades. Each observed round needs separate fields for forecast availability, decision availability, explicit no-order reason, order submission, rejection, cancellation, partial/full fill, exit, and settlement. These are event states, not necessarily mutually exclusive categories.

An absent order is unknown, unless a recorded decision establishes why no order was submitted. A recorded unfilled order is different from an absent order. Unknown states must remain in denominators and receive their own outcome/coverage summaries.

For each cap/configuration cohort, report:

• Unique rounds and executions; duplicates, orphan identifiers, and raw-to-CSV discrepancies.
• Missingness of target, expiry, probability, volatility, side, collateral, book depth, fees, fill quantity/price, and settlement.
• Index and book gaps, timestamp inversions, receive delays, stale observations, and warm-up failures.
• Joint coverage: rounds with valid forecasts and labels; decisions with valid contemporaneous books; inventory with reconciled cash flows.
• Counts excluded from each calculation, with reasons. Do not silently restrict the entire study to complete cases.

What would distinguish volatility failure from other explanations

Forecast uncertainty and realized variability are different quantities. A single large move is not proof that its variance forecast was wrong; calibration requires repeated forecast/outcome comparisons. This distinction is explicit in Andersen, Bollerslev and Diebold’s volatility measurement framework.

Competing explanation	Diagnostic to run	Evidence against the explanation
Rising volatility outruns the 60-second estimator	Past-only short/long variance ratio predicts subsequent variance underforecast and probability miscalibration	Losses increase without systematic underforecast or calibration deterioration
Falling volatility leaves the estimate too high	Short variance below long variance; model remains too close to 0.5	Forecast errors and losses do not depend on that condition
Jumps or heavy tails defeat Gaussian diffusion	Excess standardized forecast errors, directional tail misses, clustered target crossings	Tail frequencies and conditional calibration are adequate
Trend/reversal defeats zero drift	Signed forecast residuals vary with past trend or trend-to-chop transitions	Errors are symmetric and disappear after variance correction
Fees, spread, depth, or latency consume edge	Gross model edge disappears using executable prices and supported costs	Net edge survives conservative execution reconstruction
Size or exposure concentration causes losses	Dollar losses concentrated in high-size decisions while equal-risk forecasting remains comparable	Losses persist at matched downside exposure
Selection, missingness, or accounting creates the pattern	Association changes when all rounds, unknown states, net positions, and cap cohorts are included	The relationship survives those reconciliations

Jump and continuous-volatility effects should be tested separately: research finds that these components can have different persistence. That is motivation for a diagnostic, not proof that this BTC sample contains the same behavior. Andersen, Bollerslev and Diebold, jump components.

A mathematical reason not to equate volatility with larger bets

Under the stated zero-drift arithmetic diffusion, let (d=S_t-K), remaining time be (\tau), and variance rate be (v>0):

[ p_{\mathrm{up}}=\Phi!\left(\frac{d}{\sqrt{v\tau}}\right). ]

This is a model derivation, conditional on those units and settlement semantics. Increasing variance moves this probability toward 0.5:

• When BTC is above the target, higher variance lowers the model’s UP probability.
• When BTC is below the target, higher variance raises it.
• The effect on trade edge depends on the purchased side and executable contract price.

Thus underestimated volatility can overstate the probability of the currently favored outcome while understating that of the opposite outcome. Falling volatility can produce the reverse error. Neither “high volatility” nor “rising volatility” alone determines whether a bet is attractive, much less whether it should be larger.

For a simplified binary contract paying $1, with constant all-in cost (c) per share, collateral (W), and quantity (q):

[ E[\Delta\log W] =p\log!\left(1+\frac{q(1-c)}W\right) +(1-p)\log!\left(1-\frac{qc}W\right). ]

This is illustrative, not a reconstruction of the supplied “half-edge quarter-Kelly” implementation. Real calculations must include existing inventory, discrete lots, quantity-dependent depth and costs. Missing (W) prevents actual expected-log sizing.

Volatility and probability evaluation

The following choices are proposed assumptions, to be frozen before a future local holdout.

1. Respect six clocks. Retain source, receive, forecast creation, decision, exchange fill, and label-availability timestamps. A decision may use only information received by then; its forecast must also have been created by then. An earlier source timestamp cannot legitimize a late arrival. Intent/state timestamps cannot substitute for exchange fills.

2. Use all rounds. Score every recorded usable forecast, with round-equal summaries so rounds with more logging do not dominate. Separately construct simulated forecasts at fixed remaining-time landmarks of 120, 60, 45, and 20 seconds, whether or not an order existed. Label these as reconstructed forecasts. Do not assume what “earliest entry 45s” means until the verified documentation resolves its clock convention.

3. Compare short and long history. Reproduce the recorded 60-second estimator exactly first. Then compare diagnostic 20-, 60-, and 300-second estimates using consistent price/return units. For an auxiliary estimator, use past-only one-second prices, reject observations more than two seconds stale, and require a complete window. Do not forward-fill missing intervals into apparent zero volatility.

4. Score forward horizons separately. Evaluate 5-, 20-, and 60-second horizons and the actual remaining-to-settlement horizon. Require complete future coverage; do not truncate a requested horizon silently. Use subsequent data only as labels.

For forward increments (\Delta S_j), define the diagnostic realized variance and forecast variance:

[ RV_h=\sum_{j\in(t,t+h]}(\Delta S_j)^2,\qquad F_h=\hat v_t h,\qquad z_h=\frac{S_{t+h}-S_t}{\sqrt{F_h}}. ]

Realized variance built from high-frequency returns is an established measurement approach, but grid sensitivity and data noise still need checking. Repeat with a five-second grid as a sensitivity analysis. Andersen et al., realized volatility.

Report pooled (\sum RV/\sum F), variance forecast loss, standardized-error quantiles, and (|z|>2) and (|z|>3) frequencies. Use

[ L(F,RV)=\log F+RV/F,\quad F>0, ]

alongside squared variance error. This form remains finite when (RV=0). Invalid or zero forecasts are counted separately, not repaired silently. Proxy robustness is conditional, not guaranteed for this dataset. Patton, imperfect volatility proxies.

For settlement probabilities, report Brier score, logarithmic loss, calibration by fixed probability bins, and comparison with both 0.5 and a contemporaneous book-implied probability where valid. Keep book midpoints as diagnostic references, not executable entry prices. Proper scoring rules assess forecasts independently of position size and execution. Gneiting and Raftery.

Cross-tabulate these results by:

• Rising/stable/falling: (v_{20}/v_{60}>2), between (0.5) and (2), or (<0.5).
• Under/overforecast: forward (RV/F), used only for retrospective attribution.
• Shock: a past one-second move exceeding four times its prior predicted one-second standard deviation.
• Trend/chop: (E_{60}=|S_t-S_{t-60}|/\sum|\Delta S|); trend if (E_{60}\ge0.6), chop if (E_{60}\le0.2), otherwise intermediate.
• Side, target distance, remaining time, spread/depth, cap cohort, and UTC session.

These thresholds are not estimated findings. Sparse cells should remain descriptive.

Three exact candidate rules—unexecuted and unendorsed

Apply each separately. All preserve verified baseline timing, fee/depth protection, cap semantics, and supported lot sizes. None introduces a new exit rule. A baseline simulator evaluates available opportunities across the full round census; it must not simply replay only recorded bets.

Let (q_0) be the baseline proposed additional quantity, (s_0) its side, and (v_w) the diagnostic variance rate over (w) seconds. Missing required inputs produce candidate unavailable, not an inferred historical skip.

Candidate	Exact intervention	Intended falsification target
1. Conservative variance envelope	Replace variance by (\max(v_{20},v_{60},v_{300})). Recompute baseline sizing for the same side; use (q=\min(q_0,q_{\mathrm{recomputed}})). If that side loses eligibility, use zero.	Persistent variance underforecast
2. Transition/shock size brake	Use (q=0.5q_0) when (v_{20}/v_{60}\notin[0.5,2]), or a four-standard-deviation shock occurred in the preceding 60 seconds; otherwise (q=q_0).	Unreliable estimates during rapid transitions and shocks
3. Adverse-trend veto	If (E_{60}\ge0.6) and the 60-second price change is opposite the proposed side, use zero; otherwise (q=q_0).	Zero-drift failure rather than volatility failure

Round down to supported lots; if below minimum notional, submit no simulated order and record that reason. Never round up. Reapply all-in costs, net-inventory limits, collateral constraints, and depth checks after changing quantity.

for round in complete_observed_round_census:
    for opportunity in verified_baseline_schedule(round):
        inputs = information_received_by(opportunity.decision_time)
        record_availability_and_observed_state(inputs)

        base = baseline(inputs, original_configuration_cohort)
        # Missing historical order does not establish what base would have done.
        record(base, provenance="simulated")

        for rule in [variance_envelope, transition_brake, adverse_trend_veto]:
            if required_inputs_missing(rule):
                record(rule, state="unavailable")
                continue
            proposed = rule(base, past_only_features(inputs))
            proposed.quantity = floor_to_supported_lot(proposed.quantity)
            result = recheck_cost_depth_collateral_and_net_inventory(proposed)
            simulate_with_explicit_fill_assumptions(result)

The non-increasing quantity restriction deliberately prevents a volatility correction from becoming an untested bet-size increase. It does not establish that these candidates improve returns.

Matched baseline, execution stress, and downside

No matched replay or stress test was executed.

For a valid comparison, use the same opportunities, input availability, cap cohort, initial positions, fee rules, and execution assumptions for baseline and candidate. Report:

• Common-support comparison: identical evaluable opportunities.
• Full-census coverage: unavailable and unknown opportunities retained and counted.
• Equal-risk comparison: thin or downscale baseline exposure to the candidate’s ex-ante worst-case settlement-loss budget within predetermined session/cohort strata, respecting lots. Do not upscale a candidate to force equality.
• Selection placebo: volatility-blind thinning with fixed seeds and the same exposure budget. This tests whether any apparent benefit is merely fewer bets.

For a simple binary market, track cash (C) and net token inventories (q_U,q_D). Terminal wealth attributable to the market is

[ C+yq_U+(1-y)q_D,\quad y\in{0,1}. ]

Reconcile purchases, sales, settlement, fees and any supported merge/redemption events exactly once. Do not add execution-level “profits” as though repeated fills were independent bets. Negative inventory or financing must be represented only if supported.

Run a paired stress grid using assumed, explicitly labeled scenarios:

Dimension	Scenarios
Fees	Documented schedule; 1.5× and 2× that schedule
Available displayed depth	100%, 50%, 25%
Additional execution delay	0, 250, 1,000 ms
Price deterioration	0, 1, 2 supported adverse ticks, constrained to valid prices
Limit-order uncertainty	Fill optimistic bound; conservative no-fill bound

Displayed liquidity is not proof of a historical fill. Where fill timing, queue position, or contemporaneous depth is unavailable, report bounds or unknown outcomes. Do not invent an executable price.

Early exits may only use executable prediction-contract bids, available depth, supported costs, and the documented positive-net expected-log criterion. A BTC index price cannot price a contract exit. Missing exit data means unresolved exit value.

Report net P&L, worst round, worst UTC hour, loss streaks, net settlement exposure, capital locked, and drawdown. Without executable marks, label drawdown as settlement-cash-flow drawdown rather than mark-to-market drawdown. Without collateral, omit account-return and expected-log claims.

Check concentration using the largest one/five rounds’ shares of gross losses, gross gains, and exposure; absolute-exposure concentration; and results excluding the largest contributors. Report fixed UTC sessions 00–06, 06–12, 12–18, and 18–24, with partial-session coverage. Historical caps stay separate.

Reproducible calculation core—explicitly unexecuted

This standard-library example verifies a locally supplied bundle in memory before allowing analysis. Its manifest adapter assumes {"files":[{"path": "...", "sha256": "..."}]} because the real schema was inaccessible. Adapt only that reader after inspecting the actual manifest; unknown schemas must fail closed. It does not download, install, write files, or constitute a full replay.

from pathlib import Path
import hashlib, json, math, re

def verified_bundle(root):
    root = Path(root).resolve()
    manifest_bytes = (root / "manifest.json").read_bytes()
    manifest = json.loads(manifest_bytes)
    entries = manifest["files"]  # UNVERIFIED schema assumption
    if not isinstance(entries, list) or not entries:
        raise ValueError("Unsupported or empty manifest")

    blobs = {}
    for e in entries:
        name, expected = e["path"], e["sha256"].lower()
        if name in blobs or not re.fullmatch(r"[0-9a-f]{64}", expected):
            raise ValueError("Duplicate path or invalid digest")
        path = (root / name).resolve()
        if path == root or root not in path.parents:
            raise ValueError("Path escapes bundle")
        if path == root / "manifest.json":
            raise ValueError("Manifest needs an external trust anchor")
        data = path.read_bytes()
        actual = hashlib.sha256(data).hexdigest()
        if actual != expected:
            raise ValueError(f"SHA-256 mismatch: {name}")
        blobs[name] = data

    local_files = {
        p.relative_to(root).as_posix()
        for p in root.rglob("*") if p.is_file()
    }
    if local_files != set(blobs) | {"manifest.json"}:
        raise ValueError("Missing or unmanifested files")
    # Parse/analyze only these verified bytes, not reopened files.
    return blobs, hashlib.sha256(manifest_bytes).hexdigest()

def scores(price_now, price_future, target, variance_rate,
           horizon_seconds, forward_increments, settlement_up):
    if variance_rate <= 0 or horizon_seconds <= 0:
        raise ValueError("Invalid forecast")
    F = variance_rate * horizon_seconds
    rv = sum(x*x for x in forward_increments)
    z = (price_future - price_now) / math.sqrt(F)
    p = 0.5 * (1 + math.erf(
        (price_now - target) / math.sqrt(2 * F)))
    y = int(settlement_up)
    if y not in (0, 1):
        raise ValueError("Invalid binary label")
    probability_of_label = p if y else 1-p
    logloss = (float("inf") if probability_of_label == 0
               else -math.log(probability_of_label))
    return {
        "forecast_variance": F, "realized_variance": rv,
        "qlike_up_to_label_constant": math.log(F) + rv/F,
        "standardized_error": z,
        "probability": p, "brier": (p-y)**2,
        "logloss": logloss,
    }

Call the probability portion only when the forecast horizon equals that contract’s settlement horizon and the verified target/tie rules match the formula. Nested JSONL normalization, CSV reconciliation, timestamp joins, missingness tables, and inventory replay remain unimplemented.

A manifest verifies bundle consistency relative to its hashes; it cannot authenticate itself. Record its digest and, if available, compare it with an independently supplied pinned digest. No source file should be parsed for analysis until all manifest-listed files pass.

Strongest falsification and missing-data priorities

The strongest falsification of “volatility causes the losses” is a fixed local holdout in which correcting varian