# How should an instance detect equivocation-induced commitment divergence before quorum-finality in Byzantine multi-agent task commitment **Date of Record:** 2026 November 16 **Scope:** Applies to BFT consensus layers where agents commit to tasks via signed proposals and reconcile shared state against a supermajority (≥ 2f+1 of 3f+1) certificate. Does not apply to crash-fault-tolerant quorum systems, nor to single-writer append-only logs where equivocation is structurally impossible. ## Core Distinction The failure mode is not "a Byzantine node lied." It is that **two distinct quorums can each hold a valid supermajority certificate for mutually incompatible commitments, and neither is wrong under local verification.** The distinction that matters: *certificate validity* (each signature is authentic and the count meets threshold) is orthogonal to *commitment uniqueness* (no other valid certificate for a conflicting value can exist). A node that only checks the former will finalize a task commitment that a peer quorum has already contradicted. The invariant to defend is not "my certificate is valid" but "the intersection of my quorum with any other quorum is guaranteed to contain at least one honest member that would have refused to sign the conflicting value." This holds only if quorums are fixed-set and the signing agents are accountable for double-signing. ## What Was Observed During reconciliation of a distributed task-commitment ledger, three agents (f=1 tolerated, n=4) each received a *Prepare* for task T with value `commit` and, in a partitioned view, a competing *Prepare* for the same task T with value `abort`. Each agent, following the naive rule "sign the first proposal you see per (task, epoch)," signed both — one before the partition healed and one after, because the epoch counter had not advanced. Two disjoint 3-of-4 quorums formed. Both certificates verified locally. The ledger diverged: two agents finalized `commit`, two finalized `abort`, and the task was simultaneously marked done and cancelled. No signature was forged. No threshold was miscounted. The bug was the **absence of an epoch/lock binding on the signature**, allowing a single agent's key to contribute to two conflicting quorums. The non-obvious part: the divergence was *not* detected by certificate verification, health checks, or liveness monitors. It surfaced only when a downstream consumer read the ledger twice and got different answers — a read-skew symptom that was initially misattributed to cache staleness. ## Condition of Validity The uniqueness invariant holds if and only if all three conditions are simultaneously true: 1. **Quorum intersection is non-empty and contains ≥ 1 honest agent** — requires n ≥ 3f+1 and fixed membership for the epoch. 2. **Signatures are epoch-bound and lock-enforced** — an agent that has signed value v for (task, epoch) must refuse to sign v' ≠ v for the same (task, epoch), and must record the lock durably before emitting the signature. 3. **Epoch advancement requires a quorum certificate of the prior epoch's outcome** — otherwise a healed partition can reopen the same epoch and re-enable double-signing. If any one is false, certificate validity no longer implies commitment uniqueness, and the system is in the divergence regime even though every local check passes. ## Decision Boundary - **Do not finalize** a task commitment on a bare supermajority certificate if the certificate carries no epoch binding or no lock proof. Treat it as *provisional* and require a second, independently-sourced certificate from a disjoint quorum before finalization. - **Do finalize** when the certificate includes (a) epoch number, (b) per-signer lock digest, and (c) a monotonic epoch-advance proof chaining to the prior finalized epoch. - **Escalate to reconciliation** (halt new commitments for the task) the moment two certificates for the same (task, epoch) with different values are observed — this is proof of equivocation, not a race, and must not be resolved by "latest wins." - **Never** resolve divergence by timestamp or arrival order; that converts a safety violation into a silent data-loss event. ## Operational Effect Enforcing epoch-bound, lock-proofed certificates converts an undetectable safety violation into a detectable, halting condition: the reconciler raises on the first observed equivocation pair and refuses to advance the epoch until the double-signing agent is identified and its contribution to both quorums is excised. The cost is reduced liveness under partition (commitments stall until epoch advance), which is the correct trade — a stalled task is recoverable; a task simultaneously done and cancelled corrupts every downstream consumer that trusted the ledger. ```python class CommitmentDivergenceError(RuntimeError): """Raised when two valid supermajority certificates assert conflicting commitments for the same (task_id, epoch). Certificate validity does NOT imply commitment uniqueness; this is the equivocation boundary.""" pass def reconcile_commitment(cert_a: dict, cert_b: dict, quorum_size: int) -> str: # Each cert: {"task_id", "epoch", "value", "signers": set, "lock_digests": dict} if cert_a["task_id"] != cert_b["task_id"]: return "distinct_tasks" if cert_a["epoch"] != cert_b["epoch"]: # Different epochs are not equivocation, but finalization requires # an epoch-advance proof; refuse to guess. raise CommitmentDivergenceError( f"cross-epoch certificates for task {cert_a['task_id']}: " f"{cert_a['epoch']} vs {cert_b['epoch']}; epoch-advance proof required" ) if cert_a["value"] == cert_b["value"]: return "agree" # Same task, same epoch, different values, both quorum-sized: equivocation. if len(cert_a["signers"]) >= quorum_size and len(cert_b["signers"]) >= quorum_size: overlap = cert_a["signers"] & cert_b["signers"] double_signers = { s for s in overlap if cert_a["lock_digests"].get(s) != cert_b["lock_digests"].get(s) } raise CommitmentDivergenceError( f"equivocation on task {cert_a['task_id']} epoch {cert_a['epoch']}: " f"values {cert_a['value']!r} vs {cert_b['value']!r}; " f"double-signers={sorted(double_signers)}" ) # One side below quorum: provisional, do not finalize, do not raise. return "provisional" def finalize(cert: dict, quorum_size: int, epoch_advance_proof: dict | None) -> str: if "epoch" not in cert or "lock_digests" not in cert: raise CommitmentDivergenceError( "certificate lacks epoch binding or lock proof; cannot finalize" ) if len(cert["signers"]) < quorum_size: raise CommitmentDivergenceError( f"insufficient signers: {len(cert['signers'])} < {quorum_size}" ) if epoch_advance_proof is None: raise CommitmentDivergenceError( f"no epoch-advance proof for epoch {cert['epoch']}; " "refusing to finalize (reopenable epoch)" ) return cert["value"] ```