Monte-Neo strategy verifier

Write a validation dossier folder from a certificate, for a model-risk committee, a validator or an auditor. The folder holds dossier.html (one page: summary, checks, framework map, assumptions and limitations, how to reproduce, blank sign-off fields), dossier.json, certificate.json, environment.json, REPRODUCE.md and limitations.md. The framework map shows evidence per clause, not compliance. Args: certificate_path: A strategy-verdict/1 certificate (JSON). out_dir: Folder to write. framework: 'generic', 'sr11-7', 'ss1-23' or 'rts6'. name: Model name. owner: Model owner. purpose: What the model is for. alpha_path: Optional alpha-report/1 JSON of the strategy's signal.

Check the Ed25519 signature of a strategy-verdict/1 certificate. Args: certificate_path: Signed JSON certificate. public_key: The issuer's published key ('ed25519:<base64>' or a .pub file). Without it the check proves only that the certificate was not edited after signing.

What changed between two certificates: verdict, metrics, check statuses, and whether the verdict regressed.

Break-even cost (bps per side) and returns under 0/1/2 bars of execution delay. Args: ohlcv_path: CSV/Parquet with open, high, low, close. signals_path: Positions per bar file (or use strategy_path). strategy_path: Python file 'path.py[:func]' defining func(df) -> positions. commission_bps: Commission per side in basis points. slippage_bps: Slippage per side in basis points. side_mode: 'long_flat' or 'long_short' (default inferred). positions: 'sign', 'weight' or 'auto' (see verify_strategy). timeout: Seconds allowed for the signal() call; the strategy runs in a worker process.

Known problems of a data provider's export (Binance, Yahoo, Polygon, Databento, TradingView, MT5): bar labels, time zones, units, adjustments.

Search causal indicator formulas on a price table and verify the winner. The search is counted (effective trials after clustering), tested against the same search on shuffled markets, Reality Check / SPA, and a lockbox opened once. Returns found, reasons, the source of the winner, the certificate and the search statistics (the per-candidate journal is left out). Nothing is written.

Ask the hold-out oracle (Thresholdout) whether a strategy's hold-out result agrees with its training result. Answers 'consistent' with the training Sharpe, or 'not consistent' with a noisy hold-out Sharpe that spends budget. The hold-out is never shown. Initialise once with `monte-neo oracle init`.

After launch: does the live (or paper) strategy behave like its backtest, and is the alpha dead? (live-monitor/1) Live against backtest on the same dates (correlation, tracking error), realised slippage from fills against the modelled one (with a recommended value), sequential alarms (CUSUM, SPRT) against the backtest edge shrunk by ``haircut``, and the live history still needed to confirm the edge. Args: certificate_or_backtest_path: The strategy's certificate (.json) or a backtest returns file (date, return). live_path: Live or paper returns (date, return) or fills (timestamp, symbol, side, quantity, price[, reference_price]). fills_path: Optional fills file when live_path holds returns. slippage_bps: Modelled slippage to compare with (default: the certificate's). haircut: Share of the backtest edge expected live (default 0.5).

Look-ahead probes only: static lint, outside data, determinism, truncation, future perturbation. Args: ohlcv_path: CSV/Parquet with open, high, low, close. strategy_path: Python file 'path.py[:func]' defining func(df) -> positions. timeout: Seconds allowed per signal() call; the strategy runs in a worker process. jobs: Worker processes for the probe calls. isolate: Block network, subprocesses and file writes for the strategy.

Reproduce a strategy-verdict/1 certificate from its original inputs. Args: certificate_path: JSON certificate written by verify (--out) or returned by a tool. ohlcv_path: The same OHLCV file that was verified (not for a quote certificate). signals_path: The same positions file (or use strategy_path). strategy_path: The same strategy file that was verified. timeout: Seconds allowed per signal() call; the strategy runs in a worker process. isolate: Block network, subprocesses and file writes for the strategy. quotes_path: The same quotes file, for a certificate issued by verify_quotes (needs strategy_path).

Write a hypothesis down before testing it (pre-registration, hash-chained in .monte-neo/registrations.jsonl). Pass the returned id as ``registration`` to verify_strategy: the certificate then says whether the verified code is the registered one. Register before the first run; a later registration does not protect against HARKing.

Write a certificate as a self-contained HTML report for people (equity chart, checks, periods). Args: certificate_path: JSON certificate written by verify (--out) or saved from verify_strategy. html_path: Where to write the .html file.

