Paper deep dive
Odds Law: The Decomposition Algebra On How Intelligence Organizes Itself to Solve Difficult Problems Reliably
Hidayet Aksu
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 97%
Last extracted: 6/20/2026, 6:45:32 AM
Summary
The paper introduces the 'Odds Law', a decomposition algebra that models how unreliable elementary problem-solvers can be organized into reliable compound solvers using four combinators: sequential composition, parallel ensembling, verification gating, and recursive reduction. The core result is the 'Verification Odds Law', which states that a verification gate multiplies the odds of correctness by the verifier's likelihood ratio (Λ). The research demonstrates that reliability can be amplified to a target level 1-δ with logarithmic depth O(log 1/δ) as long as the verifier is informative (Λ > 1), establishing a threshold dichotomy for reliability amplification. The work uses the framework of Markov categories and provides formal proofs for the limits of self-organization, information ceilings, and the necessity of diversity to overcome shared error causes.
Entities (10)
Relation Signals (4)
Decomposition Algebra → contains → Sequential Composition
confidence 100% · four combinators (sequential composition, parallel ensembling, verification gating, and recursive reduction) generate the space of compound solvers.
Reliability Amplification Theorem → dependson → Likelihood Ratio (Λ)
confidence 100% · giving target reliability 1−δ at O(log 1/δ) verification depth whenever Λ>1
Sequential Composition → ispartof → Decomposition Algebra
confidence 100% · four combinators (sequential composition, parallel ensembling, verification gating, and recursive reduction) generate the space of compound solvers.
Verification Gating → multipliesoddsby → Likelihood Ratio (Λ)
confidence 100% · a verification gate multiplies the odds of correctness by the verifier's likelihood ratio Λ
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:We ask a structural question: given unreliable elementary problem-solvers, what organizations of them solve hard problems reliably, and what are the limits? We develop a $decomposition~algebra$: elementary solvers are morphisms in a stochastic category, and four combinators (sequential composition, parallel ensembling, verification gating, and recursive reduction) generate the space of compound solvers. We equip this algebra with two homomorphisms, a $reliability$ valuation into the ordered monoid $([0,1],\le)$ and a $cost$ valuation into a commutative semiring, and we derive the composition laws that govern how reliability flows through structure. Our central results are (i) a $verification~odds~law$ (the result that names this report), showing that a verification gate multiplies the odds of correctness by the verifier's likelihood ratio $\Lambda$, so that $k$ conditionally independent gates yield geometric amplification; (ii) a $reliability~amplification~theorem$, giving target reliability $1-\delta$ at $O(\log 1/\delta)$ verification depth whenever $\Lambda>1$; and (iii) a $threshold~dichotomy$: above the critical parameters reliability can be driven arbitrarily close to one at logarithmic cost, while at or below them no amplification is possible. We then show that $self-organization$ is the least fixed point of a monotone improvement operator on the complete lattice of strategies, and that this fixed point equalizes marginal log-odds gain per unit cost. Finally, we prove matching limits: an information ceiling bounds per-gate amplification by a divergence quantity; shared error causes create a strictly positive voting floor, so diversity is $necessary$ for unbounded amplification. Reliability, in short, is neither free nor magical: it is bought with independent information, arranged by composition, and bounded by the verifier.
Tags
Links
- Source: https://arxiv.org/abs/2606.15712v1
- Canonical: https://arxiv.org/abs/2606.15712v1
Trouble viewing inline? Open PDF directly →
Full Text
61,286 characters extracted from source content.
Expand or collapse full text
Odds Law: The Decomposition Algebra On How Intelligence Organizes Itself to Solve Difficult Problems Reliably Hidayet Aksu hidayetaksu@gmail.com Abstract. We ask a structural question: given unreliable elementary problem-solvers, what organizations of them solve hard problems reliably, and what are the limits? We develop a decomposition algebra: elementary solvers are morphisms in a Markov (stochastic) category, and four combinators (sequential composition, parallel ensembling, verification gating, and recursive reduction) generate the space of compound solvers. We equip this algebra with two homomorphisms, a reliability valuation into the ordered monoid ([0,1],≤)([0,1],≤) and a cost valuation into a commutative semiring, and we derive the composition laws that govern how reliability flows through structure. Our central results are (i) a verification odds law (the result that names this report), showing that a verification gate multiplies the odds of correctness by the verifier’s likelihood ratio Λ , so that k conditionally independent gates yield geometric amplification; (i) a reliability amplification theorem, giving target reliability 1−δ1-δ at O(log1/δ)O( 1/δ) verification depth whenever Λ>1 >1; and (i) a threshold dichotomy: above the critical parameters (Λ⋆=1 =1 for verification, p⋆=12p = 12 for majority voting) reliability can be driven arbitrarily close to one at logarithmic cost, while at or below them no amplification is possible. We then show that self-organization (the spontaneous appearance of layered, verifier-saturated structure) is the least fixed point of a monotone improvement operator on the complete lattice of strategies, and that this fixed point equalizes marginal log-odds gain per unit cost (a water-filling characterization). Finally, we prove matching limits: an information ceiling bounds per-gate amplification by a divergence quantity; shared error causes create a strictly positive voting floor (we characterize exactly when), so diversity is necessary for unbounded amplification; and a no-free-lunch corollary shows that, averaged over all problem families, no decomposition beats its base solver. Reliability, in short, is neither free nor magical: it is bought with independent information, arranged by composition, and bounded by the verifier. These results form Odds Law, the theory layer of a two-part program (Theory: Odds Law → Framework: Maestro Order); the companion report builds the Maestro Order harness on these laws. problem decomposition, reliability, verification, ensembles, Markov categories, fixed points, threshold theorems, bounded rationality †copyright: none 1. Introduction A single attempt at a hard problem is rarely trustworthy. Yet collections of unreliable attempts, suitably organized, can be made arbitrarily trustworthy; this is the everyday experience of science, engineering, bureaucracy, and biological computation. Von Neumann’s classical question, how to build a reliable organism (or automaton) from unreliable components (vonneumann1956, ), is the same question one asks of a research group, a compiler with its test suite, or an ensemble of fallible reasoners. The components differ; the organizing principle may not. This paper takes that organizing principle as its object of study. We fix a population of elementary problem-solvers (each a randomized map from problem instances to candidate answers, and each only partly reliable) and ask which compositions of them are reliable, at what cost, and against what fundamental limits. We deliberately abstract away the internals of a solver (whether it is a person, a heuristic, a learned model, or an exact algorithm) and study only the calculus by which solvers are combined. The thesis is that reliable problem-solving is a property of structure, and that this structure obeys algebraic laws. The four combinators. Empirically, intelligent systems combine solvers in a small number of recurring ways. They decompose a problem into ordered subproblems and solve them in sequence (planning, proofs, pipelines). They run several attempts and aggregate (committees, juries, self-consistency, ensembles). They check candidate answers and keep only those that pass (proofs verified, code unit-tested, claims corroborated). And they recurse, treating a subproblem with the very same repertoire. We argue that these four (sequential composition, parallel ensembling, verification gating, and recursion) are not an arbitrary list but a generating set for a well-behaved algebra of solvers, in which reliability and cost are homomorphic images of structure. Contributions. • A decomposition algebra (§2–§3). We model solvers as morphisms in the Kleisli category of the subdistribution monad (a Markov category (fritz2020, ; chojacobs2019, )), and define four combinators that generate the free algebra (B) A(B) over a base set B. Reliability and cost are valuations into an ordered monoid and a commutative semiring, respectively. • Composition laws (§4). We prove how each combinator transforms reliability: sequential composition degrades (Lemma 4.1), majority voting amplifies above a threshold (Lemma 4.2), and, as our key primitive, a verification gate multiplies the odds of correctness by the verifier’s likelihood ratio (Lemma 4.3). • Amplification and a threshold dichotomy (§5). Theorem 5.1 achieves reliability 1−δ1-δ at verification depth O(log1/δ)O( 1/δ) whenever the verifier is informative; Theorem 5.2 shows this is sharp: at the critical parameters, no amplification is possible. This is the problem-solving analogue of fault-tolerance threshold theorems (vonneumann1956, ; aharonov1997, ). • Self-organization as a fixed point (§6). Strategies form a complete lattice under refinement; a greedy, budget-aware improvement operator is monotone, so by Knaster–Tarski (tarski1955, ) it has a least fixed point, the canonical self-organized strategy, which we characterize as verifier-saturated and marginal-rate-equalizing. • Matching limits (§7). An information ceiling bounds per-gate amplification (Theorem 7.1); shared error causes impose a strictly positive voting floor exactly when they can push the committee below chance, so diversity is necessary (Theorem 7.2); and a no-free-lunch corollary (wolpert1997, ) shows decomposition gains are paid for with priors matched to the problem. A companion report instantiates this algebra as a concrete, model-agnostic orchestration harness (Maestro Order) and measures the predicted laws; here we develop the theory in the abstract. 2. The Solver Model We work over a problem family: a measurable space of instances X, an answer space A (with a distinguished symbol ⊥∉ for abstention), and a correctness oracle Y⋆:→2∖∅Y :X→ 2^A \ \ assigning to each instance its nonempty set of acceptable answers. A distribution D over X specifies which instances occur and how often. Definition 2.1 (Solver). A solver is a Markov kernel s:↝∪⊥s:X ∪\ \, i.e. a measurable map →Δ(∪⊥)X→ (A∪\ \) from instances to (sub)distributions over answers and abstention. Write s(⋅∣x)s(· x) for the output law on instance x. Two scalar valuations summarize a solver. Let cov(s)≜ℙx∼[s(x)≠⊥]cov(s) _x [\,s(x)≠ \,] be its coverage (the probability it commits to an answer). Definition 2.2 (Reliability). The reliability of s is the conditional correctness rate on committed answers, ρ(s)≜ℙx∼,a∼s(x)[a∈Y⋆(x)|a≠⊥],ρ(s)\; \;P_x ,\;a s(x)\! [a∈ Y (x)\, |\,a≠ ], with the convention ρ(s)=0ρ(s)=0 if cov(s)=0cov(s)=0. We also use the worst-case variant ρ¯(s)=infx∈ℙa∼s(x)[a∈Y⋆(x)∣a≠⊥] ρ(s)= _x P_a s(x)[a∈ Y (x) a≠ ] when distribution-freeness is required. Separating coverage from reliability is deliberate: a solver may raise reliability by abstaining more (refusing hard instances), and the coverage/reliability trade-off is a recurring theme (§4, §8). Definition 2.3 (Cost). A cost valuation assigns to s a value c(s)c(s) in a commutative semiring (,⊕,⊗,0,1)(K, , ,0,1). We instantiate =(ℝ≥0∪∞,+,⋅)K=(R_≥ 0∪\∞\,+,·), with c(s)c(s) the expected number of base-solver invocations used by s. Sequential work adds (++); independent repetition multiplies counts by branching factor. Table 1. Notation. Symbol Meaning ,,⊥X,A, instances, answers, abstention Y⋆(x)Y (x) acceptable-answer set (oracle) s,g,vs,g,v solver, generator, verifier ρ(s)ρ(s) reliability (Def. 2.2) cov(s)cov(s) coverage (commit probability) c(s)c(s) expected base invocations β,αβ,α verifier completeness, false-acceptance Λ=β/α =β/α verifier discrimination (likelihood ratio) o=ρ/(1−ρ)o=ρ/(1-ρ) odds; ℓ=logo = o log-odds ;,⊕A,Vv,μ ;, _A,V_v,μ sequential, vote, verify, recurse (B) A(B) decomposition algebra over base B Categorical view. Solvers compose. Fix the Kleisli category Stoch of the subdistribution monad: objects are (typed) problem spaces, a morphism A↝BA B is a Markov kernel, and composition is the Chapman–Kolmogorov integral. Stoch is a Markov category (fritz2020, ; chojacobs2019, ): it is symmetric monoidal under the product ⊗ , with copy/discard structure modelling duplication and erasure of intermediate results. Sequential decomposition is categorical composition; running solvers “side by side” is the monoidal tensor. This is the ambient category in which our algebra lives; we keep the categorical language light and verify all quantitative claims directly. Readers unfamiliar with category theory can read this paragraph as saying only that randomized solvers can be wired together in sequence and in parallel, and that both operations behave well. 3. The Decomposition Algebra Let B be a finite set of base solvers. The decomposition algebra (B) A(B) is the smallest set of solvers containing B and closed under the four combinators below. Figure 1 depicts them. s1s_1s2s_2s3s_3xxyy(a) sequential ; ;ssssssAAxxyy(b) parallel ⊕A _Aggvvrejectxxaccept →y→ y(c) verify–refine VvV_vr A⨆ (d) recursion μ Figure 1. The four generators of the decomposition algebra. (a) ordered subproblems; (b) replicated solvers aggregated by A; (c) a generator g gated by a verifier v with refinement on rejection; (d) a reducer r that emits subproblems solved recursively and recombined. (1) Sequential composition ; ;. For solvers s1,…,sks_1,…,s_k whose types chain (si+1s_i+1 consumes the output of sis_i), the pipeline sk;⋯;s1s_k ;·s ;s_1 is their Kleisli composite. It models decomposition into dependent subproblems: the final answer is correct only if each stage produces a usable intermediate (we make the dependence precise in Lemma 4.1). (2) Parallel ensembling ⊕A _A. Given a solver s, a replication count n, and an aggregator A:(∪⊥)n↝∪⊥A:(A∪\ \)^n ∪\ \, the ensemble ⊕A(s,n) _A(s,n) draws n independent samples a1,…,an∼s(x)a_1,…,a_n s(x) and returns A(a1,…,an)A(a_1,…,a_n). The canonical aggregator is plurality vote A=majA= *maj. (3) Verification gating VvV_v. A verifier is a kernel v:×↝acc,rejv:X×A \ acc, rej\. Given a generator g and budget T∈ℕT , the gate Vv(g,T)V_v(g,T) repeatedly samples a∼g(x)a g(x), returns the first a with v(x,a)=accv(x,a)= acc, and abstains (⊥ ) after T rejections. A verifier is summarized by its completeness β≜ℙ[v=acc∣a∈Y⋆(x)]β [v= acc a∈ Y (x)] and soundness 1−α1-α, where α≜ℙ[v=acc∣a∉Y⋆(x)]α [v= acc a∉ Y (x)] is its false-acceptance rate. Its discrimination is the likelihood ratio Λ≜β/α∈[0,∞] β/α∈[0,∞]. (4) Recursion μ. A reducer r:↝≤mr:X ^≤ m maps an instance to a finite tuple of subinstances, with a recombiner ⨆:≤m↝ :A^≤ m . The recursive solver μFμ\,F is the least solution of S=F(S)S=F(S) where F(S)=⨆∘S⊗∘rF(S)= \,S r applies S to each subinstance. Well-posedness (a least fixed point exists) is established in §6. Definition 3.1 (Decomposition algebra). (B) A(B) is the closure of B under ;,⊕A,Vv,μ\ ;, _A,V_v,μ\. An element of (B) A(B) is a strategy; its syntax tree is its organization. The algebra is not a metaphor. The four combinators are the formal skeleton of organizations that already work. Table 2 lists canonical instantiations across very different substrates; in each case the “verifier” is whatever cheaply certifies a candidate, and the reliability laws of §4 apply unchanged. That a jury, a compiler’s test suite, a proof checker, and a MapReduce job are all the same algebra evaluated on different base solvers is the unifying claim of this paper. Table 2. Canonical instantiations of the decomposition algebra. Each row fixes a base solver and a verifier; the combinators and laws are shared. System Base solver Verifier v Dominant combinator Math proof prover proof checker VvV_v (high Λ ) Software coder test suite / types Vv;V_v\! ; Jury / panel juror — ⊕maj _ *maj Ensemble ML weak learner — ⊕maj _ *maj Science lab/group replication Vv⊕V_v\, MapReduce mapper re-execution μ;μ\, ; Valuations are (lax) homomorphisms. Cost is an exact homomorphism into K: c(sk;⋯;s1)=∑ic(si)c(s_k ;·s ;s_1)= _ic(s_i), c(⊕A(s,n))=nc(s)+c(A)c( _A(s,n))=n\,c(s)+c(A), and c(Vv(g,T))=[N](c(g)+c(v))c(V_v(g,T))=E[N]\,(c(g)+c(v)) with N≤TN≤ T the number of rounds. Reliability is a lax homomorphism: it does not factor through structure exactly, but is bounded above and below by explicit functions of the children’s reliabilities. Deriving those bounds is the goal of the next section. Two bands: the log-odds semiring. Reliability composes most cleanly not in [0,1][0,1] but in log-odds. Write ℓ(s)≜logρ(s)1−ρ(s)∈ℝ∪±∞ (s) ρ(s)1-ρ(s) ∪\±∞\. The point of the next section is that the natural operations live in two algebraic bands: a reliability band, where verification cascades add log-odds, and a cost band, where work adds invocation counts. Proposition 3.2 (Log-odds additivity). On the sub-algebra generated by verification gates, the map ℓ is a monoid homomorphism from conditionally independent gate cascades (under composition) to (ℝ,+)(R,+): stacking gates Vv1,…,VvkV_v_1,…,V_v_k sends ℓ↦ℓ+∑ilogΛi + _i _i. Pairing ℓ with cost c∈(ℝ≥0,+)c∈(R_≥ 0,+) yields a graded monoid (ℝ×ℝ≥0,+)(R×R_≥ 0,+) in which the slope Δℓ/Δc / c is the marginal rate optimized in §6. Proof. Immediate from Lemma 4.3 and Theorem 5.1: ℓ after a cascade is ℓ0+∑ilogΛi _0+ _i _i, additive and associative with identity the uninformative gate (logΛ=0 =0). Cost adds by Definition 2.3. The product monoid is the stated grading. ∎ This is why log-odds is the right currency: it linearizes the strongest combinator and turns “how to organize” into a linear-programming intuition over marginal slopes. 4. Reliability Composition Laws Throughout, treat distinct invocations of a base solver as independent unless stated otherwise; §7 removes this assumption and shows how much depends on it. 4.1. Sequential composition degrades Lemma 4.1 (Serial law). Let s1,…,sks_1,…,s_k be stages whose composite is correct iff every stage is correct (no error masking), with per-stage reliabilities ρi _i. Then 1−∑i=1k(1−ρi)≤ρ(sk;⋯;s1)≤miniρi,1- _i=1^k(1- _i)\;≤\;ρ(s_k ;·s ;s_1)\;≤\; _i _i, and if stage errors are independent, ρ(sk;⋯;s1)=∏i=1kρiρ(s_k ;·s ;s_1)= _i=1^k _i. Proof. Let EiE_i be the event that stage i errs. Correctness is ⋂iEi¯ _i E_i. The upper bound is monotonicity: ℙ[⋂iEi¯]≤ℙ[Ej¯]=ρjP[ _i E_i] [ E_j]= _j for each j. The lower bound is the union bound: ℙ[⋃iEi]≤∑i(1−ρi)P[ _iE_i]≤ _i(1- _i), so ℙ[⋂iEi¯]≥1−∑i(1−ρi)P[ _i E_i]≥ 1- _i(1- _i). Independence gives ℙ[⋂iEi¯]=∏iℙ[Ei¯]=∏iρiP[ _i E_i]= _iP[ E_i]= _i _i. ∎ Interpretation. Pure decomposition into dependent steps can only lose reliability, and it loses geometrically with depth. The error budget ∑i(1−ρi) _i(1- _i) is the right first-order accounting. This is the problem that the other three combinators exist to solve. 4.2. Parallel voting amplifies above one half Consider a decision with a unique correct answer and a per-sample correctness probability p (the binary or large-margin case). Lemma 4.2 (Vote law). For n independent samples (take n odd to avoid ties) aggregated by majority, if p>12p> 12 then ρ(⊕maj(s,n))≥ 1−exp(−2n(p−12)2),ρ( _ *maj(s,n))\;≥\;1- \! (-2n(p- 12)^2 ), while if p<12p< 12 the same argument applied to the complement shows the majority is correct with probability at most exp(−2n(12−p)2)→0 (-2n( 12-p)^2)→ 0, and if p=12p= 12 the votes carry no information about the answer. For M-ary answers in which the correct answer beats every alternative by expected margin θ>0θ>0, ρ≥1−(M−1)exp(−nθ2/2)ρ≥ 1-(M-1) (-nθ^2/2). Proof. Let Xj=[sample j correct]X_j=1[sample j correct], i.i.d. Bernoulli(p)(p). Majority is correct iff X¯>12 X> 12. By Hoeffding’s inequality (hoeffding1963, ), ℙ[X¯≤12]=ℙ[X¯−p≤−(p−12)]≤exp(−2n(p−12)2)P[ X≤ 12]=P[ X-p≤-(p- 12)]≤ (-2n(p- 12)^2) when p>12p> 12. For M-ary, apply a Hoeffding bound to the gap between the true answer’s count and each competitor’s and union-bound over the M−1M-1 competitors. ∎ The phase transition at p⋆=12p = 12 is Condorcet’s jury theorem (condorcet1785, ) in quantitative form: a committee of better-than-chance jurors converges to truth; a committee of worse-than-chance jurors converges to falsehood. 4.3. Verification multiplies the odds Write the odds of correctness as o(s)≜ρ(s)/(1−ρ(s))o(s) ρ(s)/(1-ρ(s)). The following lemma is the central tool of the paper. Lemma 4.3 (Verification odds law). Let g generate a correct candidate with probability p, and let v be a verifier with completeness β and false-acceptance α>0α>0, whose errors are independent of g’s given correctness. Condition on acceptance. Then the accepted answer’s odds of correctness satisfy opost=opre⋅Λ,Λ=βα,o_post\;=\;o_pre· , = βα, where opre=p/(1−p)o_pre=p/(1-p). Equivalently the post-acceptance reliability is r=pβpβ+(1−p)αr= pβpβ+(1-p)α. Proof. By Bayes’ rule on the event acc, ℙ[corr∣acc]ℙ[wrong∣acc]=ℙ[acc∣corr]ℙ[acc∣wrong]⋅ℙ[corr]ℙ[wrong]=βα⋅p1−p.∎ P[corr acc]P[wrong acc]= P[ acc ]P[ acc ]· P[corr]P[wrong]= βα· p1-p. Two consequences are immediate and important. First, verification is a Bayesian update: each gate contributes additively in log-odds, log(opost)=log(opre)+log(Λ) (o_post )= (o_pre )+ ( ). Second, the gain from a single gate is capped by the verifier: one gate multiplies the odds by at most Λ=β/α =β/α, no matter how the candidate was produced; a perfect verifier (α=0,Λ=∞α=0,\ =∞) certifies correctness outright, while an uninformative one (Λ=1 =1) changes nothing. Verification converts generation luck into checking power. Lemma 4.4 (Coverage of a gate). The per-round acceptance probability is q=pβ+(1−p)αq=pβ+(1-p)α, so the gate Vv(g,T)V_v(g,T) commits with probability 1−(1−q)T1-(1-q)^T and the expected number of rounds is [N]=(1−(1−q)T)/q≤1/qE[N]=(1-(1-q)^T)/q≤ 1/q. Proof. Rounds are i.i.d.; acceptance per round has probability q by the law of total probability. The commit probability and truncated-geometric mean follow. ∎ 5. Amplification and the Threshold Dichotomy We now stack gates. Suppose we hold a candidate and submit it to k verifiers whose errors are conditionally independent given correctness, accepting the candidate only if all accept (re-generating otherwise). By Lemma 4.3 applied k times the odds multiply. Theorem 5.1 (Reliability amplification). Let the base generator have correctness probability p0∈(0,1)p_0∈(0,1) and let k conditionally independent verifiers have discriminations Λ1,…,Λk _1,…, _k. Conditioned on joint acceptance, the reliability is rk=ok/(1+ok)r_k=o_k/(1+o_k) with ok=p01−p0∏i=1kΛio_k= p_01-p_0 _i=1^k _i. In particular, with each Λi≥Λ>1 _i≥ >1, reliability 1−δ1-δ is attained once k≥log1−δ+log1−p0p0logΛ=O(1logΛlog1δ),k\;≥\; 1-δ+ 1-p_0p_0 \;=\;O\! ( 1 1δ ), and the expected number of base invocations is of order k/(p0∏iβi)k/(p_0 _i _i). Proof. Joint acceptance has likelihood ∏iβi _i _i under correctness and ∏iαi _i _i under error (conditional independence). The odds form of Bayes gives ok=o0∏i(βi/αi)=o0∏iΛio_k=o_0 _i( _i/ _i)=o_0 _i _i. Solving rk≥1−δ⇔ok≥(1−δ)/δr_k≥ 1-δ o_k≥(1-δ)/δ and taking logarithms yields the stated k. For cost, by Lemma 4.4 the per-attempt joint-acceptance probability is at least p0∏iβip_0 _i _i, so the expected number of generate-and-check attempts is O(1/(p0∏iβi))O(1/(p_0 _i _i)), each costing k+1k+1 invocations. ∎ The depth is logarithmic in the target error δ: closing the reliability gap is exponentially cheap in structure, provided the verifier is informative. The next theorem shows that proviso is exactly a phase boundary. Theorem 5.2 (Threshold dichotomy). Fix a base solver and consider amplifying its reliability with bounded per-stage cost. (1) (Verification.) If Λ>1 >1, then for every δ>0δ>0 there is a strategy of depth O(log1δ)O( 1δ) and reliability ≥1−δ≥ 1-δ. If Λ=1 =1, then for every verification strategy ρ≤p0ρ≤ p_0; the verifier adds nothing. If Λ<1 <1 (that is, β<αβ<α), swapping the verifier’s accept and reject verdicts gives discrimination (1−β)/(1−α)>1(1-β)/(1-α)>1, so amplification is again possible and Λ⋆=1 =1 is the sole critical value. (2) (Voting.) If p>12p> 12, majority voting reaches any 1−δ1-δ with n=O(1(p−12)2log1δ)n=O\! ( 1(p- 12)^2 1δ ) samples; if p≤12p≤ 12, ρ(⊕maj(s,n))ρ( _ *maj(s,n)) does not exceed p and tends to 0 for p<12p< 12. The critical value is p⋆=12p = 12. Proof. Part (1), Λ>1 >1: Theorem 5.1. Part (1), Λ=1 =1: then β=αβ=α, so acceptance is independent of correctness; conditioning on acc leaves ℙ[corr∣acc]=p0P[corr acc]=p_0 by Lemma 4.3 with Λ=1 =1, and composing such gates preserves the posterior, so no strategy built only from uninformative gates exceeds p0p_0. Λ<1 <1: swap the verdicts as in the statement. Part (2): the upper direction is Lemma 4.2; for p<12p< 12, X¯→p<12 X→ p< 12 a.s. by the law of large numbers, so majority is eventually always wrong and ρ→0ρ→ 0; for p=12p= 12 the votes are independent of the truth, so no aggregation rule can do better than probability 12 12. ∎ This is the problem-solving counterpart of the fault-tolerance threshold theorems for unreliable computation and quantum error-correction (vonneumann1956, ; aharonov1997, ): there is a critical component quality above which arbitrarily reliable computation is achievable at modest overhead, and below which it is not. Here the “component quality” that matters for checking is the verifier’s likelihood ratio, and for voting it is being better than chance. Figure 2 plots the two regimes. 0224466880.40.40.60.60.80.811gates kkreliability rkr_k(a) amplification, p0=0.55p_0=0.55Λ=2 =2Λ=4 =4Λ=8 =810102020303040405050606000.20.20.40.40.60.60.80.811samples nnreliability(b) voting thresholdp=0.6p=0.6p=0.52p=0.52p=0.4p=0.4 Figure 2. (a) Verification amplifies reliability geometrically in the number of gates; larger discrimination Λ reaches the 1−δ1-δ target (dashed) in fewer gates (Theorem 5.1). (b) Majority voting amplifies above p⋆=12p = 12 and degrades below it (Theorem 5.2); the curve for p=0.52p=0.52 shows how slowly near-threshold solvers improve. 6. Self-Organization as a Fixed Point We now explain why structure should appear: why a system that locally improves itself converges to a stable, layered organization. The strategy lattice. Let S be the set of strategies for a fixed problem family, augmented with a bottom element ⊥ _S (the trivial abstaining solver) and a top element ⊤ _S (the oracle). Define the refinement order σ⊑σ′σ σ to mean σ′σ is obtained from σ by a finite sequence of reliability-monotone expansions: wrapping a subtree in a vote (only where the subtree is above chance), in a gate (only with Λ≥1 ≥ 1), or in an additional refinement round, or replacing a leaf by a decomposition whose composite dominates it pointwise. The qualifiers matter: by the laws of §4, these are exactly the conditions under which each expansion cannot decrease reliability. Lemma 6.1 (Complete lattice). (,⊑)(S, ) is a complete lattice: every subset has a supremum (the join obtained by parallel ensembling with a correctness-selecting aggregator) and an infimum. Proof sketch. Finite joins exist by ⊕ with an idealized selector that returns a correct member if any branch is correct, which dominates each branch in ⊑ ; finite meets exist dually by restricting coverage to the common domain. Arbitrary joins/meets exist by Dedekind–MacNeille completion of the resulting poset, which adjoins all suprema and infima while preserving existing ones (daveypriestley2002, ). The adjoined ⊤,⊥ _S, _S are the global bounds. (The join is an idealization used only to give the order a complete-lattice structure; the improvement operator below never needs to construct it.) ∎ The improvement operator. Fix a cost budget κ and a marginal-rate threshold λ>0λ>0. Define Φκ:→ _κ:S as the operator that, given a strategy σ, applies the single combinator (add a gate, add a vote, deepen a decomposition) that maximizes the marginal log-odds gain per unit cost, provided that rate exceeds λ and the budget κ is not exhausted; otherwise Φκ(σ)=σ _κ(σ)=σ. (Ties in the maximization are broken by a fixed priority order, so Φκ _κ is a well-defined function.) Algorithm 1: SelfOrganize: iterate the improvement operator 1:input: seed strategy σ0 _0, budget κ, rate threshold λ, candidate expansions ℰE 2:σ←σ0σ← _0 3:while c(σ)<κc(σ)<κ do 4: e⋆←argmaxe∈ℰ(σ)Δlogo(e)Δc(e)e ← *arg\,max_e (σ) o(e) c(e) ⊳ best marginal log-odds per cost 5: if Δlogo(e⋆)Δc(e⋆)≤λ o(e ) c(e )≤λ then 6: break ⊳ verifier-saturated: no rate exceeds λ 7: end if 8: σ←e⋆(σ)σ← e (σ) ⊳ apply gate / vote / decomposition (monotone) 9:end while 10:return σ Algorithm 1 realizes Φκ _κ as hill-climbing on the strategy lattice. Its termination and the structure of its output are not implementation details but theorems: Lemma 6.2 (Monotonicity). Under the reliability-monotone expansion order, Φκ _κ is order-preserving: σ⊑σ′⇒Φκ(σ)⊑Φκ(σ′)σ σ _κ(σ) _κ(σ ). Proof sketch. Each admissible expansion is, by Lemmas 4.2–4.3, reliability non-decreasing and acts on a subtree; applying the same class of expansion to a refinement σ′σ of σ yields a refinement of Φκ(σ) _κ(σ) because refinement is preserved under wrapping in a gate/vote and under dependent substitution. Hence the image order is preserved. ∎ Theorem 6.3 (Existence of a self-organized strategy). Φκ _κ has a least fixed point above any seed σ0 _0 and a greatest fixed point below ⊤ _S. Moreover, the iteration σ0 _0, Φκ(σ0) _κ( _0), Φκ2(σ0) _κ^2( _0), … reaches the least fixed point above σ0 _0, denoted σκ⋆σ _κ, after finitely many steps. Proof. By Lemma 6.1 the domain is a complete lattice and by Lemma 6.2 Φκ _κ is monotone, so the Knaster–Tarski theorem (tarski1955, ) (every order-preserving map on a complete lattice has least and greatest fixed points) applies. For the iteration: every step that changes the strategy adds at least the cost cmin>0c_ >0 of the cheapest combinator, and total cost is capped by κ, so after at most ⌈κ/cmin⌉ κ/c_ steps the iteration is constant at some fixed point σκ⋆⊒σ0σ _κ _0. It is the least such: if τ is any fixed point with τ⊒σ0τ _0, monotonicity gives Φκn(σ0)⊑Φκn(τ)=τ _κ^\,n( _0) _κ^\,n(τ)=τ for all n, hence σκ⋆⊑τσ _κ τ. ∎ Proposition 6.4 (Characterization: verifier-saturation). At the fixed point σκ⋆σ _κ, no admissible combinator yields marginal log-odds gain per unit cost exceeding λ. Consequently the organization is verifier-saturated: under the amplification law (Theorem 5.1), additional gates have been added until their marginal rate logΛ/Δc / c falls to λ, and the optimal allocation of a fixed budget across J candidate expansions equalizes the marginal rates, ∂logo∂c|j=λfor all active j, ∂ o∂ c |_j=λ all active j, a water-filling condition: budget flows to whichever expansions currently offer the highest return, until all active ones offer the same rate λ. (This is the standard first-order condition for constrained maximization.) Proof. At a fixed point Φκ(σ)=σ _κ(σ)=σ, so by definition of Φκ _κ no available expansion has rate >λ>λ within budget; hence every active expansion sits at rate =λ=λ (lower-rate ones are inactive), which is the stationarity (KKT) condition of maximizing logo o subject to c≤κc≤κ with multiplier λ. ∎ Two messages follow. First, organization is emergent and inevitable under local improvement: any hill-climbing process on the strategy lattice that prefers higher reliability-per-cost terminates at a layered, verifier-saturated structure; it does not need a designer. Second, the shape of that structure is dictated by the laws of §4: it allocates checking where information is cheapest, exactly as a rational designer would, because the fixed point coincides with the constrained optimum. 7. Fundamental Limits Amplification is bounded by information, by correlation, and by the absence of free lunches. 7.1. An information ceiling on verification A verifier is a channel from the latent bit “correct/incorrect” to its verdict. Its discrimination cannot exceed the information that channel carries. Theorem 7.1 (Information ceiling). Let a verifier output verdict W from latent correctness C∈0,1C∈\0,1\. The expected log-odds gain it produces (averaged over the verdict, given a correct candidate) is the divergence between its two verdict distributions: [logopost−logopre]=DKL(PW∣C=1∥PW∣C=0),E [ o_post- o_pre ]=D_KL\! (P_W C=1\,\|\,P_W C=0 ), and no cascade of verifiers that are all functions of the same evidence Z can yield a more reliable decision than the best decision based on Z itself. In particular, by the data-processing inequality, achievable reliability is limited by the mutual information I(C;Z)I(C;Z) between correctness and all evidence the system can observe. Proof. The posterior log-odds update on verdict W is the log-likelihood ratio logPW∣C=1(W)PW∣C=0(W) P_W C=1(W)P_W C=0(W); its expectation when W∼PW∣C=1W P_W C=1 is, by definition, DKL(PW∣1∥PW∣0)D_KL(P_W 1\|P_W 0). Verdicts are (possibly randomized) functions of Z, so by the data-processing inequality (cover2006, ) I(C;verdicts)≤I(C;Z)I(C;verdicts)≤ I(C;Z), and a decision based on a function of Z cannot be more accurate than the best decision based on Z. Fano’s inequality then bounds achievable reliability in terms of I(C;Z)I(C;Z). ∎ Stacking gates (Theorem 5.1) therefore pays off only when each gate contributes new, conditionally independent evidence; gates that re-read the same signal are redundant, and their effective Λ collapses toward 11. Amplification consumes information. 7.2. Diversity is necessary Independence was assumed in Lemmas 4.2–4.3. Real populations of solvers often make errors together: they share training, methods, or blind spots. We now show exactly when shared errors put a hard floor under majority voting. We model shared causes in the standard way: the voters are conditionally i.i.d. given a latent factor S that collects everything they have in common. (By de Finetti’s theorem, every infinite exchangeable population has this form, so this is not a special assumption.) Write p(S)p(S) for the per-voter accuracy conditional on S, with [p(S)]=pE[p(S)]=p, σ2=p(1−p)σ^2=p(1-p), and pairwise correlation γ=Var(p(S))/σ2γ=Var(p(S))/σ^2. Theorem 7.2 (Shared-cause voting floor). In the latent-factor model, with n odd: (i) the vote share satisfies Var(X¯)=σ2n+n−1nγσ2→n→∞γσ2Var( X)= σ^2n+ n-1nγσ^2 n→∞γσ^2, so for γ>0γ>0 it never concentrates at p; and (i) if ℙ[p(S)=12]=0P[p(S)= 12]=0, then limn→∞ℙ[majority wrong]=ℙ[p(S)<12]. _n→∞P[majority wrong]\;=\;P\! [p(S)< 12 ]. The floor on the right is strictly positive exactly when shared circumstances can push the whole committee below chance, and no amount of replication removes it. In particular, in the Gaussian-copula model (the model used in the companion simulations) the floor is strictly positive for every γ>0γ>0. Proof. (i) is the variance expansion of Var(1n∑Xj)Var( 1nΣ X_j) with equal pairwise covariances Cov(Xi,Xj)=Var(p(S))=γσ2Cov(X_i,X_j)=Var(p(S))=γσ^2. (i) Conditional on S, the law of large numbers gives X¯→p(S) X→ p(S) almost surely, so the majority indicator [X¯>12]1[ X> 12] converges to [p(S)>12]1[p(S)> 12] outside the null event p(S)=12\p(S)= 12\; bounded convergence yields the limit. For the Gaussian-copula model, Xj=[γS+1−γεj≤u]X_j=1[ γ\,S+ 1-γ\, _j≤ u] with independent standard normal S,εjS, _j and u=Φ−1(p)u= ^-1(p), where Φ is the standard normal distribution function; then p(S)=Φ((u−γS)/1−γ)p(S)= ((u- γ\,S)/ 1-γ ) takes every value in (0,1)(0,1) with positive density, so ℙ[p(S)<12]>0P[p(S)< 12]>0 for every γ>0γ>0. ∎ The characterization has two sides. If shared factors only add noise but never drag the committee below chance (p(S)>12p(S)> 12 almost surely), majority voting still converges to the truth; correlation merely slows it down. But if some situations make the whole committee wrong together, those situations are lost no matter how many copies vote. Corollary 7.3 (Effective committee size). Matching the vote-share variance, correlated voting behaves like independent voting with an effective sample size neff=n1+(n−1)γ→1γn_eff= n1+(n-1)γ→ 1γ: in terms of how sharply its vote share concentrates, a correlated committee is never worth more than 1/γ1/γ independent voters, however many members it has. Proof. Match variances: Var(X¯)=σ2/neffVar( X)=σ^2/n_eff with the expression of Theorem 7.2 gives neff=n/(1+(n−1)γ)n_eff=n/(1+(n-1)γ), whose limit is 1/γ1/γ. ∎ For example, at correlation γ=0.1γ=0.1 even a thousand-member committee concentrates no better than about ten independent voters, so the value of one more correlated member is already negligible. Diversity, meaning conditionally independent errors, is therefore not a luxury but a requirement for unbounded amplification. Organizations that clone a single fallible solver inherit its blind spots no matter how large they grow; useful committees are built from members who fail differently. 7.3. No free lunch Corollary 7.4 (No universal decomposition). Averaged uniformly over all problem families with a given answer space, every strategy in (B) A(B) has the same expected reliability as its base solvers: decomposition confers no advantage absent a prior matching structure to problems. Proof sketch. This is the no-free-lunch theorem for search and optimization (wolpert1997, ) transported to our setting: combinators are deterministic re-wirings of base-solver calls, so over the uniform mixture of oracles every fixed strategy induces the same marginal distribution over (instance, answer) correctness as calling the base solvers directly. Gains on a subfamily are exactly offset elsewhere. ∎ The corollary is not nihilistic; it is a statement about where reliability comes from. The combinators do not manufacture reliability; they transport the information already present in solvers and verifiers to the place a decision is made, and they only help on the structured problem families we actually face: those where verifiers are informative and errors are diverse. 8. The Cost–Reliability Frontier Collecting the laws, we can compare combinators on a common axis: the cost (base invocations) to reach error δ. Table 3. Work needed to reach error δ and amplification behaviour of each combinator (p: base correctness; Λ : verifier discrimination). Verification work counts gates; with an incomplete verifier (β<1β<1), regenerations add a factor of at most β−kβ^-k, negligible for β near 11. Combinator Work for error δ Regime Sequential ; ; — anti-amplifying (ρ↓ρ\! ) Voting ⊕maj _ *maj Θ(1(p−12)2log1δ) \! ( 1(p- 12)^2 1δ ) needs p>12p> 12 Verify VvV_v Θ(1logΛlog1δ) \! ( 1 1δ ) needs Λ>1 >1 Recurse μ depth-dependent inherits children Proposition 8.1 (Log-optimality and allocation). Both voting and verification reach error δ with structure size Θ(log1δ) ( 1δ) (samples for voting, gates for verification), which is optimal for any method whose error decays at most geometrically per unit of structure; verification’s constant is governed by logΛ and voting’s by (p−12)2(p- 12)^2, so verification dominates whenever a sufficiently discriminating checker exists. Under a fixed budget the reliability-maximizing strategy equalizes marginal log-odds gain per cost across stages (Proposition 6.4), preferring the combinator with the largest current marginal rate. Proof. Each accepted gate adds logΛ to the log-odds, and each batch of n votes adds Θ((p−12)2n) ((p- 12)^2n) to a Chernoff exponent; both give log(1/δ) (1/δ) scaling, and error that decays at most geometrically per unit of structure needs Ω(log1δ) ( 1δ) structure. The allocation rule is the first-order optimality (KKT) condition of Proposition 6.4. In total calls, verification additionally pays a regeneration factor of at most β−kβ^-k, which equals 11 for a complete verifier and stays small for β near 11. ∎ A worked organization. Suppose a base solver with p0=0.55p_0=0.55 and a verifier with Λ=4 =4 (β=0.8,α=0.2β=0.8,α=0.2). Each gate multiplies the odds by 44; the log-odds grow linearly while reliability saturates toward one (Table 4). Reaching δ=10−3δ=10^-3 needs k=⌈(log999+log0.450.55)/log4⌉=5k= ( 999+ 0.450.55)/ 4 =5 gates, matching Theorem 5.1. Pure voting from p0=0.55p_0=0.55 would instead need ∼12(0.05)2log103≈1400 \! 12(0.05)^2 10^3≈ 1400 samples for the same target: counting all calls (including regenerations), verification is roughly two orders of magnitude cheaper here (a few dozen calls versus about 14001400), which is exactly why effective organizations are built around checkers. Table 4. Reliability calculus for the worked organization: k gates, p0=0.55p_0=0.55, Λ=4 =4. Odds multiply; reliability saturates. gates k odds oko_k reliability rkr_k error 1−rk1-r_k 0 1.22 0.550 4.5×10−14.5× 10^-1 1 4.89 0.830 1.7×10−11.7× 10^-1 2 19.6 0.951 4.9×10−24.9× 10^-2 3 78.2 0.987 1.3×10−21.3× 10^-2 4 313 0.997 3.2×10−33.2× 10^-3 5 1252 0.9992 8.0×10−48.0× 10^-4 9. Recursive Decomposition: A Reliability Master Theorem The recursion combinator μ raises the stakes: a problem is reduced to subproblems, each solved by the same repertoire, to a depth d. Without correction, recursion is the serial law (Lemma 4.1) compounded across an exponentially growing tree, and reliability collapses. With verification at each node it is reliable at polylogarithmic overhead. We make this precise. Consider a balanced recursion of depth d and branching b: an internal node reduces its instance to b subinstances, solves each recursively, and recombines with reliability ρc _c (the recombiner is correct, given correct children, with probability ρc _c); a leaf is solved by a base solver of reliability p. Proposition 9.1 (Unverified recursion collapses). Without per-node verification, the reliability r(d)r(d) of the recursive solver obeys r(d)=ρcr(d−1)br(d)= _c\,r(d-1)^b with r(0)=pr(0)=p, whose closed form is r(d)=ρc(bd−1)/(b−1)pbd.r(d)\;=\; _c^\,(b^d-1)/(b-1)\;p^\,b^d. Hence for b≥2b≥ 2, unless p=ρc=1p= _c=1, r(d)→0r(d)→ 0 as d→∞d→∞, and the decay is doubly exponential in the depth d. Proof. A node is correct iff its recombiner is correct and all b children are correct; by independence r(d)=ρcr(d−1)br(d)= _c\,r(d-1)^b. Unrolling the recurrence gives r(d)=ρc 1+b+⋯+bd−1pbd=ρc(bd−1)/(b−1)pbdr(d)= _c^\,1+b+·s+b^d-1p^\,b^d= _c^\,(b^d-1)/(b-1)p^\,b^d. Both exponents grow like bdb^d, so r(d)=cbd(1+o(1))r(d)=c^\,b^d(1+o(1)) with c=pρc1/(b−1)<1c=p\, _c^1/(b-1)<1 unless p=ρc=1p= _c=1. ∎ This is why naive “decompose-and-recurse” degrades with depth: each level multiplies the number of opportunities for error by the branching factor b. The remedy is to restore each node’s reliability before its result propagates upward. Theorem 9.2 (Recursion master theorem). Let the tree have N=bd+1−1b−1N= b^d+1-1b-1 nodes, and suppose each node is wrapped in a verification gate that drives its local error (given correct inputs) to at most η. Then the whole computation is correct with probability at least 1−Nη1-Nη. Consequently, to achieve overall error δ it suffices to verify each node to error η=δ/Nη=δ/N, which by Theorem 5.1 requires per-node verification depth knode=O(1logΛ(log1δ+dlogb)),k_node=O\! ( 1 ( 1δ+d b ) ), and total cost O(Nknode)=O(bd(log1δ+dlogb)/logΛ)O\! (N\,k_node )=O\! (b^d\,( 1δ+d b)/ ): linear in the work bdb^d up to a polylogarithmic overhead, provided Λ>1 >1. Proof. Let AvA_v be the event that node v’s local step errs despite correct inputs, ℙ[Av]≤ηP[A_v]≤η. The output is correct unless some node errs, so by the union bound the failure probability is at most ∑vℙ[Av]≤Nη _vP[A_v]≤ Nη. Setting Nη=δNη=δ gives η=δ/Nη=δ/N; achieving per-node error δ/Nδ/N from a fixed base by Theorem 5.1 costs O(log(N/δ)/logΛ)O( (N/δ)/ ) gates, and logN=Θ(dlogb) N= (d b). Summing over N nodes gives the total. The count is in gate evaluations; with an incomplete verifier (β<1β<1), regenerations multiply per-node cost by at most β−knode=(N/δ)ln(1/β)/lnΛβ^-k_node=(N/δ) (1/β)/ , a mild polynomial factor that equals 11 for a complete checker (β=1β=1, e.g. a proof checker). ∎ Corollary 9.3 (Threshold for recursion). Recursive decomposition is reliability-preserving to arbitrary depth iff an informative verifier exists (Λ>1 >1). At Λ=1 =1 no per-node correction is possible and reliability follows the collapsing recurrence of Proposition 9.1. A worked recursion. Take depth d=4d=4, branching b=3b=3 (so N=35−12=121N= 3^5-12=121 nodes), target δ=10−2δ=10^-2, and a robust verifier with Λ=4 =4. The master theorem asks each node to reach error η=δ/N≈8.3×10−5η=δ/N≈ 8.3× 10^-5, i.e. odds ≈1.2×104≈ 1.2× 10^4, which from p0=0.55p_0=0.55 takes knode=⌈(log(1.2×104)+log0.450.55)/log4⌉=7k_node= ( (1.2×10^4)+ 0.450.55)/ 4 =7 gates. The unverified recurrence (Prop. 9.1) with the same leaves and ρc=0.9 _c=0.9 instead falls to 0.150.15 after one level, 0.0030.003 after two, and below 10−710^-7 after three, a clear illustration that depth without checking destroys reliability, while depth with logarithmic-overhead checking preserves it. The master theorem is the recursion-level counterpart of the threshold dichotomy and of fault-tolerant computing: depth is affordable when each level is checked. The polylogarithmic-per-node overhead is precisely the price of preventing error from compounding across the tree; it has the same shape as the overhead in fault-tolerant circuits, but is derived here from the odds law rather than from code distance. 10. Selective Reliability: Abstention and Calibration So far reliability was measured on committed answers (Definition 2.2). The freedom to abstain (⊥ ) is itself a reliability lever: a system can decline the instances it is least sure of and raise its reliability on the rest. This is selective prediction (chow1970, ; elyaniv2010, ), and it interacts cleanly with our laws because the verifier already supplies a confidence signal: its log-likelihood-ratio score. Definition 10.1 (Risk–coverage). For a score ϕ(x,a)φ(x,a) (e.g. the accumulated log-odds after gating) and threshold τ, the selective solver commits iff ϕ≥τφ≥τ. Its coverage is cov(τ)=ℙ[ϕ≥τ]cov(τ)=P[φ≥τ] and its risk is R(τ)=ℙ[a∉Y⋆∣ϕ≥τ]R(τ)=P[a∉ Y φ≥τ]. The risk–coverage curve is τ↦(cov(τ),R(τ))τ (cov(τ),R(τ)). Proposition 10.2 (Abstention monotonicity and optimal threshold). If ϕφ is the true log-odds of correctness (a calibrated score), then R(τ)R(τ) is non-increasing in τ: tightening the acceptance threshold never worsens reliability on the covered region. Moreover, under costs cerrc_err for a wrong commit and cabsc_abs for abstaining, the risk-minimizing policy is Chow’s rule: commit iff the posterior correctness exceeds 1−cabs/cerr1-c_abs/c_err, equivalently ϕ≥logcerr−cabscabsφ≥ c_err-c_absc_abs. Proof. For calibrated ϕφ, ℙ[wrong∣ϕ]=σ(−ϕ)P[wrong φ]=σ(-φ) is decreasing in ϕφ, so the conditional risk over the region ϕ≥τ\φ≥τ\ is an average of decreasing tails and is non-increasing in τ. The Bayes-optimal decision compares expected costs cerrℙ[wrong∣ϕ]c_err\,P[wrong φ] against cabsc_abs; commit when the former is smaller, which rearranges to the stated log-odds threshold (Chow’s rule (chow1970, )). ∎ Thus the verifier does double duty: as a gate it amplifies reliability (§5); as a score it orders instances for selective abstention (here). The risk–coverage curve is the achievable frontier of an organization, and escalation (abstaining and routing hard instances to a stronger sub-organization) is just abstention with a fallback, inheriting these guarantees. 11. Generator–Verifier Games The amplification theorem assumed the generator’s errors are indifferent to the verifier. When a generator instead optimizes for acceptance, as learned systems do under a reward and as nature does under selection, the verifier’s discrimination can silently collapse. This is Goodhart’s law (a proxy measure stops tracking what it was meant to measure once it is optimized directly) expressed in our calculus, and it limits how much reliability organization can manufacture. Model a Stackelberg interaction: the verifier v is fixed (the leader); the generator chooses an output distribution g (the follower) to maximize acceptance probability, possibly concentrating mass on wrong answers that v nonetheless accepts. Let α†(v)=supg:g wrongℙ[vacc∣g]α (v)= _g:\,g wrongP[v\ acc g] be the adversarial false-acceptance rate. Definition 11.1 (Non-gameable verifier). A verifier is Λ -robust if its discrimination stays above Λ>1 >1 against the worst-case generator, i.e. β/α†(v)≥Λβ/α (v)≥ . Theorem 11.2 (Robust amplification). If every gate is Λ -robust with Λ>1 >1, the amplification and master theorems (Thms. 5.1, 9.2) hold verbatim against adversarial generation, with Λ replaced by the robust Λ . If some gate has α†=βα =β (fully gameable), its effective Λ→1 → 1 and it contributes no amplification regardless of its nominal β/αβ/α on benign inputs. Proof. The odds law (Lemma 4.3) used only ℙ[acc∣corr]P[ acc ] and ℙ[acc∣wrong]P[ acc ]; substituting the worst-case wrong-acceptance α†α for α yields posterior odds multiplied by β/α†≥Λβ/α ≥ , and the proofs of Theorems 5.1 and 9.2 go through with Λ . If α†=βα =β the multiplier is 11, so by the Λ=1 =1 case of Theorem 5.2 no amplification occurs. ∎ The lesson sharpens §7: it is not enough for a verifier to be discriminating on average; to support reliable organization under optimization pressure it must be discriminating against an adversary that searches for what it will wrongly accept. Proof checkers and type systems are robust in this sense (their false-acceptance is bounded by soundness, independent of how the prover was chosen); learned reward models and shallow heuristics often are not, which is precisely why reliability built on them erodes as generators are optimized against them. Robust verification is the scarce resource on which reliable intelligence is built. 12. Related Work Reliable computation from unreliable parts. Von Neumann’s multiplexing and the subsequent fault-tolerance threshold theorems (vonneumann1956, ; aharonov1997, ) established that redundancy plus error-correction yields arbitrarily reliable computation above a component-quality threshold. Our Theorem 5.2 is the analogue for problem-solving, with the verifier’s likelihood ratio in the role of component quality and verification in the role of correction. Aggregation and ensembles. The Condorcet jury theorem (condorcet1785, ), boosting and ensemble learning (schapire1990, ), and concentration of measure (hoeffding1963, ) explain when many weak deciders make a strong one; our vote law and diversity floor (Theorems 4.2, 7.2) are the reliability-calculus form, emphasizing that correlation caps the gain. Verification and learning theory. The asymmetry that checking can be easier than producing underlies complexity theory’s verifier-centric definitions and PAC learning (valiant1984, ); Lemma 4.3 quantifies the value of a checker as a likelihood ratio and connects to information-theoretic limits (cover2006, ). Selective prediction and the reject option (chow1970, ; elyaniv2010, ) furnish the abstention frontier of §10, and our generator–verifier analysis (§11) formalizes the Goodhart effect that erodes non-robust checkers under optimization pressure. Compositional and categorical models. Markov categories give a clean syntax for stochastic composition (fritz2020, ; chojacobs2019, ); lattice and fixed-point methods underlie program semantics (tarski1955, ; daveypriestley2002, ). We use both to make “organization” a formal object and to prove that self-organization is a fixed point. Problem-solving architectures. From the General Problem Solver and means–ends analysis (newell1972, ) to the society-of-mind view that intelligence is the organization of many small unintelligent processes (minsky1986, ), and the divide-and-conquer paradigm in algorithms and distributed systems (dean2004, ), the recurring idea is that capability is a property of structure. We supply a reliability-theoretic account of which structures work and why. 13. Discussion and Conclusion We modeled problem-solving as an algebra over unreliable solvers and found that a small generating set (sequence, vote, verify, recurse) suffices to express the organizations intelligence actually uses, and that reliability flows through these combinators by explicit laws. Sequencing degrades; voting amplifies above chance; verification multiplies the odds by the checker’s likelihood ratio and so, stacked, closes the error gap at logarithmic depth. Above critical parameters (Λ⋆=1 =1, p⋆=12p = 12) reliability is essentially free to buy; at or below them it cannot be bought at all. Crucially, the layered, verifier-saturated organizations we observe in capable systems are not accidental: they are the fixed points of local improvement on the strategy lattice, and they coincide with the constrained optima that equalize marginal information per cost. And reliability has hard limits: the information the verifier carries, the diversity of the solvers, and the absence of a universal free lunch. Three implications stand out. (i) Build checkers, not just generators: when a discriminating verifier exists, verification beats voting by orders of magnitude (§8), so the highest-value engineering is often in the test, not the attempt. (i) Cultivate diversity: cloning a single solver gains nothing beyond its shared-error floor (Theorem 7.2). (i) Expect emergent layering: any system that locally trades cost for reliability will grow verification layers on its own (Theorem 6.3), so the design question is less whether to layer than where the marginal information is. Why organizations look the way they do. The same laws explain recurring features of human and biological problem-solving. Peer review, replication, and reproducibility are verification gates; the scientific premium on independent confirmation is Corollary 7.3 in cultural form. Bureaucratic sign-off chains are gate cascades trading latency for reliability. Modular redundancy in engineering (running three units and taking the majority) is voting above threshold. Division of labor is sequential decomposition made safe by local checking (inspection, unit tests). That such different systems converge on layered, checker-saturated structure is, on this account, not convergent accident but the shared fixed point of local improvement under the reliability laws (Theorem 6.3). Limitations and future work. Our assumptions of independence and conditional independence are idealized; §7 bounds the cost of violating them but a tight theory of partially correlated verifier cascades remains open. We treated verifier quality as given; learning the decomposition and the verifier, together with the game-theoretic dynamics when generators adapt to checkers, is the natural sequel, as is a quantitative bridge from these laws to the behavior of real model harnesses, which the companion paper takes up empirically. References (1) John von Neumann. 1956. Probabilistic Logics and the Synthesis of Reliable Organisms from Unreliable Components. In Automata Studies, C.E. Shannon and J. McCarthy (Eds.). Princeton Univ. Press, 43–98. (2) Dorit Aharonov and Michael Ben-Or. 1997. Fault-Tolerant Quantum Computation with Constant Error. In Proc. STOC. ACM, 176–188. (3) Wassily Hoeffding. 1963. Probability Inequalities for Sums of Bounded Random Variables. J. Amer. Statist. Assoc. 58, 301 (1963), 13–30. (4) Marquis de Condorcet. 1785. Essai sur l’application de l’analyse à la probabilité des décisions rendues à la pluralité des voix. Paris. (5) Robert E. Schapire. 1990. The Strength of Weak Learnability. Machine Learning 5, 2 (1990), 197–227. (6) Leslie G. Valiant. 1984. A Theory of the Learnable. Commun. ACM 27, 11 (1984), 1134–1142. (7) Thomas M. Cover and Joy A. Thomas. 2006. Elements of Information Theory (2nd ed.). Wiley. (8) Tobias Fritz. 2020. A Synthetic Approach to Markov Kernels, Conditional Independence and Theorems on Sufficient Statistics. Advances in Mathematics 370 (2020), 107239. (9) Kenta Cho and Bart Jacobs. 2019. Disintegration and Bayesian Inversion via String Diagrams. Mathematical Structures in Computer Science 29, 7 (2019), 938–971. (10) Alfred Tarski. 1955. A Lattice-Theoretical Fixpoint Theorem and Its Applications. Pacific J. Math. 5, 2 (1955), 285–309. (11) B.A. Davey and H.A. Priestley. 2002. Introduction to Lattices and Order (2nd ed.). Cambridge Univ. Press. (12) David H. Wolpert and William G. Macready. 1997. No Free Lunch Theorems for Optimization. IEEE Trans. Evolutionary Computation 1, 1 (1997), 67–82. (13) Allen Newell and Herbert A. Simon. 1972. Human Problem Solving. Prentice-Hall. (14) Marvin Minsky. 1986. The Society of Mind. Simon & Schuster. (15) Jeffrey Dean and Sanjay Ghemawat. 2004. MapReduce: Simplified Data Processing on Large Clusters. In Proc. OSDI. USENIX, 137–150. (16) C.K. Chow. 1970. On Optimum Recognition Error and Reject Tradeoff. IEEE Trans. Information Theory 16, 1 (1970), 41–46. (17) Ran El-Yaniv and Yair Wiener. 2010. On the Foundations of Noise-Free Selective Classification. J. Machine Learning Research 11 (2010), 1605–1641.