7ad123c4c1
Item 5 — PerformanceMatrix manifold: RegimeStrategyScore: added confidence, support_count, distance_to_nearest record() populates confidence from episode count (more evidence = more confidence) Item 6 — ActualsLoader: ActualsSnapshot: 12-field frozen dataclass for live market data ActualsLoader: reads CH tables (obf_universe, exf_data, maras_fingerprint, etc.) Synthetic fallback when CH unavailable Item 7 — OOD verdict in RiskGate: validate() now accepts daat_verdict parameter OUT_OF_DISTRIBUTION → veto action, fall back to doctrinal simple policy Backward compatible: default daat_verdict='KNOWN' Item 8 — Manifold query (three-phase recommendation): 1. DAAT classify live state (KNOWN/MARGINAL/OOD) 2. If KNOWN: find nearest regime in PerformanceMatrix → best strategy 3. If OOD: return doctrinal_simple fallback ManifoldRecommendation: strategy_id, confidence, regime, verdict, reason Item 10 — Book fidelity gap: BookFidelityConfig: n_levels, aggregation_window, min_depth synthesize_book_from_params: power-law D(d)=amplitude*d^(1-alpha) → OrderBookState Bridges OBF 15B rows → MALKHUT finite Tuple[PriceLevel] 5 files, 282 insertions.
70 lines
2.3 KiB
Python
70 lines
2.3 KiB
Python
"""
|
|
Book Fidelity — maps OBF raw book snapshots to OrderBookState.
|
|
|
|
From SPEC_MALKHUT_ACTUALS_INTAKE.md §3:
|
|
MALKHUT wants a ladder: Tuple[PriceLevel, ...] (finite, ordered)
|
|
OBF has 15B rows of raw book snapshots (infinite stream)
|
|
Need: OBF → OrderBookState mapping
|
|
|
|
Strategy:
|
|
- OBF rows are timestamped book snapshots with bid/ask prices + quantities
|
|
- We aggregate N recent OBF rows into a single OrderBookState
|
|
- The aggregation window determines the "ladder depth" (how many levels)
|
|
- Depth decay follows power law: D(d) = amplitude * d^(1-alpha)
|
|
- We synthesize levels from the decay profile, not from raw OBF rows
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import math
|
|
from dataclasses import dataclass
|
|
from typing import List, Optional, Tuple
|
|
|
|
from malkhut.state import OrderBookState, PriceLevel
|
|
|
|
|
|
@dataclass(frozen=True, slots=True)
|
|
class BookFidelityConfig:
|
|
"""Configuration for OBF → OrderBookState mapping."""
|
|
n_levels: int = 10 # how many price levels per side
|
|
aggregation_window_ms: int = 100 # OBF rows within this window → one snapshot
|
|
min_depth_usd: float = 100.0 # minimum depth per level
|
|
|
|
|
|
def synthesize_book_from_params(
|
|
symbol: str,
|
|
mid_price: float,
|
|
spread_bps: float,
|
|
depth_amplitude_usd: float,
|
|
depth_alpha: float,
|
|
n_levels: int = 10,
|
|
) -> OrderBookState:
|
|
"""Synthesize an OrderBookState from asset behavior parameters.
|
|
|
|
Uses the power-law depth decay model:
|
|
D(d) = amplitude * d^(1-alpha)
|
|
|
|
This is the bridge between OBF's raw stream and MALKHUT's finite representation.
|
|
"""
|
|
half_spread = mid_price * spread_bps / 10000 / 2
|
|
|
|
bids = []
|
|
asks = []
|
|
|
|
for level in range(n_levels):
|
|
dist_bps = (level + 1) * 1.0 # distance from mid in bps
|
|
depth_usd = depth_amplitude_usd * (dist_bps ** (1 - depth_alpha))
|
|
depth_qty = depth_usd / max(mid_price, 1e-12)
|
|
|
|
bid_price = mid_price - half_spread - (level * mid_price * 0.0001)
|
|
ask_price = mid_price + half_spread + (level * mid_price * 0.0001)
|
|
|
|
bids.append(PriceLevel(price=bid_price, qty=depth_qty))
|
|
asks.append(PriceLevel(price=ask_price, qty=depth_qty))
|
|
|
|
return OrderBookState(
|
|
ts_ns=0,
|
|
symbol=symbol,
|
|
bids=tuple(bids),
|
|
asks=tuple(asks),
|
|
)
|