betting_combat.rounds.live.replay

A past card replayed through the live decision path (decision), fight by fight and round start by round start, on a recorded clock, books and trade tape: the known answers of the live path and the weekly forward check.

inputs   the card's Dataset 1 rows (the round starts that happened, i.e. the rounds the
         feed would have shown starting; their outcomes settle the bets), the fight clock
         (start, snap, rounds), the Set 4 minute books, the Kalshi trade tables and,
         optionally, Polymarket's
mode     how the moment is recreated:

PARITY      the research forward test (``ufc/modeling/forward.py``, fixed 2026-09-30):
            the decision minute of ``meta.entry_time`` (round 1: the minute before the
            start), the research windows (round-0 ``sofar`` carried past t), every round
            start decided, and the events so decided then filled by the research's own
            execution engine (``backtest.capacity.instruments`` / ``run``: Kalshi +
            Polymarket, the arrival price after 1 s, fractional contracts, the settled
            daily stop, round 0 bet only with ``trade_round0``). Pair the settings with
            ``pair_draw_share=0`` (the engine prices the pair at p).
PRODUCTION  the live rules (``trading.rounds.RoundsRunner``; the end-to-end replay test
            runs the runner itself and gets the same bets):
              timing   the live clock: the feed shows the fight live ``feed_lag_s`` after
                       its start (the lag includes the poll), each round 5:00 after the
                       feed showed it the break is found, and the first poll then decides
                       (t = start + 6r - 1 min + lag); the window edges from the feed's
                       start
              gates    no decision once the winner books have priced the result (A's
                       fair price outside 3-97c) and no bet on a market whose own book
                       has; a fight's side markets, once unpriceable, stay out
              windows  causal (nothing at or after t), the tape in (time, trade id) order
              money    whole contracts sized at the IOC limits; each decision's bets
                       reserve their room in turn, the fills then replace the
                       reservations; no bet on the other side of a market the fight
                       holds; the daily stop on SETTLED P&L (a fight settles at its snap)
              fills    each leg an IOC at its limit, filled at the arrival price (the
                       worst of the quote and every print on our side within the latency)
                       when that is within the limit; a pair's second leg sized to the
                       first leg's fill, an uneven pair kept as it is (the over-filled leg
                       pays if its fighter wins on the cards)
            Round 0 only if ``trade_round0``; Kalshi only; the pair priced at
            p x (1 - draw share).

Classes

ReplayInputs

ReplayMode

ReplayResult

Functions

fight_clock

fight_clock(minutes: pd.DataFrame, rows: pd.DataFrame) -> pd.DataFrame

The research fight clock recovered from Set 4 (start = ts - t_min, to the microsecond; snap = the first minute the result is priced; rounds from Dataset 1).

replay

replay(artifact: RoundsArtifact, inputs: ReplayInputs, settings: Settings, mode: ReplayMode) -> ReplayResult

Decide every round start of the card, then take the bets in time order under the card’s caps (see the module doc for the two modes).