Direct Preference Optimization

With π = softmax(z), log π_y = z_y − log Σ_k e^z_k, so ∇_z log π_y = e_y − π and ∇_z(log π_w − log π_ℓ) = e_w − e_ℓ. The reference q is fixed, so ∇_zv = β(e_w − e_ℓ).

For one record, ℓ(v) = −log σ(v) = log(1 + e^−v), so dℓ/dv = −σ(−v) and ∇_zℓ = −β σ(−v)(e_w − e_ℓ). A well-ordered record (large v) pulls weakly; a badly ordered one pulls with weight near 1.

With n_AB = 3 and n_BA = 1, the mean is L = −(3 log s + log(1 − s)) / 4 with s = σ(β(z_A − z_B − log(q_A/q_B))). This is an average of hard labels, not label smoothing. It is minimized at s = 3/4, which gives z_A − z_B = log(q_A/q_B) + logit(3/4)/β = 2 log 3, so π_A/π_B = 9, with minimum H(3/4) = 0.562335 nats. z_C does not appear.

Every gradient has the form (g, −g, 0). From z₀ = 0, plain steps therefore keep z = (a, −a, 0), with a ← a + ½η(¾ − σ(a)) at β = ½. The fixed point is a = log 3, giving (9/13, 1/13, 3/13). A finite number of steps approaches it; this holds for this start and plain full-batch steps, not for other initializations, momentum, weight decay or shared parameters.

The ledger’s coverage: the compared responses split into {A, B} and {C}, so no unique policy is identified.

Records r5 (B ≻ C) and r6 (C ≻ B) are appended under the same comparison task. They are two judgments, not a tie label and not proof of indifference. The comparisons now link A, B and C, and the minimizer is unique up to a common logit shift: π = (9/11, 1/11, 1/11) ≈ (0.818182, 0.090909, 0.090909), with mean record loss 0.605939.

In this changed ledger the four-record family no longer fits equally: P gives 0.606055 and Q gives 0.700098. The mean 0.605939 belongs to a different dataset than 0.562335; comparing the two is not a measure of improvement.

Whole-ledger copies. The whole ledger written three times, with distinct IDs, makes 12 rows in the same proportions. At z₁ the mean loss is 0.663849 (the four-record value is 0.663849) and the mean gradient is unchanged; only the summed loss triples. Copies are not independent evidence, and they still say nothing about C.

One more A ≻ B record. The counts become 4:1, the share 0.8, and the optimal A/B odds (4)^1/β = 16 instead of 9. Duplicating an existing favorable row would reweight the objective in the same way without adding a new judgment.

B ≻ C only. Adding just r5 connects all three responses, but the B–C comparison is one-sided: pushing π_C toward 0 keeps lowering the loss (0.593835 at c = 0.1, 0.505064 at c = 0.01, 0.456095 at c = 0.0001) toward (4/5)H(3/4) = 0.449868, which no strictly positive policy attains. Connectedness alone does not give a finite fit. Three A ≻ B records and no reverse record likewise have no finite optimum for the A–B log-ratio.

KL(P ‖ q) = 0.480955 and KL(Q ‖ q) = 0.390223 nats over all three responses. In the source, β is the coefficient of this KL in the regularized objective from which the loss is derived, but the recorded loss itself has no KL term. A smaller KL is not a tie-break the records supply, and it does not make either policy the intended one.

A discrepancy in this version. Appendix A.4 (printed p. 17) writes the loss as Eq. 21 with the loser-minus-winner margin inside −log σ, and its final gradient weights each pair by σ(v) rather than σ(−v). Eq. 7, the §4 gradient and Appendix B all use the winner-minus-loser margin, and differentiating Eq. 7 gives the weight σ(−v). This page follows Eq. 7; the note concerns this PDF version, not the method or other versions.

The weights agree only at v = 0, so the worked step at z₀ cannot tell them apart. At P, where each A ≻ B record has v = log 3, the correct weight is σ(−log 3) = ¼, not ¾. The correct mean gradient at P is (0, 0, 0); the printed weight would give (−0.25, 0.25, 0), as though P were not yet fitted.

A different freedom. The source identifies rewards only up to a prompt-only term β log Z(x). Moving from P to Q changes the detached scores β log(π/q) by (−0.549306, −0.549306, 0.972955): not one constant for all responses. The freedom here comes from comparisons that were never recorded.

