# Bandwagon football calculation contract ## Three explicit player-guide modes Sensitivity policy `projection-sensitivity-v1`; remaining-projection policy `projected-exposure-v2`, introduced/revised October 20, 2026. **Simple — Points exposure** ranks a player's projected remaining points in selected own starting lineups minus projected points in opposing lineups, using each league's scoring and optional importance weights. Three opposing appearances at 20 points each mean 60 aggregate points against the user, not one 60-point game. One-sided exposure keeps a clear rooting call even when projections are missing. Missing values remain unavailable, not zero. **Advanced — Matchup impact** ranks how much a player's different finishes can change projected matchup results, with all other remaining players held at their projections. It uses the same Sleeper baseline as Simple and does not generate random football futures. It does not display win probabilities or call a sensitivity result expected wins. No simulation silently overrides either mode's direction or ranking. **Monte Carlo — Experimental** varies other players as well as the player being examined. It draws from a frozen library of historical NFL stat lines, reweights those observations toward the current Sleeper projection, and scores each sampled performance under every selected league's rules. A player receives one shared performance across leagues. It does not assume a normal or uniform distribution of fantasy points. The displayed probabilities are estimates under this model, not calibrated Sleeper probabilities. Simple and Advanced retain their existing calculations. A player with 50 projected points in comfortable matchups can be less important than a player with 15 points in a close matchup. However, the calculation must actually test the first player's quiet finish: that player may be the reason the baseline projects a win. ### Source inputs and assumptions The documented Sleeper API supplies current scores, starters, and scoring settings. Public undocumented Sleeper feeds supply weekly statistical projections (observed provider: Rotowire) and actual statistics (Sportradar). The feed audit on October 20, 2026 found no player outcome distributions, remaining-performance quantiles, or matchup win probabilities. Means alone cannot identify these quantities. Each appearance uses its league's scoring. Before kickoff the full projection is used, subtracting already credited defensive points. Live offensive remaining production uses full projection times the remaining clock fraction. This is Bandwagon's approximation, not a refreshed Sleeper remaining forecast. Supplied pregame defensive bucket indicators are provider scoring inputs, not verified probabilities. Unsupported live offensive nonlinear yardage-bonus forecasts remain unavailable. Finished, bye, and confirmed-out players have zero remaining production. Live defenses use an explicit deterministic stat-line proxy. For actual cumulative stats A, full-game projected accumulating stats P, known remaining clock fraction f, and league-specific score function S_l: ```text Proxy final stats = A + f * P Additional points q_l = S_l(A + f * P) - S_l(A) ``` Points-allowed and yards-allowed scoring tiers are recomputed from the actual and proxy-final cumulative totals. Supplied projected tier indicators are ignored for this live calculation; tiers are neither scaled as probabilities nor stacked with previous tiers. Missing required cumulative or projected totals remain unavailable. An actual sole active `pts_allow_0 = 1` identifies exactly zero points allowed; a nonzero tier cannot identify an exact total. Negative deltas are preserved. The additional delta is added to the official matchup score; reconstructing actual stats does not replace that score or introduce a second full defensive credit. This permits complete matchup baselines when sufficient recorded defensive inputs exist. It does not claim that nonlinear scoring of this proxy equals expected fantasy points. Method `live_defense_statline_proxy` records the clock fraction, cumulative and proxy-final totals, and formula in the per-appearance `remainingTrace`. `backend/remaining-defense.js` implements this calculation. It is a conditional clock-based baseline, not a calibrated forecast or probability. At period four with zero regulation clock and explicit regulation-clock timing, method `regulation_end_hold` conditionally sets additional points to zero while the feed resolves final/overtime status. The observed game status is unchanged; no overtime duration or final result is inferred. Genuinely unknown timing stays unavailable. ### Advanced arithmetic Let c_l be the current own-minus-opponent score, q_lp the additional projected points for player p in league l, a_lp the signed starting exposure (+1 own, -1 opponent, 0 both/neither), and w_l the nonnegative league importance. ```text Baseline final margin: m_l = c_l + sum_p(a_lp * q_lp) Player sensitivity: m_lp(x) = m_l + a_lp * q_lp * (x - 1) Tie threshold: t_lp = 1 - m_l / (a_lp * q_lp), when the denominator is nonzero r_l(x) = 1 for a positive margin, 0.5 for a tie, 0 for a negative margin U_p(x) = sum_l(w_l * r_l(x)) Impact = max_x U_p(x) - min_x U_p(x) ``` The common multiplier x varies the selected player's remaining contribution across their leagues. All other players stay at projection. This is a fantasy-score sensitivity; it does not jointly vary quarterbacks, receivers, defenses, or teammates, nor reconstruct a physically realizable football stat line under every league's nonlinear rules. The versioned test range is 0 <= x <= 2, with baseline 1. Zero means no additional points, one means the remaining projection, and two means twice that projection. These are explicit stress assumptions, not confidence bounds, equally likely cases, or physical limits. Negative scoring and bigger finishes outside the range are not ruled out. Every in-range tie threshold, endpoint, baseline, and intervening interval is checked. This finds narrow middle optima that a three-point check misses. For example, a player can need more than eight points in one matchup and fewer than nine in another. Boundaries are evaluated separately for ties. Supplied decimal values are summed before numeric conversion; ties at analytic thresholds use equality, not an absolute point band that would swallow small scoring differences. The response exposes numeric equality policy, slopes, thresholds, tested results, and best ranges for auditing. With equal league weights U counts projected wins plus half-credit ties in a particular test case; it is not an expectation or a probability. Unequal weights measure priority-weighted results. Advanced sorts by impact, then distance from baseline to the nearest result boundary, then Simple exposure and stable name/ID ordering. Direction is separate: monotonically increasing results favor more points; decreasing results favor fewer; an interior best range favors a moderate finish; other conflicts remain tradeoffs. An offsetting win and loss is disclosed even when total impact is zero. If no result changes, a clear Simple rooting call remains with a low-impact explanation, never a claim that the matchup is locked. Missing affected-matchup data, unknown selected rosters, or mismatched source periods prevent a complete Advanced conclusion. Independently timed cumulative player-stat mismatches remain visible warnings. Official matchup totals remain the anchor; live defensive deltas additionally require the cumulative scoring context described above. Every complete selected league stays in the comparison, including leagues where the player has no exposure and the result therefore stays constant. A genuinely incomplete unrelated matchup may be excluded as an unknown constant, with scope disclosed. Same-league shared points can cancel even if their value is missing, without fabricating either final score. Zero or negative direct projections can contribute to a baseline but cannot support that player's ordered multiplier comparison; those players retain a labeled Simple fallback and do not disappear. ### Traceability and verification `backend/projection-exposure.js` supplies `board.exposureGuide` with scoring, projection methods, per-appearance `remainingTrace`, and provenance. `backend/remaining-defense.js` supplies defensive deltas and the explicit regulation-end condition. `backend/projection-sensitivity.js` supplies `board.matchupGuide` with per-league baseline margins, per-player thresholds and scenario results, impact and best ranges, policy, and exclusions. `backend/api.js` uses the same three guide paths for live inputs and frozen replay; replay skips only the older interactive play simulator. `backend/monte-carlo.js` supplies `board.monteCarloGuide` using the versioned server-side historical library. An unavailable simulation retains a labeled Simple fallback rather than fabricating a zero probability. `dist/player-outlook.js` selects the mode and sorts; `dist/football-app.js` explains the result. Calculation details are inspectable in the website. The repository's `docs/ADVANCED_RANKING_MODEL.md` is the human walkthrough, including a worked own-two/facing-one example and a change checklist. `tests/projection-sensitivity.test.mjs` checks hand-calculated results, thresholds, narrow middle preferences, cancellation, weights, side swaps, coverage, and invariants. API/UI tests check independent mode selection, fallbacks, and frozen replay. Historical replay tests responsiveness and consistency, not calibration. Policy changes must update code, tests, this public specification, and the human walkthrough together. ### Fixed Week 6 diagnostic replay **Test saved Week 6** on the welcome screen opens the saved Shaankapur recordings directly, without first fetching a live account. The server-side fixture contains 18 genuine 2026 Week 6 checkpoints and all four leagues, from Sunday afternoon through Monday's all-games-final state. Its original inputs and hashes remain unchanged when the calculation changes. Today's model is rerun on each saved frame, and its calculation time is separate from the historical input timestamps. The fixture stays Week 6 as the season advances; normal username search still resolves the current NFL week from Sleeper. The archive does not query live Sleeper/scoreboard providers, interpolate missing scores, or invent unrecorded Thursday and Sunday-kickoff states. The regression contract requires complete four-league baselines at every saved checkpoint under the disclosed projection and regulation-end assumptions. At all-games-final there should be no active rooting players. Documentation and provenance are in `docs/DIAGNOSTIC_REPLAY.md`. ## Experimental historical Monte Carlo guide The human walkthrough is `docs/MONTE_CARLO_MODEL.md`. This is a separate selectable guide, not a replacement for Advanced's deterministic threshold analysis or the older linked-play forecast described below. The historical library contains actual regular-season appearances from 2023–2025. Historical games must precede the target season/week. The sampler retains observed zero production and negative scores; it does not add an arbitrary zero spike, assume uniformly likely point totals, or cap a player at 1.5 times their career high. It cannot estimate performances beyond the historical support, including unprecedented extremes. New players can use their position's historical pool. Missing support remains explicit. For donor stat line H_k and fixed reference scoring function S_ref, the reweighted empirical distribution is: ```text Q(H_k) = b_k * exp(lambda * S_ref(H_k)) / sum_j b_j * exp(lambda * S_ref(H_j)) Choose lambda so sum_k Q(H_k) * S_ref(H_k) = source reference projection. Effective sample size = 1 / sum_k Q(H_k)^2. ``` Base weights b combine a player's own history with their position pool. The blend and support thresholds are declared modeling policies, not fitted proofs of predictive accuracy. The projection is treated as a mean anchor; Sleeper does not certify that interpretation. Matching one reference score does not match every projected statistic or every league's expected score. There is no as-issued historical forecast archive in this library, so this is not a validated model of historical forecast errors. Before kickoff the sampled full stat line is used. During a game, offensive event counts are thinned with the remaining clock fraction: a selected touchdown remains a whole touchdown. The model does not award a fraction of six points as the only possible late score. Related counts are grouped; yardage uses the retained share of its event family. Live defensive points and yards allowed use a continuous allowance proxy before recomputing tiers. These are explicit approximations because weekly totals do not reveal the timing or sequence of the historical plays. They do not use possessions, field position, substitutions, or a refreshed estimate of player opportunity. Official current matchup scores remain the anchor. For draw i: ```text M_li = current margin_l + sum_p signed additional fantasy points_lpi R_li = 1 if M_li > 0, 0.5 for a tie, and 0 otherwise U_i = sum_l weight_l * R_li Baseline estimated result = mean_i U_i ``` For every sampled player finish h, replace that player's contribution in every league by the same stat line h and cross it with all other players' draws. The comparison estimates V_p(h) = mean_i U_i(h). Ranking policy v2 uses one likelihood-weighted ordering: ```text center_p = mean_h V_p(h) importance_p = mean_h abs(V_p(h) - center_p) ``` Sample frequencies already represent modeled probability. This is the mean absolute deviation of expected weighted wins across plausible finishes, not the former largest-minus-smallest spread. A finish that flips one league with frequency p gives importance 2p(1-p), so a 50/50 close contest ranks above a 1% extreme with the same full-win range. Effects across leagues are summed before taking the absolute deviation. The centering mean comes from recombined target/non-target draws; finite samples can make it differ from the original paired baseline. The metric is not a probability or an expected improvement the user can cause. Sorted residual margins evaluate every empirical pair with the same rounded win/tie policy without constructing a quadratic matrix. The card labels this quantity **Win impact** in **expected wins**, or **weighted wins** when league importance differs from one. It is not an invented normalization or a 0–100 grade. A value of 0.20 means an average absolute deviation of 0.20 expected results around that player's recombined mean; it is neither a 20% win chance nor a promised 0.20-win improvement. Compare scores under the same league selection, weights and snapshot. Opposing exposures are combined before taking the absolute deviation, so the combined MAD need not equal the sum of weighted per-league MADs. Display precision is two decimals, except positive values below 0.01 use `<0.01`. `0.00` means an observed zero effect in the sampled comparisons, not a locked matchup. A Win impact score requires a valid available comparison with complete selected-league coverage; fallback calls have no substitute Monte Carlo score. Direction compares average V in the lower, middle and upper probability thirds of sampled reference-score finishes. Tied reference scores are shared fairly across boundaries. Increasing means favor more production, decreasing means less, a higher middle favors a moderate finish, and a lower middle means a tradeoff. This is a descriptive rule, not a proven optimal point interval. The 20th/50th/80th percentile examples and tail/zero cases remain explicitly labeled details. Their range is retained as scenarioRange, never the primary ranking. Neither these examples nor a finite grid exhaust all possible finishes. The primary Why table and card insights use per-league averages over these same equal-probability thirds, with the same canonical-score tie splitting. The old three fixed examples are collapsed separately. For every band: ```text league expectedResult = P(win) + 0.5 * P(tie) combined expectedWeightedResults = sum_l weight_l * league expectedResult ``` Win chance displays pure P(win); it must not silently include half-credit ties. A tie-driven result change explicitly shows tie evidence. All selected leagues remain in the table, including constant rows for no exposure or both-sided exposure. Insight candidates exclude those constant exposures and zero-weight leagues, order the affected rows by `weight * per-league MAD`, and select a visible probability change supporting the overall direction. Moderate or mixed preferences can identify the two competing league effects. No generic explanation is substituted when specific evidence is unavailable. Trace fields are `players[].rankingScore` (also `impact`), `comparison.likelihoodWeighted`, and `rows[].likelihoodWeighted`. Each row includes `sampleCount`, `meanExpectedResult`, `meanWinProbability`, `meanTieProbability`, unweighted `meanAbsoluteDeviation`, and `bands.{lower,middle,upper}`. Every band includes its probability mass of 1/3 and separate win, tie, loss and expected-result values. Per-sample arrays stay internal. The new card score and evidence summaries leave the existing ranking metric, direction, sampling policy and deterministic seeds unchanged. Win and tie probabilities, weighted expected results, history support, simulation count, coverage, and sampling uncertainty are traceable in the response. Ties count as half a result. A one-sided starter retains their root-for/root-against direction when estimated impact is small. Missing selected matchup data cannot silently become a complete portfolio claim. Score-reconciliation warnings now flow into Monte Carlo. A conflicting live defensive score with cumulative tier rules temporarily withholds that league's estimate; other disagreements qualify the estimates while preserving official matchup totals. Imported leagues remain visible and missing overall estimates retain labeled Simple exposure calls. Source health and request timestamps are reported without treating them as proof of play-level freshness. Different NFL players are sampled independently in this first version. Sharing a player across leagues is implemented, but QB/receiver, opposing defense, and game-environment dependence is not. Paired player interventions are statistical sensitivity tests, not causal, physically complete game simulations. The older event ledger has different linked-play mechanics; it is not silently mixed into this guide. Injury probabilities and future lineup changes are also outside the model. Repeated runs with identical input/data versions use stable pseudorandom streams. More draws reduce Monte Carlo noise inside this specified model; they do not resolve model error, improve historical coverage, or demonstrate calibration. Sampling policy v1 remains unchanged by ranking policy v2, keeping the existing random draws stable. Scenario standard errors are not uncertainty estimates for player priority or band-based direction. Tests and Week 6 replay establish implementation consistency, not that a displayed 70% chance wins 70% of future matchups. Rolling temporal backtests, calibration and comparison against simpler baselines remain required before making accuracy claims. ## Separate experimental event forecast The remaining sections describe the retained event ledger and experimental stochastic forecast used by the optional play explorer. Their probability estimates and old cohort rankings do not drive Simple or Advanced. The forecast remains uncalibrated; extra simulation samples improve numerical precision, not the correctness of its assumptions. ## Additional scoring and forecast calculations Beyond this primary guide, Bandwagon separates two questions: 1. **What does a specified football event do to every fantasy matchup?** This is scoring arithmetic, exact for the supported rules and supplied event context. 2. **How likely are different remaining outcomes?** This is a forecast conditional on a stated stochastic model and provider inputs. A correct implementation does not establish predictive accuracy. ## Exact shared scoring ledger Let `l` index leagues, `p` index players or team defenses, and `w_l >= 0` be the user's league importance. Define the signed exposure ```text a_lp = 1[p starts for the user in l] - 1[p starts for the opponent in l]. ``` Let `X` contain cumulative football statistics and `S_lp(X)` be player `p`'s fantasy score under league `l`'s rules. An event `e` changes the common state through `T_e(X)`. Its exact matchup-margin change is ```text delta_l(e | X) = sum_p a_lp * (S_lp(T_e(X)) - S_lp(X)). ``` The event exists once. Its effects on a passer, receiver, opposing defense, and any other supported participant all flow from the same ledger. A league does not invent a separate performance for a player it scores differently. A player appearing on both fantasy sides has `a_lp = 0`, so their mean and uncertainty cancel for that matchup. Scoring before and after a state transition matters for nonlinear rules. For example, moving from one points-allowed tier to the next replaces the defensive credit. It does not add a second tier. Sleeper also treats cumulative player-yardage milestones and reception-distance bands as exclusive, while its long-touchdown bonuses can stack. See [Sleeper scoring options](https://support.sleeper.com/en/articles/3998131-what-scoring-options-are-available) and [Sleeper's stacking rules](https://support.sleeper.com/en/articles/3186339-what-stacks). A normal completed pass couples the passer's yards to the receiver's yards. A passing touchdown also couples their touchdown counts. A successful extra point is a separate event; it must not be silently added to the touchdown. Defensive yards allowed use net rushing and net passing yardage, so sack yardage changes that total. See [Sleeper's yards-allowed definition](https://support.sleeper.com/en/articles/4126427-how-are-yards-allowed-calculated). Unsupported scoring rules or missing required context must be reported, rather than silently scored as zero. “Exact” refers to supported scoring applied to the stated inputs; it does not certify provider accuracy or the possibility of every arbitrary event sequence. The public legacy event ledger is sparse: individual player entries whose point delta is exactly zero are omitted, with `omittedZeroPlayerCount` on each league row. Nonzero and unavailable deltas, league totals, issues and exact stat changes remain. The full server model is retained for scenario evaluation. This avoids repeatedly transmitting unchanged starters for hundreds of plays; it does not change scoring or exclude a league. ## Multi-league objective For a common future football outcome `omega`, let `M_l(omega)` be the resulting fantasy matchup margin. The chosen utility is ```text u_l(omega) = 1, if M_l(omega) > 0 1/2, if M_l(omega) = 0 0, if M_l(omega) < 0 U(omega) = sum_l w_l * u_l(omega). ``` Thus `0 <= U <= sum_l w_l`. Equal league weights measure the expected number of weekly wins, with a tie worth half a win. The engine uses a small numerical tolerance around zero margin to prevent floating-point arithmetic from creating a spurious win. This is a user-selected objective, not an objective definition of what every user should value. It does not measure the probability of winning every league simultaneously, playoff qualification, championship odds, or prize money. All baseline and scenario comparisons must use the same included leagues and weights. Removing an unsupported league from only one scenario would change the objective being compared. Excluded league counts, reasons, and weights must remain visible. For a single known finish, `U` is deterministic. For a forecast distribution `Q` over shared future outcomes, the desired quantity is `E_Q[U]`. The calculation's meaning depends on `Q`; means alone do not identify a joint distribution or a win probability. ## Explicit event-process assumptions The implementation entry points are `createFootballState`, `applyFootballEvents`, `scoreFootballDelta`, `analyzeFootball`, and `evaluateFootballEvent` in `backend/football-engine.js`. The API calls the same engine used by deterministic tests. `createFootballState` anchors the calculation to imported matchup scores and current cumulative statistics. Pregame cumulative stats start at zero. Pregame defensive tier credits are introduced when the simulated game becomes active, subtracting any defensive starter credit already included in each league's imported score. A live defensive score changes by the difference between its old and new tiers. Current matchup scores remain the anchor instead of being replaced with a reconstructed historical fantasy total. Exact event cards isolate the play after the initial defensive credit, so a pass is not credited with starting the entire game's defensive score. The forecast constructs shared event channels. Counts are sampled per channel and every resulting play updates one common football ledger. Reconciled receiving channels update the same quarterback and receiver together. Rushing, passing, field-goal, turnover, and supported defensive events also affect the opposing team where the scoring rules require it. For each active team, the primary projected quarterback anchors aggregate completions, passing touchdowns, and passing yards. Receiver projection totals are rescaled to those team totals. For example, if `c_q` is the quarterback's completion projection and receivers have projected catches `c_r`, their adjusted catch means are ```text c'_r = c_r * c_q / sum_r c_r. ``` Touchdown and yardage shares are reconciled separately. These adjustments change provider marginal forecasts and are reported in `diagnostics.reconciliations`. They are bookkeeping choices, not newly observed evidence. A projection set that cannot support an event mechanism must produce an explicit issue rather than an unreported zero contribution. Non-touchdown and touchdown completion channels are disjoint: a receiver's reconciled catch rate `c` and touchdown rate `t` yield rates `c - t` and `t`. Rushing channels use the analogous attempt split. A touchdown channel represents a touchdown **within** a catch or rush, so it does not create an extra catch or rush on top of that event. Integer yardage marks use a maximum-entropy distribution on a declared finite support: ```text P(Y = y | theta) = exp(theta * y) / sum_z exp(theta * z) choose theta such that E[Y] equals reconciled projected yards per play. ``` The initial forecast supports nonnegative yards `0...99`, or `1...99` for touchdowns. That support and the maximum-entropy choice are assumptions; a provider mean does not identify a real yardage distribution. Exact event calculations separately support negative-yard plays. The process does not track field position, drives, possessions, substitutions, or clock consumption. A sequence can obey shared-stat identities without being a complete physical simulation of a game. A sampled offensive touchdown can generate a linked PAT attempt. Its conversion parameter uses the available projected make/attempt ratio. The current process does not model the decision to attempt a two-point conversion. Supplied “touchdown only” what-if events remain separate from an extra-point event; the engine must not silently add the kick to an exact point-change table. Defensive return touchdowns are marks on the opposing offense's interception and lost-fumble events. Forced fumbles are marks on fumble events; blocked kicks are marks on missed-kick events. The intended mark probability is the projected marked-event rate divided by the available parent-event rate. A mark probability cannot exceed one; any resulting reduction of an inconsistent projection is reported as a reconciliation. A missing parent mechanism is an input-coverage failure. Safeties and special-teams touchdowns use separate channels in this first process; the detailed play sequence that caused them is not generated. Made-field-goal distances preserve the projected counts in each available distance bin. Within a bin, a common exponential tilt determines the maximum-entropy distance probabilities. The tilt is fitted so the expected total made-field-goal yards matches the provider's projected total. If bin `b` has count mean `lambda_b` and distance bounds `[lo_b, hi_b]`, feasibility requires ```text sum_b lambda_b * lo_b <= projected FG yards <= sum_b lambda_b * hi_b. ``` Infeasible constraints are reported. Field-goal support begins at 10 yards; the under-20-yard bin uses `10...19`. A provider's combined `50+` bin can therefore imply a modeled split between `50–59` and `60+`; that split is inferred, not observed. Unallocated makes assigned to the under-20-yard bin are also reported. Missing sack-loss means or missed-kick distances can leave particular scoring categories unsupported even when standard scoring remains usable. The common field-goal tilt follows by maximizing `sum_b lambda_b * H(P_b)` subject to normalization within each bin and the one total-yardage constraint. A Lagrange multiplier on that shared constraint yields `P_b(d) proportional to exp(theta * d)` with the same `theta` for every bin. This explains the fitting rule; it does not establish that real kick distances maximize entropy. Live event means inherit the feed adapter's full-game projection multiplied by remaining clock share. This scaling is an assumption, not a possession-aware estimate. It does not subtract a hot player's actual points from their original projection. Finished, bye, and confirmed out states produce no future event rate; missing game timing or required projections remain unavailable. ## Monte Carlo precision and calibration The connected backend uses explicit event-count assumptions rather than invented position-specific point spreads. Where an event count is modeled as Poisson, ```text P(N = k | lambda) = exp(-lambda) * lambda^k / k!, k = 0, 1, ... E[N] = Var(N) = lambda. ``` This is a distributional assumption. It makes count variance depend on the input rate; it does not prove that football events have Poisson variance or occur independently. The distribution's definition and moments are given by the [NIST Poisson reference](https://www.itl.nist.gov/div898/handbook/eda/section3/eda366j.htm). For `n` independent simulated worlds, the Monte Carlo estimate and its numerical standard error are ```text mean_U = sum_i U_i / n s_U^2 = sum_i (U_i - mean_U)^2 / (n - 1) MCSE = s_U / sqrt(n). ``` For a scenario compared using the same random worlds, use paired differences `D_i = U_i(scenario) - U_i(baseline)` and `s_D / sqrt(n)`. Do not sum independent league-error estimates: leagues share football outcomes. The sample-mean standard-error formula is described by [NIST](https://www.itl.nist.gov/div898/handbook/eda/section3/eda352.htm). Monte Carlo standard error measures sampling noise **inside the chosen model**. It does not measure projection error, missing football mechanisms, wrong event-rate assumptions, provider latency, injury uncertainty, or calibration error. More samples can narrow this numerical error without making a forecast closer to reality. A zero estimated error when every sample agrees is not a guarantee. Approximate baseline and event intervals are pointwise sampling intervals; they do not certify the ordering of hundreds of selected event estimates. ## Meaning of an event ranking For each displayed event `e`, the engine computes a paired added-event perturbation: ```text Delta_e = E_Q[U(T_e(omega)) - U(omega)]. ``` It appends the specified event to each already sampled finish while holding other sampled events fixed. This is not `P(win | e happened)`, does not replace a different play, and does not consume time or reduce the remaining opportunity count. A recommendation applies to that defined perturbation. Its sign can differ from the value of replacing a passing touchdown with a rushing touchdown, or from the value of a real observed play that changes possession and clock. The detailed play explorer sorts by the absolute estimated effect of one extra specified event. The experimental player-cohort output uses the quiet, middle, and strong finish comparisons documented below; neither primary guide mode uses those rankings. Fixed distances displayed in an event title are what-if templates. A channel's expected count generally covers all modeled distances, so it must not be described as the expected number of plays at exactly the displayed distance. Count scenarios repeat the same linked event; they are additions to sampled production, not a minimum touchdown requirement or a guaranteed winning target. Current-state exact point changes and terminal-world point changes can differ when a defense or cumulative bonus crosses a scoring threshold. The response keeps exact current-state deltas and sampled terminal delta ranges separate. ## Data provenance and coverage The backend imports public Sleeper leagues, selected-week starting lineups, current matchup scores, and each league's scoring settings. It then expands the football context to provider rows from the relevant NFL teams and their scheduled opponents, including players who appear in none of the user's fantasy lineups. This prevents the user's fantasy holdings from defining which receivers or quarterbacks exist in a game. The input bundle keeps projection and actual-stat timestamps, provider identifiers, game statuses, remaining clock fractions, original starter IDs, context-player IDs, and missing-coverage indicators. Unprojected context players remain distinguishable from explicit zero projections. Scores, player team associations, injuries, and projections must match the chosen period; current injuries must not be retroactively applied to historical weeks. The public projection/stat endpoints and ESPN scoreboard are undocumented dependencies. Their availability and schemas can change. Provider marginal projections are inputs, not a proof of consistent joint football outcomes. Any reconciliation of conflicting team and player totals must be described by the implementation and exposed as a model assumption. Sleeper charges offensive touchdowns, qualifying special-teams touchdowns, field goals, and all successful tries to the opposing defense's points allowed. A defensive interception/fumble-return touchdown itself does not count against the other fantasy defense, but its subsequent successful try does. The exact ledger keeps those steps distinct. See [Sleeper's points-allowed rules](https://support.sleeper.com/en/articles/4126495-how-are-points-allowed-calculated). The server keeps one recent analysis in process memory for a short scenario window; there is no account database or disk persistence. A failed refresh retains the previous unexpired analysis. This cache is ephemeral: another analysis replaces it, and a restart or request served by a different Worker isolate can lose it. Scenario requests include a validated analysis configuration so a cache miss rebuilds and evaluates within the same request. The response includes the refreshed baseline, which the interface replaces alongside the scenario; it must not compare a new result with an old baseline. If the selected event no longer exists, the response supplies the refreshed board without substituting a different event. Requests without refresh configuration retain the explicit expired-analysis response. HTTP responses use `Cache-Control: no-store`. Public league data is processed by the backend for the request and short-lived scenario window. ## Validation acceptance Deterministic tests should establish the following before probability displays are used: - A linked pass updates every supported participant once and is scored under every league's rules. - PPR, passing-touchdown rates, position premiums, and supported defensive thresholds produce hand-calculated deltas. - Swapping fantasy sides negates margin changes; identical exposure on both sides cancels. - Sequential event deltas telescope to the final-minus-initial score, including nonlinear threshold crossings. - Missing actors, invalid team/game relationships, unsupported scoring, and missing required cumulative statistics never produce a falsely exact aggregate. - A finished player or game has no modeled future production. Unknown inputs remain unknown. - Baseline and scenario utility stay in bounds and share the same league cohort. - Seeded runs are reproducible. Shared outcomes are reused across leagues. - API requests are bounded and validated before computation; cached scenarios refer to server-held, unexpired analyses. Forecast validation is separate. It requires historical inputs captured as they were available at prediction time, held-out weeks or seasons, comparison with a simple baseline, probability calibration checks, and proper scoring rules such as Brier or log score. No claim of calibration should be made before those results exist. Unit tests and a low Monte Carlo standard error do not substitute for that evaluation. --- # Player rooting recommendations Recommendations compare **quiet, middle, and strong remaining finishes** within one shared football simulation. The cohorts contain the lowest quarter, middle half, and highest quarter of each player's simulated fantasy performance. They retain shared quarterback/receiver statistics, defensive effects, and every included league's individual scoring rules. The response identifies this policy as `partial-preferences-v2`. Useful guidance does not require one cohort to be uniquely best: both a decent and a strong finish can help, or both a quiet and a decent finish can be preferable to a big one. Covered active players stay visible when the sample cannot support advice. These are conditional associations, not interventions or guaranteed point requirements. The added-event API remains a separate calculation: it adds a specified linked event to each future world while holding other events fixed. Neither calculation is a clock-aware counterfactual of a real observed play. ## Portfolio objective and event linkage The account baseline remains `E[U] = E[Σ_l w_l × (I(win_l) + 0.5 I(tie_l))]`. Included leagues with positive importance weight contribute. With equal weights, this is an expected number of weekly win equivalents; unequal weights make it a priority-weighted result. It is not the probability of winning every league. Each independently sampled event channel has one input identity. Its count and all its random marks belong to that identity, including yardage, return/block marks, and linked PAT offspring. Each player carries the set of inputs that may change their raw statistics. Each league carries the union for its active, non-cancelling starters. A player and league are linked only if their sets intersect. Finished, bye, and out starters cannot create a dependency. A player on both fantasy sides cancels and cannot by itself link that league. This is a conservative dependency boundary inside the stated model. It may retain an input whose changed stat earns no points under a particular rule, but it must not remove a possible scoring dependency. Disjoint input sets are independent in the event process and cannot supply accidental cohort associations. Sets are intersected directly, without transitive closure: two independent receiver channels do not become dependent merely because both also update a common QB. Real football can have relationships that this model does not represent. Let `L_p` be these linked leagues. The recommendation's world utility is `U_ps = Σ_(l in L_p) w_l × (I(win_ls) + 0.5 I(tie_ls))`. The full account baseline is not changed. `linkedBaselineObjective` and `linkedTotalWeight` identify the local comparison; they may both be zero for a visible player with no uncancelled stochastic dependency. A linked league's result can also depend on independent inputs, including other games; this remaining uncertainty is retained. ## Player performance and cohort membership Let `E_p` contain included positive-weight leagues in which the player starts on either fantasy side. Performance in world `s` is `X_ps = Σ_(l in E_p) w_l × futurePoints_pls / Σ_(l in E_p) w_l`. Each league applies its supported exact scoring rules to the same raw statistics. Ownership does not negate the performance axis: larger values mean more fantasy production by the player. A player appearing on both sides enters a league's axis once. Known pregame defensive credits already included in imported scores are subtracted from future production. League priorities affect both the utility and this scoring-average axis; changing priorities can change cohort membership. For `N` worlds, quiet and strong each have sample mass `N/4`. Middle has mass `N/2`. At a tied boundary, all worlds sharing that performance receive the same fractional membership needed to fill the cohort. Portfolio outcomes never break performance ties. Middle membership is `1 − quietWeight − strongWeight` in every world, so the three memberships partition the full sample even when boundary values overlap. A rare-scoring player's quiet and strong cutoff can both be zero: the strong quarter can contain every positive finish plus some zero finishes. Cohort means are averages, not exact obtainable scores or target boundaries. For cohort `c`, calculate `A_pc = Σ_s membership_pcs × U_ps / cohortMass_c`. Each league separately exposes **true** `P(win | c)` and `P(tie | c)`. Its expected result is `P(win | c) + 0.5 P(tie | c)`. A half-credit tie score must not be labeled win probability. Per-league probabilities are unweighted; importance weights enter only aggregate utility. Do not sum percentages and call the sum an overall probability. Per-league cohort rows also expose mean player remaining fantasy points under that league's rules and both fantasy teams' mean remaining points. Player points can be null where scoring the unowned contextual player is unsupported. These conditional means do not isolate one player's causal contribution. The partition creates useful audit identities: `.25 quiet + .50 middle + .25 strong` recovers each league's unconditional win/tie/result probabilities and the player's overall mean remaining points. The same mixture of aggregate cohort utilities recovers `linkedBaselineObjective`, not necessarily the full-account baseline. ## Sampling support and classification Three contrasts determine the recommendation: - `strongMinusQuiet = A_strong − A_quiet` - `middleMinusQuiet = A_middle − A_quiet` - `middleMinusStrong = A_middle − A_strong` The engine uses 128 bootstrap resamples of the complete simulated world indices. The same resample counts apply to every player and every league, retaining their joint dependence. Every resample recomputes the quiet/middle/strong membership from its empirical performance distribution, including fractional boundary ties. It does not treat the three cohorts as independent groups or hold their observed membership fixed. For each contrast `j`, let `D_j` be the original estimate and `D*_jb` its bootstrap value. Let `s_j` be the sample standard deviation of those bootstrap values. For each replicate, form `M_b = max_j |D*_jb − D_j| / s_j`, where the maximum includes all three contrasts for every retained player with nonzero bootstrap standard deviation. The empirical 95th percentile `k` of these maxima defines intervals `D_j ± k s_j`, intersected with the mathematical utility bounds. Contrasts with zero empirical bootstrap variation have zero estimated sampling width. That does not establish impossibility of unseen outcomes. These are **approximate simultaneous Monte Carlo intervals**, intended to restrain selection of noisy extremes in the displayed player lists. Their finite-sample and discrete-quantile behavior is not a coverage guarantee. They address sampling inside the chosen model, not projection accuracy, missing football mechanisms, or forecast calibration. A fixed seed provides reproducibility, not evidence of correctness. More simulations can improve numerical resolution without fixing model errors. Classification uses a numerical tolerance of `1e-8`. First, a player with no sampled performance variation or no sampled linked-utility variation remains visible as `kind: unclear`, `intent: low_sampled_impact`. Its label says that no matchup swing was seen **in these simulations**. This never establishes a lock or impossibility of an unseen rare outcome. For other players, the following cases are evaluated in order: - **moderate:** the lower bounds for both middle-minus-quiet and middle-minus-strong are positive; - **for / strong_finish:** strong-minus-quiet has a positive lower bound, and middle-minus-strong has a nonpositive upper bound; - **against / quiet_finish:** strong-minus-quiet has a negative upper bound, and middle-minus-quiet has a nonpositive upper bound; - **for / avoid_quiet:** both middle-minus-quiet and strong-minus-quiet have positive lower bounds. Both better cohorts are supported; their ordering is unresolved; - **against / avoid_strong:** middle-minus-strong has a positive lower bound and strong-minus-quiet has a negative upper bound. Both quieter cohorts are supported; their ordering is unresolved; - otherwise, a direction may follow from the restricted analytical proof below; if not, the result is **unclear / unresolved**. `bestCohort` is null for partial preferences. The interface must not relabel `avoid_quiet` as proof that a huge game is optimal, or `avoid_strong` as proof that zero production is optimal. `supportedComparisons` records each named contrast whose interval lies wholly above or below zero. A middle recommendation means the middle cohort beats both outer cohorts; it is not proof of a globally optimal exact point interval. These are conditional finish comparisons, not an instruction that every play involving the player has the same effect. ### Restricted analytical monotonicity The engine can prove a direction in **net future fantasy points** when all of the following hold: - The player's exposed included leagues use identical applicable scoring maps. - All uncancelled direct exposures are on one fantasy side. - No other uncancelled active starter in any included positive-weight league shares an event input with this player. Under these conditions, each affected margin is `+X + Z` or `-X + Z`, with the same side in every league. Here `X` is the player's net fantasy production and `Z` does not share its stochastic inputs. Winning/tie utility is monotone in the margin, so the weighted result is monotone in `X`. This can establish a direction even when a finite bootstrap interval fails to respect a known plateau or a rare observed swing. The engine applies this fallback only after the sample shows both performance variation and linked-result variation; it does not promote an unobserved rare swing into a material recommendation. This proof deliberately rejects linked QB/receiver/DST/PAT exposure and differing scoring maps, even when a broader proof might be possible. Ownership alone is insufficient. It establishes neither a calibrated win probability nor the value of an arbitrary football event: an event can change multiple players and the real game's clock. The field `recommendation.evidence.basis` distinguishes `analytical_monotonicity`, `simulation`, and `insufficient_simulation`. The ranking score is `max_c A_pc − min_c A_pc`. Rows sort by that observed range, then deterministic name/ID tie breaks. The score prioritizes consequential comparisons; its confidence is separately represented by the classification and intervals. Only supported `for` and `against` rows belong in confident direction lists. Moderate and unclear rows require their own labels. ## Eligibility, metadata, and compatibility Finished, bye, out, unknown-status, uncovered, zero-weight-only, and unsupported players are excluded. Covered active players remain even when performance or linked utility is constant across all sampled worlds. Equal quiet and strong means do not exclude a useful middle preference. Exclusion reasons are recorded in `playerRankingExclusions`; absence of variation is instead described in the visible row's `recommendation.evidence`. Candidates remain the user's fantasy starters and their opponents' starters. Unowned context players remain in the shared football process. Observed game metadata, such as a supplied halftime detail, period, and display clock, is preserved; no exact clock is invented when the feed omits it. `recommendation`, `guidance`, `cohorts`, `linkedLeagueIds`, and `uncertainty` are the authoritative recommendation fields. Legacy `associationDelta`, `importance`, `direction`, `lowExpectedWins`, and `highExpectedWins` remain full-account two-tail audit summaries for compatibility. They can be neutral or disagree with the new classification and must not drive the new UI. Every included positive-weight league remains in `leagues[]`; its `linked` flag determines whether it contributes to the new cohort utility. The underlying event model remains uncalibrated. Its Poisson event assumptions, maximum-entropy yardage marks, clock-based remaining-rate estimates, and omitted mechanisms still apply. Unit tests and Monte Carlo intervals establish internal behavior, not predictive accuracy. Production-size regression tests assert `recommendation.kind` and `intent`, not just the obsolete legacy direction. They cover the original conflicting-league case, unresolved plateaus, analytical monotonicity, unseen rare outcomes, same-game independent receivers, shared PAT exposure, ties, scoring variants, and a useful middle preference. A larger simulation budget improves numerical resolution only. Finished actors retain fixed base statistics instead of repeated per-world arrays, reducing memory use late in the week without changing results. ## Exact current-score requirements and sampling budget The API also returns `board.rootingTargets`, independently of simulation outcomes. For each league, a win requires current score margin plus own remaining fantasy-point changes minus opposing remaining changes to be strictly positive. Every term uses that league’s scoring; equality is a tie. Negative point changes and conditional dependencies on other remaining players are preserved. Unknown status stays explicit and cannot establish a finished matchup. Current-score results remain subject to later stat corrections. The target module compares league-credited player points with cumulative stats scored under the same rules. A mismatch is a data-quality warning, not permission to overwrite authoritative matchup totals. Provider update time, fetch time and game-clock state are separate; age alone does not prove a stalled feed. The hosted API uses 512 worlds normally and 2,048 only for a bounded remaining slate: at most 48 active context players, two games and eight leagues, with no unknown starter statuses or active game IDs. Finished actors retain their fixed state without duplicated sample columns. This controls runtime and improves simulation precision; it does not calibrate the probability model. The separate offline calibration evaluator requires timestamped forecasts, predeclared evaluation horizons and final outcomes known after prediction. It excludes pending truth and leakage, and measures Brier scores/reliability against a simple baseline without claiming established calibration.