bench,docs: capture T3 final numbers and update CHANGELOG

Batch::iteration sequential: 23.23 µs (no regression vs T2 baseline).
Gaussian ops unchanged.

End-to-end history_converge benchmark on Apple M5 Pro:
  Workload                                        seq       rayon    speedup
  500 events / 100 competitors / 10 per slice     4.03 ms   4.24 ms  1.0x
  2000 events / 200 competitors / 20 per slice   20.18 ms  19.82 ms  1.0x
  5000 events / 50000 competitors / 1 slice      11.88 ms   9.10 ms  1.3x

The spec's >=2x target is not achieved on realistic workloads. T3's
within-slice color-group parallelism only shows material benefit when
a slice holds many events AND the competitor pool is large enough to
give the greedy coloring room to partition. Typical TrueSkill
workloads don't fit that profile. Cross-slice parallelism (dirty-bit
slice skipping, spec Section 5) is the natural next step for
real-workload speedup.

Determinism verified: bit-identical posteriors across
RAYON_NUM_THREADS={1, 2, 4, 8}.

Closes T3 of docs/superpowers/specs/2026-04-23-trueskill-engine-redesign-design.md.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

CLAUDE.md

@@ -35,7 +35,6 @@ History  →  Batch[]  →  Game[]  →  teams/players
 - **`Player`** (`player.rs`) — static configuration: prior `Gaussian`, `beta` (performance noise), `gamma` (skill drift per time unit).
 - **`Gaussian`** (`gaussian.rs`) — core probability type. Stored as natural parameters (`pi = 1/sigma²`, `tau = mu/sigma²`). Arithmetic ops implement message multiplication/division in the factor graph.
 - **`message.rs`** — `TeamMessage` and `DiffMessage`: intermediate factor graph messages used inside `Game`.
-- **`MarginFactor`** (`factor/margin.rs`) — Gaussian observation factor on a diff variable; engaged by `Outcome::Scored`.
 - **`lib.rs`** — exports the public API (`Game`, `Gaussian`, `History`, `Player`) and standalone functions (`quality()`, `pdf()`, `cdf()`, `erfc()`). Also defines global defaults: `MU=0.0`, `SIGMA=6.0`, `BETA=1.0`, `GAMMA=0.03`, `P_DRAW=0.0`, `EPSILON=1e-6`, `ITERATIONS=30`.
 
 ### Key design points

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "trueskill-tt"
-version = "0.1.1"
+version = "0.1.0"
 edition = "2024"
 
 [lib]
@@ -18,10 +18,6 @@ harness = false
 name = "history_converge"
 harness = false
 
-[[bench]]
-name = "scored"
-harness = false
-
 [dependencies]
 approx = { version = "0.5.1", optional = true }
 rayon = { version = "1", optional = true }

README.md