Source: Rafailov et al. (2023). Direct Preference Optimization: Your Language Model is Secretly a Reward Model. NeurIPS 2023. arXiv:2305.18290v3 (PDF).

A separate implementation of the ledger, update, policy logits, log-softmax and implicit scores. The site’s test suite runs this exact text with Python and NumPy and compares shared valid and invalid cases with the TypeScript helper. The rubric, interval, sampling-share, identification and display helpers exist only in TypeScript.

import math
import re
from fractions import Fraction

import numpy as np

# One prompt; three complete responses, always in the order A, B, C.
RESPONSES = ("A", "B", "C")
ID_PATTERN = re.compile(r"[A-Za-z0-9][A-Za-z0-9._:-]{0,63}", re.ASCII)
MAX_RECORDS = 10_000
SUM_TOLERANCE = 1e-12


class PreferenceCoverageError(ValueError):
    """A coded refusal: the calculation does not apply, or a value is not representable."""

    def __init__(self, code, detail):
        super().__init__(f"{code}: {detail}")
        self.code = code


def real(x):
    """A Python int or float as binary64, else None. A bool is not a number here."""
    if isinstance(x, bool) or not isinstance(x, (int, float)):
        return None
    try:
        return float(x)
    except OverflowError:
        return None


def vector(value, what):
    if not isinstance(value, (list, tuple)) or len(value) != 3:
        raise PreferenceCoverageError("malformed-vector", f"{what} must be exactly three numbers")
    xs = [real(x) for x in value]
    if None in xs:
        raise PreferenceCoverageError("malformed-vector", f"{what} has a missing or non-numeric entry")
    return xs


def check_logits(z):
    z = vector(z, "logits")
    if not all(map(math.isfinite, z)):
        raise PreferenceCoverageError("nonfinite-logit", "every logit must be finite")
    return z


def check_distribution(p, role):
    """Three finite, strictly positive entries summing to 1: never clamped or renormalized."""
    p = vector(p, role)
    if not all(map(math.isfinite, p)):
        raise PreferenceCoverageError(f"{role}-nonfinite", f"every {role} entry must be finite")
    if any(x < 0 for x in p):
        raise PreferenceCoverageError(f"{role}-negative", f"a {role} entry is negative")
    if any(x == 0 for x in p):
        raise PreferenceCoverageError(f"{role}-zero", "a structural zero: its log-ratio is undefined, so the calculation does not apply")
    if not abs(p[0] + p[1] + p[2] - 1) <= SUM_TOLERANCE:
        raise PreferenceCoverageError(f"{role}-not-normalized", f"{role} entries must sum to 1 within {SUM_TOLERANCE}")
    return p


def check_beta(beta):
    b = real(beta)
    if b is None or not math.isfinite(b) or not b > 0:
        raise PreferenceCoverageError("invalid-beta", "beta must be finite and greater than 0")
    return b


def check_step_size(eta):
    e = real(eta)
    if e is None or not math.isfinite(e) or not e >= 0:
        raise PreferenceCoverageError("invalid-step-size", "the step size must be finite and at least 0")
    return e


def check_records(records):
    """Each record is (id, winner, loser). An empty ledger has no mean and no update."""
    if not isinstance(records, (list, tuple)):
        raise PreferenceCoverageError("malformed-ledger", "records must be a list")
    if not records:
        raise PreferenceCoverageError("empty-ledger", "no records: no empirical mean and no update, not a loss of 0")
    if len(records) > MAX_RECORDS:
        raise PreferenceCoverageError("too-many-records", f"at most {MAX_RECORDS} records")
    seen = set()
    for i, record in enumerate(records):
        if not isinstance(record, (list, tuple)) or len(record) != 3:
            raise PreferenceCoverageError("malformed-record", f"record {i} must be (id, winner, loser)")
        rid, w, l = record
        if not isinstance(rid, str) or not ID_PATTERN.fullmatch(rid):
            raise PreferenceCoverageError("invalid-id", f"record {i} needs an ID such as r1")
        if not all(isinstance(x, str) and x in RESPONSES for x in (w, l)):
            raise PreferenceCoverageError("invalid-label", f"record {rid}: winner and loser must be A, B or C")
        if w == l:
            raise PreferenceCoverageError("same-response", f"record {rid} compares {w} with itself")
        if rid in seen:
            raise PreferenceCoverageError("duplicate-id", f"record ID {rid} appears twice")
        seen.add(rid)
    return [tuple(r) for r in records]


