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_w | family-maj | simple | naive | cluster | w_family |
| 0.0 | 0.8438 | 0.8747 | 0.8747 | 0.8444 | 1.686 |
| 0.2 | 0.8000 | 0.8465 | 0.8465 | 0.8260 | 1.386 |
| 0.3 | 0.7853 | 0.8333 | 0.8333 | 0.8198 | 1.297 |
| 0.4 | 0.7741 | 0.8206 | 0.8206 | 0.8151 | 1.232 |
| 0.5 | 0.7656 | 0.8083 | 0.8083 | 0.8116 | 1.184 |
| 0.8 | 0.7521 | 0.7728 | 0.7728 | 0.8059 | 1.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
- Chapter 1 · Condorcet's Binomial Majority: Why Independent Votes Grow More Accurate
- Chapter 2 · Correlated Errors and the Ceiling: the Beta-Binomial Model, Opinion Leaders and Shared Origins
- Chapter 3 · Measuring Correlation: Pairwise Correlation, the Q Statistic, Effective Votes and Colliding Wrong Answers
- Chapter 4 · Comparing Ways to Decorrelate: Resampling, Different Prompts, Different Models and Standard-Library Checks
- Chapter 6 · How Many Models and How Many Labelled Questions: the Vote Ledger and the Labelling Ledger below the Ceiling
- Chapter 7 · Classical Sources East and West: "When Three Read, Follow the Two" in the Great Plan and Condorcet's Essai of 1785
- Chapter 8 · Closing the Loop on Decorrelated Multi-Model Verdicts: a Procedure, the Correlated Voting Accuracy Calculator and a Pre-Registered Plan of Refutation