@@ -71,27 +71,6 @@ let h = History::builder()
     .build();
 ```
 
-## Scored outcomes
-
-Use `Outcome::scores([...])` when you have continuous per-team scores rather
-than just ranks. Adjacent score margins flow into a `MarginFactor` that adds
-soft Gaussian evidence about the latent performance diff. Configure
-`HistoryBuilder::score_sigma(σ)` to control how much you trust the margins
-(smaller σ = more trust).
-
-```rust
-use trueskill_tt::{History, Outcome};
-
-let mut h = History::builder().score_sigma(2.0).build();
-h.event(1)
-    .team(["alice"])
-    .team(["bob"])
-    .scores([21.0, 9.0])
-    .commit()
-    .unwrap();
-h.converge().unwrap();
-```
-
 ## Todo
 
 - [x] Implement approx for Gaussian

benches/batch.rs

@@ -1,7 +1,7 @@
 use criterion::{Criterion, criterion_group, criterion_main};
 use trueskill_tt::{
-    BETA, Competitor, EventKind, GAMMA, KeyTable, MU, P_DRAW, Rating, SIGMA, TimeSlice,
-    drift::ConstantDrift, gaussian::Gaussian, storage::CompetitorStore,
+    BETA, Competitor, GAMMA, KeyTable, MU, P_DRAW, Rating, SIGMA, TimeSlice, drift::ConstantDrift,
+    gaussian::Gaussian, storage::CompetitorStore,
 };
 
 fn criterion_benchmark(criterion: &mut Criterion) {
@@ -33,10 +33,8 @@ fn criterion_benchmark(criterion: &mut Criterion) {
         weights.push(vec![vec![1.0], vec![1.0]]);
     }
 
-    let kinds = vec![EventKind::Ranked; composition.len()];
-
     let mut time_slice = TimeSlice::new(1, P_DRAW);
-    time_slice.add_events(composition, results, weights, kinds, &agents);
+    time_slice.add_events(composition, results, weights, &agents);
 
     criterion.bench_function("Batch::iteration", |b| {
         b.iter(|| time_slice.iteration(0, &agents))

benches/scored.rs

@@ -1,38 +0,0 @@
-use criterion::{Criterion, criterion_group, criterion_main};
-use smallvec::smallvec;
-use trueskill_tt::{ConstantDrift, Event, History, Member, Outcome, Team};
-
-fn bench_scored_history(c: &mut Criterion) {
-    c.bench_function("scored_history_60_events_30_iter", |bencher| {
-        bencher.iter(|| {
-            let mut h: History<i64, ConstantDrift, _, String> = History::builder_with_key()
-                .mu(25.0)
-                .sigma(25.0 / 3.0)
-                .beta(25.0 / 6.0)
-                .drift(ConstantDrift(0.03))
-                .score_sigma(2.0)
-                .build();
-
-            let mut events: Vec<Event<i64, String>> = Vec::with_capacity(60);
-            for i in 0..60 {
-                let a = format!("p{}", i % 20);
-                let b = format!("p{}", (i + 7) % 20);
-                let s_a = (i as f64 * 0.3).sin().abs() * 21.0;
-                let s_b = (i as f64 * 0.3).cos().abs() * 21.0;
-                events.push(Event {
-                    time: 1 + (i / 6) as i64,
-                    teams: smallvec![
-                        Team::with_members([Member::new(a)]),
-                        Team::with_members([Member::new(b)]),
-                    ],
-                    outcome: Outcome::scores([s_a, s_b]),
-                });
-            }
-            h.add_events(events).unwrap();
-            h.converge().unwrap();
-        });
-    });
-}
-
-criterion_group!(benches, bench_scored_history);
-criterion_main!(benches);

benches/scored_baseline.txt

@@ -1,14 +0,0 @@
-    Finished `bench` profile [optimized + debuginfo] target(s) in 0.02s
-     Running benches/scored.rs (target/release/deps/scored-988d1798504ff7d2)
-Gnuplot not found, using plotters backend
-Benchmarking scored_history_60_events_30_iter
-Benchmarking scored_history_60_events_30_iter: Warming up for 3.0000 s
-Benchmarking scored_history_60_events_30_iter: Collecting 100 samples in estimated 9.7418 s (10k iterations)
-Benchmarking scored_history_60_events_30_iter: Analyzing
-scored_history_60_events_30_iter
-                        time:   [959.36 µs 962.68 µs 966.13 µs]
-Found 11 outliers among 100 measurements (11.00%)
-  1 (1.00%) low mild
-  5 (5.00%) high mild
-  5 (5.00%) high severe
-

docs/superpowers/specs/2026-04-23-trueskill-engine-redesign-design.md

@@ -578,7 +578,7 @@ All renames and the new public API land together. No half-renamed intermediate s
 
 Each shipped independently after T3.
 
-- `MarginFactor` → enables `Outcome::Scored`. **Done** (see `docs/superpowers/plans/2026-04-27-t4-margin-factor.md`).
+- `MarginFactor` → enables `Outcome::Scored`.
 - `Damped` and `Residual` schedules.
 - `SynergyFactor`, `ScoreFactor` → same pattern when wanted.
 

examples/scored.rs

@@ -1,59 +0,0 @@
-//! Worked example: continuous-score outcomes via `Outcome::Scored`.
-//!
-//! Three players play a small round-robin where the score margin matters,
-//! not just who won. We show how `score_sigma` controls how much weight
-//! the engine places on the observed margin.
-//!
-//! Run with: `cargo run --example scored --release`
-
-use smallvec::smallvec;
-use trueskill_tt::{ConstantDrift, Event, History, Member, Outcome, Team};
-
-fn main() {
-    let mut h = History::builder()
-        .mu(25.0)
-        .sigma(25.0 / 3.0)
-        .beta(25.0 / 6.0)
-        .drift(ConstantDrift(0.03))
-        .score_sigma(2.0) // tune to data; smaller = trust margins more
-        .build();
-
-    let events: Vec<Event<i64, &'static str>> = vec![
-        Event {
-            time: 1,
-            teams: smallvec![
-                Team::with_members([Member::new("alice")]),
-                Team::with_members([Member::new("bob")]),
-            ],
-            outcome: Outcome::scores([21.0, 9.0]),
-        },
-        Event {
-            time: 2,
-            teams: smallvec![
-                Team::with_members([Member::new("bob")]),
-                Team::with_members([Member::new("carol")]),
-            ],
-            outcome: Outcome::scores([21.0, 18.0]),
-        },
-        Event {
-            time: 3,
-            teams: smallvec![
-                Team::with_members([Member::new("alice")]),
-                Team::with_members([Member::new("carol")]),
-            ],
-            outcome: Outcome::scores([21.0, 21.0]),
-        },
-    ];
-    h.add_events(events).unwrap();
-
-    let report = h.converge().unwrap();
-    println!(
-        "converged={}, iterations={}, log_evidence={:.4}",
-        report.converged, report.iterations, report.log_evidence
-    );
-
-    for who in &["alice", "bob", "carol"] {
-        let s = h.current_skill(who).unwrap();
-        println!("{:>6}: mu={:>7.3}  sigma={:.3}", who, s.mu(), s.sigma());
-    }
-}

src/error.rs

@@ -10,8 +10,6 @@ pub enum InferenceError {
     },
     /// A probability value is outside `[0, 1]`.
     InvalidProbability { value: f64 },
-    /// A scalar parameter is outside its valid range.
-    InvalidParameter { name: &'static str, value: f64 },
     /// Convergence exceeded `max_iter` without falling below `epsilon`.
     ConvergenceFailed {
         last_step: (f64, f64),
@@ -34,9 +32,6 @@ impl fmt::Display for InferenceError {
             Self::InvalidProbability { value } => {
                 write!(f, "probability must be in [0, 1]; got {value}")
             }
-            Self::InvalidParameter { name, value } => {
-                write!(f, "{name} is invalid: {value}")
-            }
             Self::ConvergenceFailed {
                 last_step,
                 iterations,

src/event_builder.rs

@@ -75,12 +75,6 @@ where
         self
     }
 
-    /// Set explicit per-team continuous scores; higher = better.
-    pub fn scores<I: IntoIterator<Item = f64>>(mut self, scores: I) -> Self {
-        self.event.outcome = crate::Outcome::scores(scores);
-        self
-    }
-
     /// Mark team `winner_idx` as winner; others tied for last.
     pub fn winner(mut self, winner_idx: u32) -> Self {
         self.event.outcome = Outcome::winner(winner_idx, self.event.teams.len() as u32);

src/factor/margin.rs

@@ -1,123 +0,0 @@
-use crate::{
-    N_INF,
-    factor::{Factor, VarId, VarStore},
-    gaussian::Gaussian,
-    pdf,
-};
-
-/// Gaussian observation factor on a diff variable.
-///
-/// Encodes the soft evidence `m_obs ~ N(diff, sigma²)`. The outgoing message
-/// to `diff` is the constant `N(m_obs, sigma²)`, so this factor converges in a
-/// single propagation: subsequent calls return a zero delta.
-#[derive(Debug)]
-pub struct MarginFactor {
-    pub diff: VarId,
-    pub m_obs: f64,
-    pub sigma: f64,
-    pub(crate) msg: Gaussian,
-    pub(crate) evidence_cached: Option<f64>,
-}
-
-impl MarginFactor {
-    pub fn new(diff: VarId, m_obs: f64, sigma: f64) -> Self {
-        debug_assert!(sigma > 0.0, "score sigma must be positive");
-        Self {
-            diff,
-            m_obs,
-            sigma,
-            msg: N_INF,
-            evidence_cached: None,
-        }
-    }
-}
-
-impl Factor for MarginFactor {
-    fn propagate(&mut self, vars: &mut VarStore) -> (f64, f64) {
-        let marginal = vars.get(self.diff);
-        let cavity = marginal / self.msg;
-
-        if self.evidence_cached.is_none() {
-            self.evidence_cached = Some(cavity_evidence(cavity, self.m_obs, self.sigma));
-        }
-
-        let new_msg = Gaussian::from_ms(self.m_obs, self.sigma);
-        let new_marginal = cavity * new_msg;
-        let old_msg = self.msg;
-        self.msg = new_msg;
-        vars.set(self.diff, new_marginal);
-
-        old_msg.delta(new_msg)
-    }
-
-    fn log_evidence(&self, _vars: &VarStore) -> f64 {
-        self.evidence_cached.unwrap_or(1.0).ln()
-    }
-}
-
-fn cavity_evidence(cavity: Gaussian, m_obs: f64, sigma: f64) -> f64 {
-    let combined_sigma = (cavity.sigma().powi(2) + sigma.powi(2)).sqrt();
-    pdf(m_obs, cavity.mu(), combined_sigma)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn first_propagate_writes_tilted_marginal() {
-        let mut vars = VarStore::new();
-        let diff = vars.alloc(Gaussian::from_ms(0.0, 6.0));
-        let mut f = MarginFactor::new(diff, 5.0, 1.0);
-
-        f.propagate(&mut vars);
-
-        let result = vars.get(diff);
-        // pi = 1/36 + 1 ≈ 1.027778; tau = 0 + 5 = 5
-        // mu = 5 / 1.027778 ≈ 4.864865; sigma = 1/sqrt(1.027778) ≈ 0.986394
-        assert!((result.mu() - 4.864864864864865).abs() < 1e-12);
-        assert!((result.sigma() - 0.986393923832144).abs() < 1e-12);
-    }
-
-    #[test]
-    fn converges_in_one_step() {
-        let mut vars = VarStore::new();
-        let diff = vars.alloc(Gaussian::from_ms(0.0, 6.0));
-        let mut f = MarginFactor::new(diff, 5.0, 1.0);
-
-        f.propagate(&mut vars);
-        let (dmu, dsig) = f.propagate(&mut vars);
-        assert!(
-            dmu < 1e-12,
-            "expected ~0 delta on second propagate, got {dmu}"
-        );
-        assert!(dsig < 1e-12);
-    }
-
-    #[test]
-    fn evidence_cached_on_first_propagate() {
-        let mut vars = VarStore::new();
-        let diff = vars.alloc(Gaussian::from_ms(0.0, 6.0));
-        let mut f = MarginFactor::new(diff, 5.0, 1.0);
-        assert!(f.evidence_cached.is_none());
-
-        f.propagate(&mut vars);
-        let z = f.evidence_cached.unwrap();
-        // pdf(5, 0, sqrt(37)) ≈ 0.046783
-        assert!((z - 0.04678300292616668).abs() < 1e-10);
-
-        // Subsequent propagations don't change it.
-        f.propagate(&mut vars);
-        assert_eq!(f.evidence_cached.unwrap(), z);
-    }
-
-    #[test]
-    fn log_evidence_matches_cached_ln() {
-        let mut vars = VarStore::new();
-        let diff = vars.alloc(Gaussian::from_ms(0.0, 6.0));
-        let mut f = MarginFactor::new(diff, 5.0, 1.0);
-        f.propagate(&mut vars);
-        let logz = f.log_evidence(&vars);
-        assert!((logz - (-3.062235327364623)).abs() < 1e-10);
-    }
-}

src/factor/mod.rs

@@ -78,7 +78,6 @@ pub enum BuiltinFactor {
     TeamSum(team_sum::TeamSumFactor),
     RankDiff(rank_diff::RankDiffFactor),
     Trunc(trunc::TruncFactor),
-    Margin(margin::MarginFactor),
 }
 
 impl Factor for BuiltinFactor {
@@ -87,20 +86,17 @@ impl Factor for BuiltinFactor {
             Self::TeamSum(f) => f.propagate(vars),
             Self::RankDiff(f) => f.propagate(vars),
             Self::Trunc(f) => f.propagate(vars),
-            Self::Margin(f) => f.propagate(vars),
         }
     }
 
     fn log_evidence(&self, vars: &VarStore) -> f64 {
         match self {
             Self::Trunc(f) => f.log_evidence(vars),
-            Self::Margin(f) => f.log_evidence(vars),
             _ => 0.0,
         }
     }
 }
 
-pub mod margin;
 pub mod rank_diff;
 pub mod team_sum;
 pub mod trunc;
@@ -149,20 +145,4 @@ mod tests {
         assert_eq!(store.len(), 0);
         assert_eq!(store.marginals.capacity(), cap);
     }
-
-    #[test]
-    fn builtin_factor_dispatches_to_margin() {
-        use super::margin::MarginFactor;
-        let mut vars = VarStore::new();
-        let diff = vars.alloc(Gaussian::from_ms(0.0, 6.0));
-        let mut f = BuiltinFactor::Margin(MarginFactor::new(diff, 5.0, 1.0));
-
-        f.propagate(&mut vars);
-
-        let result = vars.get(diff);
-        assert!((result.mu() - 4.864864864864865).abs() < 1e-12);
-
-        let logz = f.log_evidence(&vars);
-        assert!((logz - (-3.062235327364623)).abs() < 1e-10);
-    }
 }

src/factors.rs

@@ -6,8 +6,8 @@
 
 pub use crate::{
     factor::{
-        BuiltinFactor, Factor, VarId, VarStore, margin::MarginFactor, rank_diff::RankDiffFactor,
-        team_sum::TeamSumFactor, trunc::TruncFactor,
+        BuiltinFactor, Factor, VarId, VarStore, rank_diff::RankDiffFactor, team_sum::TeamSumFactor,
+        trunc::TruncFactor,
     },
     schedule::{EpsilonOrMax, Schedule, ScheduleReport},
 };

src/game.rs

@@ -5,63 +5,16 @@ use crate::{
     arena::ScratchArena,
     compute_margin,
     drift::Drift,
-    factor::{VarId, margin::MarginFactor, trunc::TruncFactor},
+    factor::{Factor, trunc::TruncFactor},
     gaussian::Gaussian,
     rating::Rating,
     time::Time,
     tuple_gt, tuple_max,
 };
 
-/// Per-adjacent-pair link factor in the game's diff chain.
-///
-/// `Trunc` is used for `Outcome::Ranked` (rank-based truncation).
-/// `Margin` is used for `Outcome::Scored` (Gaussian observation on the diff).
-#[derive(Debug)]
-pub(crate) enum DiffFactor {
-    Trunc(TruncFactor),
-    Margin(MarginFactor),
-}
-
-impl DiffFactor {
-    pub(crate) fn diff(&self) -> VarId {
-        match self {
-            Self::Trunc(f) => f.diff,
-            Self::Margin(f) => f.diff,
-        }
-    }
-
-    pub(crate) fn msg(&self) -> Gaussian {
-        match self {
-            Self::Trunc(f) => f.msg,
-            Self::Margin(f) => f.msg,
-        }
-    }
-
-    pub(crate) fn evidence(&self) -> f64 {
-        match self {
-            Self::Trunc(f) => f.evidence_cached.unwrap_or(1.0),
-            Self::Margin(f) => f.evidence_cached.unwrap_or(1.0),
-        }
-    }
-
-    pub(crate) fn propagate(&mut self, vars: &mut crate::factor::VarStore) -> (f64, f64) {
-        use crate::factor::Factor;
-        match self {
-            Self::Trunc(f) => f.propagate(vars),
-            Self::Margin(f) => f.propagate(vars),
-        }
-    }
-}
-
-/// Per-game inference options.
-///
-/// `p_draw` and `convergence` apply to ranked outcomes (`Game::ranked`).
-/// `score_sigma` applies only to scored outcomes (`Game::scored`); it controls
-/// how much the engine trusts the observed score margin (smaller σ = more trust).
 #[derive(Clone, Copy, Debug)]
 pub struct GameOptions {
     pub p_draw: f64,
-    pub score_sigma: f64,
     pub convergence: crate::ConvergenceOptions,
 }
 
@@ -69,7 +22,6 @@ impl Default for GameOptions {
     fn default() -> Self {
         Self {
             p_draw: crate::P_DRAW,
-            score_sigma: 1.0,
             convergence: crate::ConvergenceOptions::default(),
         }
     }
@@ -112,26 +64,6 @@ impl<T: Time, D: Drift<T>> OwnedGame<T, D> {
         }
     }
 
-    pub(crate) fn new_scored(
-        teams: Vec<Vec<Rating<T, D>>>,
-        scores: Vec<f64>,
-        weights: Vec<Vec<f64>>,
-        score_sigma: f64,
-    ) -> Self {
-        let mut arena = ScratchArena::new();
-        let g = Game::scored_with_arena(teams.clone(), &scores, &weights, score_sigma, &mut arena);
-        let likelihoods = g.likelihoods;
-        let evidence = g.evidence;
-        Self {
-            teams,
-            result: scores,
-            weights,
-            p_draw: 0.0,
-            likelihoods,
-            evidence,
-        }
-    }
-
     pub fn posteriors(&self) -> Vec<Vec<Gaussian>> {
         self.likelihoods
             .iter()
@@ -200,39 +132,6 @@ impl<'a, T: Time, D: Drift<T>> Game<'a, T, D> {
         this
     }
 
-    pub(crate) fn scored_with_arena(
-        teams: Vec<Vec<Rating<T, D>>>,
-        scores: &'a [f64],
-        weights: &'a [Vec<f64>],
-        score_sigma: f64,
-        arena: &mut ScratchArena,
-    ) -> Self {
-        debug_assert!(
-            scores.len() == teams.len(),
-            "scores must have the same length as teams"
-        );
-        debug_assert!(
-            weights
-                .iter()
-                .zip(teams.iter())
-                .all(|(w, t)| w.len() == t.len()),
-            "weights must have the same dimensions as teams"
-        );
-        debug_assert!(score_sigma > 0.0, "score_sigma must be positive");
-
-        let mut this = Self {
-            teams,
-            result: scores,
-            weights,
-            p_draw: 0.0,
-            likelihoods: Vec::new(),
-            evidence: 0.0,
-        };
-
-        this.likelihoods_scored(arena, score_sigma);
-        this
-    }
-
     fn likelihoods(&mut self, arena: &mut ScratchArena) {
         arena.reset();
 
@@ -256,9 +155,9 @@ impl<'a, T: Time, D: Drift<T>> Game<'a, T, D> {
 
         let n_diffs = n_teams.saturating_sub(1);
 
-        // One DiffFactor per adjacent sorted-team pair; each owns a diff VarId.
-        // links stays local (fresh state per game; Vec capacity is typically small).
-        let mut links: Vec<DiffFactor> = (0..n_diffs)
+        // One TruncFactor per adjacent sorted-team pair; each owns a diff VarId.
+        // trunc stays local (fresh state per game; Vec capacity is typically small).
+        let mut trunc: Vec<TruncFactor> = (0..n_diffs)
             .map(|i| {
                 let tie = self.result[arena.sort_buf[i]] == self.result[arena.sort_buf[i + 1]];
                 let margin = if self.p_draw == 0.0 {
@@ -275,7 +174,7 @@ impl<'a, T: Time, D: Drift<T>> Game<'a, T, D> {
                     compute_margin(self.p_draw, (a + b).sqrt())
                 };
                 let vid = arena.vars.alloc(N_INF);
-                DiffFactor::Trunc(TruncFactor::new(vid, margin, tie))
+                TruncFactor::new(vid, margin, tie)
             })
             .collect();
 
@@ -290,30 +189,30 @@ impl<'a, T: Time, D: Drift<T>> Game<'a, T, D> {
             step = (0.0_f64, 0.0_f64);
 
             // Forward sweep: diffs 0 .. n_diffs-2 (all but the last).
-            for (e, lf) in links[..n_diffs.saturating_sub(1)].iter_mut().enumerate() {
+            for (e, tf) in trunc[..n_diffs.saturating_sub(1)].iter_mut().enumerate() {
                 let pw = arena.team_prior[e] * arena.lhood_lose[e];
                 let pl = arena.team_prior[e + 1] * arena.lhood_win[e + 1];
                 let raw = pw - pl;
-                arena.vars.set(lf.diff(), raw * lf.msg());
-                let d = lf.propagate(&mut arena.vars);
+                arena.vars.set(tf.diff, raw * tf.msg);
+                let d = tf.propagate(&mut arena.vars);
                 step = tuple_max(step, d);
 
-                let new_ll = pw - lf.msg();
+                let new_ll = pw - tf.msg;
                 step = tuple_max(step, arena.lhood_lose[e + 1].delta(new_ll));
                 arena.lhood_lose[e + 1] = new_ll;
             }
 
             // Backward sweep: diffs n_diffs-1 .. 1 (reverse, all but the first).
-            for (rev_i, lf) in links[1..].iter_mut().rev().enumerate() {
+            for (rev_i, tf) in trunc[1..].iter_mut().rev().enumerate() {
                 let e = n_diffs - 1 - rev_i;
                 let pw = arena.team_prior[e] * arena.lhood_lose[e];
                 let pl = arena.team_prior[e + 1] * arena.lhood_win[e + 1];
                 let raw = pw - pl;
-                arena.vars.set(lf.diff(), raw * lf.msg());
-                let d = lf.propagate(&mut arena.vars);
+                arena.vars.set(tf.diff, raw * tf.msg);
+                let d = tf.propagate(&mut arena.vars);
                 step = tuple_max(step, d);
 
-                let new_lw = pl + lf.msg();
+                let new_lw = pl + tf.msg;
                 step = tuple_max(step, arena.lhood_win[e].delta(new_lw));
                 arena.lhood_win[e] = new_lw;
             }
@@ -325,20 +224,23 @@ impl<'a, T: Time, D: Drift<T>> Game<'a, T, D> {
         if n_diffs == 1 {
             let raw = (arena.team_prior[0] * arena.lhood_lose[0])
                 - (arena.team_prior[1] * arena.lhood_win[1]);
-            arena.vars.set(links[0].diff(), raw * links[0].msg());
-            links[0].propagate(&mut arena.vars);
+            arena.vars.set(trunc[0].diff, raw * trunc[0].msg);
+            trunc[0].propagate(&mut arena.vars);
         }
 
         // Boundary updates: close the chain at both ends.
         if n_diffs > 0 {
             let pl1 = arena.team_prior[1] * arena.lhood_win[1];
-            arena.lhood_win[0] = pl1 + links[0].msg();
+            arena.lhood_win[0] = pl1 + trunc[0].msg;
             let pw_last = arena.team_prior[n_teams - 2] * arena.lhood_lose[n_teams - 2];
-            arena.lhood_lose[n_teams - 1] = pw_last - links[n_diffs - 1].msg();
+            arena.lhood_lose[n_teams - 1] = pw_last - trunc[n_diffs - 1].msg;
         }
 
         // Evidence = product of per-diff evidences (each cached on first propagation).
-        self.evidence = links.iter().map(|l| l.evidence()).product();
+        self.evidence = trunc
+            .iter()
+            .map(|t| t.evidence_cached.unwrap_or(1.0))
+            .product();
 
         // Inverse permutation: inv_buf[orig_i] = sorted_i.
         arena.inv_buf.resize(n_teams, 0);
@@ -370,120 +272,6 @@ impl<'a, T: Time, D: Drift<T>> Game<'a, T, D> {
             .collect::<Vec<_>>();
     }
 
-    fn likelihoods_scored(&mut self, arena: &mut ScratchArena, score_sigma: f64) {
-        arena.reset();
-
-        let n_teams = self.teams.len();
-
-        arena.sort_buf.extend(0..n_teams);
-        arena.sort_buf.sort_by(|&i, &j| {
-            self.result[j]
-                .partial_cmp(&self.result[i])
-                .unwrap_or(Ordering::Equal)
-        });
-
-        arena.team_prior.extend(arena.sort_buf.iter().map(|&t| {
-            self.teams[t]
-                .iter()
-                .zip(self.weights[t].iter())
-                .fold(N00, |p, (player, &w)| p + (player.performance() * w))
-        }));
-
-        let n_diffs = n_teams.saturating_sub(1);
-
-        let mut links: Vec<DiffFactor> = (0..n_diffs)
-            .map(|i| {
-                // After descending-by-score sort, m_obs >= 0 for every adjacent pair.
-                let m_obs = self.result[arena.sort_buf[i]] - self.result[arena.sort_buf[i + 1]];
-                let vid = arena.vars.alloc(N_INF);
-                DiffFactor::Margin(MarginFactor::new(vid, m_obs, score_sigma))
-            })
-            .collect();
-
-        arena.lhood_lose.resize(n_teams, N_INF);
-        arena.lhood_win.resize(n_teams, N_INF);
-
-        let mut step = (f64::INFINITY, f64::INFINITY);
-        let mut iter = 0;
-
-        while tuple_gt(step, 1e-6) && iter < 10 {
-            step = (0.0_f64, 0.0_f64);
-
-            for (e, lf) in links[..n_diffs.saturating_sub(1)].iter_mut().enumerate() {
-                let pw = arena.team_prior[e] * arena.lhood_lose[e];
-                let pl = arena.team_prior[e + 1] * arena.lhood_win[e + 1];
-                let raw = pw - pl;
-                arena.vars.set(lf.diff(), raw * lf.msg());
-                let d = lf.propagate(&mut arena.vars);
-                step = tuple_max(step, d);
-
-                let new_ll = pw - lf.msg();
-                step = tuple_max(step, arena.lhood_lose[e + 1].delta(new_ll));
-                arena.lhood_lose[e + 1] = new_ll;
-            }
-
-            for (rev_i, lf) in links[1..].iter_mut().rev().enumerate() {
-                let e = n_diffs - 1 - rev_i;
-                let pw = arena.team_prior[e] * arena.lhood_lose[e];
-                let pl = arena.team_prior[e + 1] * arena.lhood_win[e + 1];
-                let raw = pw - pl;
-                arena.vars.set(lf.diff(), raw * lf.msg());
-                let d = lf.propagate(&mut arena.vars);
-                step = tuple_max(step, d);
-
-                let new_lw = pl + lf.msg();
-                step = tuple_max(step, arena.lhood_win[e].delta(new_lw));
-                arena.lhood_win[e] = new_lw;
-            }
-
-            iter += 1;
-        }
-
-        if n_diffs == 1 {
-            let raw = (arena.team_prior[0] * arena.lhood_lose[0])
-                - (arena.team_prior[1] * arena.lhood_win[1]);
-            arena.vars.set(links[0].diff(), raw * links[0].msg());
-            links[0].propagate(&mut arena.vars);
-        }
-
-        if n_diffs > 0 {
-            let pl1 = arena.team_prior[1] * arena.lhood_win[1];
-            arena.lhood_win[0] = pl1 + links[0].msg();
-            let pw_last = arena.team_prior[n_teams - 2] * arena.lhood_lose[n_teams - 2];
-            arena.lhood_lose[n_teams - 1] = pw_last - links[n_diffs - 1].msg();
-        }
-
-        self.evidence = links.iter().map(|l| l.evidence()).product();
-
-        arena.inv_buf.resize(n_teams, 0);
-        for (si, &orig_i) in arena.sort_buf.iter().enumerate() {
-            arena.inv_buf[orig_i] = si;
-        }
-
-        self.likelihoods = self
-            .teams
-            .iter()
-            .zip(self.weights.iter())
-            .enumerate()
-            .map(|(orig_i, (players, weights))| {
-                let si = arena.inv_buf[orig_i];
-                let m = arena.lhood_win[si] * arena.lhood_lose[si];
-                let performance = players
-                    .iter()
-                    .zip(weights.iter())
-                    .fold(N00, |p, (player, &w)| p + (player.performance() * w));
-                players
-                    .iter()
-                    .zip(weights.iter())
-                    .map(|(player, &w)| {
-                        ((m - performance.exclude(player.performance() * w)) * (1.0 / w))
-                            .forget(player.beta.powi(2))
-                    })
-                    .collect::<Vec<_>>()
-            })
-            .collect::<Vec<_>>();
-    }
-
     pub fn posteriors(&self) -> Vec<Vec<Gaussian>> {
         self.likelihoods
             .iter()
@@ -521,13 +309,7 @@ impl<T: Time, D: Drift<T>> Game<'_, T, D> {
             });
         }
 
-        let ranks = outcome
-            .as_ranks()
-            .ok_or(crate::InferenceError::MismatchedShape {
-                kind: "Game::ranked requires Outcome::Ranked",
-                expected: 0,
-                got: 0,
-            })?;
+        let ranks = outcome.as_ranks();
         let max_rank = ranks.iter().copied().max().unwrap_or(0) as f64;
         let result: Vec<f64> = ranks.iter().map(|&r| max_rank - r as f64).collect();
         let teams_owned: Vec<Vec<Rating<T, D>>> = teams.iter().map(|t| t.to_vec()).collect();
@@ -536,42 +318,6 @@ impl<T: Time, D: Drift<T>> Game<'_, T, D> {
         Ok(OwnedGame::new(teams_owned, result, weights, options.p_draw))
     }
 
-    pub fn scored(
-        teams: &[&[Rating<T, D>]],
-        outcome: crate::Outcome,
-        options: &GameOptions,
-    ) -> Result<OwnedGame<T, D>, crate::InferenceError> {
-        if options.score_sigma <= 0.0 || options.score_sigma.is_nan() {
-            return Err(crate::InferenceError::InvalidParameter {
-                name: "score_sigma",
-                value: options.score_sigma,
-            });
-        }
-        if outcome.team_count() != teams.len() {
-            return Err(crate::InferenceError::MismatchedShape {
-                kind: "outcome scores vs teams",
-                expected: teams.len(),
-                got: outcome.team_count(),
-            });
-        }
-        let scores = outcome
-            .as_scores()
-            .ok_or(crate::InferenceError::MismatchedShape {
-                kind: "Game::scored requires Outcome::Scored",
-                expected: 0,
-                got: 0,
-            })?
-            .to_vec();
-        let teams_owned: Vec<Vec<Rating<T, D>>> = teams.iter().map(|t| t.to_vec()).collect();
-        let weights: Vec<Vec<f64>> = teams.iter().map(|t| vec![1.0; t.len()]).collect();
-        Ok(OwnedGame::new_scored(
-            teams_owned,
-            scores,
-            weights,
-            options.score_sigma,
-        ))
-    }
-
     pub fn one_v_one(
         a: &Rating<T, D>,
         b: &Rating<T, D>,
@@ -1059,131 +805,6 @@ mod tests {
         assert_ulps_eq!(p[0][0], p[1][0], epsilon = 1e-6);
     }
 
-    #[test]
-    fn diff_factor_dispatch_trunc_and_margin() {
-        use super::DiffFactor;
-        use crate::factor::{VarStore, margin::MarginFactor, trunc::TruncFactor};
-
-        let mut vars = VarStore::new();
-        let dt = vars.alloc(Gaussian::from_ms(0.0, 6.0));
-        let dm = vars.alloc(Gaussian::from_ms(0.0, 6.0));
-
-        let mut t = DiffFactor::Trunc(TruncFactor::new(dt, 0.0, false));
-        let mut m = DiffFactor::Margin(MarginFactor::new(dm, 5.0, 1.0));
-
-        let _ = t.propagate(&mut vars);
-        let _ = m.propagate(&mut vars);
-
-        // Smoke: both diffs got written; their msgs are non-N_INF.
-        assert!(t.msg().pi() > 0.0);
-        assert!(m.msg().pi() > 0.0);
-        assert_eq!(t.diff(), dt);
-        assert_eq!(m.diff(), dm);
-    }
-
-    #[test]
-    fn scored_path_sharper_when_margin_is_large() {
-        let prior = R::new(
-            Gaussian::from_ms(25.0, 25.0 / 3.0),
-            25.0 / 6.0,
-            ConstantDrift(25.0 / 300.0),
-        );
-        let teams = vec![vec![prior], vec![prior]];
-        let result = vec![10.0, 0.0]; // a beat b by 10
-        let weights = [vec![1.0], vec![1.0]];
-        let mut arena = ScratchArena::new();
-        let g = Game::scored_with_arena(
-            teams, &result, &weights, 1.0, // score_sigma
-            &mut arena,
-        );
-        let p = g.posteriors();
-        let a = p[0][0];
-        let b = p[1][0];
-        assert!(
-            a.mu() > b.mu(),
-            "expected team a posterior mu > team b; got {} vs {}",
-            a.mu(),
-            b.mu()
-        );
-
-        // Tighter score_sigma should produce a stronger update.
-        let mut arena2 = ScratchArena::new();
-        let g_tight = Game::scored_with_arena(
-            vec![vec![prior], vec![prior]],
-            &result,
-            &weights,
-            0.1, // tighter score_sigma
-            &mut arena2,
-        );
-        let p_tight = g_tight.posteriors();
-        let a_tight = p_tight[0][0];
-        assert!(
-            a_tight.mu() > a.mu(),
-            "expected tighter sigma to push posterior further; {} vs {}",
-            a_tight.mu(),
-            a.mu()
-        );
-    }
-
-    #[test]
-    fn game_scored_public_ctor() {
-        use crate::Outcome;
-        let prior = R::new(
-            Gaussian::from_ms(25.0, 25.0 / 3.0),
-            25.0 / 6.0,
-            ConstantDrift(25.0 / 300.0),
-        );
-        let opts = GameOptions {
-            score_sigma: 1.0,
-            ..GameOptions::default()
-        };
-        let g = Game::scored(&[&[prior], &[prior]], Outcome::scores([8.0, 2.0]), &opts).unwrap();
-        let p = g.posteriors();
-        assert!(p[0][0].mu() > p[1][0].mu());
-    }
-
-    #[test]
-    fn game_scored_rejects_ranked_outcome() {
-        let prior = R::new(
-            Gaussian::from_ms(25.0, 25.0 / 3.0),
-            25.0 / 6.0,
-            ConstantDrift(25.0 / 300.0),
-        );
-        let err = Game::scored(
-            &[&[prior], &[prior]],
-            crate::Outcome::winner(0, 2),
-            &GameOptions::default(),
-        )
-        .unwrap_err();
-        assert!(matches!(err, crate::InferenceError::MismatchedShape { .. }));
-    }
-
-    #[test]
-    fn game_scored_rejects_zero_score_sigma() {
-        let prior = R::new(
-            Gaussian::from_ms(25.0, 25.0 / 3.0),
-            25.0 / 6.0,
-            ConstantDrift(25.0 / 300.0),
-        );
-        let opts = GameOptions {
-            score_sigma: 0.0,
-            ..GameOptions::default()
-        };
-        let err = Game::scored(
-            &[&[prior], &[prior]],
-            crate::Outcome::scores([1.0, 0.0]),
-            &opts,
-        )
-        .unwrap_err();
-        assert!(matches!(
-            err,
-            crate::InferenceError::InvalidParameter {
-                name: "score_sigma",
-                ..
-            }
-        ));
-    }
-
     #[test]
     fn test_2vs2_weighted() {
         let t_a = vec![

src/history.rs

@@ -13,7 +13,7 @@ use crate::{
     sort_time,
     storage::CompetitorStore,
     time::Time,
-    time_slice::{self, EventKind, TimeSlice},
+    time_slice::{self, TimeSlice},
     tuple_gt, tuple_max,
 };
 
@@ -30,7 +30,6 @@ pub struct HistoryBuilder<
     drift: D,
     p_draw: f64,
     online: bool,
-    score_sigma: f64,
     convergence: ConvergenceOptions,
     observer: O,
     _time: PhantomData<T>,
@@ -61,7 +60,6 @@ impl<T: Time, D: Drift<T>, O: Observer<T>, K: Eq + Hash + Clone> HistoryBuilder<
             beta: self.beta,
             p_draw: self.p_draw,
             online: self.online,
-            score_sigma: self.score_sigma,
             convergence: self.convergence,
             observer: self.observer,
             _time: self._time,
@@ -79,15 +77,6 @@ impl<T: Time, D: Drift<T>, O: Observer<T>, K: Eq + Hash + Clone> HistoryBuilder<
         self
     }
 
-    pub fn score_sigma(mut self, score_sigma: f64) -> Self {
-        assert!(
-            score_sigma > 0.0,
-            "score_sigma must be positive (got {score_sigma})"
-        );
-        self.score_sigma = score_sigma;
-        self
-    }
-
     pub fn convergence(mut self, opts: ConvergenceOptions) -> Self {
         self.convergence = opts;
         self
@@ -101,7 +90,6 @@ impl<T: Time, D: Drift<T>, O: Observer<T>, K: Eq + Hash + Clone> HistoryBuilder<
             drift: self.drift,
             p_draw: self.p_draw,
             online: self.online,
-            score_sigma: self.score_sigma,
             convergence: self.convergence,
             observer,
             _time: self._time,
@@ -121,7 +109,6 @@ impl<T: Time, D: Drift<T>, O: Observer<T>, K: Eq + Hash + Clone> HistoryBuilder<
             drift: self.drift,
             p_draw: self.p_draw,
             online: self.online,
-            score_sigma: self.score_sigma,
             convergence: self.convergence,
             observer: self.observer,
         }
@@ -137,7 +124,6 @@ impl Default for HistoryBuilder<i64, ConstantDrift, NullObserver, &'static str>
             drift: ConstantDrift(GAMMA),
             p_draw: P_DRAW,
             online: false,
-            score_sigma: 1.0,
             convergence: ConvergenceOptions::default(),
             observer: NullObserver,
             _time: PhantomData,
@@ -162,7 +148,6 @@ pub struct History<
     drift: D,
     p_draw: f64,
     online: bool,
-    score_sigma: f64,
     convergence: ConvergenceOptions,
     observer: O,
 }
@@ -189,7 +174,6 @@ impl<K: Eq + Hash + Clone> History<i64, ConstantDrift, NullObserver, K> {
             drift: ConstantDrift(GAMMA),
             p_draw: P_DRAW,
             online: false,
-            score_sigma: 1.0,
             convergence: ConvergenceOptions::default(),
             observer: NullObserver,
             _time: PhantomData,
@@ -466,7 +450,6 @@ impl<T: Time, D: Drift<T>, O: Observer<T>, K: Eq + Hash + Clone> History<T, D, O
         results: Vec<Vec<f64>>,
         times: Vec<T>,
         weights: Vec<Vec<Vec<f64>>>,
-        kinds: Vec<EventKind>,
         mut priors: HashMap<Index, Rating<T, D>>,
     ) -> Result<(), InferenceError> {
         if !results.is_empty() && results.len() != composition.len() {
@@ -490,13 +473,6 @@ impl<T: Time, D: Drift<T>, O: Observer<T>, K: Eq + Hash + Clone> History<T, D, O
                 got: weights.len(),
             });
         }
-        if kinds.len() != composition.len() {
-            return Err(InferenceError::MismatchedShape {
-                kind: "kinds",
-                expected: composition.len(),
-                got: kinds.len(),
-            });
-        }
 
         competitor::clean(self.agents.values_mut(), true);
 
@@ -581,11 +557,9 @@ impl<T: Time, D: Drift<T>, O: Observer<T>, K: Eq + Hash + Clone> History<T, D, O
                 (i..j).map(|e| weights[o[e]].clone()).collect::<Vec<_>>()
             };
 
-            let kinds_chunk: Vec<EventKind> = (i..j).map(|e| kinds[o[e]]).collect();
-
             if self.time_slices.len() > k && self.time_slices[k].time == t {
                 let time_slice = &mut self.time_slices[k];
-                time_slice.add_events(composition, results, weights, kinds_chunk, &self.agents);
+                time_slice.add_events(composition, results, weights, &self.agents);
 
                 for agent_idx in time_slice.skills.keys() {
                     let agent = self.agents.get_mut(agent_idx).unwrap();
@@ -595,7 +569,7 @@ impl<T: Time, D: Drift<T>, O: Observer<T>, K: Eq + Hash + Clone> History<T, D, O
                 }
             } else {
                 let mut time_slice = TimeSlice::new(t, self.p_draw);
-                time_slice.add_events(composition, results, weights, kinds_chunk, &self.agents);
+                time_slice.add_events(composition, results, weights, &self.agents);
 
                 self.time_slices.insert(k, time_slice);
 
@@ -652,7 +626,6 @@ impl<T: Time, D: Drift<T>, O: Observer<T>, K: Eq + Hash + Clone> History<T, D, O
             vec![vec![1.0, 0.0]],
             vec![time],
             vec![],
-            vec![EventKind::Ranked],
             HashMap::new(),
         )
     }
@@ -669,7 +642,6 @@ impl<T: Time, D: Drift<T>, O: Observer<T>, K: Eq + Hash + Clone> History<T, D, O
             vec![vec![0.0, 0.0]],
             vec![time],
             vec![],
-            vec![EventKind::Ranked],
             HashMap::new(),
         )
     }
@@ -694,15 +666,15 @@ impl<T: Time, D: Drift<T>, O: Observer<T>, K: Eq + Hash + Clone> History<T, D, O
         let mut results: Vec<Vec<f64>> = Vec::with_capacity(events.len());
         let mut times: Vec<T> = Vec::with_capacity(events.len());
         let mut weights: Vec<Vec<Vec<f64>>> = Vec::with_capacity(events.len());
-        let mut kinds: Vec<EventKind> = Vec::with_capacity(events.len());
         let mut priors: HashMap<Index, Rating<T, D>> = HashMap::new();
 
         for ev in events {
-            if ev.outcome.team_count() != ev.teams.len() {
+            let ranks = ev.outcome.as_ranks();
+            if ranks.len() != ev.teams.len() {
                 return Err(InferenceError::MismatchedShape {
-                    kind: "outcome vs teams",
+                    kind: "outcome ranks vs teams",
                     expected: ev.teams.len(),
-                    got: ev.outcome.team_count(),
+                    got: ranks.len(),
                 });
             }
 
@@ -726,24 +698,13 @@ impl<T: Time, D: Drift<T>, O: Observer<T>, K: Eq + Hash + Clone> History<T, D, O
             composition.push(event_comp);
             weights.push(event_weights);
 
-            let event_result: Vec<f64> = match &ev.outcome {
-                crate::Outcome::Ranked(ranks) => {
-                    let max_rank = ranks.iter().copied().max().unwrap_or(0) as f64;
-                    kinds.push(EventKind::Ranked);
-                    ranks.iter().map(|&r| max_rank - r as f64).collect()
-                }
-                crate::Outcome::Scored(scores) => {
-                    kinds.push(EventKind::Scored {
-                        score_sigma: self.score_sigma,
-                    });
-                    scores.to_vec()
-                }
-            };
-            results.push(event_result);
+            let max_rank = ranks.iter().copied().max().unwrap_or(0) as f64;
+            let inverted: Vec<f64> = ranks.iter().map(|&r| max_rank - r as f64).collect();
+            results.push(inverted);
             times.push(ev.time);
         }
 
-        self.add_events_with_prior(composition, results, times, weights, kinds, priors)
+        self.add_events_with_prior(composition, results, times, weights, priors)
     }
 }
 
@@ -1705,10 +1666,4 @@ mod tests {
         assert!(report.iterations < 30);
         assert!(report.final_step.0 <= 1e-6);
     }
-
-    #[test]
-    #[should_panic(expected = "score_sigma must be positive")]
-    fn history_builder_rejects_zero_score_sigma() {
-        let _ = History::builder().score_sigma(0.0).build();
-    }
 }

src/lib.rs

@@ -8,7 +8,7 @@ mod approx;
 pub(crate) mod arena;
 mod time;
 mod time_slice;
-pub use time_slice::{EventKind, TimeSlice};
+pub use time_slice::TimeSlice;
 mod color_group;
 mod competitor;
 mod convergence;

src/outcome.rs

@@ -1,7 +1,8 @@
 //! Outcome of a match.
 //!
-//! `Ranked(ranks)` for ordinal results; `Scored(scores)` for continuous
-//! per-team scores (engages `MarginFactor` in the engine).
+//! In T2, only `Ranked` is supported; `Scored` will be added together with
+//! `MarginFactor` in T4. The enum is `#[non_exhaustive]` so adding `Scored`
+//! is non-breaking for downstream `match` expressions.
 
 use smallvec::SmallVec;
 