def softplus(x):
    """log(1 + e^x) without overflow. A record's loss is softplus(-v) = -log sigmoid(v)."""
    return x + math.log1p(math.exp(-x)) if x > 0 else math.log1p(math.exp(x))


def sigmoid(x):
    if x >= 0:
        return 1 / (1 + math.exp(-x))
    e = math.exp(x)
    return e / (1 + e)


def mean(values):
    """Divide each term first, add left to right (not sum(), which compensates); refuse a mean that rounds past the largest double."""
    n, total = len(values), 0.0
    for v in values:
        total += v / n
    return finite(total, "the mean")


def finite(x, what):
    if not math.isfinite(x):
        raise PreferenceCoverageError("unrepresentable", f"{what} is not representable in binary64")
    return x


def evaluate(z, q, records, beta):
    """Every record at the same logits z, then the mean loss and the mean gradient."""
    beta, z = check_beta(beta), check_logits(z)
    q, records = check_distribution(q, "reference"), check_records(records)
    log_q = [math.log(x) for x in q]
    rows = []
    for rid, w, l in records:
        i, j = RESPONSES.index(w), RESPONSES.index(l)
        policy = finite(z[i] - z[j], "z_w - z_l")  # = log pi_w - log pi_l: the normalizer cancels
        reference = log_q[i] - log_q[j]  # kept explicit even when it is 0
        m = finite(policy - reference, "the margin m")
        v = finite(beta * m, "beta * m")
        grad = [0.0, 0.0, 0.0]
        grad[i], grad[j] = -beta * sigmoid(-v), beta * sigmoid(-v)  # -beta sigma(-v) (e_w - e_l)
        rows.append({"id": rid, "m": m, "v": v, "s": sigmoid(v), "loss": softplus(-v), "grad": grad})
    return {
        "rows": rows,
        "loss": mean([r["loss"] for r in rows]),
        "grad": [mean([r["grad"][c] for r in rows]) for c in range(3)],
    }


def step(z, q, records, beta, eta):
    """One full-batch update: all rows at the same z, averaged, then z' = z - eta * mean gradient."""
    beta, eta, z = check_beta(beta), check_step_size(eta), check_logits(z)
    before = evaluate(z, q, records, beta)
    z_next = [finite(z[c] - eta * before["grad"][c], "a stepped logit") for c in range(3)]
    return z_next, before, evaluate(z_next, q, records, beta)


def softmax(z):
    top = max(z)
    e = [math.exp(x - top) for x in z]
    return [x / (e[0] + e[1] + e[2]) for x in e]


def policy_logits(p):
    """z = log pi for a supplied positive policy (any common shift would do)."""
    return [math.log(x) for x in check_distribution(p, "policy")]


# Appendix B of the source (arXiv 2305.18290v3), with NumPy in place of PyTorch.
# -F.logsigmoid(x) is softplus(-x), which np.logaddexp(0, -x) computes stably.
def dpo_loss(pi_logps, ref_logps, yw_idxs, yl_idxs, beta):
    pi_yw_logps, pi_yl_logps = pi_logps[yw_idxs], pi_logps[yl_idxs]
    ref_yw_logps, ref_yl_logps = ref_logps[yw_idxs], ref_logps[yl_idxs]
    pi_logratios = pi_yw_logps - pi_yl_logps
    ref_logratios = ref_yw_logps - ref_yl_logps
    losses = np.logaddexp(0.0, -beta * (pi_logratios - ref_logratios))
    rewards = beta * (pi_logps - ref_logps)  # .detach() in the source: scores, not a training signal
    return losses, rewards


def log_softmax(z):
    """In shifted coordinates, so a common offset cannot absorb the normalizer; an unrepresentable shift is refused."""
    z = check_logits(z)
    top = max(z)
    shifted = [finite(x - top, "a shifted logit") for x in z]
    return np.array(shifted) - math.log(math.exp(shifted[0]) + math.exp(shifted[1]) + math.exp(shifted[2]))


def implicit_scores(p, q, beta):
    """beta log(pi / q) per response, the source's detached score; a product out of range is refused."""
    beta, p, q = check_beta(beta), check_distribution(p, "policy"), check_distribution(q, "reference")
    return [finite(beta * (math.log(a) - math.log(b)), "a scaled score") for a, b in zip(p, q)]