Repair a strategy's defects without overfitting it, or say why it cannot be repaired (repair-report/1). Look-ahead and repainting are corrected first (causal rewrites, one-bar delay). Then a few declared repairs (smoothing, holding period, no-trade band, volatility targeting, neutralisation, caps, liquidity filter) are chosen on the first 70 % of the history by the number of defects, never by return, each counted as a trial. The rest of the history is a lockbox opened once. Outcomes: REPAIRED (the lockbox still earns after costs and is not rejected; read its failed checks), REPAIRED_NO_EDGE (the profit was in the defect), NOT_REPAIRABLE (what the user must do), NOTHING_TO_REPAIR. The original file is never changed; out_dir gets strategy.repaired.py, repair.diff, certificate.json and repair-report.json/html. Do not call it again on the same data to look for a better outcome: report the outcome as it is. Args: ohlcv_path: Prices (.csv / .parquet). strategy_path: Strategy file 'path.py[:func]'. out_dir: Folder for the results. commission_bps: Commission per side. slippage_bps: Slippage per side. n_trials: Variants tried before the repair. budget: At most this many candidate repairs.

Suggest a causal rewrite of a strategy file that reads the future (negative shifts, centred windows, whole-table statistics...). Returns the rewrites (rule, line, before, after), the patched source, a unified diff and the lint findings that remain. The patch keeps the shape of the strategy, not its meaning: verify it with verify_strategy before using it, and write the patched source to a new file yourself (nothing is written here). Comments are not kept.

Does a cross-sectional score predict returns, and can its top-minus-bottom portfolio be traded? (alpha-report/1) Call it before you call a ranking signal "alpha". Family A: rank IC with Newey-West t, IC decay, quantile monotonicity, long and short legs, breadth, permuted-score placebos, selection against timing. Family D: market impact and participation at ``aum``, capacity curve, short feasibility, holding period against signal decay, dependence on the rebalance day. Args: prices_path: Universe prices (.csv / .parquet): timestamp, symbol, close[, volume]. scores_path: Scores (.csv / .parquet): timestamp (or date), symbol, score; the score at t ranks returns after t. horizon: Forward-return horizon in bars. quantiles: Quantile buckets. claimed_ir: Claimed annual information ratio (checked against IC and breadth). aum: Capital you plan to run, for market impact and participation. seed: Seed for bootstraps and placebos. factors_path: Factor returns file (date + factors); default: market, size, momentum, reversal and low-volatility factors built from the universe. book_path: Returns of the user's existing book (date + one column per strategy): marginal Sharpe, overlap. n_trials: Variants tried before this one (Harvey-Liu-Zhu hurdle, minimum backtest length, Sharpe haircut). The report also covers attribution (is it a known factor, hidden short volatility), value to a book, multiple testing and risk (neutrality, concentration, named crises, tail risk).

JSON schema of the strategy-verdict/1 certificate.

Execution semantics and check catalogue — read before building a backtest.

