What does Multi-Model Voting with Correlated Errors conclude, in numbers, about “Weighted Majorities: Log-Odds Weights and the Double Counting of Correlated Clusters”?

Answer: Under independence, log-odds weighting is the optimal rule, and when one vote's weight exceeds the sum of all others it should decide alone, which gives Chapter 4's deciding check its theoretical footing. Under correlation, log-odds weights count the same evidence twice, and family votes should be merged into one before weighting; the boundary between merging and counting lies roughly between within-family correlations of 0.4 and 0.5. The next chapter returns to the budget: below the ceiling, how many models does a target accuracy require, and how many questions with known answers are needed to measure accuracy and correlation precisely?

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 onlyprinted values that match the answer: 0.4, 0.5

family of 3 (p 0.75) + two outside models (p 0.70)
rho_wfamily-majsimplenaiveclusterw_family
0.00.84380.87470.87470.84441.686
0.20.80000.84650.84650.82601.386
0.30.78530.83330.83330.81981.297
0.40.77410.82060.82060.81511.232
0.50.76560.80830.80830.81161.184
0.80.75210.77280.77280.80591.110
naive weights: family 3 x 1.099 = 3.296, outside 2 x 0.847
Show the full program
# Chapter 5. p52: log-odds weights over-count a correlated cluster.
# Model: three models of one family, each right with prob 0.75 and
# pairwise correlated (exchangeable Beta-binomial, rho_w), plus two
# outside models right with prob 0.70, independent of the family and
# of each other. Rules compared: simple majority of five; "naive"
# log-odds weights that treat all five as independent; and "cluster"
# weighting, which first takes the family's own majority, scores it
# with its exact accuracy A, and weights it ln(A / (1 - A)) next to
# the outside models. Exact enumeration, math.fsum. Illustrative.
import itertools
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 pmf(n, p, rho):
    if rho == 0:
        return [math.comb(n, k) * p ** k * (1 - p) ** (n - k)
                for k in range(n + 1)]
    a, b = ab(p, rho)
    return [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 + 1)]


def lo(p):
    return math.log(p / (1 - p))


def rules(pf, rho, po):
    fam = pmf(3, pf, rho)
    ac = math.fsum(fam[2:])
    out = {"simple": [], "naive": [], "cluster": []}
    for k, wk in enumerate(fam):
        for pat in itertools.product((1, 0), repeat=2):
            pr = wk
            for r in pat:
                pr = pr * (po if r else 1 - po)
            right = k + pat.count(1)
            if right >= 3:
                out["simple"].append(pr)
            yes = k * lo(pf) + pat.count(1) * lo(po)
            no = (3 - k) * lo(pf) + pat.count(0) * lo(po)
            if yes > no:
                out["naive"].append(pr)
            cv = 1 if k >= 2 else 0
            yes = cv * lo(ac) + pat.count(1) * lo(po)
            no = (1 - cv) * lo(ac) + pat.count(0) * lo(po)
            if abs(yes - no) < 1e-12:
                out["cluster"].append(pr / 2)
            elif yes > no:
                out["cluster"].append(pr)
    return ac, {k: math.fsum(v) for k, v in out.items()}


if __name__ == "__main__":
    print("family of 3 (p 0.75) + two outside models (p 0.70)")
    print("  rho_w  family-maj  simple   naive  cluster  w_family")
    for rho in (0.0, 0.2, 0.3, 0.4, 0.5, 0.8):
        ac, r = rules(0.75, rho, 0.70)
        print("  {:<5}  {:10.4f}  {:.4f}  {:.4f}   {:.4f}   {:.3f}".format(
            rho, ac, r["simple"], r["naive"], r["cluster"], lo(ac)))
    print("naive weights: family 3 x {:.3f} = {:.3f}, outside 2 x {:.3f}"
          .format(lo(0.75), 3 * lo(0.75), lo(0.7)))

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 5: Weighted Majorities: Log-Odds Weights and the Double Counting of Correlated Clusters. 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