q = [1 / 3, 1 / 3, 1 / 3]
records = [("r1", "A", "B"), ("r2", "A", "B"), ("r3", "A", "B"), ("r4", "B", "A")]
beta, eta, z0 = 0.5, 1.0, [0.0, 0.0, 0.0]

# 1. One full-batch step from z0.
z1, before, after = step(z0, q, records, beta, eta)
print("row gradients at z0:", [r["grad"] for r in before["rows"]])
print("mean gradient:", before["grad"], "-> z1:", z1)
print("pi(z1):", [round(x, 12) for x in softmax(z1)])
print("mean loss:", round(before["loss"], 12), "->", round(after["loss"], 12))
print("row losses at z1:", [round(r["loss"], 6) for r in after["rows"]])
assert [r["grad"] for r in before["rows"]] == 3 * [[-0.25, 0.25, 0.0]] + [[0.25, -0.25, 0.0]]
assert before["grad"] == [-0.125, 0.125, 0.0] and z1 == [0.125, -0.125, 0.0]
# The same four rows written as counts: -(3 log s + log(1 - s)) / 4, with s = sigma(beta (z_A - z_B)).
s1 = sigmoid(beta * (z1[0] - z1[1]))
assert math.isclose(after["loss"], -(3 * math.log(s1) + math.log(1 - s1)) / 4, rel_tol=1e-14)
# The after-state again from literal logits, not from the step's own output. The mean fell; r4's loss rose.
again = evaluate([0.125, -0.125, 0.0], q, records, beta)
assert again["loss"] == after["loss"] < before["loss"] < after["rows"][3]["loss"]
# C's logit gradient is 0, yet pi_C moved: the softmax denominator changed.
assert before["grad"][2] == 0 and softmax(z1)[2] < 1 / 3
# The source's operation returns the same row losses at z0 and at z1.
chosen, rejected = np.array([0, 0, 0, 1]), np.array([1, 1, 1, 0])
for z, state in ((z0, before), (z1, after)):
    losses, _ = dpo_loss(log_softmax(z), np.log(q), chosen, rejected, beta)
    assert np.allclose(losses, [r["loss"] for r in state["rows"]], rtol=1e-13, atol=0)

# 2. Repeating this step keeps z_A + z_B = 0 and z_C = 0, so pi_A pi_B = pi_C ** 2 along the whole path.
z = z0
for _ in range(400):
    z, _, _ = step(z, q, records, beta, eta)
    assert z[0] + z[1] == 0 and z[2] == 0
print("400 steps approximate the stationary point (9/13, 1/13, 3/13):", [round(x, 9) for x in softmax(z)])
assert max(abs(a - b) for a, b in zip(softmax(z), [9 / 13, 1 / 13, 3 / 13])) < 1e-9

# 3. A different question: supplied policies that fit the four records equally well.
P, Q = [0.81, 0.09, 0.10], [0.27, 0.03, 0.70]
H = -(0.75 * math.log(0.75) + 0.25 * math.log(0.25))  # the minimum mean loss when 3 of 4 prefer A
for name, p in (("P", P), ("Q", Q)):
    fit = evaluate(policy_logits(p), q, records, beta)
    assert math.isclose(fit["loss"], H, rel_tol=1e-12) and max(map(abs, fit["grad"])) < 1e-12
    print(f"{name}: loss {fit['loss']:.12f}; predicted A over B {fit['rows'][0]['s']:.6f};",
          f"sampling A given A or B {p[0] / (p[0] + p[1]):.6f}; sampling A {p[0]:.2f};",
          f"pi_A pi_B - pi_C^2 = {p[0] * p[1] - p[2] ** 2:.4f}")


def kl(p):
    return sum(x * (math.log(x) - math.log(r)) for x, r in zip(p, q))


print(f"KL(P || q) = {kl(P):.12f}, KL(Q || q) = {kl(Q):.12f}; a diagnostic, the loss has no KL term")
# The source's detached scores change by different amounts per response from P to Q: not one prompt-only constant.
shift = np.subtract(implicit_scores(Q, q, beta), implicit_scores(P, q, beta))
assert np.allclose(shift, [-0.5 * math.log(3), -0.5 * math.log(3), 0.5 * math.log(7)])
_, rewards_P = dpo_loss(log_softmax(policy_logits(P)), np.log(q), chosen, rejected, beta)
assert np.allclose(rewards_P, implicit_scores(P, q, beta))  # the transcription's rewards are these scores


