Class BradleyTerryFitter

codeclash/analysis/metrics/elo.py:313–485

        boot_matrix["ALL"] = {k: [v[0], v[1]] for k, v in combined.items()}
        return boot_matrix

    def print_matrix(self) -> None:
        for game, matchups in sorted(self.win_matrix.items()):
            print(f"\n{game}:")
            for (p1, p2), (w1, w2) in sorted(matchups.items()):
                if game == "ALL":
                    print(f"  {p1} vs {p2}: {w1:.3f}-{w2:.3f}")
                else:
                    print(f"  {p1} vs {p2}: {w1:.0f}-{w2:.0f}")


class BradleyTerryFitter:
    def __init__(
        self,
        win_matrix: dict[tuple[str, str], list[float]],
        *,
        regularization: float = 0.01,
        compute_uncertainties: bool = True,
    ):
        """Fit Bradley-Terry model to a win matrix

        Args:
            win_matrix: Dictionary mapping player pairs to win counts
            regularization: L2 regularization strength
            compute_uncertainties: Whether to compute uncertainties
        """
        self.matchups = win_matrix
        self.regularization = regularization
        self.compute_uncertainties = compute_uncertainties
        self.result: dict | None = None
        """{players: list[str], strengths: np.ndarray, log_likelihood: float}"""

    def _sigmoid(self, x: np.ndarray) -> np.ndarray:
        return 1 / (1 + np.exp(-x))

    @staticmethod
    def bt_to_elo(strength: float) -> float:
        """Convert Bradley-Terry strength to Elo rating.

        Formula: R_i = R_0 + (β/ln(10)) * s_i
        where β = 400 (ELO_SLOPE), R_0 = 1200 (ELO_BASE)
        """
        return ELO_BASE + (ELO_SLOPE / np.log(10)) * strength

    def _negative_log_likelihood(self, strengths: np.ndarray, pairs: list, wins: np.ndarray) -> float:
        """Negative log-likelihood for Bradley-Terry model with L2 regularization.

        Args:
            strengths: Array of player strengths (length n_players)
            pairs: List of (i, j) player index pairs
            wins: Array of shape (n_pairs, 2) where wins[k] = [w_ij, w_ji]

        Returns:
            -log(likelihood) + λ * Σ_i s_i^2 (MAP estimate with Gaussian prior)
        """
        assert len(wins) == len(pairs)
        ll = 0.0
        for k, (i, j) in enumerate(pairs):