"""Conviction-based position sizing — 倉位跟著把握程度走. We never blindly copy the target's dollar amount. Instead we infer *how convinced the target was* on each entry and scale OUR stake to that conviction, inside hard risk caps sized for a small (<$1k), conservative bankroll. Conviction ∈ [0,1] blends two signals: stake_signal : how large this bet was vs the target's own typical bet. Betting 3x their usual size => they are unusually sure. edge_signal : how far the entry price sits from a coin flip (|p-0.5|*2). An extreme price means a strong directional view. conviction = w_stake * stake_signal + w_edge * edge_signal Our stake = bankroll * frac, where frac scales linearly from min_frac (no conviction) to max_frac (full conviction), then is clamped by: - kelly_cap * kelly_fraction (edge-aware ceiling) - remaining room under max_frac_per_market """ from __future__ import annotations import math from dataclasses import dataclass def _logistic(x: float) -> float: return 1.0 / (1.0 + math.exp(-x)) def stake_signal(trade_usdc: float, rolling_avg_usdc: float) -> float: """0.5 at the target's average bet, ->1 for oversized, ->0 for tiny.""" if rolling_avg_usdc <= 0 or trade_usdc <= 0: return 0.5 return _logistic(math.log(trade_usdc / rolling_avg_usdc)) def edge_signal(price: float) -> float: """Distance from a coin flip, in [0,1].""" return max(0.0, min(1.0, abs(price - 0.5) * 2.0)) def conviction(trade_usdc: float, rolling_avg_usdc: float, price: float, w_stake: float, w_edge: float) -> float: s = stake_signal(trade_usdc, rolling_avg_usdc) e = edge_signal(price) tot = w_stake + w_edge or 1.0 return (w_stake * s + w_edge * e) / tot def kelly_fraction(price: float, assumed_edge: float) -> float: """Full-Kelly stake for buying a YES share at `price` that pays $1. Buying at `price` costs `price` and returns 1 on win, so net decimal odds b = (1/price) - 1. The catch: the market price already IS the implied probability, so if we plug price in as our win prob the edge is zero and Kelly is zero. Copying a sharp trader only makes sense if we believe the true probability sits ABOVE the price — that gap is `assumed_edge`, which we scale with conviction in position_fraction(). Returns a fraction in [0,1).""" price = min(max(price, 1e-4), 1 - 1e-4) p_true = min(price + max(0.0, assumed_edge), 0.999) # our belief b = (1.0 / price) - 1.0 q = 1.0 - p_true f = (b * p_true - q) / b if b > 0 else 0.0 return max(0.0, min(f, 1.0)) @dataclass class SizingConfig: max_frac_per_trade: float = 0.05 max_frac_per_market: float = 0.15 min_frac_per_trade: float = 0.005 w_stake: float = 0.6 w_edge: float = 0.4 kelly_cap: float = 0.5 assumed_max_edge: float = 0.15 # max true-vs-price gap we ascribe at full conviction def position_fraction(trade_usdc: float, rolling_avg_usdc: float, price: float, market_exposure_frac: float, cfg: SizingConfig) -> tuple[float, float]: """Return (fraction_of_bankroll_to_stake, conviction) for one copied entry. market_exposure_frac = fraction of bankroll already committed to this market. """ conv = conviction(trade_usdc, rolling_avg_usdc, price, cfg.w_stake, cfg.w_edge) # linear map conviction -> [min_frac, max_frac_per_trade] frac = cfg.min_frac_per_trade + conv * (cfg.max_frac_per_trade - cfg.min_frac_per_trade) # edge-aware Kelly ceiling: assumed edge scales with conviction assumed_edge = conv * cfg.assumed_max_edge frac = min(frac, cfg.kelly_cap * kelly_fraction(price, assumed_edge)) # respect aggregate per-market cap room = max(0.0, cfg.max_frac_per_market - market_exposure_frac) frac = min(frac, room) return max(0.0, frac), conv