# 4. The pinned appendix's final line weights each record by sigma(v); Eq. 7 differentiates to sigma(-v).
def printed_weight_gradient(z, q, records, beta):
    rows, grads = evaluate(z, q, records, beta)["rows"], []
    for (_, w, l), row in zip(records, rows):
        g = [0.0, 0.0, 0.0]
        i, j = RESPONSES.index(w), RESPONSES.index(l)
        g[i], g[j] = -beta * row["s"], beta * row["s"]
        grads.append(g)
    return [mean([g[c] for g in grads]) for c in range(3)]


zP = policy_logits(P)
correct, printed = evaluate(zP, q, records, beta)["grad"], printed_weight_gradient(zP, q, records, beta)
print("gradient at P (v = log 3):", [round(x, 12) for x in correct], "; with the printed weight:", [round(x, 12) for x in printed])
assert max(map(abs, correct)) < 1e-12 and math.isclose(printed[0], -0.25, rel_tol=1e-12)
assert printed_weight_gradient(z0, q, records, beta) == before["grad"]  # equal at v = 0: a zero-margin test cannot tell

# 5. The analytic gradient against central differences, at nonzero margins and a nonuniform reference.
six = records + [("r5", "B", "C"), ("r6", "C", "B")]
q2, z2, h = [0.5, 0.25, 0.25], [0.3, -0.7, 1.1], 1e-6
g2 = evaluate(z2, q2, six, 0.8)["grad"]
for c in range(3):
    up, down = list(z2), list(z2)
    up[c], down[c] = z2[c] + h, z2[c] - h
    fd = (evaluate(up, q2, six, 0.8)["loss"] - evaluate(down, q2, six, 0.8)["loss"]) / (2 * h)
    assert abs(fd - g2[c]) < 1e-8

# 6. Evaluation: rubrics written for this page, in exact arithmetic. They change no record, logit, loss or gradient.
Pf = [Fraction(x) for x in ("0.81", "0.09", "0.10")]
Qf = [Fraction(x) for x in ("0.27", "0.03", "0.70")]


def utility(p, u):
    return sum(x * y for x, y in zip(p, u))


u_old, u_new = [1, 0, 0], [Fraction("0.2"), 0, 1]
print("u_old:", utility(Pf, u_old), utility(Qf, u_old), "| u_new:", utility(Pf, u_new), utility(Qf, u_new))
# C unscored: u = (0.2, 0, t) with t in [0, 1], so U(t) = 0.2 pi_A + pi_C t stays symbolic.
gap, slope = Pf[0] * Fraction("0.2") - Qf[0] * Fraction("0.2"), Pf[2] - Qf[2]
print(f"U_P(t) - U_Q(t) = {gap} + ({slope}) t; equal at t = {-gap / slope}")
assert -gap / slope == Fraction(9, 50) and gap > 0 > gap + slope  # P above Q at t = 0, below at t = 1

# 7. Optional data depth: a unique optimum, a connected graph without one, and copies.
fit6 = evaluate(policy_logits([9 / 11, 1 / 11, 1 / 11]), q, six, beta)
assert math.isclose(fit6["loss"], (4 * H + 2 * math.log(2)) / 6, rel_tol=1e-12) and max(map(abs, fit6["grad"])) < 1e-12
print(f"six records: optimum (9/11, 1/11, 1/11), mean loss {fit6['loss']:.12f}")
one_sided = records + [("r5", "B", "C")]
path = [evaluate(policy_logits([0.9 * (1 - c), 0.1 * (1 - c), c]), q, one_sided, beta)["loss"] for c in (0.1, 0.01, 0.0001)]
print("B over C only, as c -> 0:", [round(x, 12) for x in path], "> infimum 4H/5 =", round(4 * H / 5, 12))
assert path[0] > path[1] > path[2] > 4 * H / 5
copies = [(rid if k == 1 else f"{rid}-copy{k}", w, l) for k in (1, 2, 3) for rid, w, l in records]
assert math.isclose(evaluate(z1, q, copies, beta)["loss"], after["loss"], rel_tol=1e-14)  # same mean, not new evidence
selective = records + [("r5", "A", "B")]  # counts 4:1, so the optimal A/B odds are 16, not 9
assert max(map(abs, evaluate(policy_logits([0.8 * 16 / 17, 0.8 / 17, 0.2]), q, selective, beta)["grad"])) < 1e-12


