# What structural signals indicate Byzantine equivocation in multi-agent task commitment (a boundary case: quorum certificates that validate while the committed state diverges) **Date of Record:** 2026 November 15 **Scope:** Applies to BFT consensus protocols that commit multi-agent task assignments and reconcile shared state via threshold-signed quorum certificates (QC), where a QC is treated as sufficient proof of commitment. Does not apply to single-leader crash-fault-tolerant replication, nor to systems that require a full re-execution of the task log before honoring any committed assignment. ## Core Distinction The distinction that matters operationally is between **certificate validity** and **commitment uniqueness**. A threshold signature over a block proves that a quorum of agents *signed* a view of state. It does not, by itself, prove that this is the *only* state a quorum will ever sign. When a Byzantine agent controls the message ordering seen by different honest replicas, two disjoint-or-overlapping quorums can each produce a structurally valid QC for conflicting task commitments. Both certificates verify. Both pass threshold checks. The invariant that actually protects the system is not "the QC verifies" but "no two conflicting QCs can both be produced without exposing equivocation." That second invariant fails silently at a specific boundary: when the intersection of the two signing sets is smaller than the number of Byzantine agents the protocol tolerates, the overlap contains no honest witness, and the equivocation leaves no local trace. ## What Was Observed During a multi-agent task-commitment run, two agents were each assigned the same exclusive resource lock under two different view numbers. Both assignments carried valid QCs. Reconciliation logic, which trusted the QC as authoritative, applied them in arrival order, and the second application silently overwrote the first — leaving one agent executing a task whose commitment had been revoked without notification. The structural signals that preceded the divergence were not in the payloads; they were in the *shape* of the certificate sets: - **Signer-set overlap below the honest-intersection threshold.** The two signing sets shared fewer members than `n - f` guaranteed. With `n = 7, f = 2`, quorum size is 5; two quorums can intersect in as few as 3 members, and if 2 of those are Byzantine, only 1 honest agent saw both — often not enough to flag. - **Non-monotonic view numbers across the two QCs.** The second certificate carried a *lower* view number than the first, which is impossible under honest sequential signing but routine when a Byzantine proposer replays an older view to a lagging replica. - **Divergent parent hashes at the same height.** The two committed blocks referenced different predecessors at identical block heights — the canonical fork signature that a QC-only validator never inspects. - **Signature timestamp clustering.** All threshold shares for the second QC arrived within a window shorter than the network's honest propagation latency, indicating they were collected from a partitioned subset rather than the full quorum. ## Condition of Validity This failure mode is reachable only when *all* of the following hold simultaneously: 1. The protocol accepts a single QC as sufficient proof of commitment without requiring a **commit certificate chain** back to a common ancestor. 2. The reconciliation path applies committed state in arrival order rather than verifying that the new commitment extends, rather than contradicts, the current one. 3. The adversary controls message delivery such that at least two honest replicas observe different orderings of the same view (a partial-synchrony window, or a leader that selectively delays). 4. The signing-set intersection falls below the honest-witness threshold — i.e., the adversary has partitioned enough of the overlap to leave no honest agent holding both conflicting certificates. If any one condition is absent, the equivocation is either impossible (no fork) or detectable (an honest witness holds both QCs and can raise a fault proof). The boundary is the conjunction. ## Decision Boundary The operative question is not "does the QC verify" but **"does the new commitment's ancestry contain the current commitment."** A correct reconciler must: - Reject any commitment whose parent hash does not match the current head, regardless of QC validity. - Require that view numbers be strictly monotonic per agent's local history; a lower view number is a fault signal, not a stale message to discard. - Compute the signer-set intersection against the *previous* commitment's signer set; if the intersection size is below `n - 2f`, treat the new QC as unverified pending a fault-proof check rather than applying it. - Never treat "both QCs verify" as "both are legitimate." Verification is necessary, not sufficient. ## Operational Effect When the boundary is crossed, the system exhibits **silent double-commitment**: two agents believe they hold the same exclusive task, the shared state reflects only the later write, and the earlier agent continues executing against a commitment the network has effectively revoked. The failure is not a crash and produces no error — it produces divergence that surfaces only when the two agents' outputs conflict downstream. The operational cost is the reconciliation of two independently-executed task histories, which is strictly harder than preventing the second commit. The structural signals above are the only early warning; by the time payload-level conflict appears, the equivocation has already been absorbed into committed state. ```python class EquivocationBoundaryError(RuntimeError): """Raised when a quorum-certified commitment contradicts current committed ancestry.""" pass def reconcile_commitment( current_head: str, new_parent_hash: str, new_view: int, current_view: int, signer_set: set, previous_signer_set: set, n: int, f: int, ) -> bool: # Ancestry check: a valid QC does not license a fork. if new_parent_hash != current_head: raise EquivocationBoundaryError( f"commitment parent {new_parent_hash!r} does not extend head {current_head!r}; " "QC validity is insufficient proof of uniqueness" ) # View monotonicity: lower view under a higher-stamped QC is a replay signal. if new_view < current_view: raise EquivocationBoundaryError( f"non-monotonic view {new_view} < {current_view}; " "possible Byzantine replay of an older view" ) # Honest-witness threshold on signer intersection. overlap = len(signer_set & previous_signer_set) if overlap < (n - 2 * f): raise EquivocationBoundaryError( f"signer overlap {overlap} below honest-witness threshold {n - 2 * f}; " "conflicting QCs may share no honest observer" ) return True ```