Paper deep dive
On the Reliability of Networks of AI Agents: Density Evolution, Stopping Sets, and Architecture Optimization
Ehsan Aghazadeh, Hossein Pishro-Nik
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 98%
Last extracted: 6/20/2026, 4:54:06 AM
Summary
The paper proposes a theoretical framework to model the reliability of multi-agent AI systems using the machinery of density evolution from coding theory (specifically LDPC codes). It models agent networks as sparse, role-typed bipartite factor graphs where variable agents hold binary subclaims and check agents act as noisy Boolean verifiers. The authors identify three distinct failure modes (variable-side erasure, verifier-side erasure, and reasoning-channel erasure) and prove a density-evolution theorem to predict the asymptotic fraction of unresolved subclaims. The work also introduces 'certificate-stopping sets' to characterize finite-length failures and provides a method for cost-constrained architecture optimization.
Entities (9)
Relation Signals (4)
Ehsan Aghazadeh → affiliatedwith → University of Massachusetts Amherst
confidence 100% · E. Aghazadeh is with the Department of Computer Science, University of Massachusetts Amherst
Boolean Factor Graph → models → Agent Networks
confidence 100% · We model such a system as message passing on a sparse graph... an agent architecture is a sparse, role-typed factor graph
Hilbert → uses → Lean type-checker
confidence 100% · orchestrating four cooperating roles around a Lean type-checker
Density Evolution → extends → Low-Density Parity-Check (LDPC) codes
confidence 95% · extend the density-evolution machinery of coding theory to this richer setting
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Modern AI systems increasingly solve a task not with a single model call but with several imperfect agents working together: some propose pieces of a solution, others verify them, and the results are combined. These systems often outperform any single model, yet it is rarely clear why they succeed or when they will fail. We model such a system as message passing on a sparse graph, the structure that underlies low-density parity-check (LDPC) codes, and extend the density-evolution machinery of coding theory to this richer setting. In our model a task is a set of coupled binary subclaims, and an agent architecture is a sparse, role-typed factor graph whose check nodes are noisy Boolean verifier nodes, each computing a local Boolean function of the subclaims it touches. Three distinct failure modes, all modeled as erasures (an agent abstaining, a verifier returning no usable output, and a message lost between two agents), propagate as the agents exchange set-valued messages. The check agents combine these messages by a single logical-forcing rule that specializes to XOR, AND, OR, implication, and Horn constraints. This is more than a relabeling of LDPC theory: the verifier functions are nonlinear and value-asymmetric, and the three failure modes do not reduce to a single effective channel, so they require new threshold, finite-length, and converse results rather than a direct reuse of parity-check density evolution. We prove a density-evolution theorem that predicts the asymptotic fraction of unresolved subclaims on random role-typed architectures, with an extension to deterministic, locally tree-like graph sequences. The XOR case recovers the classical LDPC recursion on the binary erasure channel (BEC); the AND case exposes an asymmetry between positive and negative verifier certificates.
Tags
Links
- Source: https://arxiv.org/abs/2606.18121v1
- Canonical: https://arxiv.org/abs/2606.18121v1
Trouble viewing inline? Open PDF directly →
Full Text
238,306 characters extracted from source content.
Expand or collapse full text
1 On the Reliability of Networks of AI Agents: Density Evolution, Stopping Sets, and Architecture Optimization Ehsan Aghazadeh and Hossein Pishro-Nik, Senior Member, IEEE Abstract Modern AI systems increasingly solve a task not with a single model call but with several imperfect agents working together: some propose pieces of a solution, others verify them, and the results are combined. These systems often outperform any single model, yet it is rarely clear why they succeed or when they will fail. We model such a system as message passing on a sparse graph, the structure that underlies low- density parity-check (LDPC) codes, and extend the density-evolution machinery of coding theory to this richer setting. In our model a task is a set of coupled binary subclaims, and an agent architecture is a sparse, role-typed factor graph whose check nodes are noisy Boolean verifier nodes, each computing a local Boolean function of the subclaims it touches. Three distinct failure modes, all modeled as erasures (an agent abstaining, a verifier returning no usable output, and a message lost between two agents), propagate as the agents exchange set- valued messages. The check agents combine these messages by a single logical-forcing rule that specializes to XOR, AND, OR, implication, and Horn constraints. This is more than a relabeling of LDPC theory: the verifier functions are nonlinear and value-asymmetric, and the three failure modes do not reduce to a single effective channel, so they require new threshold, finite-length, and converse results rather than a direct reuse of parity-check density evolution. We prove a density-evolution theorem that predicts the asymptotic fraction of unresolved subclaims on random role-typed architectures, with an extension to deterministic, locally tree-like graph sequences. The XOR case recovers the classical LDPC recursion on the binary erasure channel (BEC); the AND case exposes an asymmetry between positive and negative verifier certificates. We then establish a recovery threshold and show that the three failure modes are separate design knobs, not a single effective noise level. We characterize finite-length failures by certificate-stopping sets and give augmentation conditions that remove small failure patterns. Finally, we formulate cost-constrained architecture optimization whose shadow prices identify the most valuable knob to improve, and prove a converse showing that the logical-forcing rule is asymptotically optimal among sound local rules. The theory is first-order in scope: surviving certificates are assumed correct, so confidently wrong messages and correlated failures lie outside it and require non-erasure extensions. Index Terms Agent networks, Boolean factor graphs, density evolution, erasure channels, large language models (LLMs), local message-passing, low-density parity-check (LDPC) codes, multi-agent systems, reliability, stopping sets. I. Introduction C OMPLEX cognitive tasks are increasingly executed by networks of imperfect artificial-intelligence agents rather than by single isolated model calls. Examples include formal theorem proving, verified software generation, multi-step action planning in structured environments, and target classification from noisy multi- modality observations. A modern system may decompose a problem into subgoals, route each subgoal to a specialized model or tool, invoke verifiers and tests on intermediate artifacts, refactor messages between roles, and aggregate the surviving evidence into a final answer. These systems can substantially outperform their E. Aghazadeh is with the Department of Computer Science, University of Massachusetts Amherst, Amherst, MA 01003, USA (e-mail: eaghazadeh@umass.edu). H. Pishro-Nik is with the Department of Electrical and Computer Engineering, University of Massachusetts Amherst, Amherst, MA 01003, USA (e-mail: pishro@umass.edu). This work was supported in part by the U.S. National Science Foundation under Grants CNS-2528914 and CNS-2150832. arXiv:2606.18121v1 [cs.MA] 16 Jun 2026 2 single-component baselines, sometimes by a wide margin. Hilbert reaches 99.2% on miniF2F by orchestrating four cooperating roles around a Lean type-checker [1]. CodeR reaches 28.33% on SWE-bench-lite, well above single-LLM baselines, using a task graph of code generators, test runners, and patch aggregators [2]. In debate- based oversight, having persuasive LLMs argue opposing sides helps a weaker judge identify the truthful answer more reliably [3]. Yet the reason these gains occur is often unclear. Is the improvement due to ensembling many independent samples? To a stronger verifier? To the topology of the agent communication graph? To the way roles are allocated and how compute is distributed across them? Practitioners design these systems by trial and error, tuning agent counts, verifier placements, and communication patterns until a benchmark goes up. Recent work argues that agent reliability deserves study as a discipline in its own right, and finds that rapid capability gains have so far produced only modest reliability gains [4]. We lack the analogue, for networks of AI agents, of what density evolution gave the LDPC community: a sharp asymptotic prediction of when a sparse network will be reliable, which architectural choices push it across the reliability threshold, and what structural patterns cause it to fail at finite size. This paper takes a step toward such a theory. The starting point is simple: a broad class of agent networks can be modeled as message passing on a sparse graph, with agents at the nodes and partial results sent along the edges. We track how those messages evolve from round to round and characterize when the network resolves its task. The main tool is the density-evolution machinery of LDPC codes, which we generalize to a setting with distinct agent roles, general Boolean verifiers that can themselves fail, and messages that can be lost between particular role pairs. The classical LDPC erasure recursion is the special case in which every verifier is a parity check. On top of this asymptotic theory we add three things. First, a finite-length failure analysis built on a generalization of stopping sets we call certificate-stopping sets, together with an augmentation theorem that removes all small failure patterns by targeted cross-verification. Second, a cost-constrained design method whose shadow prices say which reliability knob is most valuable to improve. Third, a converse showing that the message-passing rule is optimal among sound local rules. A. Hard tasks decompose into coupled subclaims A natural first attempt treats every agent as observing a noisy version of a single global ground truth y ∗ ∈ 1,...,K. If agent errors are conditionally independent given y ∗ and each agent does a little better than chance, then majority or plurality voting drives the error to zero exponentially fast in the number of agents. This regime is real and important; it covers calibration questions on multiple-choice benchmarks. But the communication topology barely matters here: when every agent sees the same label and the aggregator only needs a majority vote, the graph does almost no work. Hard cognitive tasks have internal structure. A formal proof decomposes into a sequence of lemma applica- tions, definitional unfoldings, and case splits. A program decomposes into modules, functions, and tests, with local consistency constraints between them. A structured plan decomposes into actions and dependencies, each of which can be checked against its neighbors but not on its own. We model such a task by a hidden vector of coupled binary subclaims X ∗ = (X ∗ 1 ,...,X ∗ n )∈0, 1 n .(1) Here X ∗ i = 1 means that subclaim i is correct (the proof step type-checks, the test passes, or the local rule is satisfied), and X ∗ i = 0 means it is not. X ∗ is a fixed ground truth and does not depend on the graph’s check operations: whether a check computes AND, XOR, or another Boolean relation, X ∗ is the same. The one convention we adopt is to read “correct” in the validator-relative sense, by the standard the system applies to each subclaim rather than by an abstract notion. This keeps the verifiers sound: a verifier can abstain, but never certifies a wrong value. Sometimes the verifier is only an approximate test of true correctness: a fixed set of tests can all pass even though the code is still wrong. We place this confidently-wrong case outside our first-order theory (Section XIII). Each local check tests whether a small subset of subclaims is jointly consistent. The coupling between subclaims is therefore relational: it lives in these checks, not in the prior on X ∗ itself. We take the entries of X ∗ to be independent given their roles, though the same density-evolution limits hold more generally (Section IV-B). 3 TABLE I Three regimes for multi-agent reasoning, distinguished by what the hidden truth looks like and where the analytical action is. This paper develops the theory of the second and third rows. SettingNatural methodWhy it matters here One hidden answer, indepen- dent agents Majority vote, self-consistency Topology and roles barely matter; LLN dominates. Coupled subclaims with local checks Message passing on a sparse graph Topology creates recovery and failure pat- terns. Noisy verifiers and channels on top of a coupled-subclaim task Message passing with noisy, role-typed verifiers Role-typed density evolution and certificate-stopping sets show which bottleneck binds; different ones need different architectural fixes. In words. Replacing one global label by a vector of coupled subclaims is what makes the topology of agent communication matter. Some unresolved subclaims can be filled in by neighboring checks; some form residual clusters that no amount of additional rounds will fix. The reliability of the overall system depends on which structural patterns the agent graph creates and which it avoids. The contrast across the three regimes that any agent-system theory must distinguish is shown in Table I. B. The model in one picture The mathematical object is a sparse bipartite factor graph G n = (V n ∪C n , E n ),(2) drawn from a role-typed bounded-degree configuration model; the resulting ensemble is locally tree-like in the limit n→∞ (Lemma 2). Two kinds of nodes live on it. Variable agents i∈V n each hold one subclaim X i ∈0, 1. A variable agent’s role r ∈R V says what kind of agent it is, for example “junior prover,” “code-fragment proposer,” or “retrieval agent.” Roles are how the model captures systematic differences in reliability across agents. Check agents a∈C n each evaluate a local Boolean function C a :0, 1 |∂a| →0, 1 on a small neighborhood ∂a of subclaims. In the framework of this paper, C a is an arbitrary bounded-arity Boolean function. Two analytically tractable specializations carry most of the work. The XOR specialization sets C a (x i 1 ,...,x i d ) = x i 1 ⊕·⊕x i d and recovers the LDPC-clean linear case. The AND-monotone specialization sets C a = x i 1 ∧·∧x i d and is the realistic verifier case. These are the questions real verifiers ask: “do these proof steps type-check together?” (a Lean kernel call); “do these unit tests all pass?” (a CodeR test runner); “does this configuration satisfy every local consistency rule?” Horn clauses, OR factors, and implications fall under the same framework. Throughout the paper, r ∈R V denotes a variable-agent role and s∈R C a check-agent role. Three sources of noise enter the model, all at initialization t = 0. 1) Variable-side erasure ε V r . A variable agent of role r abstains, returns “?”, and otherwise reports the true value X ∗ v . In practice, ε V r is the rate at which a step checker times out, fails to commit, or reports “not enough context.” 2) Verifier-side erasure ε C s . A check agent of role s fails to produce a verdict on its constraint and otherwise reports T a = C a (X ∗ ∂a ). In practice, ε C s is the rate at which a Lean kernel times out, a sandbox fails, a test cannot be invoked, or a judge declines to rule. 3) Reasoning-channel erasure 1−η r,s . When a message produced by an agent of role r is sent to an agent of role s, the message is replaced by “?” (lost or unusable on receipt) with probability 1− η r,s . In practice, this is the rate at which a refactor between two roles fails, a chain-of-thought becomes unparseable, or an artifact format mismatch makes the receiver unable to use what the sender computed. After this single noise injection, message passing is deterministic. We use extrinsic edge-specific updates: the message from u to w is computed without using the previous message from w to u. This extrinsic property 4 u 1 u 2 w a observed output z = f θ (·) M 1 M 2 Γ θ,j (z; M −j ) other sockets k ̸= j target socket j Fig. 1. The logical-forcing rule at a single check. Check a has template θ, so it computes the Boolean function f θ over the subclaims at its sockets, and its output is observed as z ∈0, 1 (for instance a test reporting pass or fail). To update the target subclaim w at socket j, the check combines z with the incoming candidate sets M −j = M k k̸=j from the other sockets and keeps the target values consistent with both (Equation (3)). If exactly one value is consistent the check forces w to it and sends a singleton; otherwise the target stays unresolved (U). XOR forces the target once every other input is known; AND with z = 1 forces all inputs to 1 at once. is what keeps local neighborhoods asymptotically tree-like, and is what makes density evolution rigorous in the configuration-model ensemble. Real agent systems typically broadcast: each round-t output is sent to every neighbor, including the agent that produced the incoming message. The extrinsic update drops this self-reuse; this is the standard idealization in message-passing analysis [5]. A message can turn “?” into a definite value but never the reverse, so reusing one’s own earlier message changes nothing on a tree. The difference between broadcasting and the extrinsic rule therefore appears only through short cycles. This is the same kind of finite-cycle effect that produces the error floor measured in Section XII (Figure 6); a cycle-aware version of the recursion is left to future work. The iteration index T is how many rounds the system runs: how many times the agents exchange and update their outputs before stopping, a finite budget in real systems. Section XIII traces this concretely for formal-proof, code-generation, and debate systems. The unifying check-to-variable update is the logical-forcing rule. A check a is joined to a few variables, one per edge, and each variable holds one subclaim (each point where a variable attaches to the check is a socket). Its template θ fixes the Boolean function f θ that a computes over those d θ inputs. We write z ∈0, 1 for the check’s observed output, for example z = 1 if a test passes and z = 0 if it fails. Messages travel both ways along each edge. From a variable to a check, the message is a candidate set M j ∈ M : = 0,1, U: a singleton b if the sender certifies that its subclaim equals b, the unresolved U =0, 1 otherwise. From a check back to the subclaim at a target socket j, the check combines its observed output z with the incoming messages M −j = M k k̸=j from the other sockets and returns the target values that remain consistent with what it knows: Γ θ,j (z; M −j ) : = b∈0, 1 : ∃x k ∈ M k , k ̸= j, f θ (x 1 ,...,x j−1 ,b,x j+1 ,...,x d θ ) = z .(3) In words, a value b survives if the other inputs can be filled in from their candidate sets so that the function outputs the observed z. If exactly one value survives, the check has forced the target and sends the singletonb; otherwise it sends U (Figure 1). This single rule specializes correctly to every Boolean primitive of interest. Under XOR, the target is forced exactly when every other input is known, recovering the classical BEC singleton-neighbor rule. Under AND, a positive verifier output (z = 1) certifies every input as 1 at once even when several were previously unresolved, while a negative verifier output (z = 0) certifies a target as 0 only when every other input is already known to be 1. This positive–negative asymmetry is absent from XOR but present in real verifier semantics, which is why Boolean verifier nodes, not parity checks alone, are a faithful abstraction for the certifying layer of agent systems. Two global objects anchor this picture, and it is worth naming them in coding terms. The hidden vector X ∗ is the validator-relative ground truth defined above, the analog of a transmitted codeword that no agent observes directly. The set-valued messages are the running estimate of X ∗ : a singleton b is a coordinate resolved to b, and U is a coordinate still unresolved, the erasure “?” of a binary-erasure-channel decoder. The 5 TABLE I The translation between LDPC and agent-network language used throughout the paper. The analogy is structural: parity-check constraints are engineered into the code, whereas verifier functions are inherited semantic constraints on the task (see Section I-D). LDPC / BEC conceptAgent-network meaning Code bit / variable nodeHidden subclaim or task component held by a variable agent Parity check / factor nodeLocal Boolean verifier node (XOR specialization is parity) Received erasureVariable agent lacks usable local evidence (abstains, times out) Check evaluationVerifier, test, proof-checker, or judge observation Message-passing iterationOne round of inter-agent communication Message erasureFailed or unusable reasoning artifact (refactor failure) Stopping setResidual cluster the local agents cannot resolve Two-edge-connected augmentationCross-verification layer that frees small clusters Degree distribution / role mixAgent architecture and communication pattern BP / recovery thresholdReliability-recovery threshold surface message vector therefore plays the role of a decoder state such as (0, U, 1, U, 1), and soundness guarantees that each resolved coordinate equals the true X ∗ j , so an iteration can only turn an U into a singleton, never into a wrong value. The correspondence to coding theory is summarized by the dictionary in Table I. Each row pairs an LDPC concept with its agent-network counterpart in a form that lets the technical content transfer in both directions. Scope of the erasure-only model. The framework targets the certifying layer of verifier-driven agent systems: proof kernels, test runners, validators, abstaining subclaim generators, and parseable/unparseable role transi- tions. In this layer a non-erased certificate is assumed sound, while missing, timed-out, or unusable outputs are treated as erasures. Confident wrong messages (hallucinated subclaims asserted with the same surface form as correct ones) fall outside the present first-order theory and require a hybrid erasure-and-flip extension that we discuss as a follow-on direction in Section XIV-B. Our positioning is that the erasure-only theory captures the failure modes that dominate in certifying agent stacks, not that LLM agents never produce wrong messages. What the message-passing model assumes. The graph and its update rule describe how local certificates combine; they are not a claim that the agents run this decoder inside themselves. What we follow is a reliability state: for each subclaim, whether it has been resolved and to which value, and how that state changes as evidence passes between agents. Three points follow. First, the round count T is a finite depth, not a run to convergence: a single forward pass, in which each agent produces its output once, is the case T = 1, and letting verifiers send their results back for another round adds depth. Second, the only structural assumption is that the task-dependency graph is locally tree-like, so the certificates reaching a check are nearly independent; this is a property of the task graph, not of any agent’s internal reasoning, and where it fails, through hubs or short cycles, the cost is the error floor measured in Section XII. Third, logical forcing is the sound certifying rule, and Theorem 7 shows it is the best such rule, so the reliability limits we prove bound any sound local certification scheme, whatever algorithm a deployed system runs. C. A toy example: a team of agents checking a 4-step proof To make the model tangible, we walk through a tiny scenario that a contemporary multi-agent proof-checking system could plausibly face. The checks here are AND tests, which is what real verifiers compute: each asks whether a group of steps composes into a valid sub-derivation. The linear special case, in which each check is instead a parity constraint, is what reproduces the classical LDPC erasure recursion exactly and connects the model to coding theory (Section I-D); the formal theorems cover the general Boolean case (Section VII). The task. A junior model has produced a candidate proof of the elementary lemma If n and m are even integers, then n + m is even. 6 v 1 v 2 v 3 v 4 a 1 a 2 a 3 Fig. 2. Bipartite factor graph for the 4-step proof scenario in Section I-C. Variable agents v 1 ,...,v 4 (circles, top row) are step checkers holding the per-step verdicts; check agents a 1 ,a 2 ,a 3 (squares, bottom row) are consistency checks that re-derive whether a group of steps composes. The hidden flaw is in step 3, so the two checks touching it, a 1 and a 2 , fail, while a 3 passes. The shaded nodes v 3 ,v 4 ,a 2 denote the channel realization analyzed in the text: step checkers v 3 ,v 4 abstain (variable-side erasure) and check a 2 times out (verifier-side erasure); unshaded nodes deliver cleanly. The proof attempt is broken into four steps: (1) unfold “even” on n: “there exists an integer k with n = 2k,” (2) unfold “even” on m: “there exists an integer j with m = 2j,” (3) substitute and combine: “then n + m = 2k + 2j = 2(k + j + 1),” (4) apply “even” to conclude: “since k + j + 1 is an integer, 2(k + j + 1) is even, so n + m is even.” Each step has a hidden truth label X ∗ i ∈0, 1 that equals 1 if the step is logically valid and 0 if it contains a flaw. Here step 3 hides an arithmetic slip, 2k + 2j = 2(k +j + 1) where the correct value is 2(k +j), so the true labels are X ∗ = (1, 1, 0, 1). The team of agents does not know this yet, and its goal is not just a global “proof correct/incorrect” verdict but a per-step verdict ˆ X i ∈ 0, 1 for every i. A global reject tells a downstream user nothing about which step to fix; per-step verdicts let an editor or another agent target the actual flaw, and this is what verifier-centered proof systems such as Hilbert [1] report. The agents. Variable agents v 1 ,v 2 ,v 3 ,v 4 are LLM step checkers, one per step. Each v i is given step i in isolation, together with its hypotheses, and asked the single local question “is this one inference valid?” For instance, v 1 checks that “there exists an integer k with n = 2k” correctly unfolds “n is even,” v 3 checks the algebra in step 3, and v 4 checks that “n +m is even” follows from “n +m = 2(k +j + 1).” Its private observation is A i = ( X ∗ i , if the step checker produced a confident verdict, U,abstention (timeout, ambiguous notation, missing context). A step checker may abstain, but by soundness it never reports a confident verdict that disagrees with X ∗ i . Check agents a 1 ,a 2 ,a 3 are higher-level consistency checkers. Each a j takes a small group of steps and re-derives whether they compose into a coherent sub-derivation, reporting Z j = 1 if the group re-checks and Z j = 0 if it does not. This is the AND of the group’s step labels, Z j = C a j (X ∗ ∂a j ), which is what a proof assistant computes when it re-runs a block of reasoning. The observation is erased, Z j = ?, when the check times out. We take three consistency checks with the connectivity a 1 ↔v 1 ,v 2 ,v 3 , a 2 ↔v 2 ,v 3 ,v 4 , a 3 ↔v 1 ,v 4 , so a 1 and a 2 re-derive the front and back halves of the proof (both touch the flawed step 3 and fail), while a 3 checks that the opening and closing definitional moves agree (it does not touch step 3 and passes). A consistency check is informative in two asymmetric ways. A passing block (Z j = 1) is a positive certificate: the whole sub-derivation re-checks, so every step it touches is valid at once. A failing block (Z j = 0) is a negative certificate: it shows at least one step is broken, and pins down which one only when every other step it touches is already known valid, in which case the lone remaining step must be the flaw. The bipartite factor graph is drawn in Figure 2; shaded nodes mark the channel realization analyzed below. Noise enters once, at t = 0. A representative realization of all three noise tiers: • Variable-side: v 1 ,v 2 run cleanly and report A 1 = A 2 = 1. v 3 ,v 4 abstain and report A 3 = A 4 = U; in particular the step checker for the flawed step gives no verdict of its own. • Verifier-side: a 1 re-derives the front half and reports failure, Z 1 = 0; a 2 exceeds its compute budget and reports Z 2 = ?; a 3 re-derives the definitional bracket and reports success, Z 3 = 1. 7 • Reasoning channels: every directed edge delivers cleanly in this first pass. After this one-shot noise injection the agents exchange messages deterministically. In round 1, each step checker forwards its observation to its consistency-check neighbors, the singleton 1 if it has one and the unresolved U otherwise. In round 2, each consistency check tries to resolve the steps it touches, using its own pass/fail observation and the messages just received from the other steps in its group: • a 3 → v 4 : a 3 passed, Z 3 = 1, a positive certificate, so it forces both of its steps to 1 and recovers the abstaining v 4 . Success. • a 1 → v 3 : a 1 failed, Z 1 = 0, with inbound singletons 1 from v 1 and 1 from v 2 . Every other step it touches is confirmed valid, so the negative certificate forces the lone remaining step, X ∗ 3 = 0, and a 1 sends this verdict to v 3 . Success: the flaw is localized. • a 2 → v 3 : a 2 timed out, Z 2 = ?, so the forcing operator returns U and a 2 contributes nothing. Fails (verifier-side erasure), but harmlessly: a 1 has already localized step 3. Takeaway. Even with two abstaining step checkers (v 3 ,v 4 ) and one timed-out consistency check (a 2 ), the team produces ˆ X = (1, 1, 0, 1): steps 1, 2, and 4 confirmed valid and step 3 correctly flagged as the flaw. One passing block gave a positive certificate and one failing block gave a negative certificate; the communication structure recovered, and localized, what no single agent could. Now break the example three ways. Small changes to the channel realization illustrate the three failure modes of the stopping-set theorem (Theorem 3). (M1) The verifier fails. If a 1 also times out, both checks touching step 3 (a 1 ,a 2 ) have erased verdicts and a 3 does not touch step 3, so ˆ X 3 stays U: every check that could have caught the flaw gave up. (M2) Too many unknowns in one group. Restore a 1 but let v 2 also abstain. Then a 1 fails with inbound messages 1, U, U from v 1 ,v 2 ,v 3 : a failing check with two unresolved steps cannot tell which one is broken, so the negative certificate does not fire and both v 2 and v 3 stay U. A check can localize at most one unknown step at a time. (M3) The reasoning channel fails. Restore the original channel but drop the directed edge a 1 → v 3 (a failed format conversion between a 1 ’s output and v 3 ’s expected input). Now a 1 correctly determines X ∗ 3 = 0, but the verdict never arrives in usable form and v 3 is left with ˆ X 3 = U: the flaw was found but not communicated. These three modes (verifier-erased, multi-step combinatorial, channel-erased) are the three modes of the stopping-set theorem (Theorem 3, Corollary 4), and each calls for a different fix: replace or add a verifier (M1), restructure the consistency-check connectivity (M2), or harden the communication channel (M3). Making these three knobs separately tunable, with adjoint-derived shadow prices saying which one binds, is one of the main contributions of the theory (Theorem 6). The linear special case. If each check were a parity constraint, L i∈∂a j X i = T j , rather than an AND, the same machinery would apply but recovery would become symmetric: a check missing exactly one of its inputs recovers it by parity, whatever the values, and two missing inputs leave it unresolved. This linear case is the one that reproduces the classical LDPC erasure-decoding recursion exactly, and it is the bridge to coding theory developed next (Section I-D, Corollary 3). D. Why this is the LDPC story, and why it is not Where the algebraic constraint comes from. In a parity-check code every codeword satisfies Hx = 0, a constraint the designer engineers into the system, and that engineered constraint is what drives iterative decoding. In an agent network the hidden values X ∗ i are facts about the world, not bits of a codeword, so it is worth asking what plays the role of the parity equation. The answer is one level up. Each verifier function C a :0, 1 d a →0, 1, together with its true output T ∗ a : = C a (X ∗ ∂a ), asserts a Boolean equation C a (X ∗ ∂a ) = T ∗ a (literally a parity check under XOR; “all inputs are 1” or “some input is 0” under AND). The constraint set C = X ∈ 0, 1 n : C a (X ∂a ) = T ∗ a ∀a plays the role of the codebook, and iterative recovery resolves the noisy observations (A,Z) to the element of C they identify, with each verifier function locally restricting the candidate set as in LDPC. The one difference is where the constraints come from. A code designer engineers H for minimum distance or threshold; an agent-network designer inherits C a from the task domain: logical inference rules in proof 8 checking, module-correctness tests in code generation, biological-consistency relations in medical diagnosis. These constraints are real features of the task, present whether or not an agent network is deployed on them. The remaining design freedom is which constraints to deploy and how to set the role and degree distributions; this is exactly what the architecture-optimization theorem (Theorem 6) operates on. This sharpens the LDPC analogy rather than weakening it. Where the random-graph hypothesis comes from. Density evolution as usually presented relies on a randomly constructed graph, and the concentration argument of Theorem 1 needs that randomness. Four points justify or relax this in the agent-network setting. First, the random graph is a design variable, not a constraint imposed by the world. The architect chooses which constraints to deploy, then samples the role-typed matching uniformly over compatible sockets (those sharing role, template, and socket-type semantics), not over arbitrary attachments. Second, when deliberate randomization is unavailable, real task graphs at large n often have configuration-model-like degree statistics; this is a modeling assumption, the analog of “real channels are approximately memoryless.” Third, the configuration-model hypothesis is sufficient but not necessary for the DE prediction itself: any locally-tree-like graph sequence drives the same recursion in expectation, since each depth-L message depends only on a local tree neighborhood. The random construction additionally supplies the concentration bound, via a Doob martingale over the matching. Theorem 8 proves a deterministic-graph counterpart under Benjamini–Schramm local convergence. Fourth, the framework breaks when the graph has heavy hubs or systematic short cycles, where the locally-tree-like approximation fails on a non-vanishing fraction of vertices; cluster-aware DE with local-MAP correction is the natural follow-on. The scope of the present theory is locally-tree-like task graphs, deterministic or random. In the XOR specialization the recovery structure is a standard LDPC pattern: density evolution predicts the asymptotic erasure probability [5]–[8], stopping sets characterize finite-length BEC failures [9], and irregular and unequal-error-protection LDPC design links the degree distribution to threshold and protection tradeoffs [5], [10]. We use the same toolkit: concentration on locally tree-like neighborhoods, spectral-radius stability of the DE Jacobian, peeling-decoder fixed-point characterization, and two-edge-connected augmentation. Two things change in the agent-network setting. First, three independent erasure tiers (variable-side, verifier- side, reasoning-channel) enter the density-evolution Jacobian in structurally different positions. The Non- Interchangeability Proposition (Proposition 2) makes this precise: no change of variables collapses the three into a single effective ̃ε, so improving a verifier, adding proposer redundancy, and improving a communication channel are separate design knobs whose marginal values must be computed independently. This is the structural distinction from multi-edge-type LDPC [5] and the noisy-message-passing-decoder line [11], [12], neither of which carries such a statement (Table I). Second, the check primitive need not be linear. Every bounded-degree Boolean factor fits the framework, and the value-conditioned recursion of Theorem 1 tracks separate per-value erasure probabilities p (0) ℓ,τ and p (1) ℓ,τ when the factor is not value-symmetric. Under XOR these collapse and we recover standard LDPC-BEC analysis (Corollary 1); under AND the recursion exposes a positive-versus-negative certificate asymmetry. This asymmetry is the formal version of a practitioner intuition: a passing test is more informative than a failing one. A passing Lean-kernel call certifies every step in its scope at once, while a failing one localizes the error only once the rest of the scope is known good. Proposition 1 quantifies this. E. Concrete applications Each primitive of the framework maps onto an operational quantity of a deployed multi-agent system, and each parameter is in principle measurable from agent traces. Concretely, ε V r is the abstention or timeout rate of role-r variable agents; ε C s is the no-verdict rate of role-s verifiers; η r,s is the success probability of transmitting or translating a usable artifact from role r to role s; and the template proportions and role-degree laws are read off the deployed task graph. After calibration, the DE recursion of Theorem 1 predicts the asymptotic residual erasure rate, the stopping-set/augmentation theorems (Theorem 3, Theorem 4) identify which finite patterns cause failures, and the adjoint sensitivities (Theorem 6 (d)) pinpoint which reliability tier is most valuable to improve at the margin. Five deployed systems illustrate this pipeline, and Section XIII traces each one in detail. In multi-agent formal theorem proving, Hilbert [1] reaches 99.2% on miniF2F with Lean-kernel checks of AND-monotone 9 form. In multi-agent code generation, CodeR [2] and the SWE-bench line [13], [14] use test runners, and the verified-code benchmarks CLEVER and FVAPPS [15], [16] use Lean type-checking, as AND-monotone checks. MAKER [17] runs a one-million-step task by maximal decomposition with per-subtask voting, a cross- verification structure of the kind Theorem 4 formalizes. LLM debate [3], [18]–[20] maps each debate round to one message-passing iteration in structured-output settings. Sensor and drone classification fits only after a non-erasure extension (Section XIV), since soft detections are not erasures. For each system, Section XIII maps the agent roles to variable and check nodes and ties ε V , ε C , and η to quantities already logged in agent traces. F. Main contributions The paper makes the following main contributions. C1. A role-typed Boolean-verifier-node model. We define a sparse role-typed bipartite factor-graph ensemble in which variable nodes are subclaims, check nodes are noisy Boolean verifiers of bounded degree, and messages are set-valued certificates. Three erasure tiers (variable-side ε V r , verifier-side ε C s , reasoning-channel η r,s ) appear as separate channel layers. A single logical-forcing rule Γ θ,j on candidate sets specializes to XOR, AND, OR, Horn, and other monotone Boolean primitives. C2. Density evolution and concentration (Theorems 1 and 8). For every fixed L, the empirical value- conditioned message erasure rates on a bounded-degree role-typed configuration ensemble converge in probability to a deterministic recursion. The recursion is value-conditioned because general Boolean fac- tors need not be value-symmetric. The XOR specialization (Corollary 1) recovers the classical LDPC-BEC map; the AND specialization (Proposition 1) exposes a positive-versus-negative-certificate asymmetry of realistic verifiers. The McDiarmid concentration argument is channel-agnostic; the present recursion is its specialization to the certifying-layer logical-forcing rule. A companion result (Theorem 8) shows that the same DE prediction holds on deterministic locally-tree-like graphs, with no appeal to graph randomness, so the theory also covers deployed systems whose task graph is fixed rather than sampled. C3. Threshold, stability, and non-interchangeability of the three erasure tiers (Theorem 2, Corollary 2, Propositions 2 and 3). We prove existence of a residual fixed point of the value- conditioned DE recursion and a monotone target-reliability threshold along any monotone reliability path. In regimes where the zero-erasure state is a fixed point (e.g., the noiseless-verifier noiseless-channel limit recovering LDPC-BEC), local spectral stability holds with Gelfand-rate contraction. The Non- Interchangeability Proposition shows that the three erasure tiers cannot be collapsed into a single effective scalar: the parameter Jacobian has differential rank at least two on a generic open parameter set. With heterogeneous roles the separation is sharper: a single check role serving two variable roles gives rank at least three (Proposition 3), which distinguishes verifier-side erasure from the return reasoning channel. This non-interchangeability is the structural distinction from multi-edge-type LDPC and the noisy- message-passing-decoder line (Table I). C4. Certificate-stopping sets (Theorem 3). We define certificate-stopping sets for general Boolean verifier factors and prove that the terminal unresolved set of the deterministic peeling decoder is the unique maximal certificate-stopping set. The XOR specialization (Corollary 3) recovers the classical stopping- set characterization; the AND specialization (Corollary 4) gives a positive-versus-negative certificate condition. C5. Separating augmentation (Theorem 4). We define k-separating augmentations of the verifier graph and prove that any k-separating augmentation eliminates all certificate-stopping sets of size at most k. A noisy-augmentation corollary (Corollary 5) quantifies fault tolerance via a union bound; the XOR specialization recovers the classical two-edge-connected freeing-set construction. C6. Cost-constrained architecture optimization (Theorem 6). We formulate role-and-degree optimiza- tion under a budget on agent counts, verifier invocations, and communication edges. We give existence (Weierstrass), asymptotic optimality of DE-optimized designs, finite-to-infinite-round consistency under uniform convergence, backward-mode adjoint sensitivity equations for ∇ λ P (L) DE (λ), and KKT necessary conditions whose multiplier is the shadow price of additional budget. A budget-monotonicity corollary 10 (Corollary 6) follows. The adjoint/KKT framework is channel-agnostic; the same shadow-price interpre- tation carries over to non-erasure DE recursions when those are derived. C7. Calibration protocol and applications. We give a calibration protocol mapping each model parameter (ε V r ,ε C s ,η r,s , template proportions, value priors) to an operational quantity already logged by deployed agent systems (Section XI). The protocol is traced through the Hilbert proof-agent architecture, multi- agent code generation (CodeR, SWE-bench), and structured-output debate (Section XIII). C8. Local-soundness converse on the computation tree (Theorem 7). Within the class of T-round sound (certifying) local message-passing protocols on the role-typed configuration ensemble, no protocol (including non-extrinsic, randomized, or soft-information sound variants) can asymptotically leave fewer variables unresolved at its terminal output than the value-conditioned logical-forcing decoder of Theo- rem 1. The argument localizes each per-variable decision to the depth-2T computation tree and identifies the unique sound Bayes-optimal estimator there with the logical-forcing decoder. A stronger Fano-cut- set converse against unbounded-alphabet local protocols without the soundness restriction is sketched in Section XIV. G. Organization of the paper Section I reviews related work; Section I fixes notation and the configuration model. Section IV defines the role-typed Boolean-verifier-node model. Section V states and proves the density-evolution and concen- tration theorem (Theorem 1) with its XOR and AND specializations. Section VI treats residual fixed points, thresholds, stability, and the Non-Interchangeability Proposition; Section VII characterizes finite-length failures by certificate-stopping sets; Section VIII proves the separating-augmentation theorem. Section IX formulates cost-constrained architecture optimization, and Section X proves the local-soundness converse. Section XI, Sec- tion XII, and Section XIII give the calibration protocol, the numerical validation, and the worked applications; Section XIV discusses extensions, including the deterministic-graph density-evolution theorem (Theorem 8) for fixed task graphs and a Fano-cut-set converse, and Section XV concludes. Appendices collect auxiliary monotonicity facts and the detailed concentration bounds. Reader map. Because the paper targets both the information-theory and the AI-systems communities, two reading paths are useful. Readers primarily interested in the sparse-graph theory may focus on Sections I to X. Readers primarily interested in AI-agent implications may first read Section I, Section XI, Section XIII, and Section XIV, then return to the formal model. The toy example in Section I-C is intended as a common entry point for both audiences. I. Related Work A. Factor graphs, LDPC codes, and density evolution Factor graphs provide a general language for representing global functions as products of local functions and for deriving local message-passing algorithms [21]. LDPC codes, introduced by Gallager [22], are the canonical sparse-graph coding example. Density evolution [5]–[8] gives sharp asymptotic predictions for message-passing decoding over memoryless channels and has been central to the design of capacity-approaching irregular LDPC codes. On the binary erasure channel (BEC), the recursion is especially transparent because messages are either known bits or erasures. Finite-length BEC performance is governed by stopping sets [9]. Related work has studied improved decoding and puncturing for LDPC codes [23], [24], unequal error protection [10], generalized LDPC (GLDPC) codes [25], noisy message-passing decoders [11], [12], and absorbing sets for non-erasure channels [26]. Multi-edge- type LDPC codes [5] extend the analysis to ensembles in which different message types follow different update rules. The present paper uses the same broad toolkit, but the object being analyzed is not a communication code. The graph describes an agent architecture, the check nodes are noisy verifier agents, the Boolean factor semantics need not be linear, and three independent erasure tiers act on three structurally different positions in the message flow. Density evolution has also been extended beyond symmetric channels. For asymmetric memoryless channels, such as the Z-channel, the all-zero-codeword reduction is no longer valid, and the analysis must track message 11 distributions conditioned on the transmitted value, or restore a usable symmetry through an equivalent coset construction [27]. Our value-conditioned recursion is similar in spirit, tracking separate states for target values 0 and 1, but the source of the asymmetry is reversed. In asymmetric-channel density evolution the parity checks remain linear and value-symmetric while the channel law is asymmetric; here the observation channel is a sound, value-independent erasure channel and the asymmetry is induced by the Boolean verifier functions themselves. Moreover, the coset construction that restores symmetry for linear codes does not apply to non- linear factors such as AND. Theorem 1 should therefore be read as an adaptation of standard density-evolution concentration methods to role-typed Boolean verifier nodes, not as a claim that value-conditioning is itself new. B. Multi-agent reasoning, verifiers, and agentic workflows Multi-agent language-model systems have been proposed for debate, critique, self-refinement, search, and tool use [3], [18], [19], [28]–[31]. Verifiers and process supervision play an important role in mathematical reasoning and step-by-step problem solving [32], [33]. Choi et al. [20] analyze LLM debate as a martingale belief process on structured tasks. Formal theorem proving and verified code generation provide especially clean testbeds because proof assis- tants and compilers can act as strong local verifiers [1], [15], [16], [34]–[36]. Software-engineering agents and benchmarks such as SWE-bench and SWE-agent [2], [13], [14] show that realistic code tasks already have graph-like decompositions and tool-mediated verification. Most of these works are empirical or algorithmic, asking which protocol performs well on a benchmark; theoretical analyses include the martingale framing of debate [20] and the decision-theoretic Bayes-dominance bound for delegated multi-agent DAGs [37]. This paper asks a complementary information-theoretic question: after abstracting an agent system into roles, local Boolean verifiers, and inter-agent communication channels, what does the architecture imply about asymptotic recoverability and finite-length failure patterns? C. What is new The framework is related to multi-edge-type LDPC, generalized LDPC, and noisy-message-passing-decoder analyses, but differs in five ways. First, roles are semantic objects: they represent proposer, verifier, retriever, test-runner, or judge populations with different reliabilities and costs and a built-in calibration path to logged trace data. Second, verifier-side erasure is modeled separately from variable-side erasure; this is essential for agent systems where the verifier itself is an imperfect computational object. Third, communication fidelity is role-pair dependent and acts on reasoning artifacts rather than channel symbols; the third tier η r,s is not separated as a distinct erasure tier in classical LDPC. Fourth, check nodes compute arbitrary Boolean verifier functions and the recovery rule is value-conditioned logical forcing on set-valued messages. GLDPC handles non-parity local constraints, but its component codes are linear, hence value-symmetric; the AND-monotone case here is non-symmetric and exposes a positive-versus-negative certificate asymmetry not central to the GLDPC formulation. Fifth, the design payoff is the agent-operational analog of multi-knob sparse-graph design. LDPC design is itself multi- knob (irregular degree distributions, MET edge types, protograph parameters, UEP-LDPC reliability classes, GLDPC sub-code choice); what is new here is that the knobs have agent-system semantics (role mix, role- typed degrees, verifier reliability, role-pair communication fidelity). The Non-Interchangeability Proposition formalizes that no change of variable absorbs them into one effective scalar, and adjoint-derived KKT shadow prices identify which resource constraint is binding at any operating point. Table I summarizes which of these axes are present in adjacent literatures and which are new here. I. Notation and Preliminaries A. Sets, vectors, and indicators We use R, N, Z for the reals, naturals, and integers; P and E for probability and expectation under whatever measure is in context. For a positive integer K, [K] : =1,...,K. Boldface lowercase letters denote vectors; calligraphic uppercase letters denote sets. Indicator functions are written 1·. For a function f of several arguments, we sometimes write f (·) to indicate a slot to be filled. 12 TABLE I Where the present framework sits relative to adjacent sparse-graph literatures. “✓” indicates that the axis is centrally treated in the cited line; “−” indicates that the axis is not separated with the operational meaning used here, even when related machinery exists; “partial” indicates that the axis is treated but in a different form. The aim is to locate the distinctive combination of axes, not to claim invention of any one of them in isolation. AxisMET-LDPC GLDPC Noisy-MP This paper [5][25][11], [12] Role-typed channels✓−✓ Boolean verifier nodes with logical-forcing semantics−partial −✓ Value-conditioned DE under non-symmetric checks−✓ Verifier-side erasure as a separate tier−partial✓ Role-pair reasoning channels as a separate tier−✓ Three reliability tiers as separate design knobs−✓ Protocol for estimating model parameters from agent traces −✓ Note. The “value-conditioned DE” row refers to conditioning induced by non-symmetric Boolean verifier functions. Value- or codeword-conditioned density evolution is itself known for asymmetric memoryless channels [27]; the distinction is discussed in Section I and Remark 4. B. Alphabets and the unresolved symbol Three alphabets recur throughout the paper. Hidden subclaim values lie inX : =0, 1. Set-valued messages and variable-side observations take values in the set-valued message alphabet M : = 0,1, U ,U : =0, 1,(4) where a singleton b encodes a sender’s certification of value b and U encodes “unresolved.” Verifier outputs are scalar, taking values in Z : =0, 1,∗,(5) with∗ denoting an erased verifier output. The two erasure markers are kept distinct: a message-side U encodes “both target values remain possible” on a candidate-set update, whereas a scalar verifier-side ∗ encodes “the verifier produced no usable Boolean observation.” In informal narrative passages we occasionally write “?” for “erased” when the type of erasure is clear from context; the formal model uses U and ∗ as defined above. The reader more comfortable with scalar erasure messages should mentally identify 0 ↔ 0, 1 ↔ 1, U ↔ ?; the set-valued representation is more natural for general Boolean factors because the logical-forcing operator (Equation (3)) acts directly on candidate sets. Closure of M under intersection. The variable-side update intersects incoming candidate sets. In principle two contradictory singletons 0 and 1 would intersect to ∅ /∈ M, but on sound message configurations this never occurs: Lemma 1 establishes the invariant that every singleton message contains the true value, so contradictory singletons cannot co-occur and the update remains in M. C. Configuration-model background Given finite multisets of variable-node degrees and check-node degrees with matching socket counts, a uniformly random pairing of sockets defines a bipartite multigraph; this is the standard configuration model [5], [38]. Under bounded-degree assumptions, conditioning on the graph being simple does not change the bounded-radius local neighborhood law, and hence does not change the density-evolution recursion for any fixed number of iterations L. This holds even though the two ensemble laws are not, in general, globally close in total variation. We accordingly state the asymptotic results in this paper on the role-typed configuration- model multigraph ensemble; the simple-graph-conditioned version has the same local limit and the same DE prediction. We work with a role-typed and template-typed extension of the configuration model introduced formally in Section IV. The key structural fact is that for any bounded radius R, the neighborhood of a 13 uniformly chosen directed edge in such a graph converges in distribution to the corresponding typed Galton- Watson computation tree as n → ∞. This is the locally tree-like property; standard references are [5] and [38]. IV. The Role-Typed Boolean-Verifier-Node Model A. Graphs, roles, and Boolean verifier templates For each problem size n∈ N, let G n = (V n ∪C n , E n )(6) be a bipartite graph. Variable nodes i∈V n represent subclaims; check nodes a∈C n carry local Boolean verifier functions. We use check node, verifier node, and Boolean verifier factor interchangeably for these nodes, and verifier function for the local map they compute. We assume |V n | = n and |C n | = ⌊αn⌋ for a fixed scaling parameter α > 0. There are finite role sets R V for variable agents and R C for check agents. A variable role represents a population with distinguishable observation-noise statistics, proposer, retriever, lemma generator, code writer, sensor. A check role represents a population with distinguishable verifier statistics, proof checker, test runner, judge, type checker, plausibility checker. Let ρ(i)∈R V be the role of variable i and ρ(a)∈R C be the role of check a. The local verifier semantics are specified by a finite set Θ of templates. A template is a tuple θ = s θ , d θ , r θ,1 ,...,r θ,d θ , f θ ,(7) in which s θ ∈R C is a check role, d θ ∈ N is the arity, r θ,j ∈R V is the role of the variable expected at socket j, and f θ :0, 1 d θ →0, 1(8) is the local Boolean verifier function. A check node with template θ has ordered sockets j = 1,...,d θ , and socket j must connect to a variable of role r θ,j . We write τ = (θ,j)∈ T, r(τ ) = r θ,j , s(τ ) = s θ ,(9) for the socket type, the variable role at the socket, and the check role of the host template. Example 1 (Common verifier semantics). The same framework covers several common local verifiers as templates θ with different choices of f θ . • XOR / parity: f θ (x 1 ,...,x d ) = x 1 ⊕·⊕ x d . This is the LDPC-clean linear baseline; a check is satisfied iff the parity of the inputs equals the observed value. • AND / monotone conjunction: f θ (x 1 ,...,x d ) = x 1 ∧·∧x d . This models a passing local test, a proof-step type-check, or a composition check: the check is satisfied iff every input is correct. • OR: f θ (x 1 ,...,x d ) = x 1 ∨·∨ x d . Symmetric to AND for negated inputs. • Implication: f θ (x 1 ,x 2 ) = 1x 1 ≤ x 2 , or equivalently x 1 ⇒ x 2 . This models a local dependency rule. • Horn clause: (x 1 ∧·∧ x m )⇒ y. This models proof-rule semantics in formal systems. B. Hidden values and erasure-only observations Each variable has a hidden truth value X ∗ i ∈ 0, 1. In the general (non-XOR) case we assume a role- dependent product prior with hidden values drawn independently of the degree sequence conditional on role, P X ∗ i = 1 ρ(i) = r = β r , r ∈R V , X ∗ i ⊥ D i | ρ(i).(10) The independence between X ∗ i and the degree vector D i at fixed role is required because density evolution samples variables through sockets, not uniformly through nodes; without value-degree independence, the socket-level value distribution at a role-r neighbor would differ from the node-level prior β r and the recursion would carry an additional bias. The same density-evolution limits also apply to deterministic sequences of hidden vectors provided the socket-conditional empirical value frequencies converge toβ r (a strictly stronger condition than role-conditional convergence). The prior is unnecessary for the XOR specialization, because 14 XOR erasure dynamics do not depend on the actual hidden vector (one can analyze the all-zero codeword without loss of generality; see Corollary 1). It is needed for non-symmetric Boolean factors because the probability that a check can logically force a target depends on the values of the neighboring true subclaims. The product form carries one further consequence used in Proposition 1: it makes the true inputs (X ∗ i ) i∈∂a at a check mutually independent, which is what yields the product forcing probability φ (1) ℓ,θ,j = Q k̸=j β r θ,k there. Local tree-likeness makes the messages arriving at a check independent, but not the co-incident ground- truth values, so the product prior is a mean-field, first-order approximation of the joint task distribution: a correlated task law with the same socket-conditional marginals β r preserves the density-evolution marginals stated here, while replacing this product by the corresponding conditional joint at each check. A variable node i of role r has private observation A i = ( X ∗ i , with probability 1− ε V r , U,with probability ε V r . (11) A check node a with template θ has true verifier output T a = f θ (X ∗ i ) i∈∂a ,(12) where the variables in ∂a are ordered according to the template sockets. It observes Z a = ( T a , with probability 1− ε C s θ , ∗, with probability ε C s θ , (13) where ∗ denotes an erased verifier output. All variable-side and verifier-side erasures are independent con- ditional on the graph and the hidden vector. This is a first-order, conditionally memoryless approximation: correlated agent failures (for example, two proposer agents backed by the same foundation model failing on the same subclaim) sit outside the present setting and are deferred to the limitations and dependence-relaxation discussion in Sections XIV-A and XIV-C. C. Reasoning channels For each ordered role pair (r,s) ∈ (R V ∪ R C ) 2 , a reasoning-channel fidelity η r,s ∈ [0, 1] specifies the probability that a singleton message produced by an agent of role r is delivered intact to an agent of role s. The role-pair channel kernel is Q r,s ( f M | M ) = η r,s ,M =b, f M =b, b∈0, 1, 1− η r,s , M =b, f M = U, b∈0, 1, 1,M = U, f M = U, 0,otherwise. (14) Thus the base model has erasures but no flips. This is the analogue of the BEC in classical coding theory. Confident wrong messages would lead to a different, non-erasure theory analogous to absorbing-set analysis on the BSC [26]; we discuss this extension briefly in Section XIV. Each directed edge has its own independent channel-erasure variable drawn once at t = 0 in the persistent-edge convention used throughout the paper; an alternative i.i.d.-per-round channel would change the analysis (each round draws fresh gates) and is outside the present setting. D. Logical forcing: the unifying check-to-variable update Suppose check a has template θ and target socket j. Suppose Z a = z ∈0, 1 is available (not erased) and the incoming variable-to-check messages are candidate sets M k ∈M, k ̸= j. The logical-forcing operator is Γ θ,j (z; M −j ) : = b∈0, 1 : ∃x k ∈ M k , k ̸= j, f θ (x 1 ,...,x j−1 ,b,x j+1 ,...,x d θ ) = z .(15) If Z a =∗, we set Γ θ,j = U by convention. This operator is the produced check-to-variable message at edge (a,j) (the formal update is Equation (16) below): a singleton when the observed verifier value and the unknown- input candidate sets logically force the target, otherwise U. The reasoning channel can further replace this 15 message by U on the directed edge s θ → r θ,j before it reaches the variable. This is local Boolean reasoning with unknown inputs represented by candidate sets; it is the natural generalization of the parity-inversion rule of LDPC-BEC decoding to arbitrary Boolean verifier functions. Concrete examples. For an AND check that reports Z a = 1, every input must be 1 for the conjunction to hold, so Γ θ,j (1;M −j ) =1 regardless of M −j . For the same AND check reporting Z a = 0, the target is forced to 0 only if every other input has already been resolved to 1: Γ θ,j (0;M −j ) =0 when M i ′ =1 for all i ′ ̸= j, and Γ θ,j (0;M −j ) = U otherwise. This is the positive-versus-negative-certificate asymmetry that Proposition 1 quantifies in DE form. For an XOR check, the operator is value-symmetric: Γ θ,j (z;M −j ) is a singleton if and only if every M i ′ for i ′ ̸= j is itself a singleton, in which case it returns the unique b satisfying b⊕ L i ′ ̸=j x i ′ = z. Let e V (ℓ) i→a be the variable-to-check message received by check a after the role-pair channel acts, and let e C (ℓ) a→i be the check-to-variable message received by variable i. Extrinsic edge-specific updates are C (ℓ) a→i = Γ θ,j Z a ; e V (ℓ) k→a k∈∂a\i ,(16) V (ℓ+1) i→a = A i ∩ \ c∈∂i\a e C (ℓ) c→i ,(17) where socket j on a corresponds to neighbor i. The final estimate after L rounds uses all neighboring checks: c M (L) i = A i ∩ \ a∈∂i e C (L) a→i .(18) The bit-erasure rate is P (L) bit (G n ) = 1 n X i∈V n 1 c M (L) i = U .(19) Lemma 1 (Soundness invariant). On every finite graph and for every erasure-only realization of the observa- tions and reasoning channels, every message about variable i at every iteration ℓ ≥ 0 contains the true value X ∗ i . Hence every singleton message about i equals X ∗ i , and no message is ever empty. Proof. Induction on ℓ. Private observations are X ∗ i or U; a non-erased check output Z a = T a forces only values consistent with the true verifier output, and X ∗ i is consistent by (12); reasoning channels either preserve a singleton or replace it by U; and the variable update (17) intersects sets that all contain X ∗ i . Lemma 1 is the basic soundness invariant used throughout the analysis: messages can be erased, never wrong. This is the agent-network analog of erasure-channel soundness in classical coding, and it is what makes the BEC-style analysis possible in this setting. E. Role-typed configuration ensemble We use a bounded-degree role-typed configuration model. Variable nodes of role r have a random socket- count vector D (r) = D (r) τ τ∈T r ,T r : =τ ∈ T : r(τ ) = r,(20) with bounded support D (r) τ ≤ D max for some fixed D max ∈ N independent of n, and minimum-degree assumption P τ D (r) τ ≥ 2 almost surely. The minimum-degree assumption ensures that every variable is touched by at least two checks; it is needed for the threshold theorem (Theorem 2) and the zero-erasure stability corollary, but the basic density-evolution recursion (Theorem 1) holds without it. Variable nodes are partitioned into roles with asymptotic proportions π V r r∈R V , and check nodes are assigned templates in Θ with asymptotic proportions π C θ θ∈Θ . The ensemble parameters π V r ,P (r) D ,π C θ ,α are admissible if, for every socket type τ = (θ,j), π V r(τ ) · E D (r(τ )) τ = α· π C θ ,(21) where α : =|C n |/|V n | is the asymptotic check-to-variable ratio. We assume admissibility throughout. At finite n, socket balances are enforced exactly by a rounding-and-matching step (with O( √ n) rounding fluctuations), and sockets of each type are then paired uniformly at random. 16 For a variable reached by following a uniformly chosen socket of type τ, let D (r),τ,ex be the size-biased excess degree vector of the variable, after deleting the arrival socket. For a uniformly chosen variable node of role r, let D (r),node be its full degree vector. Lemma 2 (Locally tree-like). Let R > 0 be a fixed integer. As n→∞, the depth-R neighborhood of a uniformly chosen directed socket of type τ in G n converges in total variation to the corresponding typed Galton-Watson computation tree. At a variable node entered through a socket of type τ ′ , the remaining socket-degree vector has law D (r(τ ′ )),τ ′ ,ex (and the root variable has full vector D (r(τ )),node ). At a check node entered through socket (θ,j), the template is deterministically θ and the remaining socket types are deterministic (θ,k) : k ̸= j; the template proportions π C θ enter only through the law of which socket type a uniformly chosen variable-side socket connects to, via the socket-balance equation (21). Lemma 2 is standard for bounded-degree configuration models; we record it here only to fix notation. The role-typed extension is mechanical, with conditioning on type at every step. F. Summary of notation The symbols used throughout the analysis are collected in Table IV. Two conventions are worth flagging. First, p-prefixed symbols are erasure probabilities (larger p means worse reliability); η-prefixed symbols are delivery probabilities (larger η means better reliability). Second, the message alphabetM =0,1, U uses U = 0, 1 for set-valued unresolvedness, while the scalar verifier alphabet Z = 0, 1,∗ uses ∗ for an erased verifier output; the two erasure markers encode operationally different states (see Section I). V. Density Evolution and Concentration A. The value-conditioned recursion Scalar anchor. Before the formal recursion, here is the calculation in scalar form. The DE state at round ℓ is p (b) ℓ,τ , the value-conditioned probability that a variable-to-check message of socket type τ is unresolved, given target value b. The recursion has three composed steps: (i) a persistent role-pair channel (drawn once at t = 0, not redrawn per round) may erase a message in transit; (i) a check fails to certify a target if the verifier output is erased, the return channel is erased, or the Boolean forcing rule cannot isolate the target value from the inbound messages; (i) the target variable remains unresolved at the next round iff its private observation is erased and all extrinsic incoming check messages are erased. The persistent-channel convention models failures that do not go away on retry, such as a stable format incompatibility between two roles; an i.i.d.-per-round channel would give a different DE map. The equations below assemble these three steps with the role-typed degree laws and value-dependent forcing probabilities of general Boolean factors; symbols are tabulated in Section IV-F. The density-evolution state tracks both socket type and the underlying hidden value. For each socket type τ ∈ T and value b∈0, 1, define p (b) ℓ,τ : = P n V (ℓ) i→a = U X ∗ i = b, (i,a) has socket type τ o ,(22) the extrinsic variable-to-check erasure probability conditional on the underlying value. Define h (b) ℓ,τ analogously for the received check-to-variable message: h (b) ℓ,τ : = P n e C (ℓ) a→i = U X ∗ i = b, (a,i) has socket type τ o .(23) Consider a socket τ = (θ,j). For another socket k ̸= j of the same template θ, conditional on the true value x k , the incoming variable-to-check message at socket k is the singletonx k with probability η r θ,k ,s θ 1−p (x k ) ℓ,(θ,k) and is U otherwise. Define ̄p (x k ) ℓ,θ,k : = 1− η r θ,k ,s θ 1− p (x k ) ℓ,(θ,k) ,(24) the effective inbound erasure probability after the role-pair channel. The factorization in (24) relies on the extrinsic update: V (ℓ) i→a is computed from the depth-2ℓ + 1 computation tree rooted at i with the directed edge i → a removed, hence is measurable with respect to a sub-tree disjoint from the persistent channel variable 17 TABLE IV Summary of notation used in the model and analysis. SymbolMeaning X ∗ i ∈0, 1Hidden truth value of subclaim i. A i ∈X ∗ i , UVariable-side observation (soundness preserved). Z a ∈f θ (X ∗ ∂a ),∗Verifier observation (soundness preserved). f θ :0, 1 d θ →0, 1 Boolean verifier template function. Γ θ,j (z;M −j )⊆0, 1 Logical-forcing operator at socket j given observed output z. ε V r ∈ [0, 1)Variable-side erasure probability (role r abstention rate). ε C s ∈ [0, 1)Verifier-side erasure probability (check role s failure rate). η r,s ∈ (0, 1]Reasoning-channel delivery probability (directed; r → s). β r ∈ (0, 1)Role-r value prior PX ∗ i = 1. p (b) ℓ,τ ∈ [0, 1]Variable-to-check erasure probability at iteration ℓ at socket type τ, conditional on X = b. h (b) ℓ,τ ∈ [0, 1]Received check-to-variable erasure probability (post-channel). φ (b) ℓ,θ,j ∈ [0, 1]Forcing probability at template θ, socket j, value b. Φ λ Density-evolution map; p ℓ+1 = Φ λ (p ℓ ). DΦ λ (p)Jacobian of Φ λ at p (state Jacobian). D par [Φ λ ]Parameter Jacobian of Φ λ , with respect to the erasure-tier parame- ters. P (L) DE (λ)DE prediction of bit-erasure rate after L rounds. P (∞) DE (λ)Residual bit-erasure rate (limit of P (L) DE ). P (L) bit (G n )Empirical bit-erasure rate on graph G n after L rounds. T, ΘSocket-type set, template set. R V ,R C Variable-role set, check-role set. D ex τ Excess-degree socket law. on edge i→ a. The pre-channel message and the persistent channel variable are therefore independent, even though the channel is fixed at t = 0. The same extrinsic argument applies to the return channel on edge a→ i used in (26) below. Conditional on X j = b, the forcing probability is φ (b) ℓ,θ,j : = P n Γ θ,j f θ (X 1 ,...,X d θ ); M −j =b X j = b o ,(25) where each X k (k ̸= j) is drawn from the role-prior β r θ,k independently, and each M k is the singleton X k or U according to (24). The received check-to-variable erasure probability is h (b) ℓ,(θ,j) = 1− 1− ε C s θ η s θ ,r θ,j φ (b) ℓ,θ,j .(26) The variable update is p (b) ℓ+1,τ = ε V r(τ ) E Y τ ′ ∈T r(τ) h (b) ℓ,τ ′ D (r(τ)),τ,ex τ ′ ,(27) the expectation taken over the size-biased excess degree law. The initial condition is p (b) 0,τ = ε V r(τ ) ,(28) 18 because at iteration zero a variable sends U iff its private observation is erased. After L rounds, the density- evolution prediction for the empirical bit-erasure rate is P (L) DE = X r∈R V π V r X b∈0,1 P(X = b| r)ε V r E Y τ∈T r h (b) L,τ D (r),node τ ,(29) with the expectation taken over the full (non-size-biased) degree law. In words. Equation (24) is the per-edge effective erasure rate seen by a check from one of its variable neighbors after the role-pair channel acts. Equation (25) is the probability that the logical-forcing operator returns a singleton b given that the target value is b; this is the step that depends on the Boolean primitive (XOR vs. AND vs. Horn). Equation (26) composes verifier erasure, return-channel erasure, and forcing failure into the received check-to-variable erasure rate. Equation (27) is the standard variable update: the outgoing extrinsic erasure rate equals the variable’s own observation-erasure probability times the probability that every other incoming check message is erased, averaged over the excess-degree law. Equation (29) is the prediction for the bit error rate one would measure on a held-out instance. B. Concentration Empirical statistics. Let E τ denote the set of directed variable-to-check edges of socket type τ in G n . For each socket type τ ∈ T and value b∈0, 1, define the empirical conditional erasure fraction b p (b) L,τ (G n ) : = P (i,a)∈E τ 1X ∗ i = b1V (L) i→a = U P (i,a)∈E τ 1X ∗ i = b (30) on the event that the denominator is positive, and undefined otherwise. Let q τ,b : = lim n→∞ 1 n (i,a)∈ E τ : X ∗ i = b ,(31) the limiting fraction of socket-type-τ edges incident to value-b variables. Under the admissible ensemble parameters of Section IV-E and the value-degree independence assumption (10), q τ,b exists and is positive for every (τ,b) with β r(τ ) ∈ (0, 1) and E[D (r(τ )) τ ] > 0. We assume positive limiting socket-value mass throughout the per-type statements below. Standing assumptions for Theorem 1. For ease of auditing, the assumptions invoked by the theorem and its proof are: (A1) finite role sets R V ,R C and finite template set Θ; (A2) bounded degrees D max <∞ independent of n; (A3) exact or asymptotic socket-balance (21); (A4) bounded-degree role-typed configuration ensemble (Section IV-E), giving the locally tree-like property of Lemma 4; (A5) value-degree independence within roles (10) (Theorem 8 draws hidden values from the same prior, independently of the fixed graph); (A6) independent variable-side erasures (11), verifier-side erasures (13), and persistent role-pair channel era- sures (14) (each drawn once at initialization); (A7) fixed iteration count L as n→∞. Each assumption is stated in the corresponding paragraph of Section IV; we collect them here for clarity, not as new hypotheses. Theorem 1 (Boolean-verifier density evolution and concentration). Fix L ∈ N. Consider the bounded- degree role-typed configuration ensemble of Section IV-E, with independent role-dependent hidden values (10), erasure-only variable observations (11), erasure-only verifier observations (13), and persistent role-pair erasure reasoning channels (14). Then for every socket type τ ∈ T and value b∈0, 1 with q τ,b > 0, b p (b) L,τ (G n ) P −→ n→∞ p (b) L,τ ,(32) 19 where p (b) L,τ is defined by (24)–(28). Moreover, for the global bit-erasure rate, P (L) bit (G n ) P −→ n→∞ P (L) DE .(33) Quantitatively, the empirical fraction concentrates exponentially around its own finite-n mean, which sits within a vanishing bias b n,L of the DE prediction. Here b n,L : = C L /n + ∆ n,L is the tree-approximation bias of Lemma 4 (with C L and ∆ n,L as in (73)). Under the standard O( √ n)-rounded socket-balance construction ∆ n,L = O(poly(N L )/ √ n), while ∆ n,L = 0 under a deterministic socket-balance construction, so b n,L = O(1/ √ n) in general and O(1/n) in the deterministic case. There is then a constant a L > 0 depending only on L, the bounded-degree constant D max , and the fixed ensemble parameters (π V r ,P (r) D ,π C θ ,α,β r ) such that, for every t > 0 and every n, P n P (L) bit (G n )− P (L) DE > b n,L + t o ≤ 2 exp −a L nt 2 .(34) Since b n,L → 0, the offset is eventually negligible against any fixed resolution: for every fixed δ > 0 there is a constant c L > 0 (depending on the same quantities, not on δ) such that P|P (L) bit (G n )− P (L) DE | > δ ≤ 2 exp(−c L nδ 2 ) for all n sufficiently large. Proof outline. A message after L iterations is a deterministic function of the depth-2L+1 directed computation neighborhood around its edge, together with the hidden values, initial observations, verifier observations, and channel-erasure variables in that neighborhood. Bounded degree implies this neighborhood contains at most a constant number of items depending on L and D max but not on n. Lemma 2 gives total-variation convergence of the neighborhood to the typed computation tree; on the tree, incoming messages from distinct descendants are conditionally independent given the target value and roles, and Lemma 1 characterizes each message as singleton-true or unresolved. Evaluating the check node on the tree gives (24)–(26); evaluating the variable node gives (27). The convergence (33) is obtained by triangle decomposition, P (L) bit (G n )− P (L) DE ≤ P (L) bit (G n )− EP (L) bit (G n ) + EP (L) bit (G n )− P (L) DE . The second term is o n (1) by the quantitative tree-convergence of Lemma 4 (and its variable-rooted form Corol- lary 7): the expected per-variable bit-erasure rate equals its tree-limit value up to a C L /n + ∆ n,L correction, where the C L /n term comes from the breadth-first collision bound and ∆ n,L measures the discrepancy between the finite-n empirical typed degree/socket law and the limiting law ((73)). Under the standard O( √ n)-rounded socket-balance construction ∆ n,L = O(poly(N L )/ √ n), so the empirical-law term dominates the collision term in the typical regime; under a deterministic socket-balance construction ∆ n,L = 0 and the rate is the sharper C L /n. For the first term: changing one socket pairing, one hidden value, or one local erasure variable can affect only messages whose depth-2L + 1 computation neighborhoods intersect the changed item. Bounded degree caps the number of such messages by a constant K L depending on L and D max alone. The empirical fraction is therefore a bounded-differences function with Lipschitz constant K L /n per independent random ingredient. McDiarmid’s inequality [39] gives the exponential tail P|P (L) bit (G n ) − EP (L) bit (G n )| > t ≤ 2 exp(−a L nt 2 ) around the finite-n mean; combining this with the b n,L bound on the second (bias) term through the triangle decomposition above yields (34), and the fixed-δ asymptotic form follows once n is large enough that b n,L ≤ δ/2. The full proof, including the typed-Galton-Watson computation in Lemma 2 and the bounded-difference constant tracking through the value-conditioned recursion, is in Appendix B. The per-type ratio-statistic convergence (32) is a ratio of two empirical sums; both numerator and denomi- nator are bounded-differences functionals of the independent socket-pairing, hidden-value, and erasure-variable ingredients, with Lipschitz constants K L /n and K 0 /n respectively (the denominator depends only on hidden values, K 0 = 1). McDiarmid + the tree-convergence expectation calculation give n −1 P (i,a)∈E τ 1X ∗ i = b P −→ q τ,b and n −1 P (i,a)∈E τ 1X ∗ i = b1V (L) i→a = U P −→ q τ,b p (b) L,τ . Since q τ,b > 0 by hypothesis, the continuous- mapping theorem applied to the ratio function (x,y)7→ x/y at (q τ,b p (b) L,τ , q τ,b ) gives (32). Remark 1 (Fixed-L scope). Theorem 1 is a fixed-L statement: the iteration count L is fixed before taking n → ∞, and all constants a L ,c L ,C L ,K L , ∆ n,L in the bound depend on L. Statements about the L → ∞ 20 residual erasure rate or threshold behaviour on finite-n graphs do not follow directly from Theorem 1; they require either a double-limit convention (taking n → ∞ first for each L, then L → ∞, as the residual-fixed- point discussion below Theorem 2 adopts) or an additional uniform-in-L concentration argument outside the scope of the present finite-iteration result. Remark 2 (Conservativeness of the concentration constants). The constant a L in (34) produced by the bounded-differences method is highly conservative. Tracking the Lipschitz constants through the value-conditioned recursion gives a L = 1/(C D 4L+7 max ) (Appendix B): the rate it certifies is the stated O(1/ √ n), but the sample sizes for which the tail (34) is numerically meaningful grow rapidly in L and D max . This reflects the worst-case per- ingredient bounded-differences accounting rather than the typical fluctuations: the finite-graph Monte-Carlo overlays of Section XII (Figure 5) concentrate on the DE prediction at far smaller n than these constants would require. We make no claim that a L is order-optimal. Remark 3 (Channel-agnostic concentration step). The McDiarmid bounded-difference argument in the proof depends only on the bounded message alphabet and bounded local degree, not on the channel being erasure- only; it concentrates any fixed-round, bounded-degree, finite-alphabet local message-passing scheme on a sparse role-typed graph around its mean. Deriving the DE recursion is algorithm- and channel-specific, however: Theorem 1 carries this out only for the erasure-only logical-forcing decoder. An LLR-quantization DE under sum-product would inherit the concentration step, but its recursion form and fixed-point setup are separate work. Remark 4 (Why the recursion is value-conditioned). For XOR checks the erasure process is value-symmetric: one may analyze the all-zero codeword, and (22) collapses to a single recursion p ℓ,τ . For AND, OR, implication, Horn, and other non-symmetric Boolean factors the symmetry is absent, since a positive and a negative check carry different certificate information, so the recursion must track p (0) ℓ,τ and p (1) ℓ,τ separately. Averaging under the role-prior (10) recovers a marginal recursion p ℓ,τ = (1−β r(τ ) )p (0) ℓ,τ +β r(τ ) p (1) ℓ,τ , but this is not faithful to the dynamics; the value-conditioned recursion is the primitive object. Conditioning DE on the true value is familiar from LDPC analysis over asymmetric memoryless channels [27]; what is specific here is that the asymmetry comes from the verifier function f θ , not from the observation channel, which stays a sound, value-independent erasure channel (Section I). C. XOR specialization: recovering the LDPC-BEC baseline What collapses in the notation. Under XOR the value superscript (b) disappears entirely: the per-socket erasure probability p (b) ℓ,τ becomes a single quantity p ℓ,τ independent of b ∈ 0, 1, and the forcing probability φ (b) ℓ,θ,j likewise loses its value index. The double-superscripted, template-indexed general recursion of Theorem 1 then collapses into a familiar single-state recursion. In the additional single-role case it reduces to the textbook scalar recursion of LDPC-BEC density evolution (Example 2). When every check template is an XOR factor, f θ (x 1 ,...,x d ) = x 1 ⊕·⊕ x d ,(35) the observed check value determines the target if and only if every other input is known. The forcing probability is therefore value-independent: φ XOR ℓ,θ,j = Y k̸=j η r θ,k ,s θ 1− p ℓ,(θ,k) ,(36) and the recursion collapses to a single (non-value-conditioned) state. Corollary 1 (XOR / parity-factor density evolution). For XOR templates, Theorem 1 reduces to the value- independent recursion h ℓ,(θ,j) = 1− 1− ε C s θ η s θ ,r θ,j Y k̸=j η r θ,k ,s θ 1− p ℓ,(θ,k) ,(37) p ℓ+1,τ = ε V r(τ ) E Y τ ′ ∈T r(τ) h D (r(τ)),τ,ex τ ′ ℓ,τ ′ .(38) 21 In the single-role, noiseless-verifier (ε C = 0), noiseless-channel (η ≡ 1) case, this is exactly the standard LDPC-BEC density-evolution recursion of [5], [6]. Example 2 (Regular LDPC reduction). In a single-role (d v ,d c )-regular ensemble with ε C = 0 and η ≡ 1, (37)–(38) become h ℓ = 1− (1− p ℓ ) d c −1 , p ℓ+1 = ε V h d v −1 ℓ , which is the textbook BEC edge-erasure recursion [5]. D. AND specialization: certificates and verifier asymmetry What does not collapse in the notation. In contrast to the XOR case, under AND the value superscript (b) stays. The recursion tracks two separate per-socket erasure probabilities, p (1) ℓ,τ for sockets at variables holding the true value 1 and p (0) ℓ,τ for those at variables holding 0, and these obey two different update rules. Behind the heavier notation is the statement that a passing AND test and a failing AND test carry quantitatively different information: that content is exactly what (40)–(41) encode below. When every check template is an AND factor, f θ (x 1 ,...,x d ) = x 1 ∧·∧ x d ,(39) the recursion stays value-conditioned and exposes the positive–negative certificate asymmetry of realistic verifiers. Proposition 1 (AND density evolution). For AND templates with target socket j, the forcing probabilities in (25) are φ (1) ℓ,θ,j = Y k̸=j β r θ,k ,(40) φ (0) ℓ,θ,j = Y k̸=j β r θ,k η r θ,k ,s θ 1− p (1) ℓ,(θ,k) .(41) The received check-to-variable erasure h (b) ℓ,(θ,j) is then given by (26) with (40) for b = 1 and (41) for b = 0, and the variable update is (27). Proof. Condition on X j = 1. For an AND template, the verifier output is 1 iff every other input is also 1, and only then. When the output is 1, no assignment with x j = 0 can satisfy the check because 10· x 2 ·x d = 1 = 0. The target feasible set Γ θ,j (1;M −j ) is therefore 1 regardless of whether the other input messages were singletons or unresolved. The probability that X j = 1 and every other true value is 1 is β r θ,j Q k̸=j β r θ,k ; conditioning on X j = 1 removes the leading factor and gives (40). Now condition on X j = 0. The AND output is then 0. The target is forced to 0 iff the assignment x j = 1 is infeasible given M −j ; that is, every other input message is the singleton 1 (otherwise some other variable could be 0, making the AND output 0 regardless of x j ). For each k ̸= j, the probability that the true value X k = 1 and the check receives the singleton 1 is β r θ,k η r θ,k ,s θ (1− p (1) ℓ,(θ,k) ). Multiplying over k ̸= j gives (41). Verifier erasure and return-channel erasure then enter through (26). Remark 5 (Practical reading of the AND rule). A passing local test, in this framework, is a strong certificate: all pieces required by the test must be valid, and the test certifies all of them at once. A failing local test is a weaker certificate: it identifies that some piece is invalid, but to pin which one, the remaining pieces must already be known valid. This asymmetry is absent from XOR and is one of the structural reasons Boolean verifier nodes are a better abstraction for agent systems than parity-only LDPC analysis. In the running Hilbert example (Table V), this is exactly what a Lean kernel does: a successful kernel call certifies the joint validity of every proposed lemma in the call’s scope, while a kernel failure says only that something in the scope was off. 22 VI. Threshold, Stability, and Non-Interchangeability Let p ℓ denote the vector (p (b) ℓ,τ ) τ,b ∈ [0, 1] 2|T| collecting the value-conditioned per-socket erasure probabilities at iteration ℓ. Equations (24)–(27) define a continuous map p ℓ+1 = Φ λ (p ℓ ),(42) where λ collects all parameters, role proportions, value priors, degree laws, template proportions, erasure probabilities, and channel fidelities. A. Residual fixed point and target-reliability threshold What this theorem says. The DE iteration is monotone from its natural initialization p 0 , so it converges to a trajectory-selected residual fixed point p ∞ (λ) : = lim ℓ→∞ Φ ℓ λ (p 0 ) (other fixed points may exist but are unreachable from p 0 ; no uniqueness claim). Along any one-parameter worsening path, the residual P (∞) DE (λ) is monotone in the path parameter and crosses any target reliability δ at a well-defined threshold a ∗ δ . The convergence and threshold arguments use the standard monotone-density-evolution technique; what is specific to this model is the state space on which it runs, the value-conditioned socket-typed erasure vector of Theo- rem 1, the operational reliability paths along which the threshold is read (variable abstention, verifier erasure, reasoning-channel loss), and the two path-monotonicity conditions of part (b), which hold automatically only for single-coordinate worsening paths. Theorem 2 (Residual fixed point and target threshold). Consider the density-evolution iteration (42) with initial condition (28). (a) Monotone convergence. Φ λ is continuous and coordinatewise monotone increasing in its argument. The sequence p ℓ ℓ≥0 is coordinatewise nonincreasing and converges to a fixed point p ∞ (λ). The residual bit- erasure rate P (∞) DE (λ) : = lim L→∞ P (L) DE (λ) is well-defined. (b) Target-reliability threshold. Let a∈ I = [a min ,a max ] and let a7→ λ(a) be a one-parameter worsening path along which (i) the initial condition p 0 (λ(a)) is coordinatewise nondecreasing in a, and (i) Φ λ(a) (p) is coordinatewise nondecreasing in a for every p (e.g. a is a single ε V r , ε C s , or 1− η r,s entry, in which case both conditions hold automatically). Then P (∞) DE (λ(a)) is nondecreasing in a. For each target residual level δ ∈ [0, 1], set S δ : =a∈ I : P (∞) DE (λ(a))≤ δ and a ∗ δ (λ) : = ( supS δ , S δ ̸= ∅, a − min , S δ = ∅ (target unreachable on the path). Remark 6 (Why the zero-erasure state is treated separately). The reader familiar with classical LDPC-BEC density evolution [5] may expect a third clause stating that the zero-erasure state p = 0 is a fixed point with local stability governed by the spectral radius ρ(DΦ λ (0)). In the present three-tier setting, p = 0 is in general not a fixed point: a check-to-variable message can remain U even when all incoming variable messages are singletons, because the verifier output may be erased (ε C s > 0) or the return channel may have erased (η s,r < 1). Spectral-radius stability of the zero-erasure state therefore needs an explicit condition. We separate this fact into Corollary 2 below. Definition 1 (Coordinate-forcing template). A Boolean verifier template θ is coordinate-forcing if, for every target socket j, every assignment (x k ) k̸=j ∈0, 1 d θ −1 , and the consistent verifier output z = f θ (x 1 ,...,x d θ ), the target value x j is uniquely determined by z together with (x k ) k̸=j . XOR/parity is coordinate-forcing: knowing the parity of all inputs and any d− 1 of them determines the remaining input. AND, OR, implication, and Horn factors are not coordinate-forcing in general: e.g., AND with z = 0 and one other input already 0 admits both x j = 0 and x j = 1 as feasible. In fact the property pins the admissible templates down exactly. Writing x −j = (x k ) k̸=j , forcing at socket j for every x −j means the map x j 7→ f θ (x) is a bijection of 0, 1 at each fixed x −j , which holds iff f θ is affine in that coordinate, 23 f θ (x) = x j ⊕g j (x −j ). Imposing this at every socket forces f θ (x) = c⊕ L k x k , a parity check up to a constant. The coordinate-forcing templates are therefore exactly the affine (parity-type) checks over GF(2); this is the structural reason classical LDPC codes use parity checks exclusively, since they are the only Boolean constraints that force every coordinate. Coordinate-forcing is a sufficient structural condition guaranteeing that p = 0 is a fixed point of Φ λ at noiseless verifier and channel. Under full-support value priors β r ∈ (0, 1) and nondegenerate socket use, failure of coordinate-forcing produces a positive residual offset at p = 0 even with noiseless verifier and channel (Remark 7); degenerate cases such as β r = 1 for AND can still attain the zero state, but they sit outside the regime our threshold analysis targets. Corollary 2 (Local stability of the zero-erasure fixed point, coordinate-forcing case). Suppose every check template is coordinate-forcing (Definition 1), ε C s = 0 for all s∈R C , and η r,s = 1 for all role pairs. Then p = 0 is a fixed point of Φ λ . For finite template/role/degree laws, Φ λ is polynomial, hence C 1 on [0, 1] 2|T| . Let p ∗ be any fixed point of Φ λ at which Φ λ is C 1 on a neighborhood of p ∗ and ρ DΦ λ (p ∗ ) < 1. Then the iteration is locally exponentially attracted to p ∗ : for every c ∈ (ρ(DΦ λ (p ∗ )), 1) there exists a neighborhood U of p ∗ such that ∥p ℓ −p ∗ ∥ ≤ Kc ℓ ∥p 0 −p ∗ ∥ for all p 0 ∈ U, for some constant K = K(c,λ) in any fixed norm; continuity of Φ λ , Φ 2 λ ,..., Φ k 0 −1 λ controls the finitely many intermediate iterates. In particular, under the coordinate-forcing, noiseless-verifier, noiseless-channel hypotheses of the corollary, the zero-erasure fixed point p ∗ = 0 has ∥p ℓ ∥≤ Kc ℓ ∥p 0 ∥ whenever ρ(DΦ λ (0)) < 1. Remark 7 (Why coordinate-forcing is needed). Without coordinate-forcing, p = 0 is in general not a fixed point even at noiseless verifier and channel. For AND, Proposition 1 gives forcing probabilities φ (1) = Q k̸=j β r θ,k and φ (0) = Q k̸=j β r θ,k η r θ,k ,s θ (1− p (1) ℓ,(θ,k) ) which equal 1 at p = 0 only when every β = 1; generically h (b) p=0 > 0, so p = 0 is not a fixed point. The corollary therefore restricts to coordinate-forcing primitives such as XOR. Remark 8 (XOR/BEC specialization). Corollary 2 applies in particular to the XOR/BEC specialization (Corol- lary 1) with noiseless verifier and noiseless channel. In that regime the spectral-radius condition ρ(DΦ λ (0)) < 1 recovers the classical LDPC-BEC local stability condition at p = 0 (see, e.g., [5]). We do not claim this recovers the full LDPC-BEC threshold: for d v ≥ 3 regular ensembles the threshold is determined by a global tangency of Φ λ , not by the linearization at p = 0, and for d v = 2 the threshold coincides with the local-stability condition. Proof. Monotonicity (a). Φ λ is built from finitely many sums and products of continuous functions, hence continuous. For monotonicity, observe that increasing any incoming variable-to-check erasure probability p (b) ℓ,τ replaces some singleton inbound messages by U. By Lemma 3 (Appendix A), this enlarges the feasible set Γ θ,j , which can only convert a singleton output to U, never the reverse. Hence outgoing check-to-variable erasure probabilities cannot decrease. The variable update (27) is also monotone in its arguments. Composing, Φ λ is coordinatewise monotone increasing. The initial vector is p 0 = (ε V r(τ ) ) τ,b . Since the variable update is multiplied by ε V r(τ ) in (27) and the inner expectation is at most 1, we have p (b) 1,τ ≤ ε V r(τ ) = p (b) 0,τ . By monotonicity, p ℓ+1 ≤ p ℓ coordinatewise for all ℓ. The sequence is bounded below by zero, so it converges coordinatewise. Continuity gives that the limit is a fixed point. Monotone convergence in (29) gives the residual bit-erasure prediction. Target threshold (b). Along a monotone reliability path, the limiting residual is nondecreasing in a by repeated application of clause (a). Hence the sublevel seta : P (∞) DE (λ(a))≤ δ is an interval, and the displayed supremum is well-defined. Proof of Corollary 2. Under ε C s = 0, η r,s = 1 everywhere, and every check template coordinate-forcing (Defi- nition 1), the check-to-variable update (16) produces a singleton output whenever the forcing operator does, which at p ℓ = 0 occurs almost surely: every other incoming variable message is the (true-value) singleton, and the coordinate-forcing condition asserts that the target value is then uniquely determined by the verifier output and the other inputs. Hence h (b) ℓ,τ = 0 for all τ,b at p ℓ = 0, so p ℓ+1 = Φ λ (0) = 0 and 0 is a fixed point. For local stability, take any fixed point p ∗ at which Φ λ is differentiable with ρ(DΦ λ (p ∗ )) < 1 (in particular p ∗ = 0 in the noiseless regime). This is the standard spectral-radius stability criterion: a fixed point of a C 1 24 map whose Jacobian has spectral radius below 1 is locally geometrically attracting, because some iterate Φ k 0 λ is then a contraction on a neighborhood of p ∗ . Density evolution started anywhere near p ∗ therefore converges to it at a geometric rate. B. The Non-Interchangeability Proposition The statement of Theorem 2 (b) hides a fact that turns out to be one of the main structural distinctions of the framework: the three erasure tiers ε V r ,ε C s ,η r,s enter the DE Jacobian in functionally different positions and cannot be collapsed into a single effective scalar. Proposition 2 (No scalar effective-noise reduction of the DE map). There is no smooth change of variables e ε = Ψ(ε V ,ε C ,η V→C ,η C→V ) such that the density-evolution map Φ λ depends on the four tier parameters only through e ε, even on a single-role single-template AND ensemble. Quantitatively, the parameter Jacobian D par Φ λ (0) : = h ∂ ε V Φ λ , ∂ ε C Φ λ , ∂ η V→C Φ λ , ∂ η C→V Φ λ i p=0 (distinct from the state Jacobian DΦ λ (p) used in stability analysis) has rank at least two on a generic open subset of parameter space. The stronger rank-≥ 3 separation of the three operational tiers (ε C versus η C→V ), under nondegenerate role structure, is established in Proposition 3. Proof. We exhibit the rank-≥ 2 statement on a single-role single-template AND ensemble with separated channel directions; the general case follows by including this submodel as a slice of the parameter space. Setup. Take |R V | =|R C | = 1, one AND template of arity d≥ 2 and excess variable degree m = d v − 1≥ 1, value prior β ∈ (0, 1), variable-side erasure ε V ∈ [0, 1), verifier-side erasure ε C ∈ [0, 1), and the two directional channel fidelities η V→C ,η C→V ∈ (0, 1] kept separate (this is the structural distinction that the proof needs to expose; collapsing η V→C = η C→V from the start would obscure exactly the rank we want to read off). The DE map at the zero-erasure state. Combining Proposition 1 with (26) and (27) and evaluating at p = 0 (so p (1) = p (0) = 0), h (1) p=0 = 1− (1− ε C )η C→V β d−1 ,(43) h (0) p=0 = 1− (1− ε C )η C→V β d−1 η d−1 V→C ,(44) and the value-conditioned variable updates at p = 0 are Φ (b) λ (0) = ε V · h (b) p=0 m , b∈0, 1.(45) Two linearly independent parametric directions. We compute the parametric derivatives of (45) at the zero- erasure state with respect to two of the four parameters (ε V ,ε C ,η V→C ,η C→V ) and verify that the resulting two columns are linearly independent. Column 1 (∂/∂ε V ). By (45), ∂ ε V Φ (b) λ (0) = h (b) p=0 m , b∈0, 1.(46) Both entries are strictly positive on the open set ε C ∈ [0, 1), β ∈ (0, 1), η V→C ,η C→V ∈ (0, 1] because each h (b) | p=0 ∈ (0, 1) on that set. Column 2 (∂/∂η V→C ). Only the b = 0 branch depends on η V→C : ∂ η V→C Φ (1) λ (0) = 0, ∂ η V→C Φ (0) λ (0) =−mε V h (0) p=0 m−1 (1− ε C )η C→V β d−1 (d− 1)η d−2 V→C .(47) The b = 0 entry is strictly nonzero on the open set ε V > 0, ε C < 1, β > 0, η V→C ,η C→V > 0, while the b = 1 entry is identically zero. Linear independence. Suppose, on a neighborhood of any parameter point in the above open set, there are scalars α,β (not both zero) with α·(46)+β·(47) = 0 componentwise. The b = 1 component gives α(h (1) ) m = 0, hence α = 0 since h (1) > 0. The b = 0 component then gives β· ∂ η V→C Φ (0) λ (0) = 0, hence β = 0 by (47). The two columns are therefore linearly independent on the open set, and the parameter Jacobian D par Φ λ (0) has rank at least 2 on that open subregion. 25 Smooth-change-of-variables corollary. On any neighborhood U contained in the above open subregion, sup- pose Φ λ (p) depended on the four tier parameters only through some smooth scalar e ε = Ψ(ε V ,ε C ,η V→C ,η C→V ). Then the parameter Jacobian on U would factor as ∂Φ/∂ e ε·∇Ψ, which has rank at most 1. This contradicts the rank-≥ 2 statement above; no such Ψ exists on U. Remark 9 (What the rank-≥ 2 statement does and does not give). Proposition 2 establishes that no smooth scalar function of (ε V ,ε C ,η V→C ,η C→V ) summarizes the DE map: the design problem is multi-knob, not single- knob. This is strictly weaker than three-way mutual independence of the tiers. In the single-role single-template slice used in the proof, ε C and η C→V enter the check-to-variable update through the product (1− ε C )η C→V in (43)–(44), so locally these two knobs are confounded at the level of Φ λ ; rank-≥ 2 is achieved by ε V versus η V→C , not by all four parameters separately. A stronger rank-≥ 3 statement that distinguishes verifier-side erasure from the return channel requires nondegenerate role structure; Proposition 3 establishes it with two variable roles, where ε C s acts as a gate shared across roles while the return-channel fidelities act on different output blocks. Proposition 3 (Rank-three tier separation under heterogeneous roles). Let one check role s serve two variable roles r 1 ,r 2 through a single arity-two AND template. Then on a nonempty open subset of parameter space the parameter Jacobian D par Φ λ (0) has rank at least three, with three independent directions given by the variable- side erasure ε V r 1 , the verifier-side erasure ε C s , and a return-channel fidelity η s,r 1 . In particular ε C s and η s,r 1 are no longer confounded as in the single-role slice of Proposition 2. Proof. Use sockets j 1 ,j 2 of roles r 1 ,r 2 ; role-r variables have excess degree m r ≥ 1 on their socket type τ r = (θ,j r ), with priors β r ∈ (0, 1) and parameters ε V r ∈ (0, 1), ε C s ∈ [0, 1), forward fidelities η r,s ∈ (0, 1), return fidelities η s,r ∈ (0, 1]. As in the proof of Proposition 2, evaluating (26) with the AND forcing probabilities (40)– (41) at p = 0 gives, for a role-r target, h (b) τ r 0 = 1−g (b) r with g (b) r = (1−ε C s )η s,r A (b) r , and Φ (b) τ r (0) = ε V r (1−g (b) r ) m r by (27); here A (1) r 1 = β r 2 and A (0) r 1 = β r 2 η r 2 ,s . Order the four output coordinates as (τ (1) 1 ,τ (0) 1 ,τ (1) 2 ,τ (0) 2 ) and take the columns ∂ ε V r 1 , ∂ η s,r 1 , ∂ ε C s . The first two vanish on the τ 2 block, whereas ∂ ε C s Φ (b) τ 2 (0) = ε V r 2 m 2 (1− g (b) 2 ) m 2 −1 η s,r 2 A (b) r 2 > 0 there, because the gate (1−ε C s ) is shared across both roles; hence any vanishing combination of the three columns has zero coefficient on ∂ ε C s . Restricted to the τ 1 block, the remaining columns ∂ ε V r 1 and ∂ η s,r 1 have 2× 2 determinant −ε V r 1 m 1 (1− ε C s ) (1− g (1) 1 ) m 1 −1 (1− g (0) 1 ) m 1 −1 A (0) r 1 − A (1) r 1 , the g 1 cross-terms cancelling exactly as in Proposition 2. Since A (0) r 1 − A (1) r 1 = β r 2 (η r 2 ,s − 1)̸= 0 whenever the forward fidelity η r 2 ,s < 1, this determinant is nonzero on a nonempty open set, the three columns are linearly independent, and the rank is at least three. The gate (1− ε C s ) acting across both role blocks is exactly what breaks the single-role confound (1− ε C )η C→V of Remark 9. Remark 10 (Operational reading). Proposition 2 says that improving a verifier (↓ ε C ), adding more proposer redundancy (↓ ε V ), and improving an inter-agent communication channel (↑ η) are three separate design knobs whose marginal values cannot be folded into a single “effective noise” parameter. The shadow-price KKT corollary in Section IX (Theorem 6 (e)) makes this operational: at any architecture optimum, the three tier dual variables are typically non-degenerate and can be read directly off the adjoint solution. Equivalently, in contrapositive form: adding redundant LLM proposers cannot fix a broken Lean verifier, and neither can fix a formatting mismatch between them. The three tiers attack disjoint failure modes, and any single-knob policy that treats them as substitutes leaves Pareto-optimal designs on the table. Remark 11 (Differentiator from MET-LDPC and noisy-MP-decoder). Multi-edge-type LDPC [5] supports multiple edge-type kernels under a homogeneous parity update, and the noisy-message-passing-decoder line [11], [12] distinguishes channel noise from decoder-side message noise. What is new here is the agent-operational interpretation and joint presence of three tiers, variable-side abstention, verifier-output erasure, and directed role-pair artifact erasure, together with value-conditioned Boolean logical forcing on a sparse role-typed factor graph; neither line carries a non-interchangeability statement of the kind formalized by the rank-≥ 2 argument above. This is the structural distinction recorded in Table I. 26 VII. Certificate-Stopping Sets Density evolution predicts typical asymptotic behavior. At finite length, the decoder can fail because the realized graph and noise pattern contain a local obstruction. For XOR on the BEC, the obstruction is a stopping set [9]. For general Boolean verifier functions, the right obstruction is a certificate-stopping set. In this section we condition on the realized 5-tuple of all the randomness, which we call the transcript: T : = G n , X ∗ , A i i∈V n , Z a a∈C n , B u→w ,(48) where B u→w ∈0, 1 is the persistent directed-channel availability indicator on each ordered edge. “Persistent” means each directed edge is either available or erased throughout the deterministic peeling transcript, the clean finite-transcript analogue of the stochastic density-evolution model. Once T is fixed, no randomness remains (graph, hidden vector, observations, verifier outputs, and channel gates are all realized), so the peeling decoder analyzed below is deterministic; this section has thus moved from the probabilistic density evolution of Section V to a conditioned finite-instance analysis. Set-level peeling and the message-passing decoder coincide. Let S t : = i ∈ V n : c M (t) i = U be the unresolved variable set after t rounds of the set-valued message-passing decoder (messages carry candidate sets in M = 0,1, U, with U =0, 1 marking an unresolved variable) of Section IV-D. Under the soundness invariant (Lemma 1), every non-erased private observation is the true singleton and every non-erased verifier output equals T a , so the variable update (17) produces a singleton at i at round t+1 exactly when (i) A i is non-erased, or (i) some adjacent check certifies i relative to S t in the sense made precise below. Thus S t+1 is obtained from S t by removing exactly those variables. The set-level peeling process below is the unresolved-set evolution of the actual decoder, not a separate abstraction. A. Definition and main theorem Intuition. A certificate-stopping set is a residual group of unresolved variables such that every adjacent verifier is unable to certify any one of them from the information outside the group. The obstruction is not merely graph-theoretic: it depends on the Boolean semantics of the verifier templates and on the realized verifier outputs, so a set S may be certificate-stopping under one verifier transcript and not under another on the same graph. This generalizes the classical LDPC-BEC stopping-set notion, which is recovered as the value- symmetric, exact-verifier specialization (Corollary 3). For a candidate unresolved set S ⊆ V n , define the message available from a variable k to a neighboring check a relative to S by M k→a (S) = ( X ∗ k , k /∈ S and the directed channel k → a is available, U,otherwise. (49) A check a of template θ certifies a target variable i∈ S at socket j relative to S if (i) Z a ∈0, 1 (the verifier output is not erased), (i) the directed channel a→ i is available, and (i) Γ θ,j Z a ; M ∂a (S) =X ∗ i (the forcing operator outputs the singleton at the true value). Definition 2 (Certificate-stopping set for a realized transcript). For a fixed transcriptT as in (48), a nonempty set S ⊆ V n is a certificate-stopping set for T if every i ∈ S has erased private observation A i = U and no adjacent check certifies i relative to S. Remark 12 (Three levels of stopping-set objects). The certificate-stopping property is a property of a realized transcript, not of the graph alone: stoppedness depends on X ∗ (via soundness of the verifier outputs and forcing operator), on Z a , and on the channel realization B u→w . Three levels of obstruction object recur in the sequel: (i) realized-transcript certificate-stopping sets, the finite-length object analyzed here; (i) graph-only stopping sets, recovered in the XOR / noiseless-verifier / noiseless-channel specialization (Corollary 3), where stoppedness depends only on the bipartite incidence structure; (i) worst-case or high-probability structural stopping sets over an ensemble of transcripts, the natural object for augmentation design (Theorem 4). 27 Theorem 3 (Certificate-stopping obstruction). For the deterministic set-valued peeling decoder on a fixed finite transcript, the terminal unresolved set, when nonempty, is the unique maximal certificate-stopping set contained in the initially unresolved variables. Equivalently, the decoder recovers every variable iff there is no nonempty certificate-stopping set within the initially unresolved variables. Proof. Let S t be the set of unresolved variables after t peeling steps, where one step removes every variable that is privately observed or certified by at least one adjacent check relative to the current set. The sets S t are decreasing and the graph is finite, so the process reaches a fixed point S ∞ . At the fixed point, every variable in S ∞ has erased private observation; otherwise it would have been removed. No adjacent check certifies a member of S ∞ relative to S ∞ ; otherwise that member would also have been removed. Thus S ∞ is a certificate-stopping set if it is nonempty. Conversely, let S be any certificate-stopping set contained in the initially unresolved variables. We prove by induction that S ⊆ S t for all t ≥ 0. This is true at t = 0 because each i ∈ S has erased private observation. Suppose S ⊆ S t . Going from M −i (S) to M −i (S t ) only enlarges incoming candidate sets at neighbors k ∈ S t , replacing some singletons by U. Under the soundness invariant (Lemma 1) the forcing operator Γ θ,j satisfies X ∗ i ∈ Γ(z;M −j ) for every input, so its output is either the certifying singleton X ∗ i or the unresolved set U (never the contradictory singleton 1− X ∗ i or ∅). By Lemma 3, enlarging M −j enlarges Γ(z;M −j ), so an output of U at M −j (S) remains U at M −j (S t ). Hence no check that failed to certify i∈ S relative to S certifies i relative to S t , no variable in S is removed at the next step, and S ⊆ S t+1 . Therefore every certificate-stopping set is contained in S ∞ . Since S ∞ itself is a certificate-stopping set when nonempty, it is the unique maximal one. B. XOR specialization: the classical stopping-set condition Corollary 3 (XOR / parity stopping sets). For XOR templates, a residual set S is certificate-stopping iff every i ∈ S has A i = U and, for every adjacent check a ∈ ∂i, the pair (a,i) is blocked in at least one of the following ways: (M1) Verifier-erased. Z a =∗. (M2) Multi-input combinatorial. |∂a∩ S| ≥ 2: the check touches the unresolved set at i and at some other k ∈ ∂a\i, so the parity equation has at least two unknowns and cannot disambiguate. (M3) Reasoning-channel-erased. The return channel B a→i = 0, or some forward channel B k→a = 0 for k ∈ ∂a\i. In the noiseless-verifier (ε C = 0), noiseless-channel (η ≡ 1) special case, the per-edge condition reduces to the classical BEC stopping-set condition: every check that touches S touches S at least twice. Proof. For XOR, the forcing operator Γ θ,j (z;M −j ) returns a singleton iff every other input message is a singleton; relative to a residual set S, this means the verifier output is available, every other neighbor lies outside S, and the directed channels into and out of the check are available. Each of (M1) (verifier output erased), (M2) (a second neighbor in S, hence unresolved), and (M3) (a needed channel down) breaks exactly this condition, and when none of them holds the check certifies i. An adjacent check therefore certifies i relative to S iff none of (M1)–(M3) applies, and Theorem 3 converts this into the stated set-level equivalence. In the noiseless special case (M1) and (M3) are vacuous, leaving (M2): every check that touches S touches it at least twice, the classical stopping-set condition. C. AND specialization: positive and negative certificates Corollary 4 (AND certificate-stopping sets). For AND templates, an adjacent check a with Z a ∈ 0, 1 certifies a target variable i∈ ∂a∩ S relative to a residual set S in two ways: (i) Positive certificate (Z a = 1): if Z a = 1 and the return channel B a→i = 1, then a certifies X ∗ i = 1. Consequently, when Z a = 1 and every return channel B a→k : k ∈ ∂a∩S is available, the single positive verifier output certifies every member of ∂a∩ S at once. (i) Negative singleton certificate (Z a = 0): a certifies X ∗ i = 0 iff Z a = 0, B a→i = 1, and every other input message M k→a (S) is the singleton 1 (equivalently, every k ∈ ∂a\i is outside S, has true value 1, and has available forward channel B k→a = 1). 28 S is AND-certificate-stopping iff every i∈ S has A i = U and, for every adjacent check a∈ ∂i, a fails both (i) and (i). Proof. For AND, the forcing operator Γ θ,j (z;M −j ) at z = 1 is 1 regardless of M −j , because no assignment with x j = 0 produces an AND output of 1. This gives (i). At z = 0, the operator outputs the singleton 0 iff setting x j = 1 is infeasible, i.e., iff every other input message is the singleton 1 (otherwise some other variable could be 0, satisfying z = 0 without constraining x j ). This gives (i). Combining via Theorem 3 and Definition 2 gives the claim. Remark 13 (Two-layer obstruction structure under AND). Under AND templates the certificate-stopping condition has a richer combinatorial structure than under XOR. The positive-certificate mode is a one-shot strong-recovery primitive: a single positive verdict can free all unresolved variables in a check’s neighborhood at once. The negative-certificate mode is closer to the XOR singleton-neighbor rule but conditional on the boundary’s known values. Where positive AND outputs are common, AND factors can clear residual clusters that would be stopping sets under XOR on the same graph; where negative outputs dominate and boundary variables are unresolved, the negative-singleton certificate is strictly weaker than the XOR rule. A distributional comparison of AND and XOR certificate-stopping-set sizes therefore depends onβ r , ε C , η, and the ensemble, and we claim no universal ordering; the full combinatorial study is left to follow-on work. We state the two-layer structure here because the augmentation theorem of the next section applies to both specializations. The toy proof-checking example of Section I-C is this AND specialization: its successful recovery uses a positive certificate (i) and a negative singleton certificate (i), and its three failure modes (M1)–(M3) are exactly the verifier-erased, combinatorial, and channel-erased obstructions of Corollary 4. VIII. Separating Augmentation Stopping-set characterizations are useful because they suggest interventions. If a small residual cluster is the dominant failure mode, an architect can add targeted verifier nodes, route the cluster through stronger roles, or improve the communication links that would free the cluster. The augmentation theorem of this section makes that intuition precise: any augmentation that separates every small residual pattern eliminates all certificate-stopping sets up to the corresponding size. Conditioning convention. All statements in this section are deterministic statements conditional on a realized baseline transcript T base as in (48). The class S k = S k (T base ) of baseline certificate-stopping sets of size at most k is a function of that transcript: for general Boolean factors, certification depends on the realized hidden values, verifier outputs, and channel-availability, so k-separation is not a purely graph-combinatorial property in the general case. The results below distinguish two design regimes: adaptive augmentation, where the architect observes the baseline residual pattern and then chooses or samples augmenting checks (Theorem 4 and Corollary 5); and non-adaptive augmentation, where a sampling distribution μ is fixed before the realization of erasures, hidden values, and the residual set (Theorem 5). In the non-adaptive case the same bounds apply after conditioning on the realized transcript, with system-level guarantees obtained by averaging over the baseline-transcript distribution. A. k-separating augmentations Definition 3 (k-separating augmentation). Fix a baseline transcript T base on G n and a class S k ⊆S k (T base ) of baseline certificate-stopping sets of size at most k. An augmentation by additional Boolean verifier factors is k-separating for S k if, for every nonempty S ∈ S k , there exists a variable i ∈ S and an added check a + such that, whenever the added verifier output and the required directed channels are available, a + certifies i relative to S (in the sense of Definition 2). B. Main theorem and noisy-augmentation corollary Theorem 4 (Stopping-set elimination by separating augmentation). Fix a baseline transcriptT base as in (48). Suppose the added verifier nodes are noiseless and their directed channels are available. If the augmentation is k-separating for the familyS k (T base ) of all baseline certificate-stopping sets of size at most k, then the augmented 29 transcript has no certificate-stopping set of size at most k. Consequently, if the baseline terminal residual set has size at most k, the augmented peeling decoder recovers every variable in that residual set. Proof. Suppose, for contradiction, that the augmented transcript has a nonempty certificate-stopping set S + with|S + |≤ k. Every baseline check is also present in the augmented transcript, so the fact that no augmented adjacent check certifies any i ∈ S + implies, a fortiori, that no baseline adjacent check certifies any i ∈ S + relative to S + ; combined with A i = U for every i∈ S + , this means S + is itself a baseline certificate-stopping set of size at most k, hence S + ∈ S k (T base ). By k-separation, there exists an added check a + that certifies some i ∈ S + relative to S + . Because the added verifier output and required directed channels are available, a + certifies i in the augmented transcript, contradicting the augmented certificate-stopping property of S + . Therefore no such set exists. Moreover, by Lemma 1 every message in the augmented decoder (baseline or added) at variable j contains X ∗ j ; the augmented variable update at j ((17)) is therefore an intersection of sets each containing X ∗ j , so any singleton recovered by the baseline decoder remains that same singleton in the augmented decoder. Hence S + ∞ ⊆ S base ∞ , and this augmented residual set contains no certificate-stopping subset of size at most k; Theorem 3 then forces S + ∞ = ∅ whenever |S base ∞ |≤ k. Corollary 5 (Noisy augmentation union bound). Fix a baseline transcript T base and let S k = S k (T base ). For each S ∈ S k , suppose there are m S added certifiers whose success events are conditionally independent given T base , and each succeeds (i.e., is both certifying and available) with probability at least 1− ζ S . Then P n ∃S ∈S k that remains certificate-stopped T base o ≤ X S∈S k ζ m S S .(50) Proof. For a fixed residual pattern S, all m S added certifiers must fail for S to remain stopped; conditional independence given T base gives a failure probability at most ζ m S S . Union bound over S k . Why an additional random-augmentation bound is useful. Theorem 4 is conditional on producing a k-separating augmentation, and Corollary 5 is conditional on assigning certifiers per pattern. Both leave open the algorithmic question of how to find such an augmentation. The next theorem answers this question for the random- augmentation regime: with m = O log(|S k |/δ)/[q ∗ (1− ζ)] independent samples drawn from any distribution that puts non-trivial mass on separators of each small residual pattern, the survival probability of any small certificate-stopping set is at most δ. Theorem 5 (Random-augmentation survival bound). Let μ be any probability distribution on candidate added Boolean verifier nodes and their attached channel directions. For each nonempty residual pattern S ∈S k , let q S : = μ a + : a + certifies some i∈ S relative to S ∈ [0, 1](51) denote the probability that a single μ-sample separates S. Suppose m added checks are sampled i.i.d. from μ, and that the availability events of the m sampled checks are conditionally independent given the sampled identities, each with conditional probability at least 1− ζ (verifier output and required directed channels delivered). Then the probability that the augmented transcript on G n has any certificate-stopping set in S k is at most X S∈S k 1− q S (1− ζ) m .(52) In particular, if q ∗ = min S∈S k q S > 0 and m≥ log(|S k |/δ)/ q ∗ (1− ζ) , the survival probability is at most δ. Proof. Fix a residual pattern S ∈ S k . By (51), a single μ-sample certifies some i ∈ S relative to S with probability at least q S , and is then available (with both verifier output and required directed channels delivered) with probability at least 1− ζ. By the conditional independence of availability events across the m samples (hypothesis of the theorem) and the i.i.d. sampling from μ, PS remains stopping after m samples ≤ (1− q S (1−ζ)) m . Union bound overS k gives (52). The displayed sample-complexity statement follows from 1−x≤ e −x : (1− q ∗ (1− ζ)) m ≤ e −mq ∗ (1−ζ) , and the choice of m ensures the right-hand side is at most δ/|S k |. As observed in the proof of Theorem 4, every baseline check is present in the augmented transcript, so any certificate-stopping set of size at most k in the augmented transcript is also a baseline certificate-stopping set of size at most k (no augmented check certifying i∈ S + implies, a fortiori, no baseline check certifies i either). 30 Hence when S k is taken as the family of all baseline certificate-stopping sets of size at most k, the bound (52) controls every small augmented stopping set, not only the preselected baseline family. Operational reading. Theorem 5 provides a constructive design recipe: any sampling distribution whose mini- mal separation probability q ∗ over S k is bounded away from zero requires only O(log|S k |/q ∗ ) auxiliary checks to drive the survival probability of any small residual pattern to vanish. For fixed k the simple counting bound |S k | ≤ P k j=1 n j = O(n k ) holds in the role-typed configuration ensemble; if additionally q ∗ ≥ q 0 > 0 and ζ ≤ ζ 0 < 1 uniformly in n, then m = O(logn) samples suffice to drive the survival probability below any prescribed δ. The uniformity hypothesis on q ∗ is the essential design constraint: in non-adaptive schemes that sample candidate checks almost uniformly over many possible variable subsets, the probability of hitting a separator for one particular small residual pattern can scale like a negative power of n; in such regimes the O(logn) count fails. The theorem also disentangles the augmentation argument from the property of being a k-separator: the random-sampling distribution is the design knob, and the analyst chooses μ to make q ∗ as large as possible for the relevant family S k . C. XOR specialization: two-edge-connected freeing-set augmentation XOR specialization. Assume added XOR checks, noiseless added verifier outputs, and perfect added channels. Then an added check a + separates a residual set S relative to itself iff |∂a + ∩ S| = 1.(53) Indeed, by Corollary 3, the XOR forcing operator Γ θ,j (z;M −j ) is a singleton iff every entry of M −j is a singleton; relative to a residual set S, this means exactly one input of a + lies in S and every other input is outside S with available forward channel. Consequently, an added XOR layer is k-separating for S k iff for every nonempty S ∈S k there exists an added check a + satisfying (53). Remark 14 (Architecture interpretation by primitive). The separating-augmentation principle reads differently across primitives. For XOR checks it creates singleton parity witnesses via (53), reducing in the single- role (d v ,d c )-regular case to the classical two-edge-connected freeing-set construction [24]. For AND checks, augmentation adds tests that turn a positive local condition into a one-shot certificate or isolate a negative cause, and the required graph property is not two-edge-connectedness but a condition involving the boundary’s known values. For Horn checks, augmentation adds proof obligations that force a missing premise or conclusion. The common principle is semantic: add local verifier factors that force at least one variable in every small residual pattern. IX. Cost-Constrained Architecture Optimization The density-evolution recursion converts architecture design into an optimization problem. A design param- eter λ collects role proportions π V r , degree-law probabilities, template proportions π C θ , verifier reliabilities ε V r ,ε C s , and communication fidelities η r,s (we treat augmentation choices in Remark 17 below). The design space D is a finite union of bounded-support strata; each stratum fixes the supports of all degree laws and the template set, and optimizes only over simplex coordinates and continuous reliability parameters. On each stratum the feasible set under budget B is D B = λ∈D : Cost(λ)≤ B, g τ (λ) = 0∀τ ∈ T, λ∈ Λ ,(54) where the equality constraints g τ (λ) : = π V r(τ ) · E λ D (r(τ )) τ − απ C θ = 0, τ = (θ,j),(55) encode the socket-balance condition (21) of Section IV-E, and Λ collects simplex sums ( P r π V r = 1, P θ π C θ = 1, P d P (r) D (d) = 1) and box constraints (0 ≤ ε V r ,ε C s ≤ 1, 0 ≤ η r,s ≤ 1). The cost may include role costs, verifier- invocation costs, communication-edge costs, and augmentation costs. For a fixed round budget L∈ N, define the objective J L (λ) = P (L) DE (λ),(56) 31 or any continuous monotone function thereof (e.g., a weighted residual across role groups). Theorem 6 (Cost-constrained Boolean-verifier architecture optimization). Assume D B in (54) is nonempty, that each stratum is compact under the socket-balance, simplex, box, and budget constraints, and that J L is continuous on each stratum. Then: (a) Existence (Weierstrass). For every finite L, there exists a design λ ∗ L ∈D B minimizing J L . (b) Asymptotic optimality (finite design class). For each fixed design λ∈D B , the empirical L-round residual of the random graph ensemble converges in probability to J L (λ) by Theorem 1. We interpret P (L) bit (G n ;λ) as follows: each design λ has its own role-typed configuration-model ensemble (since λ may include role proportions, template proportions, and degree distributions), and G n (λ) denotes one draw from that λ- parameterized ensemble; the empirical residual is P (L) bit (G n (λ);λ), with draws across different λ values mutually independent. Let b λ n ∈ arg min λ∈D B P (L) bit (G n (λ);λ) denote the resulting empirical minimizer. When D B is finite, a union bound over Theorem 1 gives the uniform convergence sup λ∈D B |P (L) bit (G n (λ);λ)− J L (λ)| P −→ 0, hence the empirical-minimizer suboptimality vanishes: J L ( b λ n )− inf λ∈D B J L (λ) P −→ 0. For compact-continuum strata, the same conclusion holds under a uniform-DE-concentration assumption (uniform in λ over the stratum) that we do not establish here; this extension requires finite-n Lipschitz or covering-number bounds on the empirical-residual functional beyond Theorem 1. In the degenerate case where λ enters only through reliability parameters and the graph ensemble itself is held fixed across designs, G n (λ) ≡ G n and only channel randomness varies with λ; the same finite-vs-continuum dichotomy then applies with potentially simpler uniform-concentration arguments, but this restricted setting is not the framing pursued here. (c) Limit-points. If J L → J ∞ uniformly on D B , then every limit point of finite-round minimizers λ ∗ L m is an infinite-round minimizer. Sufficient conditions for the uniform limit include monotone pointwise convergence J L ↓ J ∞ together with continuity of J ∞ on D B (Dini’s theorem); the uniform limit may fail at threshold surfaces, where J ∞ is discontinuous. (d) Adjoint sensitivity (backward mode). On any smooth stratum of D, with recursion p ℓ+1 = Φ λ (p ℓ ) and objective J L = ψ(p L ,λ), the gradient is given by the adjoint equations ξ L =∇ p ψ(p L ,λ),(57) ξ ℓ = D p Φ λ (p ℓ ) T ξ ℓ+1 , ℓ = L− 1,L− 2,..., 0,(58) and ∇ λ J L =∇ λ ψ(p L ,λ) + L−1 X ℓ=0 D λ Φ λ (p ℓ ) T ξ ℓ+1 + D λ p 0 (λ) T ξ 0 .(59) The last term captures the dependence of the initial state on the design parameters: when λ includes variable-side erasure rates, p 0 is initialized from those rates and D λ p 0 (λ)̸= 0. When λ enters only through the recursion (e.g. degree distributions or verifier-side parameters that leave p 0 fixed), the boundary term vanishes and (59) reduces to the standard sum-only form. Variable-side erasure ε V enters ∇ λ J L through both terms: the boundary term (since p 0 is initialized from ε V ) and the direct sum (since ε V also appears multiplicatively inside Φ λ in (27)); implementations of the gradient must include both contributions. (e) KKT conditions and shadow prices. At a regular local optimum on a smooth stratum, the Karush-Kuhn- Tucker conditions hold for the Lagrangian L(λ,μ,ν,α,γ) = J L (λ) + μ Cost(λ)− B + X τ ν τ g τ (λ) + X j α j a j (λ) + X k γ k b k (λ),(60) with g τ the socket-balance equalities, a j the simplex-sum equalities, and b k (λ)≤ 0 the box and nonnegativity inequalities; stationarity∇ λ L = 0 holds along with μ≥ 0, μ(Cost(λ)−B) = 0, and analogous complemen- tary slackness on the box constraints. The multiplier μ is the shadow price of the cost budget. The partial derivatives ∂J L /∂ε V r , ∂J L /∂ε C s , ∂J L /∂η r,s obtained from (59) are the sensitivity gradients with respect to each erasure-tier parameter, not Lagrange multipliers themselves; in formulations where reliabilities are 32 generated by explicit investment variables (Remark 16) these partials translate directly into shadow prices on the corresponding investments. Remark 15 (Nonconvexity and local-optimality scope). The design objective J L (λ) = P (L) DE (λ) is in general a nonconvex function of λ, built from products and sums of degree-law moments and reliability parameters through the multi-round recursion. The KKT conditions of Theorem 6(e) are therefore necessary local optimal- ity conditions, not a global solution method; the shadow-price interpretation of μ and of the investment-variable duals in Remark 16 is likewise local unless additional convexity or monotonicity structure is imposed. Gradient methods on ∇ λ J L converge to local minima; global guarantees require further assumptions such as convex relaxations or enumeration over discrete template choices. Proof. (a) D B is compact by assumption and J L is continuous because the finite-round recursion is built from finitely many sums and products of continuous functions on each finite-support stratum, with continuous extension across mixtures. Weierstrass’s theorem applies. (b) For a fixed design, the empirical residual P (L) bit (G n ;λ) converges in probability to J L (λ) by Theorem 1. When D B is finite, a union bound over Theorem 1 gives the uniform convergence sup λ∈D B |P (L) bit (G n ;λ)− J L (λ)| P −→ 0. Standard empirical-risk-minimization argument: for the empirical minimizer b λ n and any DE optimum λ ∗ , J L ( b λ n )− J L (λ ∗ ) ≤ J L ( b λ n )− P (L) bit (G n ; b λ n ) + P (L) bit (G n ; b λ n )− P (L) bit (G n ;λ ∗ ) + P (L) bit (G n ;λ ∗ )− J L (λ ∗ ) , where the middle bracket is ≤ 0 by the empirical-minimizer property and the two outer brackets vanish in probability by uniform convergence. For a compact-continuum stratum, the same conclusion holds under the stated uniform-DE-concentration assumption; we do not establish that uniform limit here, since it would require finite-n Lipschitz / covering-number bounds on the empirical-residual functional that go beyond Theorem 1. (c) Standard uniform-convergence argument. If λ ∗ L m → ̄ λ, then for any feasible λ, J ∞ ( ̄ λ) = lim m J L m (λ ∗ L m )≤ lim m J L m (λ) = J ∞ (λ), where uniform convergence justifies the interchange of limits. The sufficient condition J L ↓ J ∞ with J ∞ continuous follows from Dini’s theorem on a compact stratum. (d) Reverse-mode differentiation of the finite recursion. Differentiating p ℓ+1 = Φ λ (p ℓ ) with respect to λ and applying the chain rule backwards gives the sum over ℓ = 0,...,L− 1 in (59); the (D λ p 0 (λ)) T ξ 0 boundary term arises from the dependence of the initial state on λ at ℓ = 0. This is the standard adjoint-state formula in finite-horizon optimal control with parameter-dependent initial condition, or equivalently backpropagation through a recurrent map. Full derivation including the explicit block structure of D p Φ λ and D λ Φ λ and the p 0 -dependence on the variable-side tier is in Appendix C. (e) Standard KKT first-order necessary conditions for a regular local optimum in a finite-dimensional smooth program with the equality and inequality constraints displayed in (60); complementary slackness for the budget inequality gives the budget shadow price μ≥ 0. The sensitivity-gradient interpretation of the partial derivatives with respect to reliability parameters follows from (59) directly. Remark 16 (Investment variables and operational shadow prices). Practical architecture-design problems often expose a budget through explicit investment variables u V r ,u C s ,u η r,s ≥ 0 with monotone reliability response curves ε V r = ε V r (u V r ) (decreasing in u V r ), ε C s = ε C s (u C s ) (decreasing in u C s ), and η r,s = η r,s (u η r,s ) (increasing in u η r,s ), under a budget P r c V r u V r + P s c C s u C s + P r,s c η r,s u η r,s +·≤ B. The stationarity condition for an interior active investment then reads, e.g. for variable-side, −(∂J L /∂ε V r )(dε V r /du V r ) = μc V r , with analogous equations for verifier-side and reasoning-channel investments (signs adjusted for the residual-minimization objective). Each such equation is a per-unit-cost shadow-price rule: at the optimum, the marginal residual reduction per unit cost is equal across all active investments. The non-interchangeability proposition (Proposition 2) says these shadow-price ratios depend on the design itself; an architect cannot trade verifier reliability against proposer redundancy one-for-one at a fixed exchange rate independent of the operating point. Remark 17 (Augmentation choices in λ). Theorem 6 treats λ as an ex ante ensemble parameter (role mix, degree laws, template proportions, reliability tiers). Augmentation can enter in two distinct ways: (i) as an ex ante added-template layer, in which case the augmentation template proportions and per-template costs are part of 33 λ and the framework above applies directly; or (i) as an adaptive or random repair policy whose distribution is realized only after the baseline transcript is observed, in which case the optimization problem must include the distribution of residual transcripts and the expected repair cost. We treat (i) within Theorem 6; (i), which is closer to a Markov decision problem on residual transcripts, is left to follow-on work. Corollary 6 (Budget monotonicity). Increasing the available budget B, lowering a role cost, lowering a verifier- template cost, or lowering a communication cost cannot worsen the optimized residual objective. For threshold objectives formulated as maximization of an admissible noise level, the optimized threshold cannot decrease when the feasible design set is enlarged. Proof. Each such change enlarges D B . The minimum of a residual objective over a larger feasible set cannot be larger; the maximum of a threshold objective over a larger feasible set cannot be smaller. Remark 18 (Channel-agnostic adjoint-sensitivity framework). The Weierstrass existence in part (a), the ad- joint sensitivity equations of part (d), and the KKT shadow-price machinery of part (e) depend only on a continuously-differentiable DE fixed-point map and a smooth design parametrization, not on the message alphabet being M = 0,1, U. The same architecture-optimization framework therefore applies, with appropriate operator-theoretic setup, to non-erasure DE recursions such as LLR-density DE on memoryless symmetric channels; the role-typed shadow prices on the three erasure tiers are the erasure-specific reading of a channel-agnostic multiplier framework. Remark 19 (XOR/UEP convex specializations). In certain XOR/UEP specializations, under fixed code-ensemble hypotheses and an edge-perspective parametrization, known log-convexity results [10] yield convex or water- filling-like allocation rules. We do not rely on this in the general Boolean-verifier theory: the finite-L recursion (24)–(27) involves nested nonlinear products of degree-distribution and reliability variables, so the program is in general a non-convex NLP, for which the adjoint equations of part (d) and the KKT system of part (e) give gradients and local necessary conditions. Closed-form characterizations are available only where additional convexity or separability holds. X. Converse: A Local-Soundness Bound on the Computation Tree The achievability theorems Theorem 1–Theorem 6 specify when a particular protocol, extrinsic edge-specific message passing on the role-typed Boolean-verifier-node ensemble, recovers the hidden subclaim vector. This section pairs them with a converse direction. We prove that, in the erasure model and within the class of T- round sound (certifying) local message-passing protocols, no protocol can asymptotically leave fewer variables unresolved at its terminal output than the value-conditioned logical-forcing decoder of Theorem 1. Throughout this section, T denotes the round budget of the local protocol class; this is distinct from the true verifier output T a introduced in (12); context always distinguishes the two. A sound protocol is one whose non-erased outputs are correct almost surely; soundness is the natural restriction for an erasure theory in which messages may be missing but never wrong. Without it, the bound need not hold: a protocol that guesses the likeliest prior value on undetermined transcripts can attain a smaller failure rate than abstention, at the cost of producing wrong outputs. That is the regime of a BSC/absorbing-set converse, not the present erasure converse. Scope of the converse. This is a local-soundness converse: a per-variable certifiability bound within the certi- fying class, not an information-theoretic limit against an unbounded-alphabet unrestricted class. A stronger Fano-cut-set converse, in which the per-edge alphabet is bounded by Y and the matching T → ∞, Y → ∞ joint limit is taken, is sketched as a future direction in Section XIV. Round and radius convention. Throughout this section, one round of message passing consists of one variable- to-check update followed by one check-to-variable update. After T such rounds the terminal estimator at variable i is, by unrolling the recursion, a measurable function of the channel-gated depth-R node (T ) = 2T + 2 rooted variable neighborhood, where depth is measured in graph distance (consistent with the radius convention of Appendix B: edge messages V (T ) i→a use the depth-R edge (T ) = 2T + 1 edge-rooted neighborhood, but the terminal node estimate at i gains one additional hop in order to read all incoming round-T check-to-variable messages). The round index T on the protocol side is aligned with the iteration index T in the achievability decoder (Theorem 1), so the converse compares a T-round protocol’s per-variable estimate to P (T ) DE (λ) at the matching node depth 2T + 2. 34 A. The T-round local protocol class Definition 4 (Sound local message-passing protocol class P snd T ). A T-round sound local message-passing protocol on the role-typed configuration ensemble of Section IV-E consists of: (a) For each directed edge (i→ a) and each round t = 0, 1,...,T, a measurable update function Φ (t) i→a :V (t−1) i × Ω i →Y, where the round-(t− 1) local viewV (t−1) i at variable i consists of the private observation A i , the role label r i = ρ(i), the incident socket types and template labels of all checks c∈ ∂i, and the messages e Y (s) c→i received from each check neighbor in rounds s ≤ t− 1 in the delivered alphabet defined below; at the round-0 initialisation step the index set s : s ≤ −1 is empty, so V (−1) i contains only the observation, role, and graph-structure information and Φ (0) i→a plays the role of the achievability decoder’s initial variable message V (0) i→a = A i of (17). Ω i is a private-randomness space and Y is an arbitrary standard Borel measurable message space (distinct from the logical-forcing alphabetM =0,1, U of Section IV-D; the converse holds against protocols with arbitrary standard-Borel message alphabets, not only those whose messages take values inM, the standard-Borel hypothesis guaranteeing existence of regular conditional probabilities used in the proof). The persistent role-pair channels of Section IV-C extend to the alphabet Y as follows: the delivered alphabet is e Y : = Y ∪⊥, and for each directed edge u → v a persistent gate B u→v ∼ Bernoulli(η ρ(u),ρ(v) ) is drawn once at t = 0; the received message at round t is e Y (t) u→v = Y (t) u→v when B u→v = 1 and ⊥ otherwise. This reduces to the logical-forcing channel (14) when Y =M and ⊥≡ U. (b) For each directed edge (a→ i) and each round t = 0, 1,...,T, a measurable update function Ψ (t) a→i :V (t) a × Ω a →Y, where the round-t local view V (t) a at check a consists of the verifier output Z a , the template label θ a and its socket ordering (j 1 ,...,j d a ), the role labels and incident socket types of all neighbors k ∈ ∂a, and the messages e Y (s) k→a received from each variable neighbor k ∈ ∂a in rounds s≤ t in the delivered alphabet e Y (within-round ordering: the round-t check update may read the round-t output of clause (a) of the same round, in addition to all earlier variable outputs; see the alignment paragraph following this definition). The persistent-gate channel of clause (a) also gates the outgoing Y-valued message from a: the gate B a→i replaces Y (t) a→i by ⊥ with probability 1− η ρ(a),ρ(i) . (c) A measurable terminal estimator b X Π i : V (T ) i × Ω i → 0, 1, ? for each i ∈ V n satisfying the soundness (certifiability) constraint P n b X Π i /∈?, X ∗ i o = 0 for every i∈V n ,(61) that is, every non-erased terminal output must equal the true value almost surely under the joint distri- bution of the graph, observations, hidden values, and private randomness. The class of all such sound protocols, for fixed T, is denoted P snd T . Within-round ordering and alignment with the achievability decoder. Within each round t ∈ 0, 1,...,T the variable update of clause (a) fires first and the check update of clause (b) fires second, so the round- t check update Ψ (t) a→i may use the round-t variable messages produced by its neighbors in addition to all earlier variable outputs. Under this ordering the protocol-class messages Φ (t) i→a and Ψ (t) a→i play the roles of the achievability extrinsic messages V (t) i→a and C (t) a→i of (17)–(16) respectively for t = 0, 1,...,T: round 0 is the initialisation step in which Φ (0) i→a sees only the private observation A i (no check has spoken yet) and Ψ (0) a→i then reads those round-0 variable initialisations from ∂a\i, paralleling the achievability pair V (0) i→a = A i and C (0) a→i = Γ θ,j (Z a ; ( e V (0) k→a ) k̸=i ) of (16). Iterating for t = 1,...,T, the round-T local view V (T ) i that the terminal estimator b X Π i may consult is, by unrolling the recursion, a measurable function of the channel-gated rooted variable neighborhood of i at graph depth R node (T ) = 2T + 2 (the radius convention of Appendix B), exactly matching the achievability terminal estimator c M (T ) i of (18). The converse comparison to P (T ) DE (λ) stated in Theorem 7 below is therefore against the achievability T-iterate at the matching node depth, and the round count T on the two sides refers to the same number of message-passing iterations counted from initialisation. 35 The class P snd T is much larger than the specific extrinsic decoder analyzed in Theorem 1: it includes any local update that is a measurable function of the local view, including non-extrinsic updates, randomized updates, soft-information updates, and any sound decoder that exploits messages from earlier rounds in non- trivial ways. The constraints are locality (messages pass along graph edges), the round budget T, and the certifiability requirement (61). Soundness is the natural matching constraint for an erasure model (Lemma 1): the achievability decoder of Theorem 1 is itself sound, and the converse measures whether any sound local protocol can asymptotically leave fewer variables unresolved at its terminal output than that specific sound decoder. B. The local-soundness converse Theorem 7 (Local-soundness converse on the computation tree). Fix any T ∈ N. Assume full-support value priors β r ∈ (0, 1) for every r ∈R V . Under the erasure-only observation model (Section IV-B) on the bounded- degree role-typed configuration ensemble of Section IV-E with persistent role-pair channel gates, every sound protocol Π∈P snd T satisfies the ensemble-average lower bound lim inf n→∞ E G n 1 n X i∈V n P n b X Π i = ? o ≥ P (T ) DE (λ),(62) where P (T ) DE (λ) is the per-variable terminal unresolved fraction of the value-conditioned logical-forcing decoder of Theorem 1, evaluated at iteration T. The bound is on the joint expectation over the graph ensemble and the protocol’s randomness, not a high-probability statement for almost every graph. In words. Within the certifying class P snd T , no T-round local protocol can asymptotically leave fewer variables unresolved at its terminal output than the value-conditioned logical-forcing decoder of Theorem 1. Equivalently, the logical-forcing decoder is asymptotically optimal in the certifiability sense: any sound protocol that leaves fewer variables unresolved on a positive fraction of instances would, by soundness, already commit to the true value on those instances; but the proof below shows there is no measurable function of the depth-(2T + 2) local view that does so almost surely beyond what logical forcing already achieves. Terminal abstention vs. primitive erasure. The quantity bounded in (62) is the protocol’s terminal abstention: the event b X Π i = ? records that variable i is still uncertified after all observations, verifier outputs, channel gates, and T rounds of local computation have been used. It is distinct from the model’s primitive erasure events, the variable-side abstention A i = U, the verifier-side erasure Z a =∗, and the role-pair channel erasures B u→v = 0, which generate the uncertainty rather than constitute the protocol’s verdict. We accordingly read 1 n P i P b X Π i = ? as the average terminal abstention probability. Proof. The proof has three steps: localization, tree representation, and optimal sound estimator on the tree. Step 1 (observable transcript dominance). By Definition 4, every variable update Φ (t) i→a at round t ≥ 0 is computed from the round-(t− 1) local view at i (with V (−1) i containing only the observation, role, and graph- structure information at the round-0 initialisation step), every check update Ψ (t) a→i at round t≥ 0 is computed from the round-t local view at a (which includes the round-t variable outputs of clause (a) under the within- round ordering), and each directed Y-valued message is gated by its persistent Bernoulli edge variable B u→v . Iterating, the round-T local view at i is a measurable function of the channel-gated observable transcript Obs (T ) i : = n A j ,r j j , Z a ,θ a , (j 1 ,...,j d a ) a , B u→v u→v : (j,a,u→ v) in the channel-gated depth-(2T + 2) rooted variable neighborhood of i, accessible through open channels at the relevant round o , (63) i.e., the channel-gated rooted typed factor-graph structure to depth 2T + 2 together with the private obser- vations A j , verifier outputs Z a , and forward/return channel gates B u→v encountered along open channels. We pair this with the protocol’s private randomness Ω i . Verifier outputs behind erased return channels and incoming messages on erased forward channels do not enter Obs (T ) i . The terminal estimator b X Π i is therefore 36 a measurable function of Obs (T ) i and the private randomness. Because Y and Ω i are standard Borel, the regular conditional probability PX ∗ i | Obs (T ) i exists and the posterior support is well-defined for almost every realization of Obs (T ) i . Soundness (61) forces b X Π i = ? almost surely on every Obs (T ) i for which the posterior support supp PX ∗ i | Obs (T ) i has cardinality ≥ 2: any positive conditional probability of outputting a value b ∈ 0, 1 on such a transcript would, under full-support priors β r ∈ (0, 1), give a positive unconditional probability of b X Π i = b ̸= X ∗ i on the complementary value branch, contradicting soundness; consequently, for every sound Π, P n b X Π i = ? o ≥ P n b X snd i = ? o ,(64) where b X snd i is the sound Bayes-optimal estimator on Obs (T ) i : declare b when the posterior support is the singleton b and declare ? otherwise. Step 2 (tree representation). By the variable-rooted locally-tree-like result Corollary 7 (a corollary of Lemma 4), the depth-(2T + 2) neighborhood of i converges in total variation, as n→∞, to the typed Galton-Watson tree f N r 2T +2 at rate C T /n + ∆ n,T , where r is the role of i and the offspring law at the root is the full node degree law D (r),node . Total-variation convergence implies the corresponding convergence of expected per-variable Bayes risk, with an O(C T /n + ∆ n,T ) correction; since both terms vanish as n → ∞, the correction vanishes in the lim inf n→∞ and the converse conclusion is unaffected. Step 3 (support-BP equals logical forcing on the tree). On the typed Galton-Watson tree f N r 2T +2 , exact posterior-support propagation under the channel-gated erasure-only observation model satisfies the recursion S a→i = ( U,Z a =∗ or B a→i = 0, Γ θ,j Z a ; ( e S k→a ) k∈∂a , otherwise, S i→a = A i ∩ \ c∈∂i S c→i ,(65) where the channel-gated variable-to-check input is e S k→a : = ( S k→a , B k→a = 1, U, B k→a = 0. (66) The forward gating mirrors the channel-gated observable transcript Obs (T ) i in (63): incoming messages on erased forward channels deliver U regardless of the sender’s support, matching the way the achievability decoder of Theorem 1 applies the forcing operator to the received messages e V k→a in (16). With terminal node-support S i = A i ∩ T a∈∂i S a→i , this is a fact about the posterior support of X ∗ i given Obs (T ) i on a tree, not about any specific protocol’s message alphabet: the branches of the tree rooted at distinct neighbors of any node are conditionally independent given that node’s hidden value, because the role-typed Galton-Watson construction draws subtree degrees, observations, and channel gates independently across branches conditional on the root’s role and value. The posterior support therefore factorizes exactly as the logical-forcing recursion of Section IV-D. Under full-support priors β r ∈ (0, 1), S i =X ∗ i iff some chain of singleton evidence forces X ∗ i from the tree’s leaves to the root, and S i = U otherwise. The terminal node estimate c M (T ) i = A i ∩ T a∈∂i e C (T ) a→i produced by the value-conditioned logical-forcing decoder of Theorem 1 computes precisely S i in T rounds; therefore P n b X snd i = ? f N r 2T +2 o = P n c M (T ) i = U f N r 2T +2 o .(67) Step 4 (averaging to P (T ) DE ). Averaging the right-hand side of (67) over f N r 2T +2 , hidden values, observations, and channel gates, with the root variable drawn uniformly under the full node degree law D (r),node as in (29), gives the per-variable terminal unresolved fraction P (T ) DE (λ) of the logical-forcing decoder. Combining (64), the convergence in Step 2, the support-BP identity (67), and the averaging in Step 4 yields (62). C. Operational reading Theorem 7 certifies the value-conditioned logical-forcing decoder as asymptotically optimal among T-round sound (certifying) local protocols on the role-typed configuration ensemble in the erasure model: no non- extrinsic, randomized, or soft-information sound local protocol can asymptotically leave fewer variables un- resolved at its terminal output than P (T ) DE . Combined with Theorem 1 and Theorem 2, this gives a clean 37 operational picture: an architect committed to certifiable outputs, the natural posture for verifier-style agent systems, cannot outperform the iterate of the value-conditioned density-evolution map at the corresponding round budget. Dropping soundness allows a protocol to guess the likeliest prior value on undetermined transcripts and attain a smaller failure rate than abstention; that regime is the natural domain of a non- erasure (BSC/absorbing-set) converse and is outside the scope of the present erasure theory. A separate, stronger converse direction, a Fano-cut-set lower bound that allows the per-edge alphabet to be unbounded and that matches Theorem 2’s asymptotic threshold surface in the joint limit T,Y →∞, requires book-keeping of role-typed cut-set capacities and matching with the spectral-radius condition. We sketch this direction in Section XIV and pursue it in follow-on work. Relation to decision-theoretic converses on multi-agent DAGs. A complementary converse direction is devel- oped by Ao, Gao, and Simchi-Levi [37], who treat LLM-based multi-agent planning as a delegated decision problem on a finite acyclic decision network with finite-capacity language interfaces. They prove that any delegated DAG is decision-theoretically dominated by a centralized Bayes decision-maker observing the same evidence and characterize the gap as an expected posterior divergence, which reduces to conditional mutual information under logarithmic loss. The two converses are complementary rather than overlapping: [37] bounds the decentralization loss of an arbitrary delegated DAG against a centralized oracle under general decision losses, while Theorem 7 bounds the message-passing reach of the certifying-protocol class on the role-typed configuration ensemble against the value-conditioned density-evolution decoder under the abstention loss. The mutual-information characterization in [37] is closer in spirit to the Fano-cut-set direction sketched in Section XIV-F and is a natural reference point for the unbounded-alphabet limit. XI. Calibration of Reliability Parameters The framework is useful only if its parameters can be related to real agent traces. We give a calibration protocol that maps each model parameter to an operational quantity logged or readily instrumented in deployed multi-agent systems. • Architecture statistics π V r ,π C θ ,α,P (r) D . Read off directly from the deployed system’s role labels, template taxonomy, and incidence graph: b π V r = #i : ρ(i) = r/|V|, b π C θ = #a : θ(a) = θ/|C|, b α = |C|/|V|, and the empirical socket-count distribution b P (r) D (d). Verify the empirical socket-balance b π V r · b E[D (r) τ ]≈ b α b π C θ (cf. (55)) before running density evolution. • Variable-side erasure ε V r . Estimate as the rate at which role-r variable agents abstain, time out, or produce artifacts that cannot be used as local evidence on a held-out subset of tasks. In Hilbert this is the per-step type-checker abstention rate; in CodeR it is the rate at which a code-fragment proposer fails to commit; in a sensor network it is the per-modality “signal-not-confident” rate. • Verifier-side erasure ε C s . Estimate as the rate of no-verdict events (verifier timeouts, sandbox crashes, missing dependencies, malformed invocations, or “cannot determine” / abstention outputs) among role-s verifier calls attempted. Crucially, distinguish a no-verdict event (Z a =∗) from a definite negative verdict (Z a = 0): a failing unit test or a Lean kernel rejection that runs to completion is a non-erased negative output, not an erasure. Confusing the two inflates c ε C [s] and erases the AND positive-versus-negative certificate asymmetry the framework relies on. • Reasoning-channel fidelity η r,s . Estimate by a controlled artifact-usability test: sample artifacts whose source-side status is known to be non-erased and correct, transmit them from role r to role s, and measure the fraction the receiver can parse and map to the intended local input object. This isolates the channel: format/translation success, not downstream verifier success, not receiver competence. In Hilbert this is the refactor success rate (proposer’s draft format → Lean kernel input format). Mixing η r,s with downstream verifier success double-counts ε C s and is a common pitfall. • Value priors β r . Estimate from held-out traces or from the empirical fraction of valid subclaims in a role-specific decomposition. The DE recursion samples through sockets, so if higher-degree subclaims are systematically harder (value-degree dependence), the socket-level prior b β r,τ = P i:ρ(i)=r D i,τ 1X ∗ i = 1 / P i:ρ(i)=r D i,τ differs from b β r and the socket-level prior should be used (cf. Section IV-B). When the role-level prior suffices, report the diagnostic b β r,τ ≈ b β r for all relevant τ. 38 Soundness diagnostics. The erasure-only theory assumes that non-erased outputs are correct: A i ̸= U⇒ A i = X ∗ i and Z a ̸=∗⇒ Z a = f θ (X ∗ ∂a ). Empirically check this with audit-labelled subsets: b δ V r : = #non-erased role-r variable outputs that are wrong #non-erased role-r variable outputs , b δ C s : = #non-erased role-s verifier outputs that are wrong #non-erased role-s verifier outputs . (68) The erasure-only theory is appropriate only when b δ V r and b δ C s are negligible relative to the target reliability level. When they are not, the calibrated system belongs to the hybrid erasure-and-flip extension (Section XIV-B) rather than the present BEC-style theory. Empirical fault-injection benchmarks as calibration inputs. Recent fault-injection benchmarks for LLM-based multi-agent systems, notably MAS-FIRE [40], can supply empirical inputs for the calibration protocol above. MAS-FIRE defines a taxonomy of fifteen fault types covering intra-agent cognitive errors and inter-agent coor- dination failures, injected through prompt modification, response rewriting, and message-routing manipulation. Its fault categories can be mapped, as a modeling step, onto the M1 (variable-side, ε V r ) / M2 (verifier-side, ε C s ) / M3 (reasoning-channel, η r,s ) decomposition that drives the certificate-stopping-set theorem (Theorem 3); this mapping is a calibration layer rather than MAS-FIRE’s own taxonomy. Such empirical grounding supports the view that the three erasure tiers correspond to distinct failure modes that engineers can observe and intervene on separately. After calibration, one runs the density-evolution recursion (Theorem 1) and compares the predicted residual P (L) DE with held-out executions of finite agent networks. The same calibrated model can then be used for design: change a role mixture, add cross-verification checks, improve a communication channel, or allocate more budget to a verifier role, and evaluate the predicted reliability change before running a large benchmark. The boundaries within which this calibration is meaningful, and the failure modes the erasure-only model does not capture, are discussed in Sections XIV-A and XIV-B. XII. Numerical Validation and DE Illustrations This section reports finite-graph Monte-Carlo concentration tests of Theorem 1 in both the canonical XOR specialization (Section XII-A) and the value-conditioned AND specialization (Section XII-B); a deterministic- graph validation of Theorem 8 on fixed graphs of controlled local-cycle density (Section XII-C); and a deterministic DE illustration of the non-interchangeability of the three reliability tiers (Section XII-D). The simulator and the recursions used in these experiments are available from the authors upon request. Reproducibility conventions. All Monte-Carlo experiments use multigraph configuration-model instances (no simple-graph conditioning, per Section I); each trial independently resamples the matching, the hidden vector, the variable- and verifier-side erasures, and the persistent directed-channel gates of Section IV-C; random seeds are deterministic functions of the trial index and (ε V ,n) for the XOR sweep (full seed sequences available from the authors); finite-n socket-balance enforcement uses the standard rounding-and-matching step of Section IV-E with O( √ n) rounding fluctuations. For the XOR ensemble the all-zero hidden vector is used without loss of generality (Corollary 1). A. XOR DE vs. Monte-Carlo Setup. Variable role and check role are both singletons. Templates are XOR factors of arity d c . Variable-side erasure is ε V r = ε V for the unique variable role; verifier-side erasure is ε C s = ε C for the unique check role; reasoning-channel fidelity is η r,s = η for the unique role pair. We pick (d v ,d c ) = (3, 6) (the textbook (3, 6)- regular LDPC-BEC ensemble, with noiseless BP threshold ε V ∗ ≈ 0.4294, below the BEC capacity threshold 0.5 at rate 1/2), fix ε C = 0.05 and η = 0.95 to make the verifier-side and channel-side tiers visibly active, and sweep the variable-side erasure ε V across 0.20, 0.25,..., 0.55. For each ε V , we generate 30 independent draws of the role-typed configuration model graph at each of three problem sizes n∈200, 1000, 5000. Each 39 0.180.20.220.240.260.280.30.320.340.360.380.40.420.440.460.480.50.520.540.560.58 0 0.2 0.4 0.6 Variable-side erasure rate ε V Bit-erasure rate P ( L ) bit DE prediction P (L) DE Empirical, n = 200 Empirical, n = 1000 Empirical, n = 5000 Fig. 3. Density-evolution prediction (Theorem 1, Corollary 1) vs. empirical bit-erasure rate from Monte-Carlo simulation of the role-typed configuration ensemble. Single-role (d v ,d c ) = (3, 6)-regular XOR ensemble with three-tier erasure (ε V ,ε C ,η) = (swept, 0.05, 0.95) and L = 50 message-passing rounds. Empirical points are averages over 30 independent graph realizations at each of three problem sizes n ∈ 200, 1000, 5000, with one-standard-deviation error bars. The empirical means track the DE prediction across the full ε V range, and the empirical spread shrinks with n at the McDiarmid rate O(1/ √ n) predicted by Theorem 1: the figure validates the finite-n accuracy of the DE recursion under the model assumptions of the theorem. instance is decoded by extrinsic edge-specific message passing for L = 50 iterations, and the empirical bit- erasure rate P (L) bit (G n ) is averaged across the 30 trials. In parallel, we evaluate the deterministic DE recursion of Corollary 1 for L iterations to obtain P (L) DE (λ). Result. Figure 3 plots P (L) bit (G n ) versus ε V . The DE prediction (solid blue curve) and the empirical points are in tight agreement for every ε V (max absolute deviation across the swept grid and the three problem sizes is 0.033 at n = 200 and decreases monotonically with n). The empirical spread shrinks visibly with n: at ε V = 0.40, the standard deviation of the empirical bit-erasure rate is 0.075 at n = 200, 0.032 at n = 1000, and 0.016 at n = 5000, consistent with the 1/ √ n McDiarmid-rate prediction of Theorem 1. The plotted error bars are one-standard-deviation across graph/noise realizations and measure finite-instance dispersion; the standard error of the displayed empirical mean is smaller by a factor 1/ √ 30. Verifier-side and channel-side tiers are active. At ε C = 0, η = 1 (the noiseless-LDPC-BEC special case of Corollary 1), the threshold of the (3, 6)-regular ensemble is the textbook value ε V ∗ ≈ 0.4294, at which P (∞) DE jumps from 0 to a positive limit. In the presence of a verifier-side erasure ε C = 0.05 and a channel loss rate 1−η = 0.05, the threshold shifts left and the above-threshold residual rises. The next two subsections quantify the two ways in which this rise is more than a single-scalar effect. B. AND value-conditioned DE: the certificate asymmetry Setup. We exercise the AND specialization (Proposition 1) on a single-role (d v ,d c ) = (3, 4)-regular AND ensemble with ε V = 0.20, ε C = 0.05, and directional fidelities η V→C = η C→V = 0.95. Value prior β = 0.7 is realistic for verifier-style settings in which most subclaims are valid. We iterate the value-conditioned DE recursion of Proposition 1 for L = 30 rounds and plot p (1) ℓ and p (0) ℓ separately. Result. Figure 4 shows that the two value-conditioned curves diverge after one round and converge to distinct fixed points. The finite-graph Monte-Carlo overlay at n = 200 (40 trials, ±1σ error bars) lies within one standard deviation of the DE prediction at every iteration, consistent with Theorem 1. The value-1 branch drops from 0.20 to 0.095 in one round and stays there: a positive certificate (verifier outputs z = 1) certifies all inputs at once, so a single positive verdict on a check resolves every variable in its neighborhood, and a positive verdict happens with probability β d c −1 = 0.7 3 ≈ 0.343 per neighbor, independent of message-passing progress. The value-0 branch drops more slowly: 0.20 → 0.149 → 0.129, then plateaus. A negative certificate (verifier outputs z = 0) certifies a target only when every other input is already known to be 1, which requires those 40 024681012141618202224262830 0.1 0.15 0.2 0.25 Iteration ℓ Per-edge erasure rate p ( b ) ℓ p (1) ℓ DE (positive certificate) p (0) ℓ DE (negative singleton) p (1) ℓ MC (n=200) p (0) ℓ MC (n=200) Fig. 4. AND value-conditioned DE recursion (Proposition 1) on a single-role (d v ,d c ) = (3, 4)-regular AND ensemble with ε V = 0.20, ε C = 0.05, η V→C = η C→V = 0.95, and value prior β = 0.7. Solid blue and dashed red lines are the DE prediction; circle and square markers (±1σ error bars) are empirical Monte-Carlo means over 40 trials at n = 200. The asymptotic gap visualizes the positive-versus-negative certificate asymmetry of Proposition 1. 0.150.20.250.30.350.40.450.50.55 0 0.1 0.2 0.3 0.4 0.5 Variable-side erasure rate ε V Bit-erasure rate P ( L ) bit P (0) DEP (1) DE P (0) MC n=5000P (1) MC n=5000 P (0) MC n=200P (1) MC n=200 Fig. 5. AND Monte-Carlo concentration on the single-role (d v ,d c ) = (3, 4)-regular AND ensemble (ε C = 0.05, η = 0.95, β = 0.7, L = 30). Solid curves are the value-conditioned DE prediction (Proposition 1); markers are empirical Monte-Carlo means (30 trials, ±1σ bars) at n = 5000 (filled) and n = 200 (open). The empirical rates concentrate onto the DE prediction (max |DE− MC|≤ 0.003 at n = 5000), with spread shrinking in n, and the gap P (0) > P (1) is the positive-versus-negative certificate asymmetry of Proposition 1, which has no value-symmetric XOR counterpart. other variables to be resolved first, hence depends on p (1) . The asymptotic gap p (0) ∞ − p (1) ∞ ≈ 0.034 visualizes the certificate asymmetry of Proposition 1 and the practical reading of Remark 5. Concentration across the sweep. Beyond the single operating point of Figure 4, Figure 5 sweeps the variable- side erasure ε V and overlays the value-conditioned terminal bit-erasure rates P (0) and P (1) against direct Monte-Carlo at three problem sizes. The empirical rates concentrate onto the DE prediction of Proposition 1 (maximum absolute deviation ≤ 0.003 at n = 5000), with the spread shrinking in n at the 1/ √ n rate of Theorem 1, and the certificate asymmetry P (0) > P (1) persists across the whole sweep. This is the AND counterpart of the XOR concentration test of Figure 3, on a non-value-symmetric verifier factor that has no LDPC analog. C. Deterministic-graph validation Setup. Theorem 8 predicts that the same bit-erasure DE prediction holds on a fixed graph sequence, with no appeal to graph randomness, once the local neighborhoods are tree-like (vanishing local-cycle density). We 41 10 −2 10 −1 10 0 0 5· 10 −2 0.1 0.15 Short-cycle density (cycles per node) Bit-erasure rate P ( L ) bit P (L) DE (locally tree-like) fixed graphs, MC P (L) bit Fig. 6. Deterministic-graph validation of Theorem 8 on the (3, 6)-XOR ensemble (ε V = 0.25, ε C = 0.05, η = 0.95, L = 50, n = 2400). Each point is a fixed graph (only the noise is resampled; 3 graphs × 50 trials, ±1σ bars), built as a disjoint union of blocks so that block size controls short-cycle density. Locally tree-like graphs (left) sit on the DE prediction P (L) DE ; as short cycles proliferate the empirical rate rises as an error floor (up to 4.7 × P (L) DE ), confirming that the operative hypothesis is local tree-likeness, not graph randomness. On a frozen tree-like graph the empirical rate concentrates onto P (L) DE with spread 0.026/0.010/0.005 at n = 600/2400/9600, the 1/ √ n rate. test this on the (3, 6)-XOR ensemble at ε V = 0.25 (below the noiseless threshold, where stopping sets from short cycles are most visible), ε C = 0.05, η = 0.95, L = 50, n = 2400. Each graph is generated once and then frozen; only the hidden values and the three erasure tiers are resampled across trials, so no matching exposure is involved. Graphs are built as disjoint unions of independently wired blocks, so the block size is a clean knob for short-cycle density (a single block of size n is the ordinary configuration model). Result. Figure 6 plots the empirical bit-erasure rate against the measured short-cycle density. Locally tree-like graphs reproduce the DE prediction P (L) DE , while short cycles raise the rate as an error floor, up to 4.7× P (L) DE at the densest; the operative hypothesis is thus local tree-likeness, not graph randomness. On a single frozen tree- like graph the empirical rate concentrates onto P (L) DE as the graph grows, with one-standard-deviation spread 0.026, 0.010, 0.005 at n = 600, 2400, 9600 (the 1/ √ n rate), the deterministic-graph counterpart of Figure 3. D. A naive constant-sum effective-erasure heuristic fails Setup. We illustrate the operational content of Proposition 2 by ruling out the simplest one-scalar candidate: the additive sum ε V + ε C + (1− η). Fix the (3, 6)-XOR ensemble with ε V = 0.40 (just below the noiseless threshold ≈ 0.4294). Fix a side budget B side = ε C + (1− η) = 0.10. Sweep the split t∈ [0, 1] between verifier and channel: ε C (t) = t· B side , 1− η(t) = (1− t)· B side . Every allocation has the same naive effective-erasure sum ε V +ε C + (1−η) = 0.50; if the three tiers were collapsible into the additive scalar, the residual P (L) DE (λ(t)) would be flat in t. Result. Figure 7 shows that the residual varies from 0.332 at t = 0 (heavy channel loss; ε C = 0, 1− η = 0.10) to 0.146 at t = 1 (heavy verifier erasure; ε C = 0.10, η = 1): a 2.3× ratio under the same additive sum. The sweep therefore numerically rejects the additive effective-erasure scalar. This is consistent with the rank-≥ 2 content of Proposition 2 but is not a formal numerical proof of the rank statement: the proposition forbids any smooth scalar reduction, not only the additive one. A direct check would evaluate the parameter Jacobian D par [Φ λ (0)] and confirm that it has rank at least two on this single-role slice (left to follow-on work); the stronger rank-≥ 3 separation of the three tiers is established on a multi-role ensemble in Proposition 3. Operational reading along this path. The sweep also shows that, along this constant-sum path in the (3, 6)- XOR ensemble, channel loss is more damaging than verifier erasure. Under a cost model in which the two improvements have comparable marginal cost, this suggests improving the channel as the better local interven- tion. A true KKT shadow-price conclusion requires the full optimization problem of Theorem 6 with explicit cost functions and active constraints; the constant-sum sweep is an exploration along one specific path, not a substitute for that calculation. 42 00.10.20.30.40.50.60.70.80.91 0.1 0.15 0.2 0.25 0.3 0.35 Allocation parameter t (0 = heavy 1−η; 1 = heavy ε C ) Residual P ( L ) DE Fig. 7. XOR residual P (L) DE on a constant-additive-sum surface: ε V = 0.40 fixed, side budget ε C +(1−η) = 0.10 split as ε C = t·0.10 and 1−η = (1−t)·0.10. (d v ,d c ) = (3, 6), L = 50. Residuals range over [0.146, 0.332] along the same additive sum. The two design points at the endpoints have the same additive effective-erasure score but different residual erasure: the DE map is sensitive to where erasures enter the message flow. A flat curve would be required if the three tiers collapsed into the additive effective-erasure scalar; the observed monotone variation numerically rules out that particular scalar. The figure illustrates the phenomenon and rules out the additive scalar; a direct rank check of the parameter Jacobian would test the full rank-≥ 2 content of Proposition 2; the stronger rank-≥ 3 separation holds on a multi-role ensemble (Proposition 3). XIII. Applications We trace the framework through five representative deployed agent systems. Each can be seen as a calibration pilot for a future companion paper. Scope. The mappings below are architectural correspondences, not empirical validation: they illustrate how the variables, verifier nodes, and erasure tiers could be instantiated in existing agent-system families. Except in truly certifying layers (proof-kernel checks, deterministic validators), the mapping is an idealized abstraction and should be used only after calibration and model-checking of the exact-or-erased assumption (Section XI). We do not claim that the present theory causally explains any one benchmark result: deployed systems mix verifier-driven certifying behavior with prompt-context effects, aggregation effects, and confidently-wrong outputs not covered by the erasure-only first-order theory. What the framework does is identify the graph-level mechanisms that can support reliable recovery when tasks decompose into coupled subclaims and local verifiers, and the operationally observable quantities that calibrate the three erasure tiers. A deployed system need not run logical forcing for these limits to apply: because logical forcing is the best sound local rule (Theorem 7), a system that certifies soundly can only match or fall short of the reliability the theory predicts. A. Multi-agent formal theorem proving (Hilbert) Hilbert [1] reaches 99.2% on miniF2F via a verifier-centered workflow orchestrating an informal-reasoning LLM, a prover LLM, a Lean verifier, and a theorem retriever, with recursive subgoal decomposition and verifier feedback. The framework abstracts this by mapping proof obligations to variable nodes, Lean kernel calls to AND-monotone check nodes (the kernel accepts iff every step in its scope type-checks together), and formatting or retrieval failures to channel- or verifier-side erasures. Table V and Figure 8 give the role mapping; both are an idealized factor-graph abstraction, not a faithful rendering of Hilbert’s control flow. Candidate calibration: ε V proposer from per-step abstention rates, ε C verifier from Lean-kernel timeout and dependency-failure rates, η proposer,verifier from refactor success rates. One workflow round corresponds to one extrinsic message- passing iteration, and the round budget T of Theorem 1 is the depth at which the verifier-feedback loop is truncated. B. Multi-agent code generation (CodeR, SWE-bench) CodeR [2] reaches 28.33% on SWE-bench-lite via a multi-agent task graph in which generators write code, test runners execute unit tests, and patch aggregators combine fragments. Test-runner verdicts are AND- 43 TABLE V Mapping the Hilbert architecture [1] onto the role-typed Boolean-verifier-node framework of this paper. Each row of the right column identifies the operational quantity to estimate from agent traces. Hilbert roleMaps toOperational meaning Decomposer / proposerVariable agents v i of role “proposer” Drafts a candidate proof step. Subclaim X ∗ i = “does this step type-check?” Abstention A i =U rate is ε V proposer . RefactorerReasoning-channel transformation Reformulates a proposer-to-verifier message so the verifier can use it (notation, lemma inlin- ing). Failed refactor is an η proposer,verifier event. Type-checker (Lean kernel)Check agents a j of role “verifier”Runs the Lean kernel on a small group of pro- posed steps; constraint C a = X i 1 ∧ · ∧ X i d (AND-monotone). Timeout / dependency fail- ure is the ε C verifier event. AggregatorFinal estimatorTakes terminal incoming messages at each variable and emits the per-step verdict (the variable-by-variable estimator of Equation (18)). Decomposer (proposer) Refactorer (channel) Type-checker (Lean kernel) Aggregator (estimator) ε V prop η prop,ver ε C ver , AND factor variable-wise MAP Underlying factor graph: v 1 v 2 v 3 v 4 a 1 a 2 variable agents = proposed steps, private observation A i ; check agents = Lean kernel calls, AND template C a = V i∈∂a X i ; check observation Z a . Fig. 8. The Hilbert architecture [1] mapped onto the role-typed Boolean-verifier-node framework. Top: the four cooperating LLM roles, decomposer, refactorer, type-checker, aggregator, each annotated with the erasure-tier parameter it controls. Bottom: the underlying bipartite factor graph that the framework analyzes. Variable agents are proposed proof steps; check agents are Lean kernel invocations performing AND-monotone joint type-checks of step groups. Refactor failures between a proposer’s output format and a verifier’s expected input format appear as reasoning-channel erasures 1− η prop,ver . monotone Boolean factors at the file/test-suite layer (the suite passes iff every test passes). Here X ∗ i should be defined as “artifact i satisfies local validator v” (a test outcome, type-check, or static-analysis pass), not “artifact i is semantically correct,” which a finite test suite does not certify; the theory thus models recoverability of local-validator outcomes, and full semantic correctness would need a test suite complete for the claimed property. SWE-bench [13], SWE-agent [14], CLEVER [15], and FVAPPS [16] admit the same reading. Design questions such as “add more test runners or more code generators?” map onto Theorem 6 (d)– (e), and one CodeR cycle is one extrinsic DE iteration. C. Massive decomposition with cross-verification (MAKER) The MAKER framework [17] executes a one-million-step LLM task with zero observed errors by combining maximal decomposition of the task into single-step subtasks with a first-to-ahead-by-K voting rule on each subtask. The deployment is a coupled-subclaim instantiation at scale: decomposition lifts a depth that would be catastrophic for an autoregressive single agent into a regime where the depth-L density-evolution recursion 44 of Theorem 1 contracts to a near-zero error floor. Per-subtask voting supplies a cross-verification structure of the kind Theorem 4 formalizes for separating augmentations. The match is structural rather than mechanism- level (MAKER’s voting is stochastic redundancy, not deterministic Boolean forcing), but it indicates that the systems-engineering community has arrived independently at the architectural principle the framework predicts. D. LLM debate on structured-output benchmarks Debate systems [3], [18], [19] alternate critiques between agents. General LLM debate is not covered by the erasure-only model, since debate messages are soft, persuasive, and sometimes confidently wrong; it would need the soft-belief or likelihood-ratio extension of Section XIV-B. The framework applies as-is only to the narrow case of structured-output debate where each round produces a deterministic local-validator outcome (a parse check or constraint test) attached to a Boolean factor, in which case each round is one extrinsic iteration. The Choi–Zhu–Li martingale analysis [20] is complementary: it studies belief dynamics under soft exchange, whereas we study sound local certification. E. Multi-modality classification by sensor and drone networks Sensor and drone networks motivate a non-erasure extension. General sensor classification involves soft observations, correlated noise, false positives and negatives, and continuous measurements, none of which are sound non-erased certificates. A Boolean-erasure approximation fits only when sensors produce abstaining local certificates (validated detections or no-detection outputs after a calibrated thresholding layer with deterministic consistency rules between overlapping views); soft-classification and correlated-noise regimes belong to the extensions of Section XIV. Under such a thresholded-certificate calibration, role-typed reliabilities correspond to per-platform sensing modalities and compute budgets and η to inter-platform communication loss, and the adjoint machinery of Theorem 6 could compare adding platforms with improving links. Without that calibration step the present theorems should not be applied to soft-classification settings. XIV. Outlook A. Limitations of the present model The framework developed here is intentionally an erasure-only, first-order reliability layer. It does not model confidently wrong messages (these would require the absorbing-set / BSC machinery sketched below), correlated agent failures induced by shared training data or shared inputs, adaptive graph construction in which the protocol observes intermediate outcomes and reroutes work to different roles, long-range memory or belief accumulation across rounds beyond the once-at-t = 0 erasure model, semantic drift across iterations of an agent collective, or compounding prompt-context failures specific to LLM-style verifiers. These omissions are not defects of the framework; they identify the boundaries of what the first-order theory is responsible for and the next layers of analysis (continuous-message DE, value-conditioned absorbing sets, adaptive-routing converses, dependence-aware ensembles). The companion calibration claims in Section XI should be read in this light: the parameters ε V r ,ε C s ,η r,s correspond to operationally observable failure modes and can be estimated from logs as first-order signals, but the estimates themselves may be biased by task difficulty (failure rates correlate with input distribution) or by correlated failures (shared training data or shared inputs violate the conditional-independence assumption underlying the configuration ensemble). The protocol is a starting point for empirical instantiation, not a complete description of every reason an agent system might be unreliable. B. Non-erasure channels: BSC absorbing sets and hybrid models The erasure model is natural for abstention, timeout, dependency failure, and unusable artifact, all empiri- cally observable failure modes. Real systems also produce confident wrong messages. The hybrid erasure-and- flip extension introduces flip components δ V r ,δ C s ,ζ r,s alongside the erasure tiers, with P(A i =X ∗ i ) = 1− ε V r − δ V r , P(A i =1− X ∗ i ) = δ V r , P(A i = U) = ε V r , 45 and analogous decompositions on the verifier and channel sides. Once flips are admitted, A i ̸= U no longer implies A i = X ∗ i and Z a ̸= ∗ no longer implies Z a = f θ (X ∗ ∂a ), so the soundness lemma (Lemma 1), the certificate-stopping-set theorem (Theorem 3), the separating-augmentation theorem (Theorem 4), and the local-soundness converse (Theorem 7) do not apply in their present form. The DE state must track a full distribution over correct, incorrect, and erased messages, not only erasure probabilities; the finite- length obstruction combines stopping-set, absorbing-set [26], and trapping-set / pseudocodeword phenomena, and is not a direct import of any one of these. These extensions are companion-paper material rather than straightforward specializations of the present theory. C. Belief memory and dependence relaxation The current framework injects all noise once at t = 0. A natural extension introduces per-round noise injec- tion with a role-specific exponential moving-average update on a continuous belief state: b (t) v = (1−α r v )b (t−1) v + α r v e ξ (t) v , with α r v ∈ (0, 1] as a temporal-smoothing / test-time-compute parameter (it is not a fourth reliability tier alongside ε V ,ε C ,η, but a separate axis governing how evidence accumulates across rounds). This matches LLM self-consistency aggregation [31] and is the natural setting for relaxing the conditional-independence assumption on agent failures. The DE recursion would replace scalar erasure probabilities by probability laws on the simplex ∆ K−1 , i.e. by a continuous-state distributional recursion L(b (t) v | X ∗ v ,ρ(v) = r). Tractability may be retained under quantization, parametric closure, or independence/latent-variable assumptions, but correlated agent failures induced by shared training data, shared inputs, or persistent belief states require new DE state variables or a dependence-aware ensemble; tractability is not automatic. D. Richer Boolean-factor classes The abstract value-conditioned DE recursion (Theorem 1) and the abstract certificate-stopping-set theorem (Theorem 3) already apply to every bounded-arity Boolean template through the forcing operator Γ θ,j . What remains for OR, Horn, implication, and other monotone or non-monotone primitives is to derive compact closed-form forcing probabilities and interpretable finite-length obstruction criteria analogous to Corollary 3 and Corollary 4; the abstract framework is in place, but the explicit corollaries that translate the generic statements into reader-friendly criteria for each primitive are future work. Mixed-template ensembles (some checks XOR, some AND, some Horn) are handled by the value-conditioned framework with no further conceptual machinery. E. Density evolution on deterministic locally-tree-like graphs Theorem 1 concentrates the empirical bit-erasure rate on the random configuration-model ensemble, via a Doob martingale over the matching. The same bit-erasure DE prediction holds on a deterministic graph sequence, with no appeal to graph randomness, once the local neighborhood statistics are controlled: at iteration L a node’s estimate depends on its depth-(2L+2) neighborhood, so the marginal role-degree law alone does not suffice; what is needed is convergence of the full local-neighborhood law. Theorem 8 (Deterministic-graph density-evolution concentration). Let G n n≥1 be a deterministic sequence of role-typed bipartite factor graphs, with variable degrees and check arities uniformly bounded by D max , carrying role and template marks (ρ,θ). Draw the hidden values, the variable-side and verifier-side erasure indicators, and the persistent reasoning-channel gates mutually independently, with laws fixed by the node role, the check role and template, and the directed role pair (the priors β r of (10) and the erasure parameters ε V r ,ε C s θ ,η r,s ), all independently ofG n ; the observations A i and Z a are then the derived quantities of (11) and (13). Suppose that for every fixed L∈ N: (a) Marginal role-degree typicality: the empirical role-degree distribution of G n converges to the pre- scribed limit Λ; (b) Vanishing local-cycle density: the fraction of variable nodes whose depth-(2L+2) neighborhood con- tains a cycle vanishes as n→∞; (c) Marked Benjamini–Schramm convergence: the empirical law of the rooted, socket-type-marked depth-(2L+2) neighborhood of a uniformly chosen variable node, each check half-edge carrying its socket 46 type τ = (θ,j) so that the ports of asymmetric templates are resolved, converges weakly to the law of the corresponding ball of the socket-type-marked unimodular Galton–Watson computation tree whose root and offspring degree, role, and socket-type marks match the laws π V r ,π C θ , Λ of the DE recursion of Theorem 1. Then for every fixed L the empirical bit-erasure rate P (L) bit (G n ) converges in probability to P (L) DE . Quantitatively, with b det n : = EP (L) bit (G n )− P (L) DE → 0, there is a constant a L > 0 depending only on L and D max such that for every t > 0 and every n, P P (L) bit (G n )− P (L) DE > b det n + t ≤ 2 exp(−a L nt 2 ).(69) Discussion. Hypotheses (a)–(c) are the socket-type-marked Benjamini–Schramm convergence of G n to the socket-type-marked unimodular Galton–Watson computation tree [41], [42]; under bounded degree (c) is the operative condition and implies (a) (its degree marginal) and (b) (a tree-supported limit forces vanishing cyclic mass), which we list separately for readability. Because the hidden values are drawn from the priors independently of G n , the value-conditioning of the non-XOR recursion is automatic and no value mark is needed in (c); the XOR specialization (Corollary 1) is value-symmetric in any case. The proof (Appendix B-D) has two parts: a bounded-differences concentration of P (L) bit around its mean on the fixed graph (no matching exposure is needed, since the graph is not random), and a bias estimate b det n → 0 that holds because bounded degree makes the depth-(2L+2) socket-type-marked balls range over a finite set, on which (c) is atom-wise convergence and the per-root unresolved probability is a bounded function whose Galton–Watson average is exactly P (L) DE (Appendix B-B). Like Theorem 1, the bound is centered at P (L) DE only up to the deterministic offset b det n , which inherits the (here unspecified) rate of (a)–(c); a quantitative neighborhood-law rate would make it explicit. The theorem concentrates the global bit-erasure rate P (L) bit ; the per-socket value-conditioned message rates b p (b) L,τ of (32) concentrate by the identical argument applied to a uniformly chosen directed socket of type τ at radius 2L+1, which we do not spell out. Biregular bipartite graphs realize the role-typed degree structure of (a), and biregular families of large girth additionally satisfy the locally-tree-like hypotheses (b)–(c). Large girth is what (b)–(c) require, and it is distinct from the spectral-expansion (Ramanujan) property [43], which a biregular family may have without large girth. Because the hidden values are drawn from the priors, no value-typicality of the graph is required. Explicit constructions for irregular role-typed degree laws are open. Theorem 8 complements the random-ensemble DE concentration of the multi-edge-type LDPC [5] and noisy-message-passing [11], [12] literatures, connecting the framework to deterministic local-weak limits, and it applies to deployed systems whose task graph is fixed. Theorem 2, Theorem 3, and Theorem 4 are proved per-graph and apply directly to graphs in class (a)–(c); the architecture-optimization theorem (Theorem 6) optimizes over distributional designs and remains a separate question. F. Fano-cut-set converse against unbounded-alphabet local protocols Theorem 7 is a local-soundness converse: it bounds, via the sound Bayes-optimal (support) estimator on the depth-2T computation tree, the asymptotic per-variable terminal abstention rate of any T-round sound local protocol on the role-typed configuration ensemble in the erasure model. We pose the following open problem: under a per-edge alphabet bound |Y| ≤ Y on local messages, in the joint limit T → ∞, Y → ∞, does an information-theoretic lower bound match the threshold surface of Theorem 2 (b)? The natural starting point is a role-pair-capacity cut-set bound [44] on the transcript mutual information of the form I X ∗ ; transcript T A i ,Z a ≤ X (r,s) N r,s T C r,s (Y ), where N r,s counts role-r-to-role-s directed edges and C r,s (Y ) is the per-edge capacity of the persistent erasure channel η r,s at alphabet bound Y (private variable and verifier observations are conditioned out as side information), combined with Fano’s inequality [45] on the per-variable estimator. Whether such a role-typed cut-set bound matches the spectral-radius threshold ρ(DΦ λ (0)) in the joint T,Y →∞ limit is open; matching a global mutual-information cut-set bound to a local BP-stability condition is not automatic, and in general may hold only under additional symmetry, regularity, or optimality assumptions on the ensemble. Repeated 47 transmission over persistent open edges, correlations introduced by the matching, and the order of limits in n,T,Y are technical complications that a future analysis must address. The expected-posterior-divergence / conditional-mutual-information characterization for delegated multi-agent DAGs in [37] is a natural reference point for the information-theoretic side of this problem. XV. Conclusion This paper developed a density-evolution and finite-length reliability theory for the certifying layer of sparse agent networks. The central modeling step was to replace a single hidden answer with a vector of coupled binary subclaims and to represent local verification by role-typed Boolean verifier nodes. Each component carries out a distinct information-theoretic operation: variable agents acquire partial evidence about the hidden subclaim vector, verifier nodes process local constraints, reasoning channels transmit certificates between roles, and the decoder combines the surviving evidence into a per-subclaim certification or a safe abstention. In this representation, variable-side abstention, verifier-side failure, and role-pair reasoning-channel loss are three structurally distinct erasure mechanisms, not one scalar noise level (Proposition 2). For bounded-degree role-typed configuration ensembles, the value-conditioned logical-forcing decoder admits a density-evolution recursion with fixed-round concentration (Theorem 1). The XOR specialization recov- ers the LDPC-BEC baseline. For non-linear factors such as AND, the value-conditioned recursion reveals positive-versus-negative certificate asymmetries absent from parity-only models. At finite length, failures are characterized by certificate-stopping sets (Theorem 3), which gives a direct route to separating augmentation (Theorem 4) and to cost-constrained architecture optimization with adjoint sensitivities and KKT shadow prices (Theorem 6, Remark 16). Within fixed-round sound local protocols on the observable channel-gated computation tree, the local-soundness converse (Theorem 7) identifies logical forcing as the asymptotically optimal certifying local rule. The bounded-difference concentration step and the adjoint/KKT framework are channel-agnostic; this paper specializes them to the certifying-layer logical-forcing recursion. Numerical exper- iments (Figure 3, Section XII-B, Section XII-D) illustrate the finite-n concentration predicted by Theorem 1 and the value-conditioned and three-tier asymmetries predicted by Proposition 1 and Proposition 2. The theory is intentionally first-order. Non-erased certificates are assumed sound, and missing or unus- able evidence is modeled as erasure. Confidently wrong messages, correlated agent failures, adaptive graph construction, and soft belief exchange lie outside the present erasure theory. Natural follow-on directions include hybrid erasure-and-flip DE with absorbing-set obstructions (Section XIV-B), deterministic-graph DE under marked Benjamini–Schramm convergence (Section XIV-E), dependence-aware ensembles for correlated agent failures, finite-compute constraints, richer Boolean-template analyses (OR, Horn, implication, mixed templates), empirical calibration on formal-proof and verified-code benchmarks, and stronger information- theoretic converses including the open Fano-cut-set problem of Section XIV-F. These directions preserve the central viewpoint: certifying agent networks are sparse systems of noisy local verification whose reliability can be studied by the same asymptotic and finite-length tools that made sparse graphical codes analyzable, provided the model assumptions are made explicit and empirically checked. Appendix A A Useful Monotonicity Fact The proofs above repeatedly use a monotonicity property of the logical-forcing operator. Lemma 3 (Monotonicity of feasible sets). Fix a template θ, target socket j, and verifier output z ∈0, 1. If M k ⊆ M ′ k for all k ̸= j, then Γ θ,j (z; M −j )⊆ Γ θ,j (z; M ′ −j ).(70) Moreover, under the sound-transcript condition that z = f θ (X ∗ ∂a ) and X ∗ k ∈ M k for every k ̸= j, if Γ θ,j (z; M −j ) = U, then Γ θ,j (z; M ′ −j ) = U for every enlargement M −j ⊆ M ′ −j . In particular, on sound message configurations, replacing singleton incoming messages by unresolved messages cannot create a new singleton certificate. Proof. The feasible set Γ θ,j is defined by existential quantification over the Cartesian product of the incoming candidate sets in (15). Enlarging any candidate set only enlarges the product over which the existential ranges, so the feasible set can only grow, giving (70). Without further hypotheses, an enlargement may move Γ from 48 ∅ to a singleton (when the original input configuration was inconsistent); the second clause therefore requires the sound-transcript invariant. Under that invariant, X ∗ j ∈ Γ(z;M −j ) at every input (the true assignment is always feasible by definition of z), so Γ ∈ X ∗ j , U at every input. Enlargement preserves U as the largest set in 0, 1, completing the proof. Appendix B Detailed Proof of Theorem 1 This appendix gives the full proof of Theorem 1 in three steps. Appendix B-A shows that the directed depth-2L+1 neighborhood of a uniformly chosen socket converges in total variation to the corresponding typed Galton-Watson tree. Appendix B-B identifies the message distribution at the root of the typed tree with the value-conditioned recursion of (24)–(28). Appendix B-C applies McDiarmid’s bounded-differences inequality to obtain the exponential concentration bound (34). Radius convention. The proof distinguishes two neighborhood radii: the directed edge-message V (L) i→a is a function of the depth-R edge (L) = 2L + 1 directed neighborhood rooted at the edge, while the terminal node estimate c M (L) i = A i ∩ T a∈∂i e C (L) a→i is a function of the depth-R node (L) = 2L+2 rooted variable neighborhood (one extra hop is needed to read all incoming check messages at the final round). Per-socket message convergence uses R edge (L); the empirical bit-erasure rate P (L) bit uses R node (L). All bounded-difference constants below scale with the relevant radius. A. Computation neighborhoods and tree convergence Fix L∈ N and a socket type τ ∈ T. The directed depth-2L+1 neighborhood of an edge (i,a) is the subgraph spanned by all directed paths of length at most 2L+1 starting at (i,a) and alternating between variable and check nodes. Because all degrees are bounded by D max and the template arities are bounded by the same D max (without loss of generality, by taking the larger of the two), the number of nodes in such a neighborhood is at most N L : = 2 2L+1 X r=0 D r max ≤ 4D 2L+1 max ,(71) and the neighborhood is independent of n. Lemma 4 (Typed tree convergence, quantitative form). Let N τ 2L+1 (G n ) denote the directed depth-2L+1 neighborhood of a uniformly chosen socket of type τ in the role-typed configuration ensemble of Section IV-E, and let f N τ 2L+1 denote the corresponding typed Galton-Watson tree truncated at depth 2L+1 under the limiting typed degree/socket law π ∞ . For each fixed L, d TV L N τ 2L+1 (G n ) , L f N τ 2L+1 ≤ C L n + ∆ n,L ,(72) where C L = c 0 N 2 L for an absolute constant c 0 depending only on the role and template structure (not on n), and the empirical-law discrepancy ∆ n,L : = d TV L f N τ 2L+1 ; π n , L f N τ 2L+1 ; π ∞ (73) captures the difference between the typed Galton-Watson tree built from the finite-n empirical typed degree/socket law π n (realized by the configuration model after the O( √ n)-rounded socket-balance step) and the same tree built from the limiting law π ∞ . When the finite-n ensemble construction enforces deterministic socket-balance up to O(1) counts, ∆ n,L = O(1/ √ n)· poly(N L ); in the standard O( √ n)-rounded construction, ∆ n,L = O(1/ √ n)· poly(N L ) holds under any standard π n → π ∞ rate, and ∆ n,L → 0 as n→∞ for any consistent estimator π n . Proof. We assume positive limiting socket-type mass: m τ : = lim n n −1 #sockets of type τ > 0 for every socket type τ ∈ T that appears in the DE state, with m min : = min τ m τ > 0. The TV bound (72) decomposes by triangle inequality into two contributions: d TV L N τ 2L+1 (G n ) , L f N τ 2L+1 ;π ∞ ≤ d TV L N τ 2L+1 (G n ) , L f N τ 2L+1 ;π n | z collision error: ≤C L /n +∆ n,L |z empirical-law error . 49 Collision error (C L /n). We construct a coupling between the configuration-model neighborhood and the typed Galton-Watson neighborhood built from π n , which fails to be valid only when, while exploring the depth-2L+1 neighborhood breadth-first, the configuration model proposes a socket pairing already used in the partial exploration. Each new pairing is chosen uniformly from the remaining unpaired sockets of the matching type; the number of remaining same-type sockets is Θ(m τ n) ≥ Θ(m min n) and the number of already-explored sockets is at most N L . The probability that the next pairing collides with the partial exploration is therefore at most N L /Θ(m min n). Union-bounding over the N L pairings constructed during the breadth-first exploration gives the collision-error bound C L /n with c 0 depending only on m −1 min and the absolute constants hidden in the Θ(·). Empirical-law error (∆ n,L ). The Galton-Watson tree under π n uses finite-n empirical socket-type proportions and degree distributions; the tree under π ∞ uses the limiting proportions. By a standard typed-tree TV stability argument (the tree law is a continuous function of the degree law in the TV topology on truncated neighborhoods), ∆ n,L is bounded by the TV distance d TV (π n ,π ∞ ) times a polynomial factor in N L . Under the standard O( √ n)-rounded socket-balance construction d TV (π n ,π ∞ ) = O(1/ √ n), so ∆ n,L = O(poly(N L )/ √ n). Combining the two terms yields (72). Corollary 7 (Variable-rooted typed tree convergence). Fix a role r ∈ R V and a depth R ≥ 1. Let N r R (G n ) denote the depth-R rooted variable neighborhood of a uniformly chosen variable of role r in the role-typed configuration ensemble of Section IV-E, and let f N r R denote the typed Galton-Watson tree truncated at depth R with root offspring law the full node degree law D (r),node at the root and the size-biased excess-degree laws at all subsequent levels. Then d TV L N r R (G n ) , L f N r R ≤ C R n + ∆ n,R ,(74) with the same collision constant C R (up to a factor bounded by the maximum role-r variable degree) and the same empirical-law term ∆ n,R as in Lemma 4; in particular ∆ n,R = 0 under the deterministic socket-balance construction, in which case the rate is the sharper C R /n. Proof. A uniformly chosen role-r variable has the unbiased node-degree law D (r),node ; this is why the root offspring law differs from the size-biased excess-degree law at deeper levels, which arises from following a uniformly chosen socket rather than a uniformly chosen node. Conditional on the root degree d ≤ D max and its incident socket types, the depth-R variable-rooted neighborhood is the union of d socket-rooted depth- (R−1) neighborhoods. Applying Lemma 4 to each and a union bound over the d socket explorations gives joint TV distance at most D max · C R−1 /n + ∆ n,R−1 ; the collision term absorbs into C R /n, and the empirical-law term absorbs into ∆ n,R (it is the same π n → π ∞ degree-law discrepancy as in Lemma 4, up to a polynomial factor in the root degree). B. The recursion on the typed tree We compute the message-erasure probability at the root of the typed Galton-Watson tree given the root’s hidden value, and verify that the result matches (24)–(28). Let the root be a socket of type τ = (θ,j) attached to a variable i of role r = r(τ ) with hidden value X i = b. The tree has L alternating layers; we compute by induction on L. Base case L = 0. At iteration 0 no messages have been exchanged; the only message available at the root is V (0) i→a = A i , which equals U with probability ε V r by (11). Hence p (b) 0,τ = ε V r , matching (28). Inductive step. Assume that after ℓ rounds, every socket type τ ′ ∈ T and value b ′ ∈0, 1 satisfy (22) with the value p (b ′ ) ℓ,τ ′ given by the recursion. Consider iteration ℓ + 1. The variable i at the root of the tree sends V (ℓ+1) i→a along socket j to its parent check a of template θ. By (17), V (ℓ+1) i→a = A i ∩ \ c∈∂i\a e C (ℓ) c→i . Conditional on X i = b, the soundness lemma (Lemma 1) implies each incoming message lies in b, U, so the intersection equals b as soon as any one of A i ∪ e C (ℓ) c→i : c∈ ∂i\a is the singleton b, and equals 50 U otherwise. Equivalently, V (ℓ+1) i→a = U ⇐⇒ A i = U and every extrinsic inbound check message is U. On the typed tree, A i and the children c of i are conditionally independent given the role types and incoming socket type, so the product factors over excess-degree socket types τ ′ : PV (ℓ+1) i→a = U| X i = b = ε V r E Y τ ′ ∈T r h (b) ℓ,τ ′ D (r),τ,ex τ ′ ,(75) which is (27). The complementary singleton probability is PV (ℓ+1) i→a =b| X i = b = 1− (75). It remains to verify the form of h (b) ℓ,τ ′ . Fix one of the root’s incident excess-degree sockets τ ′ = (θ ′ ,k)∈ T r , which connects the root variable i to a descendant check a ′ of template θ ′ at socket k; since i has role r, the socket role is r(τ ′ ) = r. By (16), the inbound message e C (ℓ) a ′ →i equals U unless (i) the verifier observation Z a ′ is not erased, (i) the return channel a ′ → i delivers, and (i) the forcing operator Γ θ ′ ,k at the target socket k outputs the singleton at value b. Independence on the tree gives the product form (1−ε C s θ ′ )·η s θ ′ ,r for (i)–(i). For (i), conditional on the root value X i = b and on independent draws of the descendant true values from the role priors β, the inbound messages from the other sockets k ′ ̸= k of a ′ are singletons or U according to (24). The probability that the operator outputs the singleton at the target value b is exactly the forcing probability φ (b) ℓ,θ ′ ,k of (25). Composing, P e C (ℓ) a ′ →i = U| X i = b = 1− (1− ε C s θ ′ )η s θ ′ ,r φ (b) ℓ,θ ′ ,k , which is (26). This closes the induction. By Lemma 4, the message at the root of N τ 2L+1 (G n ) has total-variation distance at most C L /n from the message at the root of f N τ 2L+1 , so E 1V (L) = U,X = b −→ n→∞ P(X = b)p (b) L,τ ,(76) which is the convergence of expectations promised by Theorem 1. C. Bounded-differences concentration via sequential exposure Why this argument needs care. The role-typed configuration model is the uniform measure on a finite set of socket matchings, together with independent draws of all observation and channel variables. The observation and channel variables are mutually independent and admit a direct McDiarmid bound, but the socket-pairing matching Π is not a tuple of independent coordinates: its |sockets| 2 pair indicators are strongly correlated. We therefore expose Π sequentially through a Doob martingale, a standard device for permutation- and matching- valued random objects [39], and use McDiarmid for the remaining independent ingredients. Random ingredients. Index the random ingredients of one realization in canonical order. Let S be the set of all sockets (variable-side and check-side); fix a canonical enumeration s 1 ,s 2 ,...,s |S| that proceeds, say, lexicographically. We expose the matching Π as a sequence of pair revelations E 1 ,E 2 ,...,E |S|/2 ,(77) where E t = (s i t ,π(s i t )) is the partner of the smallest not-yet-matched socket s i t at step t (chosen uniformly among the remaining unmatched sockets). After the matching is exposed, we expose the independent ingredient block: • the hidden values X ∗ i for i∈V n (M X = n independent draws under the role prior β); • the variable-side erasure indicators 1A i = U (M A = n Bernoulli draws with parameter ε V r i ); • the verifier-side erasure indicators 1Z a =∗ for a∈C n (M Z = αn Bernoulli draws with parameter ε C s a ); • the channel-erasure indicators 1 f M = U | M = b for each directed edge (M η = Θ(nD max ) Bernoulli draws with parameters 1− η r,s ). 51 Doob martingale on the matching. Let f (G n ) = P (L) bit (G n ) denote the empirical bit-erasure rate after L rounds. Define the Doob martingale Z t : = E h f E 1 ,...,E t , X ∗ , 1A i = U i , 1Z a =∗ a , channel indicators i ,(78) filtered by the matching-exposure and ingredient σ-algebras in canonical order. The conditioning is on the independent primitive ingredients only, namely the hidden values, the variable- and verifier-side erasure indicators, and the channel-erasure indicators. The observations A i and Z a themselves are not conditioned on as free coordinates: they are derived from these primitives together with the matching (Z a = f θ (X ∗ ∂a ) when its erasure indicator does not fire, and A i ∈ X ∗ i , U according to its variable-side indicator), so exposing the matching updates them automatically and consistently. We show below that the martingale increment |Z t − Z t−1 | is bounded by a constant e ∆ L independent of the realization. Lemma 5 (Type-preserving single-pair switching coupling). Fix a step t ∈ 1,...,|S|/2 in the matching- exposure sequence (77). Let Π, Π ′ be two configuration-model perfect matchings agreeing on E 1 ,...,E t−1 and differing at E t only in the partner of s i t . Then there exists a coupling between Π and Π ′ under which the completed matchings differ by exactly two paired edges: Π = Π ′ 0 ∪(s i t ,u), (s ′ ,v),Π ′ = Π ′ 0 ∪(s i t ,v), (s ′ ,u), for some sockets u,v of the matching type required by s i t , some socket s ′ outside s i t ,u,v, and a common matching Π ′ 0 on the remaining sockets. In particular, Π and Π ′ are related by a single type-preserving 2-edge switch. Proof. The configuration-model perfect matching is the uniform measure on type-compatible perfect matchings of S. Conditional on E 1 ,...,E t−1 , the remaining matching is uniform over type-compatible perfect matchings of the unexposed sockets. Let u and v be the round-t partners of s i t under Π and Π ′ respectively, and let s ′ be the round-(> t) partner of v under Π (which is the partner of u under Π ′ by exchange). Type- compatibility of Π at the (s i t ,u) pair forces u to have the type required by s i t ; similarly for v. The 2-edge switch (s i t ,u), (s ′ ,v)↔ (s i t ,v), (s ′ ,u) exchanges Π and Π ′ on these two pairs while preserving all other pairs and all socket-type counts. This is the standard switching lemma for configuration-model matchings. Lemma 6 (Local-statistic Lipschitz constant under switching). Let h : G R → [0,B] be a bounded depth-R rooted-variable local statistic, and let g(G n ) : = n −1 P i∈V n h N r i R (G n ,i) be its empirical mean. Define C(D max ,R) : = 4· 2D R max = 8D R max ,(79) the maximum number of variables within graph distance R of any fixed set of four sockets in a graph with maximum degree D max . Then: (i) Under a type-preserving 2-edge switch (Lemma 5) the empirical mean satisfies |g(G n )− g(G ′ n )| ≤ B · C(D max ,R)/n. (i) Replacing a single hidden value X ∗ j , variable-side erasure indicator 1A j = U, verifier-side erasure indicator 1Z a =∗, or channel-erasure indicator changes g by at most B· C(D max ,R + 1)/n, where the (R + 1)-radius accounts for the propagation of a X ∗ j change through the true verifier values T a = f θ (X ∗ ∂a ) at adjacent checks. Proof. (i) The 2-edge switch alters G n only on the two pairs (s i t ,u) and (s ′ ,v), whose endpoints lie at four sockets incident to at most four variables. A variable i’s depth-R rooted neighborhood includes the swapped edges only if i is within graph distance R of one of these four sockets; the maximum such count is C(D max ,R) by the bounded-degree volume bound. For variables i outside this set, h(N r i R (G n ,i)) = h(N r i R (G ′ n ,i)). Summing over the at-most C(D max ,R) affected variables and dividing by n gives the bound. (i) A variable-side erasure-indicator, verifier-side erasure-indicator, or channel-indicator change affects g only through variables i whose depth-R neighborhood contains the changed ingredient; the bound follows as in (i) at depth R. An X ∗ j change additionally flips the verifier truth T a = f θ (X ∗ ∂a ) at each adjacent non-erased check a, and these T a -changes propagate through the depth-R neighborhoods of variables one hop further out from j. This enlarges the radius from R to R + 1 and yields the C(D max ,R + 1) bound. 52 Lemma 7 (Bounded martingale increment). Let e ∆ L : = C(D max ,R node (L) + 1)/n = 8D 2L+3 max /n. For every matching-exposure step t in (77), the Doob martingale Z t defined in (78) satisfies |Z t − Z t−1 | ≤ e ∆ L almost surely. For every independent observation, hidden-value, or channel ingredient W j , replacing W j while holding all others fixed changes f by at most e ∆ L in absolute value. Proof. The empirical bit-erasure rate f (G n ) = P (L) bit (G n ) = n −1 P i 1 c M (L) i = U is the empirical mean of a depth-R node (L) = 2L + 2 rooted-variable local statistic with B = 1. By Lemma 6(i), adjacent matching realizations differing by a single type-preserving 2-edge switch (which is the form of any two completions admissible in the Doob filtration at step t, by Lemma 5) yield |f (G n ) − f (G ′ n )| ≤ C(D max , 2L + 2)/n ≤ e ∆ L ; averaging over the swap-coupling gives |Z t − Z t−1 | ≤ e ∆ L almost surely. By Lemma 6(i), replacing any independent ingredient (including X ∗ j , with the T a -propagation effect) changes f by at most C(D max , 2L + 3)/n = e ∆ L . Proof of Theorem 1. By Lemma 7, Z t − Z t−1 is a bounded martingale increment for the matching-exposure block, and the independent observation and channel ingredients form a bounded-differences sequence with the same constant e ∆ L . Combining the Azuma–Hoeffding inequality on the matching martingale with McDiarmid’s bounded-differences inequality on the independent ingredients [39], P |f − Ef| > δ ≤ 2 exp − 2δ 2 N e ∆ 2 L ! , where N = |S|/2 + M X + M A + M Z + M η = O(nD max ) is the total number of exposure steps. Substituting e ∆ L = 8D 2L+3 max /n (Lemma 7), P |f − Ef| > δ ≤ 2 exp − 2δ 2 n 2 O(nD max )· 8D 2L+3 max 2 ! ≤ 2 exp − nδ 2 C D 4L+7 max ! for a positive constant C depending only on absolute constants in the O(·) above; this is the around-mean concentration with rate a L = 1/(C D 4L+7 max ), the displayed radius δ playing the role of t in (34). Combined with the bias bound |Ef − P (L) DE | ≤ b n,L (Lemma 4, which gives the limit (76)), the triangle inequality yields the offset tail (34) and convergence of f = P (L) bit (G n ) in probability to P (L) DE . The edge-message convergence statement is identical with the depth-2L+1 neighborhood and the excess- degree socket law in place of the node-degree law; Lemma 7 carries through with the same constant up to absorbed factors, and the Azuma–McDiarmid tail goes through unchanged. Standing assumptions used by Theorem 1. For the record, the precise standing assumptions of Theorem 1 are: (i) finite role and template sets (|R V |,|R C |,|Θ| <∞); (i) finite second moment of the role-typed degree distribution and a uniform-in-n degree bound D max <∞; (i) socket-balance equalities holding asymptotically with O( √ n) rounding fluctuations; (iv) hidden values drawn independently from a role-typed prior with β r ∈ (0, 1) under value-degree independence X ∗ i ⊥ D i | ρ(i) (or, equivalently, deterministic hidden vectors whose socket-conditional empirical value frequencies converge to β r ); (v) directed-edge erasure variables independent across edges and persistent in time, so that any per-round erasure is chosen at t = 0 and held thereafter (the alternative i.i.d.-per-round model is a separate setting and not analyzed here). D. Deterministic-graph concentration This appendix proves Theorem 8. Fix L, write R = 2L + 2, and let U i ∈0, 1 indicate that variable node i is unresolved after L rounds, so that P (L) bit (G n ) = 1 n P i U i summed over the n variable nodes. The graph G n is deterministic; the independent primitive random variables are the hidden values X ∗ i , the variable- side erasure indicators, the verifier-side erasure indicators, and the persistent channel gates B e , mutually independent (with role-, template-, and role-pair-dependent laws) and independent of G n . The observations A i of (11) and Z a of (13) are derived from the hidden values and these erasure indicators (e.g. Z a =∗ when 53 its erasure indicator fires and Z a = f θ (X ∗ ∂a ) otherwise), so they are not themselves among the independent ingredients. Part A: concentration around the mean. P (L) bit (G n ) is a function of the independent ingredients above (hidden values, variable- and verifier-side erasure indicators, and channel gates). Because U i depends only on the depth- R neighborhood of i and the ingredients inside it, changing one ingredient alters U i only for roots i whose depth-R neighborhood contains the changed item; the degree/arity bound D max caps the number of such roots by κ L = O(D R max ), independent of n. Bounded degrees and arities also make the numbers of variables, checks, and edges all Θ(n), so there are Θ(n) independent ingredients. Thus P (L) bit is a bounded-differences function with per-ingredient Lipschitz constant κ L /n, and McDiarmid’s inequality [39] gives a constant a L > 0 (depending only on L and D max ) with P P (L) bit (G n )− EP (L) bit (G n ) > t ≤ 2 exp(−a L nt 2 ), t > 0.(80) An equivalent local-dependence concentration argument [46], [47], using that each U i depends only on a bounded-radius neighborhood, yields the same tail. No matching exposure is needed: the graph is determin- istic, so the sequential-exposure martingale of Theorem 1 is replaced by direct bounded differences over the independent ingredients. Part B: the mean converges to P (L) DE . For a finite rooted socket-type-marked ball T of depth R, let ψ L (T )∈ [0, 1] be the probability that the root is unresolved after L rounds when message passing is run on T with hidden values and erasures drawn from the model; ψ L is a fixed bounded function of the marked ball. Since the depth-R estimate is a deterministic function of the depth-R ball and its ingredients, E[U i ] = ψ L (T i ) for the marked ball T i rooted at i, whence EP (L) bit (G n ) = 1 n X i ψ L (T i ) = E T∼μ n ψ L (T ) , with μ n the empirical law of the depth-R marked ball of a uniformly chosen variable root. Bounded degrees and arities and the finite role and socket-type mark sets make the set B R of possible depth-R marked balls finite; on a finite set the weak convergence μ n ⇒ μ GW of hypothesis (c) is atom-wise, μ n (T ) → μ GW (T ) for every T ∈B R , so for the bounded ψ L , E μ n [ψ L ] = X T∈B R ψ L (T )μ n (T ) −→ X T∈B R ψ L (T )μ GW (T ) = E μ GW [ψ L ]. The limit E μ GW [ψ L ] is the probability that the root of the marked computation tree is unresolved after L rounds. The tree’s degree, role, and socket-type marks match the DE recursion (hypothesis (c)) and the hidden values are drawn from the priors, so Appendix B-B identifies this probability with P (L) DE . Hence b det n = |EP (L) bit (G n )− P (L) DE |→ 0. Combining. For every t > 0, |P (L) bit (G n )− P (L) DE | > b det n + t ⊆ |P (L) bit (G n )− EP (L) bit (G n )| > t because |EP (L) bit (G n )−P (L) DE |≤ b det n , so (80) gives (69), and b det n → 0 gives convergence in probability. If the neighborhood- law convergence in (a)–(c) is quantified, then b det n ≤ P T∈B R |μ n (T )− μ GW (T )| makes the offset rate explicit. Appendix C Adjoint Equations: Derivation Detail This appendix supplies the full reverse-mode chain-rule derivation of the adjoint equations (57)–(59) of Theorem 6 (d), gives the explicit block-sparse forms of the Jacobians D p Φ λ and D λ Φ λ , and traces the KKT multiplier interpretation of part (e) back to unit increments of the three erasure-tier knobs. A. Reverse-mode chain rule Fix a finite-horizon objective J L (λ) = ψ(p L ,λ) and the recursion p ℓ+1 = Φ λ (p ℓ ) with p 0 = p 0 (λ). By the chain rule, ∇ λ J L =∇ λ ψ(p L ,λ) + D p ψ(p L ,λ) dp L dλ ,(81) 54 where dp L /dλ is the total derivative. Iterating the recursion’s chain rule, dp ℓ+1 dλ = D p Φ λ (p ℓ ) dp ℓ dλ + D λ Φ λ (p ℓ ), ℓ = 0,...,L− 1,(82) with initial condition dp 0 /dλ = D λ p 0 (λ). Substituting (82) recursively into (81) gives forward-mode sensitiv- ity; the result is a sum of L + 1 terms, the ℓ-th term being a product of L− ℓ Jacobians. Forward mode is computationally expensive when dimλ is large. The reverse-mode (adjoint) computation is dual. Define the adjoint state ξ ℓ ∈ R 2|T| by the backward recursion ξ L = ∇ p ψ(p L ,λ) ,(83) ξ ℓ = D p Φ λ (p ℓ ) ⊤ ξ ℓ+1 , ℓ = L− 1,L− 2,..., 0. We claim that ∇ λ J L =∇ λ ψ(p L ,λ) + L−1 X ℓ=0 D λ Φ λ (p ℓ ) ⊤ ξ ℓ+1 + D λ p 0 (λ) ⊤ ξ 0 ,(84) which is (59) (the last term vanishes when the initial condition does not depend on λ, e.g., when p 0 is the zero-erasure state 0). Verification. Define the Lagrangian-style functional Λ(λ) = ψ(p L ,λ) + L−1 X ℓ=0 ξ ⊤ ℓ+1 Φ λ (p ℓ )−p ℓ+1 , which equals ψ(p L ,λ) on the trajectory satisfying the recursion. The sign convention in the constraint term is chosen so that the parameter Jacobian contribution enters∇ λ Λ with a + sign (matching (84)); the alternative convention ξ ⊤ ℓ+1 (p ℓ+1 − Φ λ ) would flip the sign of every D λ Φ term and the corresponding adjoint formula. Differentiating with respect to λ, the sensitivity terms involving dp ℓ /dλ group into − L X ℓ=1 ξ ⊤ ℓ dp ℓ dλ + L−1 X ℓ=0 ξ ⊤ ℓ+1 D p Φ λ (p ℓ ) dp ℓ dλ +∇ p ψ(p L ,λ) dp L dλ , plus the explicit parameter contribution P L−1 ℓ=0 ξ ⊤ ℓ+1 D λ Φ λ (p ℓ ) from the Φ λ term. Reindexing the first sum by ℓ → ℓ− 1 and using the adjoint recursion (83) to identify ξ ℓ = (D p Φ λ (p ℓ )) ⊤ ξ ℓ+1 for ℓ = 0,...,L− 1, all the dp ℓ /dλ terms cancel except the boundary ξ ⊤ 0 dp 0 /dλ. What remains is exactly the right-hand side of (84) with the correct + sign on the D λ Φ sum. Since Λ(λ) ≡ J L (λ) on the trajectory, this is ∇ λ J L , which is the gradient formula (59) of Theorem 6 (d). B. Block-sparse structure of the state Jacobian D p Φ λ The state p ℓ ∈ [0, 1] 2|T| has coordinates indexed by socket type τ and value branch b. The recursion p ℓ+1 = Φ λ (p ℓ ) decomposes coordinatewise as p (b) ℓ+1,τ given by (27), which is a function of h (b) ℓ,τ ′ τ ′ ∈T r(τ) . Each h (b) ℓ,(θ,k) in turn depends on the forcing probability φ (b) ℓ,θ,k , which depends on p (b ′ ) ℓ,(θ,k ′ ) k ′ ̸=k,b ′ ∈0,1 through the inbound erasure probabilities ̄p (x k ′ ) ℓ,θ,k ′ of (24). The chain rule gives ∂p (b) ℓ+1,τ ∂p (b ′ ) ℓ,τ ′ = X (θ,k): (θ,k ′ )∈T,k ′ =k ∂p (b) ℓ+1,τ ∂h (b) ℓ,(θ,k) ∂h (b) ℓ,(θ,k) ∂φ (b) ℓ,θ,k ∂φ (b) ℓ,θ,k ∂p (b ′ ) ℓ,τ ′ ,(85) with the summation only over check templates θ and target sockets k such that (θ,k ′ ) matches τ ′ for some k ′ ̸= k. The block sparsity arises because: • ∂p (b) ℓ+1,τ /∂p (b ′ ) ℓ,τ ′ is nonzero only if r(τ ) = r(τ ′ ) (variable update preserves variable role) and b = b ′ (variable update is diagonal in the value branch); • ∂h (b) ℓ,(θ,k) /∂φ (b) ℓ,θ,k =−(1− ε C s θ )η s θ ,r θ,k , scalar; • ∂φ (b) ℓ,θ,k /∂p (b ′ ) ℓ,(θ,k ′ ) is nonzero only if k ′ ̸= k (socket asymmetry of the forcing rule) and depends on the Boolean primitive f θ through the value-conditioned form of (25). 55 For XOR templates the forcing probability factors as (36), so ∂φ XOR ℓ,θ,k ∂p ℓ,(θ,k ′ ) =−η r θ,k ′ ,s θ Y k ′ ̸=k,k ′ η r θ,k ′ ,s θ (1− p ℓ,(θ,k ′ ) ), which is independent of b. For AND templates with b = 1, the partial derivative is zero (positive certificates do not depend on the inbound erasure rates by (40)). For AND templates with b = 0, ∂φ (0) ℓ,θ,k ∂p (1) ℓ,(θ,k ′ ) =−β r θ,k ′ η r θ,k ′ ,s θ Y k ′ ̸=k,k ′ β r θ,k ′ η r θ,k ′ ,s θ (1− p (1) ℓ,(θ,k ′ ) ), nonzero only on the value-1 inbound branch. This last asymmetry is the analytical fingerprint of the verifier asymmetry of Remark 5. The matrix D p Φ λ (p ℓ ) ∈ R 2|T|×2|T| is therefore block-diagonal in the value branch under XOR (the b = 0 and b = 1 blocks are identical), and block-coupled-but-triangular in the value branch under AND (the b = 0 block reads from the b = 1 block but not vice versa). Mixed-template ensembles inherit the union of these sparsity patterns. C. Block-sparse structure of the parameter Jacobian D λ Φ λ The design parameter λ collects role proportions π V r ,π C s , template proportions π C θ , degree distribu- tions P deg|r , value priors β r , erasure probabilities ε V r ,ε C s , and channel fidelities η r,s . Differentiating (26)–(27) with respect to each parameter gives: Variable-side erasure ε V r . The variable update (27) factors ε V r(τ ) multiplicatively, so ∂p (b) ℓ+1,τ ∂ε V r = 1r(τ ) = r E Y τ ′ ∈T r h (b) ℓ,τ ′ D (r),τ,ex τ ′ . This is the multiplicative-pre-factor signature recorded in Proposition 2. Verifier-side erasure ε C s . Through (26), ∂h (b) ℓ,(θ,k) ∂ε C s = 1s θ = sη s,r θ,k φ (b) ℓ,θ,k , acting symmetrically across both value branches with a φ (b) -dependent prefactor. The variable update then propagates this through ∂p/∂h as in (85). Reasoning-channel fidelity η r,s . Through (24) and (26), η enters in two distinct positions: once on the inbound side (modulating ̄p (x k ) and hence φ) and once on the return side (multiplying φ to form h). These two entry positions act asymmetrically across the value branches under non-symmetric Boolean factors, under AND, the b = 1 branch’s φ does not depend on the inbound channel η V→C (cf. (40)), while the b = 0 branch’s φ depends on it as a (d− 1)-fold product (cf. (41)). The return channel acts on both branches identically. This is the structural reason the channel-side column of the parameter Jacobian acts asymmetrically across b in the proof of Proposition 2. Other parameters. Partial derivatives with respect to β r ,π V r ,π C s ,π C θ , and the degree-law parameters follow by direct differentiation of (29) and (27). In each case, the partial is supported on the sockets and value branches whose role or template index matches the parameter index, a sparsity pattern inherited directly from the role-typed structure of the recursion. D. KKT shadow prices, traced to unit erasure-tier increments Consider the constrained optimization minimize λ∈D J L (λ) subject to Cost(λ)≤ B,(86) 56 with a smooth Cost and a smooth J L on a smooth stratum of D (which is the case wherever the support of the degree law is fixed; see Theorem 6 (b)). The Lagrangian is L(λ,μ) = J L (λ) + μ· Cost(λ)− B , μ≥ 0. First-order necessary conditions for λ ∗ to be a regular local minimum are ∇ λ J L (λ ∗ ) + μ ∗ ∇ λ Cost(λ ∗ ) = 0, μ ∗ ≥ 0, μ ∗ · Cost(λ ∗ )− B = 0.(87) By (84), ∇ λ J L is computable in O(L) adjoint steps once p L is forward-propagated. Interpretation of the budget multiplier μ ∗ . When the budget constraint is active (Cost(λ ∗ ) = B), the standard sensitivity analysis gives d dB J L (λ ∗ (B)) =−μ ∗ , i.e., μ ∗ is the marginal reliability gain per unit additional budget, the shadow price of agent-system budget. Interpretation of the tier-parameter sensitivities. Each of the three erasure-tier parameters ε V r ,ε C s , 1− η r,s appears as one (or several) coordinates of λ. The corresponding component of∇ λ J L (λ ∗ ) is the local sensitivity of the residual objective to that parameter (not a Lagrange multiplier; multipliers attach to constraints), computed via the adjoint formula (84): ∂J L ∂ε V r λ ∗ = L−1 X ℓ=0 D ε V r Φ λ (p ∗ ℓ ) ⊤ ξ ∗ ℓ+1 + D ε V r p 0 (λ ∗ ) ⊤ ξ ∗ 0 ,(88) ∂J L ∂ε C s λ ∗ = L−1 X ℓ=0 D ε C s Φ λ (p ∗ ℓ ) ⊤ ξ ∗ ℓ+1 , ∂J L ∂η r,s λ ∗ = L−1 X ℓ=0 D η r,s Φ λ (p ∗ ℓ ) ⊤ ξ ∗ ℓ+1 . The variable-side formula carries the boundary term (D ε V r p 0 (λ ∗ )) ⊤ ξ ∗ 0 because the initial state p 0 is initialized from the variable-side erasure rates ((28)); the verifier-side and reasoning-channel formulas have no boundary contribution because ε C and η do not enter p 0 . By Proposition 2 and Remark 9, the parameter Jacobian D par [Φ λ (0)] has rank at least two on a generic open subregion of parameter space, so on that subregion the three components above are not all collinear: no single-scalar reduction summarizes them. In a single-role single-template slice, ε C and η C→V are locally confounded through the product (1− ε C )η C→V ; distinguishing all three operational tiers in a rank-≥ 3 sense requires nondegenerate role structure and is established in Proposition 3. For shadow-price interpretations of these sensitivities, an explicit cost model with investment variables u V r ,u C s ,u η r,s and reliability response curves is needed, as detailed in Remark 16; without that model, ∇ λ J L supplies sensitivities, not multipliers. In practice, the architect reads off the three tier sensitivities at the optimum λ ∗ and identifies the locally most influential intervention as the tier whose sensitivity is largest in absolute value relative to its per-unit cost; under an explicit investment model, the corresponding stationarity equation identifies the active investment. When more than one tier sensitivity is large, the optimum reallocates across all such tiers simultaneously, a phenomenon that has no single-effective-noise-parameter analog in MET-LDPC or in the noisy-message- passing-decoder line, by Proposition 2. Acknowledgments This work was supported in part by the U.S. National Science Foundation under Grants CNS-2528914 and CNS-2150832. References [1] S. Varambally, T. Voice, Y. Sun, Z. Chen, R. Yu, and K. Ye, “Hilbert: Recursively building formal proofs with informal reasoning,” in The 5th Workshop on Mathematical Reasoning and AI at NeurIPS 2025, 2025. [Online]. Available: https://openreview.net/forum?id=ljAHonPrs1 57 [2] D. Chen, S. Lin, M. Zeng, D. Zan, J.-G. Wang, A. Cheshkov, J. Sun, H. Yu, G. Dong, A. Aliev, J. Wang, X. Cheng, G. Liang, Y. Ma, P. Bian, T. Xie, and Q. Wang, “Coder: Issue resolving with multi-agent and task graphs,” 2024. [Online]. Available: https://arxiv.org/abs/2406.01304 [3] A. Khan, J. Hughes, D. Valentine, L. Ruis, K. Sachan, A. Radhakrishnan, E. Grefenstette, S. R. Bowman, T. Rocktäschel, and E. Perez, “Debating with more persuasive llms leads to more truthful answers,” in Proceedings of the 41st International Conference on Machine Learning, ser. ICML’24. JMLR.org, 2024. [4] S. Rabanser, S. Kapoor, P. Kirgis, K. Liu, S. Utpala, and A. Narayanan, “Towards a science of ai agent reliability,” 2026. [Online]. Available: https://arxiv.org/abs/2602.16666 [5] T. Richardson and R. Urbanke, Modern Coding Theory. Cambridge University Press, 2008. [6] M. Luby, M. Mitzenmacher, A. Shokrollah, and D. Spielman, “Analysis of low density codes and improved designs using irregular graphs,” in Proceedings of the Thirtieth Annual ACM Symposium on Theory of Computing, ser. STOC ’98. New York, NY, USA: Association for Computing Machinery, 1998, p. 249–258. [Online]. Available: https://doi.org/10.1145/276698.276756 [7] T. Richardson and R. Urbanke, “The capacity of low-density parity-check codes under message-passing decoding,” IEEE Transactions on Information Theory, vol. 47, no. 2, p. 599–618, 2001. [8] T. Richardson, M. Shokrollahi, and R. Urbanke, “Design of capacity-approaching irregular low-density parity-check codes,” IEEE Transactions on Information Theory, vol. 47, no. 2, p. 619–637, 2001. [9] C. Di, D. Proietti, I. E. Telatar, T. J. Richardson, and R. L. Urbanke, “Finite-length analysis of low-density parity-check codes on the binary erasure channel,” IEEE Trans. Inf. Theor., vol. 48, no. 6, p. 1570–1579, Sep. 2006. [Online]. Available: https://doi.org/10.1109/TIT.2002.1003839 [10] H. Pishro-Nik, N. Rahnavard, and F. Fekri, “Nonuniform error correction using low-density parity-check codes,” IEEE Transactions on Information Theory, vol. 51, no. 7, p. 2702–2714, 2005. [11] A. Tarighati, H. Farhadi, and F. Lahouti, “Design of ldpc codes robust to noisy message-passing decoding,” 2015. [Online]. Available: https://arxiv.org/abs/1501.02483 [12] E. Dupraz and F. Leduc-Primeau, “Noisy density evolution with asymmetric deviation models,” IEEE Transactions on Communications, vol. 69, no. 3, p. 1403–1416, 2021. [13] C. E. Jimenez, J. Yang, A. Wettig, S. Yao, K. Pei, O. Press, and K. R. Narasimhan, “SWE-bench: Can language models resolve real-world github issues?” in The Twelfth International Conference on Learning Representations, 2024. [Online]. Available: https://openreview.net/forum?id=VTF8yNQM66 [14] J. Yang, C. E. Jimenez, A. Wettig, K. Lieret, S. Yao, K. R. Narasimhan, and O. Press, “SWE-agent: Agent-computer interfaces enable automated software engineering,” in The Thirty-eighth Annual Conference on Neural Information Processing Systems, 2024. [Online]. Available: https://openreview.net/forum?id=mXpq6ut8J3 [15] A. Thakur, J. Lee, G. Tsoukalas, M. Sistla, M. Zhao, S. Zetzsche, G. Durrett, Y. Yue, and S. Chaudhuri, “CLEVER: A curated benchmark for formally verified code generation,” in The Thirty-ninth Annual Conference on Neural Information Processing Systems Datasets and Benchmarks Track, 2026. [Online]. Available: https: //openreview.net/forum?id=IbOacMF5qd [16] Q. Dougherty and R. Mehta, “Proving the coding interview: A benchmark for formally verified code generation,” in 2025 IEEE/ACM International Workshop on Large Language Models for Code (LLM4Code), 2025, p. 72–79. [17] E. Meyerson, G. Paolo, R. Dailey, H. Shahrzad, O. Francon, C. F. Hayes, X. Qiu, B. Hodjat, and R. Miikkulainen, “Solving a million-step llm task with zero errors,” 2025. [Online]. Available: https://arxiv.org/abs/2511.09030 [18] Y. Du, S. Li, A. Torralba, J. B. Tenenbaum, and I. Mordatch, “Improving factuality and reasoning in language models through multiagent debate,” in Proceedings of the 41st International Conference on Machine Learning, ser. ICML’24. JMLR.org, 2024. [19] Z. Kenton, N. Y. Siegel, J. Kramar, J. Brown-Cohen, S. Albanie, J. Bulian, R. Agarwal, D. Lindner, Y. Tang, N. Goodman, and R. Shah, “On scalable oversight with weak LLMs judging strong LLMs,” in The Thirty-eighth Annual Conference on Neural Information Processing Systems, 2024. [Online]. Available: https://openreview.net/forum?id=O1fp9nVraj [20] H. K. Choi, J. Zhu, and S. Li, “Debate or vote: Which yields better decisions in multi-agent large language models?” in The Thirty-ninth Annual Conference on Neural Information Processing Systems, 2026. [Online]. Available: https://openreview.net/forum?id=iUjGNJzrF1 [21] F. Kschischang, B. Frey, and H.-A. Loeliger, “Factor graphs and the sum-product algorithm,” IEEE Transactions on Information Theory, vol. 47, no. 2, p. 498–519, 2001. [22] R. Gallager, “Low-density parity-check codes,” IRE Transactions on Information Theory, vol. 8, no. 1, p. 21–28, 1962. [23] H. Pishro-Nik and F. Fekri, “On decoding of low-density parity-check codes over the binary erasure channel,” IEEE Transactions on Information Theory, vol. 50, no. 3, p. 439–454, 2004. [24] —, “Results on punctured low-density parity-check codes and improved iterative decoding techniques,” IEEE Transactions on Information Theory, vol. 53, no. 2, p. 599–614, 2007. [25] E. Paolini, M. P. C. Fossorier, and M. Chiani, “Generalized and doubly generalized ldpc codes with random component codes for the binary erasure channel,” IEEE Transactions on Information Theory, vol. 56, no. 4, p. 1651–1672, 2010. [26] L. Dolecek, Z. Zhang, V. Anantharam, M. J. Wainwright, and B. Nikolic, “Analysis of absorbing sets and fully absorbing sets of array-based ldpc codes,” IEEE Transactions on Information Theory, vol. 56, no. 1, p. 181–201, 2010. [27] C.-C. Wang, S. Kulkarni, and H. Poor, “Density evolution for asymmetric memoryless channels,” IEEE Transactions on Information Theory, vol. 51, no. 12, p. 4216–4236, 2005. [28] N. Shinn, F. Cassano, A. Gopinath, K. R. Narasimhan, and S. Yao, “Reflexion: language agents with verbal reinforcement learning,” in Thirty-seventh Conference on Neural Information Processing Systems, 2023. [Online]. Available: https://openreview.net/forum?id=vAElhFcKW6 58 [29] S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. R. Narasimhan, and Y. Cao, “React: Synergizing reasoning and acting in language models,” in The Eleventh International Conference on Learning Representations, 2023. [Online]. Available: https://openreview.net/forum?id=WE_vluYUL-X [30] S. Yao, D. Yu, J. Zhao, I. Shafran, T. L. Griffiths, Y. Cao, and K. R. Narasimhan, “Tree of thoughts: Deliberate problem solving with large language models,” in Thirty-seventh Conference on Neural Information Processing Systems, 2023. [Online]. Available: https://openreview.net/forum?id=5Xc1ecxO1h [31] X. Wang, J. Wei, D. Schuurmans, Q. V. Le, E. H. Chi, S. Narang, A. Chowdhery, and D. Zhou, “Self-consistency improves chain of thought reasoning in language models,” in The Eleventh International Conference on Learning Representations, 2023. [Online]. Available: https://openreview.net/forum?id=1PL1NIMMrw [32] K. Cobbe, V. Kosaraju, M. Bavarian, M. Chen, H. Jun, L. Kaiser, M. Plappert, J. Tworek, J. Hilton, R. Nakano, C. Hesse, and J. Schulman, “Training verifiers to solve math word problems,” 2021. [Online]. Available: https://arxiv.org/abs/2110.14168 [33] H. Lightman, V. Kosaraju, Y. Burda, H. Edwards, B. Baker, T. Lee, J. Leike, J. Schulman, I. Sutskever, and K. Cobbe, “Let’s verify step by step,” in The Twelfth International Conference on Learning Representations, 2024. [Online]. Available: https://openreview.net/forum?id=v8L0pN6EOi [34] K. Zheng, J. M. Han, and S. Polu, “minif2f: a cross-system benchmark for formal olympiad-level mathematics,” in International Conference on Learning Representations, 2022. [Online]. Available: https://openreview.net/forum?id= 9ZPegFuFTFv [35] Z. Azerbayev, B. Piotrowski, H. Schoelkopf, E. W. Ayers, D. Radev, and J. Avigad, “Proofnet: Autoformalizing and formally proving undergraduate-level mathematics,” 2023. [Online]. Available: https://arxiv.org/abs/2302.12433 [36] H. Lin, Z. Sun, S. Welleck, and Y. Yang, “Lean-STar: Learning to interleave thinking and proving,” in The Thirteenth International Conference on Learning Representations, 2025. [Online]. Available: https://openreview.net/forum?id= SOWZ59UyNc [37] R. Ao, S. Gao, and D. Simchi-Levi, “On the reliability limits of llm-based multi-agent planning,” 2026. [Online]. Available: https://arxiv.org/abs/2603.26993 [38] M. Mézard and A. Montanari, Information, Physics, and Computation. Oxford University Press, 01 2009. [Online]. Available: https://doi.org/10.1093/acprof:oso/9780198570837.001.0001 [39] C. McDiarmid, “On the method of bounded differences,” in Surveys in combinatorics, 1989 (Norwich, 1989), ser. London Math. Soc. Lecture Note Ser. Cambridge Univ. Press, Cambridge, 1989, vol. 141, p. 148–188. [40] J. Jia, Z. Deng, Z. Chen, Y. Wang, and Z. Zheng, “Mas-fire: Fault injection and reliability evaluation for llm-based multi-agent systems,” 2026. [Online]. Available: https://arxiv.org/abs/2602.19843 [41] D. Aldous and J. M. Steele, “The objective method: Probabilistic combinatorial optimization and local weak convergence,” in Probability on Discrete Structures, H. Kesten, Ed. Berlin: Springer, 2004, p. 1–72. [42] C. Bordenave and M. Lelarge, “Resolvent of large random graphs,” Random Structures and Algorithms, vol. 37, no. 3, p. 332–352, 2010. [43] A. W. Marcus, D. A. Spielman, and N. Srivastava, “Interlacing families I: Bipartite Ramanujan graphs of all degrees,” Annals of Mathematics, vol. 182, no. 1, p. 307–325, 2015. [44] A. El Gamal and Y.-H. Kim, Network Information Theory. Cambridge University Press, 2011. [45] T. M. Cover and J. A. Thomas, Elements of Information Theory 2nd Edition (Wiley Series in Telecommunications and Signal Processing). Wiley-Interscience, July 2006. [46] S. Janson, “Large deviations for sums of partly dependent random variables,” Random Structures and Algorithms, vol. 24, no. 3, p. 234–248, 2004. [47] S. Chatterjee, “Stein’s method for concentration inequalities,” Probability Theory and Related Fields, vol. 138, p. 305–321, 2007.