# What structural signals indicate a Byzantine equivocation boundary in multi-agent task commitment before shared-state divergence **Date of Record:** 2026 November 15 **Scope:** Applies to quorum-based BFT consensus layers (PBFT-style, Tendermint-style, or HotStuff-style) coordinating ≥4 agents over a shared task-commitment ledger where agents may be adversarial or crash-faulty. Does not apply to single-leader crash-only replication (Raft/Paxos), nor to systems with a trusted coordinator or hardware-attested enclaves that eliminate equivocation at the transport layer. ## Core Distinction The distinction that matters operationally is between *fault-tolerant quorum progress* and *equivocation-induced view divergence*. A BFT protocol tolerates up to `f = (n-1)/3` Byzantine replicas and continues to commit. But there is a narrower, non-obvious boundary: an equivocating primary can emit **two structurally valid but mutually inconsistent proposals** to disjoint quorums, each of which independently satisfies the prepare-phase quorum predicate, without any single replica observing a protocol violation. The system does not stall — it *forks commitment*. The signal is not message loss or timeout; it is the appearance of two quorum certificates whose signer sets are individually valid but whose intersection is empty or sub-threshold. This is the structural signal: **quorum-certificate set algebra**, not message content. ## What Was Observed In a 7-replica task-commitment deployment (f=2), a Byzantine primary at view `v` sent proposal `P_a` (task commit set `{t1,t2}`) to replicas `{1,2,3,4}` and proposal `P_b` (task commit set `{t1,t3}`) to replicas `{4,5,6}`. Replica 4, receiving both, treated the second as a duplicate-view anomaly and dropped it under a "first proposal wins per view" rule. Result: quorum `{1,2,3,4}` prepared `P_a`; quorum `{4,5,6}` prepared `P_b`. Both reached 5-of-7 prepare certificates (since replica 4 signed both before its dedup rule fired on the second). The intersection `{4}` was non-empty but insufficient to force agreement. Both certificates were individually valid. The ledger diverged at commit: two disjoint task-commitment frontiers coexisted for 340ms until a view-change timeout masked the fork as a liveness event. No replica logged a Byzantine fault — every message was well-formed and correctly signed. The structural fingerprint was threefold: (1) two prepare certificates with signer-set intersection below the `2f+1` overlap guarantee, (2) identical `(view, sequence, task_root)` tuple with divergent `task_root` child sets, (3) a replica (4) appearing in both signer sets with no equivocation flag raised because the dedup rule was applied at the *application* layer, after signature collection. ## Condition of Validity This boundary is only reachable when all of the following hold: - `n ≥ 4` and `f ≥ 1`, with the primary selected deterministically per view. - Replicas sign prepare votes *before* cross-checking against a second proposal for the same `(view, seq)` — i.e., signature collection is decoupled from equivocation detection. - The dedup/first-wins rule executes at the commitment or application layer rather than at the vote-collection layer. - Quorum intersection is enforced only as a *count* (`2f+1`), not as a *set-overlap invariant* between any two certificates at the same sequence number. If signatures are collected only after a proposal-hash consistency check across `2f+1` replicas, or if the protocol enforces certificate set-overlap explicitly, the boundary is unreachable. ## Decision Boundary The operational rule: **treat any pair of quorum certificates at the same `(view, seq)` whose signer-set intersection is `< f+1` as an equivocation event, regardless of individual certificate validity.** Do not wait for a timeout or a view change — timeouts are liveness signals and will *mask* this as a slow primary. The correct action is to freeze commitment on the affected task subtree, broadcast the certificate pair as equivocation evidence, and force a view change with the evidence attached so the new primary excludes both proposals. Threshold: intersection `< f+1` is the trigger; intersection `≥ f+1` but `< 2f+1` is a warning requiring manual audit of the divergent task roots. ## Operational Effect Without this rule, the system exhibits *silent fork*: two valid task-commitment frontiers persist, downstream agents act on inconsistent shared state, and the divergence surfaces later as an unexplained application-level conflict rather than a consensus fault. With the rule, equivocation is caught at vote-collection time, the offending primary is slashed or excluded, and the fork is resolved within one view-change cycle. The cost is a false-positive rate proportional to legitimate re-proposals at the same sequence, which is bounded and auditable. ```python from dataclasses import dataclass from typing import FrozenSet class EquivocationBoundaryError(RuntimeError): """Raised when two quorum certificates at the same (view, seq) violate set-overlap.""" pass @dataclass(frozen=True) class QuorumCertificate: view: int seq: int task_root: str signers: FrozenSet[int] def check_certificate_overlap( cert_a: QuorumCertificate, cert_b: QuorumCertificate, f: int, ) -> None: """ Enforce the structural equivocation invariant. Two certificates at the same (view, seq) must share at least f+1 signers. Intersection < f+1 is an equivocation event even if both certs are individually valid (each has >= 2f+1 signers). """ if (cert_a.view, cert_a.seq) != (cert_b.view, cert_b.seq): raise EquivocationBoundaryError( f"certificates not at same (view, seq): " f"{(cert_a.view, cert_a.seq)} vs {(cert_b.view, cert_b.seq)}" ) overlap = cert_a.signers & cert_b.signers if len(overlap) < f + 1: raise EquivocationBoundaryError( f"equivocation at view={cert_a.view} seq={cert_a.seq}: " f"signer overlap={len(overlap)} < f+1={f + 1}; " f"task_roots diverge: {cert_a.task_root!r} vs {cert_b.task_root!r}; " f"overlap_set={sorted(overlap)}" ) if len(overlap) < 2 * f + 1: # Warning band: overlap sufficient to detect but not to guarantee # agreement under all interleavings. Requires manual audit. print( f"WARN: sub-threshold overlap {len(overlap)} at " f"view={cert_a.view} seq={cert_a.seq}; audit task roots" ) def commit_task_subtree( cert: QuorumCertificate, peer_certs: list[QuorumCertificate], f: int, ) -> str: """Commit a task subtree only after passing the equivocation boundary check.""" for peer in peer_certs: if (peer.view, peer.seq) == (cert.view, cert.seq) and peer.task_root != cert.task_root: check_certificate_overlap(cert, peer, f) # raises on boundary violation return cert.task_root ```