edgeorluck 2.0.0__py3-none-any.whl

edgeorluck/__init__.py

@@ -0,0 +1,16 @@
+"""edge or luck: is a trading record a real edge, or luck?
+
+    import edgeorluck
+    result = edgeorluck.judge("trades.csv", variants_tried=40)
+    print(result["verdict"]["headline"])
+    print(result.to_markdown())
+
+Pure: reads its input, writes nothing, and the same input always gives the
+same result. Not financial advice: a statistical check of past trades.
+"""
+from .judge import CHANGELOG, ENGINE_VERSION, SCHEMA_VERSION
+from .result import Result, judge
+from .schema import schema
+
+__version__ = ENGINE_VERSION
+__all__ = ["judge", "schema", "Result", "ENGINE_VERSION", "SCHEMA_VERSION", "CHANGELOG", "__version__"]

edgeorluck/cli.py

@@ -0,0 +1,92 @@
+"""The command line.
+
+    edgeorluck trades.csv [--tried 50] [--benchmark 34.5] [--json | --md]
+    edgeorluck live.csv --backtest backtest.csv
+    edgeorluck -                       # read the trades from stdin
+    edgeorluck --schema                # the result's JSON Schema
+    edgeorluck --serve [--port 5078]   # the web app (needs edgeorluck[web])
+    edgeorluck --single-file out.py    # the judge in one file, for chatbots
+
+Several files are judged one by one. Exit code 0 when judged, 2 when the
+input needs something (status need_input), 1 on an error.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import List, Optional
+
+from .judge import ENGINE_VERSION
+from .result import judge
+from .schema import schema
+
+
+def _parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="edgeorluck",
+                                description="Is a trading record a real edge, or luck? Give it a trade export "
+                                            "(TradingView list of trades, exchange fills, any CSV with a P&L "
+                                            "column, XLSX, freqtrade JSON) or '-' for stdin.")
+    p.add_argument("files", nargs="*", help="trade exports to judge, one by one")
+    p.add_argument("--tried", "--variants-tried", dest="tried",
+                   help="how many versions or settings were tried in all (raises the bar)")
+    p.add_argument("--benchmark", help="what buying and holding returned over the same dates, in percent")
+    p.add_argument("--fees", help="are fees included? yes or no")
+    p.add_argument("--source", help="backtest, paper or live")
+    p.add_argument("--unit", help="'%%' or a currency like USDT, when the file doesn't say")
+    p.add_argument("--kind", help="auto, trades, fills, tradingview or pnl")
+    p.add_argument("--backtest", help="the backtest's trades, to check live trades against")
+    out = p.add_mutually_exclusive_group()
+    out.add_argument("--json", action="store_true", help="print the JSON result")
+    out.add_argument("--md", action="store_true", help="print Markdown (the default)")
+    p.add_argument("--schema", action="store_true", help="print the result's JSON Schema and exit")
+    p.add_argument("--serve", action="store_true", help="run the web app with waitress")
+    p.add_argument("--host", default="127.0.0.1", help="web app host (default 127.0.0.1)")
+    p.add_argument("--port", type=int, default=None, help="web app port (default $PORT or 5078)")
+    p.add_argument("--single-file", nargs="?", const="edgeorluck_single.py", metavar="PATH",
+                   help="write the one-file build and exit")
+    p.add_argument("--version", action="version", version=f"edgeorluck {ENGINE_VERSION}")
+    return p
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    args = _parser().parse_args(argv)
+    if args.schema:
+        print(json.dumps(schema(), indent=2))
+        return 0
+    if args.single_file:
+        from .single import write
+        print(write(args.single_file))
+        return 0
+    if args.serve:
+        try:
+            from .web.app import serve
+        except ImportError:
+            print("The web app needs: pip install 'edgeorluck[web]'", file=sys.stderr)
+            return 1
+        serve(host=args.host, port=args.port)
+        return 0
+    if not args.files:
+        _parser().print_help()
+        return 2
+    worst = 0
+    for i, path in enumerate(args.files):
+        data = sys.stdin.buffer.read() if path == "-" else path
+        result = judge(data, variants_tried=args.tried, benchmark_return_pct=args.benchmark, kind=args.kind,
+                       unit=args.unit, fees_included=args.fees, source=args.source, backtest=args.backtest)
+        if i:
+            print()
+        text = result.to_json() if args.json else result.to_markdown()
+        try:
+            print(text)
+        except UnicodeEncodeError:
+            sys.stdout.buffer.write((text + "\n").encode("utf-8"))
+        if result.status == "need_input":
+            worst = max(worst, 2)
+        elif result.status == "error":
+            worst = max(worst, 1) if worst != 2 else worst
+    return worst
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

edgeorluck/compare.py

@@ -0,0 +1,146 @@
+"""Backtest vs live: are the live trades behaving like the backtest promised?
+
+The backtest is a finished sample; live trades keep coming and the trader
+checks often. So the live average gets an anytime-valid range (one side at
+1.25%), the backtest average a fixed-sample range (one side at 1.25%), and
+the difference range is their union: valid at 95% however often the live
+side is checked. "Worse than the backtest" means the whole difference range
+is below zero, which is the same as the live e-value against the backtest's
+pessimistic average reaching 80.
+
+Next to it, plain odds (one look): if live trades were drawn from the
+backtest's own trades, how often would a live record this weak happen?
+"""
+from __future__ import annotations
+
+import hashlib
+import math
+from typing import Any, Dict, Optional
+
+import numpy as np
+
+from .evidence import half_width, log_e_one_sided, mixing_rho2, serial_factor
+from .readers import ReadResult, Trades
+from .words import count, fmt, one_in, rnd
+
+MIN_LIVE = 10
+BAR = 80.0                      # one side at 1.25% for the live side
+Z_BACKTEST = 2.2414             # one side at 1.25% for the backtest side
+DRAW_CELLS = 2_000_000
+
+
+def _live_sd(x: np.ndarray) -> float:
+    if len(x) < 2:
+        return float("nan")
+    sd = float(np.std(x, ddof=1))
+    return max(sd, 1e-12) * math.sqrt(serial_factor(x))
+
+
+def _pick(read: ReadResult, name: Optional[str] = None) -> Optional[Trades]:
+    if not read.strategies:
+        return None
+    if name:
+        for st in read.strategies:
+            if st.name == name:
+                return st
+    return read.strategies[0]
+
+
+def _series(st: Trades, unit: str) -> Optional[np.ndarray]:
+    if st.unit == unit:
+        return st.pnl
+    if unit == "%" and st.pct is not None and np.isfinite(st.pct).all():
+        return st.pct
+    return None
+
+
+def compare_runs(live_read: ReadResult, backtest_read: ReadResult) -> Dict[str, Any]:
+    why = ("A backtest is a promise. Live trades show whether the promise holds, and the sooner you know, the less "
+           "it costs.")
+    live = _pick(live_read)
+    bt = _pick(backtest_read, live.name if live else None)
+    if live is None or bt is None:
+        missing = "live trades" if live is None else "backtest trades"
+        return {"code": "need_input", "label": "Can't compare", "tone": "muted",
+                "headline": f"Can't compare: no {missing} found.",
+                "plain": (backtest_read.need or live_read.need or {}).get("problem", ""), "why": why,
+                "next_step": {"text": "Send both files: the backtest's list of trades and the live trades.",
+                              "why": "The comparison needs one result per trade on both sides."}}
+    unit = live.unit if live.unit == bt.unit else "%"
+    x, y = _series(live, unit), _series(bt, unit)
+    if x is None or y is None:
+        return {"code": "units_differ", "label": "Can't compare", "tone": "muted",
+                "headline": f"Can't compare: the live trades are in {live.unit} and the backtest in {bt.unit}.",
+                "plain": "Export both in the same unit, or with a percent column, and check again.", "why": why,
+                "next_step": {"text": "Export both lists with a percent-per-trade column, then compare again.",
+                              "why": "Money per trade depends on position size; percent compares like with like."}}
+    n, nb = len(x), len(y)
+    mean_l, mean_b = float(np.mean(x)), float(np.mean(y)) if nb else float("nan")
+    base = {"live": {"name": live.name, "trades": n, "mean": rnd(mean_l), "unit": unit},
+            "backtest": {"name": bt.name, "trades": nb, "mean": rnd(mean_b), "unit": unit},
+            "unit_compared": unit, "why": why}
+    if nb < 30:
+        return dict(base, code="too_early", label="Too early", tone="muted",
+                    headline=f"The backtest has only {count(nb, 'trade')}; it can't set a standard yet.",
+                    plain="A backtest needs at least 30 trades to say what to expect.",
+                    next_step={"text": "Run the backtest over a longer period, then compare again.",
+                               "why": "A short backtest promises very little."})
+    sd_l, sd_b = _live_sd(x), _live_sd(y)
+    h_live = half_width(n, sd_l, BAR) if n >= 2 else math.inf
+    h_bt = Z_BACKTEST * sd_b / math.sqrt(nb)
+    diff = mean_l - mean_b
+    lo, hi = diff - h_live - h_bt, diff + h_live + h_bt
+    floor = mean_b - h_bt
+    log_e = log_e_one_sided(n, float(np.sum(x - floor)), sd_l, mixing_rho2(BAR), -1) if n >= 2 else 0.0
+    p = _odds(x, y)
+    odds = one_in(p, _draws(n))
+    base.update(difference={"value": rnd(diff), "range_95": [rnd(lo), rnd(hi)]}, odds=rnd(p), odds_text=odds,
+                e_value_worse=rnd(math.exp(min(log_e, 700))), bar=BAR)
+    if n < MIN_LIVE:
+        return dict(base, code="too_early", label="Too early", tone="muted",
+                    headline=f"Too early to compare: {count(n, 'live trade')} so far.",
+                    plain=f"Live averages {fmt(mean_l, unit)} per trade and the backtest {fmt(mean_b, unit)}. With "
+                          f"{count(n, 'trade')}, luck decides almost everything.",
+                    next_step={"text": f"Collect at least {MIN_LIVE - n} more live trades, then compare again.",
+                               "why": "A handful of trades can't tell a broken strategy from a bad week."})
+    if hi < 0:
+        return dict(base, code="worse_than_backtest", label="Worse than the backtest", tone="bad",
+                    headline=f"Live is worse than the backtest promised: {fmt(mean_l, unit)} per trade live, "
+                             f"{fmt(mean_b, unit)} in the backtest.",
+                    plain=f"Over {count(n, 'live trade')} the gap is {fmt(diff, unit)} per trade (likely "
+                          f"{fmt(lo, unit)} to {fmt(hi, unit)}). If live trades were like the backtest's, a live "
+                          f"record this weak would happen {odds} times. The backtest was likely too kind: fees, "
+                          "fills, or rules tuned to the past.",
+                    next_step={"text": "Compare the live fills with the backtest's: fees, slippage and the exact "
+                                       "entry prices. Ask your AI to look for lookahead in the backtest.",
+                               "why": "The gap between backtest and live almost always comes from costs, fills or "
+                                      "a backtest that saw the future."})
+    gap_text = (f" If live trades were like the backtest's, a live record this weak would happen {odds} times."
+                if diff < 0 else "")
+    return dict(base, code="consistent", label="In line with the backtest", tone="good" if diff >= 0 else "warn",
+                headline=f"Live is in line with the backtest so far: {fmt(mean_l, unit)} per trade live, "
+                         f"{fmt(mean_b, unit)} in the backtest.",
+                plain=f"Over {count(n, 'live trade')} the gap is {fmt(diff, unit)} per trade (likely {fmt(lo, unit)} "
+                      f"to {fmt(hi, unit)}), and that includes zero.{gap_text} This does not prove the edge; it only "
+                      "says live has not broken the promise yet.",
+                next_step={"text": "Keep comparing every 20 to 30 new live trades.",
+                           "why": "The comparison stays valid however often you check, so checking often is free."})
+
+
+def _draws(n: int) -> int:
+    return int(max(2000, min(20000, DRAW_CELLS // max(n, 1))))
+
+
+def _odds(x: np.ndarray, y: np.ndarray) -> float:
+    """P(a live record of len(x) drawn from the backtest's trades sums this low)."""
+    n = len(x)
+    draws = _draws(n)
+    digest = hashlib.sha256(np.round(np.concatenate((x, y)), 8).tobytes() + b"compare").digest()
+    rng = np.random.default_rng(int.from_bytes(digest[:8], "little"))
+    obs = float(x.sum())
+    low = 0
+    for start in range(0, draws, 1000):
+        rows = min(1000, draws - start)
+        sums = y[rng.integers(0, len(y), size=(rows, n))].sum(axis=1)
+        low += int((sums <= obs + 1e-12).sum())
+    return (low + 1) / (draws + 1)

edgeorluck/data/claims.json

@@ -0,0 +1,184 @@
+{
+  "updated": "2026-10-14",
+  "statuses": {
+    "proved": {"label": "Proved", "means": "Checked by the Lean proof assistant, with no gaps. Click a name to read the proof."},
+    "measured": {"label": "Measured", "means": "Approximate on real trades, so we measure it instead of proving it: see VALIDATION.md."},
+    "choice": {"label": "Our choice", "means": "A rule we picked to stay careful. Not maths, and we say why."},
+    "unchecked": {"label": "Can't check", "means": "Something I cannot see or know. I tell you what to do about it."}
+  },
+  "steps": [
+    {
+      "id": "evidence",
+      "mood": "idle",
+      "title": "I turn your trades into one number: the evidence",
+      "flip": "First I ask: if this were pure luck, how surprised should I be?",
+      "plain": "I weigh your trades against every possible size of edge at once, small to large, and average the results. That gives one number, the evidence. With no edge it averages exactly 1, so the bigger it gets, the less luck can explain it.",
+      "formula": "e = average over edge sizes λ ≥ 0 of  exp(λS − λ²n/2)\n  = (2/√v) · exp(ρ²S²/2v) · Φ(ρS/√v),   where v = 1 + ρ²n",
+      "formula_note": "S is your total divided by the spread of your trades, n the number of trades, and the edge sizes λ are weighted by a half-normal curve of width ρ.",
+      "claims": [
+        {"status": "proved", "text": "The formula in the code is exactly this average.",
+         "lean": ["Mixture.eMix_closed_form", "Mixture.eMix_eq_exp_logEStd"], "python": "evidence.log_e_standardized"},
+        {"status": "proved", "text": "With no edge the evidence averages exactly 1; with a losing edge, at most 1.",
+         "assumes": "Normal trades with a known spread.",
+         "lean": ["Mixture.eMix_expectation_eq_one", "Mixture.eMix_expectation_le_one"]},
+        {"status": "proved", "text": "More profit always means more evidence, never less.",
+         "lean": ["Mixture.eMix_strictMono", "Mixture.logEStd_strictMono"]},
+        {"status": "measured", "text": "Real trades are not perfectly normal, and their spread has to be estimated. So we test it: on 42,000 made-up strategies with no edge, it called one a real edge 0.15% of the time, and at most 1.9% in the hardest case.",
+         "link": "VALIDATION.md"}
+      ]
+    },
+    {
+      "id": "bar",
+      "mood": "happy",
+      "title": "I say “real” only past a bar of 40",
+      "flip": "Luck would need a 1-in-40 fluke to fool me. Same for “losing”.",
+      "plain": "Because the evidence averages 1 when there is no edge, it rarely climbs to 40 by luck. Calling “real edge” at 40 on one side and “losing” at 40 on the other leaves at most a 5% chance of a false call in total. That is the 95% in the range you see.",
+      "formula": "P(e ≥ 40) ≤ 1/40",
+      "claims": [
+        {"status": "proved", "text": "The range and the verdict are the same statement: “real edge” exactly when the whole 95% range is above zero.",
+         "lean": ["Mixture.verdict_iff_range_clears_zero", "Mixture.range_eq_not_rejected"], "python": "evidence.range_of"},
+        {"status": "proved", "text": "The code's search for the range's ends always finds the right point.",
+         "lean": ["Mixture.boundary_exists_unique", "Mixture.boundary_bracket", "Mixture.boundaryCode_spec"], "python": "evidence.boundary"},
+        {"status": "proved", "text": "Evidence that averages at most 1 reaches 40 at most 1 time in 40 (Markov's inequality).",
+         "lean": ["Selection.evalue_markov"]},
+        {"status": "proved", "text": "When your total is positive, the “losing” side can't pass at the same time.",
+         "lean": ["Mixture.eMix_neg_le_one"]}
+      ]
+    },
+    {
+      "id": "versions",
+      "mood": "shrug",
+      "title": "Every version you tried raises the bar",
+      "flip": "Tried 40 settings and kept the best? Then I need 40 times more evidence.",
+      "plain": "Try enough versions of a strategy and one will look great by luck alone. So every version you tried and every strategy you show me count as one family, and the bar grows with the family. Versions you tried but didn't show count as zero evidence.",
+      "formula": "one strategy, N versions:   real edge  ⟺  e ≥ 40 · N",
+      "claims": [
+        {"status": "proved", "text": "Across any number of strategies and versions, false “real edge” calls stay under 5% of all such calls on average, however the strategies relate to each other (the e-BH procedure).",
+         "lean": ["Selection.ebh_fdr", "Selection.ebhSet_fdr"], "python": "evidence.ebh"},
+        {"status": "proved", "text": "The code's procedure is exactly that one, whatever order ties come in, and a version you didn't show is never selected.",
+         "lean": ["Selection.ebhSet_selfConsistent", "Selection.card_ebhSet", "Selection.pyTop_eq_ebhSet", "Selection.notMem_ebhSet_of_nonpos"],
+         "python": "evidence.ebh"},
+        {"status": "proved", "text": "For one strategy and N versions the rule is simply: real edge exactly when the evidence reaches 40 × N.",
+         "lean": ["Selection.single_strategy_rule_q05"], "python": "evidence.describe_family"},
+        {"status": "proved", "text": "Keeping the best of N versions and dividing its evidence by N is still fair evidence.",
+         "lean": ["Selection.best_div_isEValue", "Selection.best_of_N_markov"]},
+        {"status": "measured", "text": "Keep the best of 1,000 random versions without saying so and I'm fooled 51% of the time. Say you tried 1,000 and it falls to 0.2%. That's why I ask.",
+         "link": "VALIDATION.md"}
+      ]
+    },
+    {
+      "id": "anytime",
+      "mood": "happy",
+      "title": "Checking again and again doesn't fool me",
+      "flip": "Look after every trade if you like. I was built for that.",
+      "plain": "An ordinary 95% range checked after every trade is wrong about half the time, because sooner or later luck pokes out of it. Mine holds at every check at once: under luck the evidence behaves like a fair game that can't drift up, and such a game rarely ever reaches 40.",
+      "formula": "P(the evidence ever reaches 40, at any number of trades) ≤ 1/40      (Ville's inequality)",
+      "claims": [
+        {"status": "proved", "text": "Ville's inequality: a fair or losing game that starts at 1 ever reaches 40 at most 1 time in 40.",
+         "lean": ["Anytime.ville_super", "Anytime.ville"]},
+        {"status": "proved", "text": "Under luck, the evidence is such a game.",
+         "assumes": "Independent normal trades.",
+         "lean": ["Anytime.martingale_mix", "Anytime.supermartingale_mix"]},
+        {"status": "proved", "text": "So the 95% range holds at every number of trades at once, and a strategy with no edge, or a losing one, is ever called real at most 1 time in 40.",
+         "assumes": "Independent normal trades with a known spread.",
+         "lean": ["Anytime.anytime_range_95", "Anytime.above_zero_false_alarm"]},
+        {"status": "measured", "text": "With the spread estimated from your trades and a check every 10 trades: wrongly “real” 0.5% of the time for ordinary trades, 1.9% for streaky ones.",
+         "link": "VALIDATION.md"},
+        {"status": "choice", "text": "No range before 30 trades. A spread measured on a handful of trades is too unsteady to promise anything (see my mistakes below)."}
+      ]
+    },
+    {
+      "id": "shapes",
+      "mood": "shrug",
+      "title": "Lopsided and streaky trades get a higher bar",
+      "flip": "Many small wins and a rare huge loss fool simple tests. So I get stricter, never looser.",
+      "plain": "When losses are rarer but bigger than wins, a few dozen trades can look great before the big loss arrives. When trades move together, they carry less information than their count suggests. In both cases I raise the bar.",
+      "claims": [
+        {"status": "proved", "text": "The lopsidedness adjustment can only raise the bar and widen the range, never the opposite.",
+         "lean": ["Mixture.skewShift_nonneg", "Mixture.skew_never_raises_e", "Mixture.range_with_skew_contains"], "python": "evidence.skew_shift"},
+        {"status": "proved", "text": "The streakiness factor never narrows the range: it stays between 1 and 10.",
+         "lean": ["Counting.serialFactorOf_mem", "Counting.ar1Floor_mem"], "python": "evidence.serial_factor"},
+        {"status": "proved", "text": "Its main ingredient is right: when trades follow each other like an AR(1) process, the spread of the average grows by (1 + r)/(1 − r) as trades pile up.",
+         "lean": ["Counting.variance_mean_ar1", "Counting.tendsto_ar1Ratio"]},
+        {"status": "measured", "text": "What the guards buy, measured: martingale-like records were called real 37% of the time at 30 trades before them, now 0%; lopsided ones 3.4%, now under 1%.",
+         "link": "VALIDATION.md"},
+        {"status": "choice", "text": "Nothing is called real before five losing trades: an unseen loss could be any size."}
+      ]
+    },
+    {
+      "id": "pictures",
+      "mood": "idle",
+      "title": "Everything around the verdict adds up",
+      "flip": "The coin flips, the streak odds, the money sentence and the paired trades are checked too.",
+      "plain": "Around the verdict sit smaller calculations: the coin-flip picture, the odds of a losing streak, the money sentence, the live-vs-backtest range, the drawdown, the time in the market and the pairing of exchange fills into trades. Where they are exact, they are proved; where they are estimates, they say so.",
+      "claims": [
+        {"status": "proved", "text": "“Your average trade is up but you lost money: your losing trades were bigger” is said only when it is a theorem, when every trade's percent and money point the same way. Otherwise I point at fees and costs.",
+         "lean": ["Selection.losers_bigger"], "python": "judge._money_vs_percent"},
+        {"status": "proved", "text": "The live-vs-backtest range adds a 97.5% range on each side, so it holds at 95% even when you check your live trades often.",
+         "lean": ["Selection.diff_range_union_bound", "Selection.worse_false_alarm"], "python": "compare.compare_runs"},
+        {"status": "proved", "text": "The range on your win rate is Wilson's: exactly the rates a fair test wouldn't reject.",
+         "lean": ["Selection.wilson_score_inversion", "Selection.wilson_roots"], "python": "evidence.wilson_bounds_count"},
+        {"status": "proved", "text": "My own forecasts are graded with the Brier score, which rewards honest probabilities, and compared with always guessing the usual rate, not just with a coin flip.",
+         "lean": ["Selection.brier_expected", "Selection.brier_proper", "Selection.brier_base_rate_beats_coin"], "python": "web.ledger.Ledger"},
+        {"status": "proved", "text": "The losing-streak odds are exact: the code's calculation equals the probability over every possible sequence of wins and losses.",
+         "lean": ["Counting.pStreakAtMost_eq", "Counting.maxRun_le_iff"], "python": "judge._p_streak_at_most"},
+        {"status": "proved", "text": "The coin-flip picture is a fair test: if your trades were pure luck (symmetric around zero), a result this good would show up no more often than the picture says.",
+         "lean": ["Counting.orbit_count_le", "Counting.randP_valid", "Counting.coinFlip_valid"], "python": "judge._coin_flips"},
+        {"status": "measured", "text": "The page draws 1,000 random flips, not all of them, so its count carries a little noise. And it is only a picture: the verdict comes from the evidence."},
+        {"status": "proved", "text": "Pairing an exchange's buys and sells first in, first out keeps every coin and every dollar accounted for.",
+         "lean": ["Counting.fifo_coins", "Counting.fifo_pnl_pieces", "Counting.fifo_flat"], "python": "fills.round_trips"},
+        {"status": "proved", "text": "The worst drop and the trades since your peak are computed exactly as defined.",
+         "lean": ["Counting.worstDrop_spec", "Counting.lastPeak_is_last_high"], "python": "judge._drawdown"},
+        {"status": "proved", "text": "Time in the market is the true length of the union of your trades' time spans.",
+         "lean": ["Counting.sweep_eq_volume"], "python": "judge._exposure"},
+        {"status": "measured", "text": "The drawdown odds, “faded” and the live-vs-backtest odds come from resampling your own trades: estimates, and labelled as such."}
+      ]
+    }
+  ],
+  "limits": [
+    {"status": "measured", "text": "Real trades are not normal, their spread is estimated, and they can depend on each other. The proofs above assume the textbook case; for real trades I measure instead. That is where 0.15%, and 1.9% at worst, come from.",
+     "link": "VALIDATION.md"},
+    {"status": "unchecked", "text": "I can't see your code. A backtest that peeks at future prices or skips fees hands me trades that look better than they were. When the shape looks too good, I flag it and give you a prompt to have the code checked."},
+    {"status": "unchecked", "text": "The past is not the future. A real edge can stop working, which is why I check whether it has faded, and why you should come back."},
+    {"status": "choice", "text": "When the evidence decides fastest is a rule of thumb: tuned for about 100 trades, though the exact best is near 112. It costs 0.03%.",
+     "lean": ["Mixture.logEStd_scale_free"]}
+  ],
+  "mistakes": [
+    {"date": "2026-10-14", "title": "I showed a range from just two trades.",
+     "impact": "At 2 trades it missed the true average 9% of the time, against the 5% I promise; for someone checking after every trade from 2 on, about 13%.",
+     "found": "The Lean proof assumes a known spread, so a test checked what happens with an estimated one.",
+     "fix": "No range before 30 trades, where verdicts start. From there it holds (about 2.2%)."},
+    {"date": "2026-10-14", "title": "My coin-flip sentence could contradict my verdict.",
+     "impact": "A passing card could read “3 copies ended higher … a pass needs 1 or fewer … It passes.” The picture and the verdict are different tests.",
+     "found": "A test checking the coin-flip proof's conditions against 400 random records.",
+     "fix": "The bar is now said as odds, never as a count of copies. The verdict itself was never affected."},
+    {"date": "2026-10-14", "title": "I blamed trade sizes when fees were the cause.",
+     "impact": "“Your losing trades were bigger” was said even when every trade was up in percent and down in money, which happens when fees are in the money but not in the percent.",
+     "found": "Proving the sentence showed exactly when it is true.",
+     "fix": "It is said only when it is a theorem. Otherwise I say the percent and the money point opposite ways, and why."},
+    {"date": "2026-10-14", "title": "One blank cell broke my money sentence.",
+     "impact": "A single empty percent cell turned the average into “n/a”, and could invent a mismatch between percent and money, or hide a real one.",
+     "found": "A test checking the money sentence against its theorem.",
+     "fix": "Only trades with both numbers count now."},
+    {"date": "2026-10-14", "title": "My report card set the bar too low.",
+     "impact": "I called my own forecasts “better than guessing” when they beat a coin flip. But always guessing the usual rate beats a coin flip too.",
+     "found": "Proving what the Brier score rewards.",
+     "fix": "I now compare my forecasts with always guessing the usual rate."},
+    {"date": "2026-10-14", "title": "A rounding tolerance misread large amounts.",
+     "impact": "A strategy exactly back at its high could read “0.000000 USDT below your peak, 2 trades ago”.",
+     "found": "A test comparing the drawdown with its definition.",
+     "fix": "The tolerance is now relative to the size of the numbers."},
+    {"date": "2026-10-14", "title": "A shortcut far below zero.",
+     "impact": "Where the evidence is tiny, a one-term shortcut overstated it by up to 1.5%. It never changed a verdict.",
+     "found": "A test comparing the code with the proved formula.",
+     "fix": "The exact formula is used there now."},
+    {"date": "2026-10-14", "title": "I said my tuning was the best at 100 trades.",
+     "impact": "It is best near 112 trades; at 100 the difference is 0.03%.",
+     "found": "Trying to prove the claim showed it is only approximately true.",
+     "fix": "Worded as the rule of thumb it is."},
+    {"date": "2026-10-14", "title": "Three kinds of records fooled me in testing.",
+     "impact": "Lopsided records were wrongly called real 3.4% of the time, martingale-like ones 37% at 30 trades, streaky ones checked often 3.4%.",
+     "found": "The validation run on records whose truth is known.",
+     "fix": "A higher bar for lopsided trades, five losses before “real”, and a streakiness floor. Now under 1%, 0% and 1.9%."}
+  ]
+}