@@ -9,19 +10,14 @@ use smallvec::SmallVec;
 ///
 /// `Ranked(ranks)`: lower rank = better. Equal ranks mean a tie between those
 /// teams. `ranks.len()` must equal the number of teams in the event.
-///
-/// `Scored(scores)`: higher score = better. Adjacent (sorted) pairs feed
-/// observed margins to `MarginFactor`. `scores.len()` must equal the number
-/// of teams in the event.
 #[derive(Clone, Debug, PartialEq)]
 #[non_exhaustive]
 pub enum Outcome {
     Ranked(SmallVec<[u32; 4]>),
-    Scored(SmallVec<[f64; 4]>),
 }
 
 impl Outcome {
-    /// `n`-team outcome where team `winner` won and everyone else tied for last.
+    /// `N`-team outcome where team `winner` won and everyone else tied for last.
     ///
     /// Panics if `winner >= n`.
     pub fn winner(winner: u32, n: u32) -> Self {
@@ -40,29 +36,16 @@ impl Outcome {
         Self::Ranked(ranks.into_iter().collect())
     }
 
-    /// Explicit per-team continuous scores; higher = better.
-    pub fn scores<I: IntoIterator<Item = f64>>(scores: I) -> Self {
-        Self::Scored(scores.into_iter().collect())
-    }
-
     pub fn team_count(&self) -> usize {
         match self {
             Self::Ranked(r) => r.len(),
-            Self::Scored(s) => s.len(),
         }
     }
 
-    pub(crate) fn as_ranks(&self) -> Option<&[u32]> {
+    #[allow(dead_code)]
+    pub(crate) fn as_ranks(&self) -> &[u32] {
         match self {
-            Self::Ranked(r) => Some(r),
-            Self::Scored(_) => None,
-        }
-    }
-
-    pub(crate) fn as_scores(&self) -> Option<&[f64]> {
-        match self {
-            Self::Scored(s) => Some(s),
-            Self::Ranked(_) => None,
+            Self::Ranked(r) => r,
         }
     }
 }
@@ -74,26 +57,26 @@ mod tests {
     #[test]
     fn winner_two_teams() {
         let o = Outcome::winner(0, 2);
-        assert_eq!(o.as_ranks(), Some(&[0u32, 1][..]));
+        assert_eq!(o.as_ranks(), &[0u32, 1]);
         assert_eq!(o.team_count(), 2);
     }
 
     #[test]
     fn winner_three_teams_second_wins() {
         let o = Outcome::winner(1, 3);
-        assert_eq!(o.as_ranks(), Some(&[1u32, 0, 1][..]));
+        assert_eq!(o.as_ranks(), &[1u32, 0, 1]);
     }
 
     #[test]
     fn draw_three_teams() {
         let o = Outcome::draw(3);
-        assert_eq!(o.as_ranks(), Some(&[0u32, 0, 0][..]));
+        assert_eq!(o.as_ranks(), &[0u32, 0, 0]);
     }
 
     #[test]
     fn ranking_from_iter() {
         let o = Outcome::ranking([2, 0, 1]);
-        assert_eq!(o.as_ranks(), Some(&[2u32, 0, 1][..]));
+        assert_eq!(o.as_ranks(), &[2u32, 0, 1]);
     }
 
     #[test]
@@ -101,25 +84,4 @@ mod tests {
     fn winner_out_of_range_panics() {
         let _ = Outcome::winner(2, 2);
     }
-
-    #[test]
-    fn scored_two_teams() {
-        let o = Outcome::scores([10.0, 4.0]);
-        assert_eq!(o.team_count(), 2);
-        assert_eq!(o.as_scores(), Some(&[10.0, 4.0][..]));
-        assert_eq!(o.as_ranks(), None);
-    }
-
-    #[test]
-    fn scored_team_count_matches_input() {
-        let o = Outcome::scores([3.0, 1.0, 2.0, 0.0]);
-        assert_eq!(o.team_count(), 4);
-    }
-
-    #[test]
-    fn ranked_as_scores_returns_none() {
-        let o = Outcome::winner(0, 2);
-        assert!(o.as_scores().is_none());
-        assert!(o.as_ranks().is_some());
-    }
 }

src/time_slice.rs

@@ -44,13 +44,6 @@ impl Default for Skill {
     }
 }
 
-#[derive(Debug, Clone, Copy)]
-#[non_exhaustive]
-pub enum EventKind {
-    Ranked,
-    Scored { score_sigma: f64 },
-}
-
 #[derive(Debug)]
 struct Item {
     agent: Index,
@@ -89,7 +82,6 @@ pub(crate) struct Event {
     teams: Vec<Team>,
     evidence: f64,
     weights: Vec<Vec<f64>>,
-    kind: EventKind,
 }
 
 impl Event {
@@ -137,14 +129,7 @@ impl Event {
     ) {
         let teams = self.within_priors(false, false, skills, agents);
         let result = self.outputs();
-        let g = match self.kind {
-            EventKind::Ranked => {
-                Game::ranked_with_arena(teams, &result, &self.weights, p_draw, arena)
-            }
-            EventKind::Scored { score_sigma } => {
-                Game::scored_with_arena(teams, &result, &self.weights, score_sigma, arena)
-            }
-        };
+        let g = Game::ranked_with_arena(teams, &result, &self.weights, p_draw, arena);
 
         for (t, team) in self.teams.iter_mut().enumerate() {
             for (i, item) in team.items.iter_mut().enumerate() {
@@ -220,7 +205,6 @@ impl<T: Time> TimeSlice<T> {
         composition: Vec<Vec<Vec<Index>>>,
         results: Vec<Vec<f64>>,
         weights: Vec<Vec<Vec<f64>>>,
-        kinds: Vec<EventKind>,
         agents: &CompetitorStore<T, D>,
     ) {
         let mut unique = Vec::with_capacity(10);
@@ -290,7 +274,6 @@ impl<T: Time> TimeSlice<T> {
                 teams,
                 evidence: 0.0,
                 weights,
-                kind: kinds[e],
             }
         });
 
@@ -316,22 +299,13 @@ impl<T: Time> TimeSlice<T> {
                 let teams = event.within_priors(false, false, &self.skills, agents);
                 let result = event.outputs();
 
-                let g = match event.kind {
-                    EventKind::Ranked => Game::ranked_with_arena(
-                        teams,
-                        &result,
-                        &event.weights,
-                        self.p_draw,
-                        &mut self.arena,
-                    ),
-                    EventKind::Scored { score_sigma } => Game::scored_with_arena(
-                        teams,
-                        &result,
-                        &event.weights,
-                        score_sigma,
-                        &mut self.arena,
-                    ),
-                };
+                let g = Game::ranked_with_arena(
+                    teams,
+                    &result,
+                    &event.weights,
+                    self.p_draw,
+                    &mut self.arena,
+                );
 
                 for (t, team) in event.teams.iter_mut().enumerate() {
                     for (i, item) in team.items.iter_mut().enumerate() {
@@ -500,28 +474,21 @@ impl<T: Time> TimeSlice<T> {
         // log_evidence is infrequent; a local arena avoids needing &mut self.
         let mut arena = ScratchArena::new();
 
-        let run_event = |event: &Event, arena: &mut ScratchArena| -> f64 {
-            let teams = event.within_priors(online, forward, &self.skills, agents);
-            let result = event.outputs();
-            match event.kind {
-                EventKind::Ranked => {
-                    Game::ranked_with_arena(teams, &result, &event.weights, self.p_draw, arena)
-                        .evidence
-                        .ln()
-                }
-                EventKind::Scored { score_sigma } => {
-                    Game::scored_with_arena(teams, &result, &event.weights, score_sigma, arena)
-                        .evidence
-                        .ln()
-                }
-            }
-        };
-
         if targets.is_empty() {
             if online || forward {
                 self.events
                     .iter()
-                    .map(|event| run_event(event, &mut arena))
+                    .map(|event| {
+                        Game::ranked_with_arena(
+                            event.within_priors(online, forward, &self.skills, agents),
+                            &event.outputs(),
+                            &event.weights,
+                            self.p_draw,
+                            &mut arena,
+                        )
+                        .evidence
+                        .ln()
+                    })
                     .sum()
             } else {
                 self.events.iter().map(|event| event.evidence.ln()).sum()
@@ -529,14 +496,25 @@ impl<T: Time> TimeSlice<T> {
         } else if online || forward {
             self.events
                 .iter()
-                .filter(|event| {
+                .enumerate()
+                .filter(|(_, event)| {
                     event
                         .teams
                         .iter()
                         .flat_map(|team| &team.items)
                         .any(|item| targets.contains(&item.agent))
                 })
-                .map(|event| run_event(event, &mut arena))
+                .map(|(_, event)| {
+                    Game::ranked_with_arena(
+                        event.within_priors(online, forward, &self.skills, agents),
+                        &event.outputs(),
+                        &event.weights,
+                        self.p_draw,
+                        &mut arena,
+                    )
+                    .evidence
+                    .ln()
+                })
                 .sum()
         } else {
             self.events
@@ -631,7 +609,6 @@ mod tests {
             ],
             vec![vec![1.0, 0.0], vec![0.0, 1.0], vec![1.0, 0.0]],
             vec![],
-            vec![EventKind::Ranked; 3],
             &agents,
         );
 
@@ -708,7 +685,6 @@ mod tests {
             ],
             vec![vec![1.0, 0.0], vec![0.0, 1.0], vec![1.0, 0.0]],
             vec![],
-            vec![EventKind::Ranked; 3],
             &agents,
         );
 
@@ -788,7 +764,6 @@ mod tests {
             ],
             vec![vec![1.0, 0.0], vec![0.0, 1.0], vec![1.0, 0.0]],
             vec![],
-            vec![EventKind::Ranked; 3],
             &agents,
         );
 
@@ -820,7 +795,6 @@ mod tests {
             ],
             vec![vec![1.0, 0.0], vec![0.0, 1.0], vec![1.0, 0.0]],
             vec![],
-            vec![EventKind::Ranked; 3],
             &agents,
         );
 
@@ -886,7 +860,6 @@ mod tests {
             ],
             vec![vec![1.0, 0.0], vec![1.0, 0.0], vec![1.0, 0.0]],
             vec![],
-            vec![EventKind::Ranked; 3],
             &agents,
         );
 

tests/api_shape.rs

@@ -223,26 +223,3 @@ fn predict_outcome_two_teams_sums_to_one() {
     assert!((p[0] + p[1] - 1.0).abs() < 1e-9);
     assert!(p[0] > p[1]);
 }
-
-#[test]
-fn fluent_event_builder_scores() {
-    use trueskill_tt::ConstantDrift;
-    let mut h = History::builder()
-        .mu(25.0)
-        .sigma(25.0 / 3.0)
-        .beta(25.0 / 6.0)
-        .drift(ConstantDrift(0.0))
-        .build();
-
-    h.event(1)
-        .team(["alice"])
-        .team(["bob"])
-        .scores([12.0, 4.0])
-        .commit()
-        .unwrap();
-    h.converge().unwrap();
-
-    let a = h.current_skill(&"alice").unwrap();
-    let b = h.current_skill(&"bob").unwrap();
-    assert!(a.mu() > b.mu());
-}

tests/equivalence.rs

@@ -42,7 +42,6 @@ fn game_1v1_draw_golden() {
         Outcome::draw(2),
         &GameOptions {
             p_draw: 0.25,
-            score_sigma: 1.0,
             convergence: Default::default(),
         },
     )

tests/game.rs

@@ -45,7 +45,6 @@ fn game_ranked_rejects_bad_p_draw() {
         Outcome::winner(0, 2),
         &GameOptions {
             p_draw: 1.5,
-            score_sigma: 1.0,
             convergence: ConvergenceOptions::default(),
         },
     )

tests/scored.rs

@@ -1,139 +0,0 @@
-//! Integration tests for `Outcome::Scored` routing through `History::add_events`.
-
-use smallvec::smallvec;
-use trueskill_tt::{ConstantDrift, Event, History, Member, Outcome, Team};
-
-#[test]
-fn scored_two_team_one_event_pulls_winner_up() {
-    let mut h: History = History::builder()
-        .mu(0.0)
-        .sigma(2.0)
-        .beta(1.0)
-        .drift(ConstantDrift(0.0))
-        .score_sigma(1.0)
-        .build();
-
-    let events: Vec<Event<i64, &'static str>> = vec![Event {
-        time: 1,
-        teams: smallvec![
-            Team::with_members([Member::new("a")]),
-            Team::with_members([Member::new("b")]),
-        ],
-        outcome: Outcome::scores([10.0, 4.0]),
-    }];
-    h.add_events(events).unwrap();
-
-    let mu_a = h.current_skill(&"a").unwrap().mu();
-    let mu_b = h.current_skill(&"b").unwrap().mu();
-
-    assert!(
-        mu_a > 0.0,
-        "winner mu should be pulled up; got mu_a = {mu_a}"
-    );
-    assert!(
-        mu_b < 0.0,
-        "loser mu should be pulled down; got mu_b = {mu_b}"
-    );
-    assert!(
-        mu_a > mu_b,
-        "winner mu should exceed loser mu; got mu_a = {mu_a}, mu_b = {mu_b}"
-    );
-}
-
-#[test]
-fn scored_zero_margin_treats_as_tie() {
-    let mut h: History = History::builder()
-        .mu(0.0)
-        .sigma(2.0)
-        .beta(1.0)
-        .drift(ConstantDrift(0.0))
-        .score_sigma(1.0)
-        .build();
-
-    let events: Vec<Event<i64, &'static str>> = vec![Event {
-        time: 1,
-        teams: smallvec![
-            Team::with_members([Member::new("a")]),
-            Team::with_members([Member::new("b")]),
-        ],
-        outcome: Outcome::scores([5.0, 5.0]),
-    }];
-    h.add_events(events).unwrap();
-
-    let mu_a = h.current_skill(&"a").unwrap().mu();
-    let mu_b = h.current_skill(&"b").unwrap().mu();
-    let sigma_a = h.current_skill(&"a").unwrap().sigma();
-
-    // Equal scores: posterior means stay symmetric around the prior mean.
-    assert!(
-        (mu_a - mu_b).abs() < 1e-9,
-        "equal scores should leave mu_a == mu_b; got {mu_a} vs {mu_b}"
-    );
-    assert!(
-        mu_a.abs() < 1e-9,
-        "equal scores against equal priors should leave mu near zero; got {mu_a}"
-    );
-
-    // A zero-margin scored event still reduces uncertainty.
-    assert!(
-        sigma_a < 2.0,
-        "expected sigma to tighten below prior 2.0; got {}",
-        sigma_a
-    );
-}
-
-#[test]
-fn scored_three_team_partial_order() {
-    let mut h: History = History::builder()
-        .mu(0.0)
-        .sigma(2.0)
-        .beta(1.0)
-        .drift(ConstantDrift(0.0))
-        .score_sigma(1.0)
-        .build();
-
-    let events: Vec<Event<i64, &'static str>> = vec![Event {
-        time: 1,
-        teams: smallvec![
-            Team::with_members([Member::new("a")]),
-            Team::with_members([Member::new("b")]),
-            Team::with_members([Member::new("c")]),
-        ],
-        outcome: Outcome::scores([9.0, 5.0, 1.0]),
-    }];
-    h.add_events(events).unwrap();
-
-    let mu_a = h.current_skill(&"a").unwrap().mu();
-    let mu_b = h.current_skill(&"b").unwrap().mu();
-    let mu_c = h.current_skill(&"c").unwrap().mu();
-
-    assert!(
-        mu_a > mu_b,
-        "team with highest score should rank highest; mu_a = {mu_a}, mu_b = {mu_b}"
-    );
-    assert!(
-        mu_b > mu_c,
-        "middle score should outrank lowest; mu_b = {mu_b}, mu_c = {mu_c}"
-    );
-}
-
-#[test]
-fn scored_rejects_outcome_team_count_mismatch() {
-    use trueskill_tt::InferenceError;
-
-    let mut h: History = History::builder().build();
-    let events: Vec<Event<i64, &'static str>> = vec![Event {
-        time: 1,
-        teams: smallvec![
-            Team::with_members([Member::new("a")]),
-            Team::with_members([Member::new("b")]),
-        ],
-        outcome: Outcome::scores([10.0, 4.0, 1.0]), // 3 scores, 2 teams
-    }];
-
-    let err = h.add_events(events).unwrap_err();
-    assert!(
-        matches!(err, InferenceError::MismatchedShape { .. }),
-        "expected MismatchedShape error, got {err:?}"
-    );
-}