# 8. Where the calculation does not apply, or a value is not representable: a coded refusal, no repair.
def refusal(f, *args):
    try:
        f(*args)
    except PreferenceCoverageError as error:
        return error.code
    return None


assert refusal(evaluate, z0, [0.5, 0.5, 0.0], records, beta) == "reference-zero"
assert refusal(evaluate, z0, [0.5, 0.25, 0.26], records, beta) == "reference-not-normalized"
assert refusal(evaluate, z0, q, [], beta) == "empty-ledger"
assert refusal(evaluate, z0, q, [("r1", "A", "A")], beta) == "same-response"
assert refusal(evaluate, z0, q, [("r1", "A", "Z")], beta) == "invalid-label"
assert refusal(evaluate, [1e308, -1e308, 0.0], q, records, beta) == "unrepresentable"
assert refusal(log_softmax, [1.7e308, -1.7e308, 0.0]) == "unrepresentable"
assert refusal(implicit_scores, [0.8, 0.1, 0.1], [0.01, 0.49, 0.5], 1e308) == "unrepresentable"
# A common offset keeps the normalizer: each log-probability is -log 3, not 0.
assert np.allclose(log_softmax([1e20, 1e20, 1e20]), [-math.log(3)] * 3, rtol=1e-15, atol=0)
extreme = evaluate([1000.0, -1000.0, 0.0], q, records, beta)  # pi_B and pi_C underflow to 0; the loss does not
assert extreme["loss"] == 250.0 and extreme["grad"] == [0.125, -0.125, 0.0] and softmax([1000.0, -1000.0, 0.0])[1:] == [0.0, 0.0]
print("refusals checked; at logits (1000, -1000, 0) the mean loss is", extreme["loss"])

The helper refuses rather than repairs: no epsilon, clamping, renormalizing or dropped record. Each line is its actual response.

• reference q = (0.5, 0.5, 0) with the four recordsreference-zero: a reference entry is exactly 0, so a log-ratio involving it is undefined; the calculation does not apply (no epsilon is added)
• reference q = (0.5, 0.25, 0.26)reference-not-normalized: reference entries sum to 1.01, not 1 within 1e-12; nothing is renormalized
• no recordsempty-ledger: no records: there is no empirical mean and no update (not a loss of 0)
• record r1: A ≻ Asame-response: record r1 compares A with itself
• two records both named r1duplicate-id: record ID r1 appears twice
• β = 0invalid-beta: beta must be a finite number greater than 0
• logits (10³⁰⁸, −10³⁰⁸, 0)unrepresentable: z_A - z_B is not representable in binary64; nothing is returned or applied

Finite extremes are different: at logits (1000, −1000, 0) the displayed probabilities round to (1, 0, 0), yet the mean record loss is 250 and the mean gradient (0.125, −0.125, 0), computed from logit differences rather than from logs of rounded probabilities.

Rehearsal with the worked values above in view. Opening an answer is help; a later retry is practice, not a test. Nothing is recorded.

1. At z₀, which way does r4’s own gradient push z_A, and why does the step still raise it?

   Show an answer

   r4’s gradient is (0.25, −0.25, 0); subtracting it lowers z_A for that record alone. The step uses the mean: (3 · (−0.25) + 0.25) / 4 = −0.125 for A, so z_A rises by 0.125.

2. z_C is still 0 after the step. Why did π_C change?

   Show an answer

   π_C = 1 / (e^0.125 + e^−0.125 + 1): the normalizer grew from 3 to 3.015645.

3. P and Q have the same record loss. Which should be used?

   Show an answer

   The records cannot say. They fix π_A/π_B only. The answer depends on an evaluation rubric; with C’s score known only to lie in [0, 1], it depends on t. What is missing is a judgment about C, or comparisons that involve C.

4. Two extra copies of the whole ledger, or one extra A ≻ B record: which changes the optimum?

   Show an answer

   The extra record: counts 4:1 give odds 16. Whole-ledger copies keep the mean and the optimum. Neither is new independent evidence about C.