What does Multi-Model Voting with Correlated Errors conclude, in numbers, about “How Many Models and How Many Labelled Questions: the Vote Ledger and the Labelling Ledger below the Ceiling”?

Answer: Under correlation the vote ledger fills with "never": the higher the target, the less correlation it tolerates, and beyond the threshold no number of extra calls helps. The labelling ledger reminds the owner that all these judgements rest on estimates whose precision improves only with the square root of the number of questions; three hundred questions are the starting point and a thousand the check near a threshold. The next chapter leaves the shop floor for a while and returns to two classical sources: the majority rule "when three read, follow the two" in the Great Plan chapter of the Book of Documents, and Condorcet's Essai of 1785.

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

A. smallest odd n reaching the target, p = 0.70
rho0.800.850.900.950.99ceiling
0.057917311.0000
0.01571119471.0000
0.02571123910.9979
0.05591985never0.9649
0.1715nevernevernever0.8996
0.221nevernevernevernever0.8180
B. the same at p = 0.80
rho0.800.850.900.950.99ceiling
0.01357131.0000
0.011357151.0000
0.021357171.0000
0.051359390.9973
0.113517never0.9755
0.21315nevernever0.9202
Show the full program
# Chapter 6. p61: how many models a target needs once errors correlate.
# Model: exchangeable Beta-binomial (p21) at mean accuracy p = 0.70.
# For each target, the smallest odd n whose majority reaches it, found
# by a step-2 search up to 3001, or "never" when the ceiling
# P(theta > 1/2) does not exceed the target. Panel B repeats it at
# p = 0.80. Correlations and targets 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 "never"
    n = 1
    while bb_major(n, p, rho) < target - 1e-12 and n < cap:
        n += 2
    return str(n) if n < cap else ">" + str(cap)


def table(p):
    print("   rho      0.80   0.85   0.90   0.95   0.99   ceiling")
    for rho in (0.0, 0.01, 0.02, 0.05, 0.1, 0.2):
        cells = "  ".join("{:>5}".format(calls(p, rho, t))
                          for t in (0.8, 0.85, 0.9, 0.95, 0.99))
        print("  {:<6} {}   {:.4f}".format(rho, cells, limit(p, rho)))


if __name__ == "__main__":
    print("A. smallest odd n reaching the target, p = 0.70")
    table(0.7)
    print("B. the same at p = 0.80")
    table(0.8)

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 6: How Many Models and How Many Labelled Questions: the Vote Ledger and the Labelling Ledger below the Ceiling. 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