What does Multi-Model Voting with Correlated Errors conclude, in numbers, about “Closing the Loop on Decorrelated Multi-Model Verdicts: a Procedure, the Correlated Voting Accuracy Calculator and a Pre-Registered Plan of Refutation”?

Answer: Chapter 8 gives the empirical loop for decorrelated multi-model verdicts, the distilled Correlated Voting Accuracy Calculator and a pre-registered plan of refutation. Marked boxes separate published evidence, runnable Python calculations (19 programs), classical sources and the author's hypotheses.

Scope of the numbers: Its parameters are illustrative; all calculations are generated by its programs; it is general business analysis, not business advice. Marked boxes separate published evidence, runnable Python calculations (19 programs), classical sources and the author's hypotheses.

中文版

Data table

The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python only

target accuracy 0.80
5 resamples of one model
  final 0.7316  (independent benchmark 0.8624)
  ceiling 0.7366  n_eff 1.47  cap 1.7
  verdict DECORRELATE
5 different models
  final 0.7533  (independent benchmark 0.8095)
  ceiling 0.8257  n_eff 3.12  cap 6.7
  verdict ADD-VOTES  (n = 21)
5 different models + check
  final 0.8983  (independent benchmark 0.8095)
  ceiling 0.9273  n_eff 3.12  cap 6.7
  verdict PASS
Show the full program
# Chapter 8. p81: the audit of a multi-model verdict, as in the tool.
# Model: a pool of n votes with measured mean accuracy p and error
# correlation rho (exchangeable Beta-binomial, p21), optionally a
# standard-library check covering a share cov of questions with
# accuracy pc that decides where it applies (p42). Reported: the
# accuracy at n, the independent benchmark, the ceiling, n_eff and its
# cap 1/rho, the calls a target needs, and a verdict:
#   PASS        the design already reaches the target
#   ADD-VOTES   more votes of the same pool reach it (n given)
#   DECORRELATE the ceiling lies below the target: more of the same
#               pool can never reach it; change prompts, makers, or
#               add a deterministic check
# The three cases are illustrative.
import math



def lbeta(a, b):
    return math.lgamma(a) + math.lgamma(b) - math.lgamma(a + b)


def ab(p, rho):
    s = 1 / rho - 1
    return p * s, (1 - p) * s


def bb_major(n, p, rho):
    if rho == 0:
        lp, lq = math.log(p), math.log(1 - p)
        terms = [math.exp(math.lgamma(n + 1) - math.lgamma(k + 1)
                          - math.lgamma(n - k + 1) + k * lp
                          + (n - k) * lq)
                 for k in range(n // 2 + 1, n + 1)]
        return math.fsum(terms)
    a, b = ab(p, rho)
    terms = [math.exp(math.lgamma(n + 1) - math.lgamma(k + 1)
                      - math.lgamma(n - k + 1) + lbeta(k + a, n - k + b)
                      - lbeta(a, b))
             for k in range(n // 2 + 1, n + 1)]
    return math.fsum(terms)


def betacf(a, b, x):
    tiny = 1e-300
    c, d = 1.0, 1.0 - (a + b) * x / (a + 1)
    d = 1.0 / (d if abs(d) > tiny else tiny)
    h = d
    for m in range(1, 400):
        m2 = 2 * m
        for num in (m * (b - m) * x / ((a + m2 - 1) * (a + m2)),
                    -(a + m) * (a + b + m) * x / ((a + m2) * (a + m2 + 1))):
            d = 1.0 + num * d
            d = 1.0 / (d if abs(d) > tiny else tiny)
            c = 1.0 + num / c
            c = c if abs(c) > tiny else tiny
            h *= d * c
        if abs(d * c - 1.0) < 1e-15:
            break
    return h


def betai(a, b, x):
    if x <= 0:
        return 0.0
    if x >= 1:
        return 1.0
    lead = math.exp(a * math.log(x) + b * math.log(1 - x) - lbeta(a, b))
    if x < (a + 1) / (a + b + 2):
        return lead * betacf(a, b, x) / a
    return 1.0 - lead * betacf(b, a, 1 - x) / b


def limit(p, rho):
    if rho == 0:
        return 1.0 if p > 0.5 else 0.0
    a, b = ab(p, rho)
    return 1.0 - betai(a, b, 0.5)


def calls(p, rho, target, cap=3001):
    if limit(p, rho) <= target:
        return None
    n = 1
    while bb_major(n, p, rho) < target - 1e-12 and n < cap:
        n += 2
    return n if n < cap else None


def audit(n, p, rho, target, cov=0.0, pc=0.995):
    acc = bb_major(n, p, rho)
    final = cov * pc + (1 - cov) * acc
    ceil = limit(p, rho)
    top = cov * pc + (1 - cov) * ceil
    neff = n / (1 + (n - 1) * rho)
    if final >= target:
        verdict = "PASS"
    elif top <= target:
        verdict = "DECORRELATE"
    else:
        verdict = "ADD-VOTES"
    need = calls(p, rho, (target - cov * pc) / (1 - cov)) \
        if verdict == "ADD-VOTES" else None
    return {"acc": acc, "indep": bb_major(n, p, 0.0), "final": final,
            "ceiling": top, "n_eff": neff,
            "cap": 1 / rho if rho > 0 else float("inf"),
            "verdict": verdict, "need": need}


if __name__ == "__main__":
    cases = (("5 resamples of one model", 5, 0.72, 0.6, 0.0),
             ("5 different models", 5, 0.68, 0.15, 0.0),
             ("5 different models + check", 5, 0.68, 0.15, 0.6))
    target = 0.8
    print("target accuracy {:.2f}".format(target))
    for name, n, p, rho, cov in cases:
        r = audit(n, p, rho, target, cov)
        print(name)
        print("  final {:.4f}  (independent benchmark {:.4f})".format(
            r["final"], r["indep"]))
        print("  ceiling {:.4f}  n_eff {:.2f}  cap {:.1f}".format(
            r["ceiling"], r["n_eff"], r["cap"]))
        tail = "" if r["need"] is None else \
            "  (n = {})".format(r["need"])
        print("  verdict {}{}".format(r["verdict"], tail))

Single source and citation

Fan, Y. (2026). Condorcet's Jury Theorem with Correlated Errors: When Multi-Model Voting Gets More Accurate and When Shared Origins Make Everyone Wrong Together (Version 1.0.0), Chapter 8: Closing the Loop on Decorrelated Multi-Model Verdicts: a Procedure, the Correlated Voting Accuracy Calculator and a Pre-Registered Plan of Refutation. 5D Library. DOI pending

DOI pending · monograph page goes live after publication · 5DL-B-309 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026309,
  author    = {Fan, Yafu},
  title     = {Condorcet's Jury Theorem with Correlated Errors: When Multi-Model Voting Gets More Accurate and When Shared Origins Make Everyone Wrong Together},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book