Run the parameter search inside the verifier and verify the best combo. Prefer this over verify_strategy when you tuned parameters: n_trials and the spread of trial Sharpes are measured instead of declared, and an anchored walk-forward scores re-selected parameters out of sample. Args: ohlcv_path: CSV/Parquet with open, high, low, close. strategy_path: Python file 'path.py[:func]' defining func(df, **params) -> positions. grid: Parameter grid, e.g. {"fast": [10, 20], "slow": [50, 100]} (max 512 combos). commission_bps: Commission per side in basis points. slippage_bps: Slippage per side in basis points. side_mode: 'long_flat' or 'long_short' (default long_short). folds: Walk-forward folds. positions: 'sign', 'weight' or 'auto' (see verify_strategy). timeout: Seconds allowed per signal() call; the strategy runs in worker processes. jobs: Worker processes (the grid's combos run in parallel). isolate: Block network, subprocesses and file writes for the strategy. claim: What was claimed (see verify_strategy); compared with the verified result. funding_bps_per_bar: Funding on every open position, bps of its value per bar (default 0). borrow_bps_per_bar: Borrow fee on short positions only, bps of their value per bar (default 0). sl_pct: Stop-loss in percent of the entry price, tested inside each bar (default 0 = off). tp_pct: Take-profit in percent of the entry price (default 0 = off). trail_pct: Trailing stop in percent from the best price since entry (default 0 = off). symbol_costs: Universes only: costs by symbol, e.g. {"AAA": {"commission_bps": 2, "slippage_bps": 1}, "default": {"slippage_bps": 10}} (or a JSON file path). A symbol takes its own values, then "default", then the uniform costs above. compact: Drop details of passing checks to keep the response short.

Re-derive a spread / pairs / stat-arb strategy's P&L from its leg positions and compare it with the reported return. Catches "phantom mean reversion": a rolling hedge ratio booked as position * change of the spread earns a profit that no trader could (it even earns on independent random walks). The check fails (verdict REJECT, check ``accounting_mismatch``) when more than ``tolerance`` of the reported P&L is not what the legs earned. The fix is in ``next_actions``: book position.shift(1) * (d_y - beta.shift(1) * d_x). Args: legs_path: CSV/Parquet with date, px_<leg> and qty_<leg> for every leg, and reported_return. The quantity is held over the bar that ends at date (decided at the previous bar); optional ``cost`` column. tolerance: Largest unexplained share of the P&L (default 0.05). pnl: "log" (P&L = quantity * change of the log price) or "simple" (quantity = fraction of equity). periods_per_year: Bars per year; inferred from the dates when omitted.

Verify several strategies together: effective number of independent strategies, SPA over the list, the best one deflated, the ensemble.

Verify a strategy against the time its quotes really arrived; returns a strategy-verdict/1 certificate. Use this for intraday strategies built on bid/ask quotes. A backtest that bins quotes by the exchange stamp lets the strategy act on prices that had not reached you yet; this tool also bins them by stamp + latency and compares. Args: quotes_path: CSV/Parquet of one instrument with timestamp, bid, ask and latency_ms (or an arrival timestamp). strategy_path: Python file 'path.py[:func]' defining func(df) -> positions on bars of open, high, low, close, volume. Runs with your permissions. bar_ms: Bar length in milliseconds. commission_bps: Commission per side in basis points (default 1: quote strategies trade often). slippage_bps: Slippage per side in basis points. latency_samples: Seeded redraws of the observed latency for the Monte Carlo. positions: 'sign', 'weight' or 'auto'. compact: Drop details of passing checks to keep the response short. symbol: The symbol to verify when the table holds several. order_latency_ms: Delay from the decision to the fill in ms (the data latency comes from the quotes). feeds: Other symbols the strategy reads (needs symbol); their columns are prefixed by the symbol with non-word characters replaced by "_", e.g. ETH_USDT_X_close. latency_model: Assume the data latency instead of reading it: "constant:MS" or "lognormal:MEDIAN_MS,P95_MS". probes: Also run the look-ahead probes of verify_strategy on the arrival bars.

Due diligence on a track record given only as returns (no code, no positions): strategy-verdict/1. Smoothed returns (Getmansky-Lo-Makarov), missing small losses (a kink at zero), implausibly consistent gains, round numbers, significance with the manager's number of strategies (Deflated Sharpe), a drawdown too shallow for the volatility, the relation to a benchmark and a claim check. Look-ahead and costs cannot be checked from returns alone; the report says so. Args: returns_path: CSV/Parquet with a date column and a return column (decimals or percent). benchmark_path: Optional benchmark returns in the same format. n_strategies: How many funds or strategies the manager runs (prices the selection of the best one). claim: What the manager claims, e.g. {"annual_return": 0.18, "sharpe": 2.0, "max_drawdown": 0.06}.

Verify a strategy backtest and return a strategy-verdict/1 certificate. Args: ohlcv_path: CSV/Parquet with open, high, low, close (optional timestamp). signals_path: Positions per bar (+1 long, 0 flat, -1 short, or weights in [-1, 1]) as CSV/Parquet/NPY. strategy_path: Python file 'path.py[:func]' defining func(df) -> positions. Enables look-ahead probes and static lint. Runs with your permissions. n_trials: Number of variants tried before choosing this one (selection bias). ledger: Count the variants tried on this data in .monte-neo/ledger.jsonl (hash-chained); the larger of the count and n_trials deflates the Sharpe. Turn it on when you try several variants. commission_bps: Commission per side in basis points. slippage_bps: Slippage per side in basis points. side_mode: 'long_flat' or 'long_short' (default inferred). warmup_bars: Bars skipped before trading (default min(60, n/10)). positions: 'sign' (+1/0/-1), 'weight' (fraction of equity in [-1, 1]) or 'auto' (weights when all values are in [-1, 1] and some are fractional). timeout: Seconds allowed per signal() call; the strategy runs in a worker process. jobs: Worker processes for the probe calls (raise for slow strategies). isolate: Block network, subprocesses and file writes for the strategy. claim: What was claimed, e.g. {"sharpe": 2.1, "total_return": 0.85, "max_drawdown": 0.12, "n_trades": 300} (or a JSON file path): a claim better than the verified result fails. funding_bps_per_bar: Funding on every open position, bps of its value per bar (default 0). borrow_bps_per_bar: Borrow fee on short positions only, bps of their value per bar (default 0). sl_pct: Stop-loss in percent of the entry price, tested inside each bar (default 0 = off). tp_pct: Take-profit in percent of the entry price (default 0 = off). trail_pct: Trailing stop in percent from the best price since entry (default 0 = off). symbol_…