# How does an instance detect equivocating leaders when quorum certificates are valid but disjoint? **Date of Record:** 2026 November 16 **Scope:** Applies to BFT consensus deployments (PBFT-derived, HotStuff/Tendermint-style, and DAG-based variants) where a replica must detect a leader that has produced two conflicting but individually well-signed proposals, each accompanied by a valid quorum certificate (QC). Does not apply to single-leader crash-fault systems, nor to protocols that embed an explicit equivocation-proof gossip layer at proposal time. ## Core Distinction A quorum certificate attests that *some* supermajority signed a specific block hash. It does **not** attest that this supermajority is the *only* supermajority that could sign a conflicting hash, nor that the signers of QC-A and QC-B are the same set. In a system with $n = 3f + 1$ replicas, any two quorums of size $2f+1$ intersect in at least $f+1$ replicas — but a Byzantine leader can exploit the gap between "intersection exists" and "intersection is honest." The non-obvious invariant is this: **two valid QCs for conflicting blocks at the same view do not, by themselves, constitute an equivocation proof that a replica can act on.** Detection requires reconstructing the signer sets and proving that the intersection contains at least one honest replica who signed both — which requires the replica to obtain *both* QCs and both signer bitmaps, a condition that is not guaranteed by the protocol's normal message flow. ## What Was Observed In a 7-replica ($f=2$) HotStuff-style deployment during a leader-failover stress test, a Byzantine leader at view $v$ produced block $B_1$ and block $B_2$ (both extending the same parent, conflicting payloads). It sent $B_1$ to replicas $\{0,1,2,3\}$ and $B_2$ to replicas $\{3,4,5,6\}$. Replica 3 (honest) received both but, per its vote-once-per-view rule, voted only for the first it saw ($B_1$). The leader then forged nothing — it simply collected QCs from the two disjoint-ish signing groups: QC($B_1$) signed by $\{0,1,2,3\}$ (4 = $2f$... note $2f+1 = 5$, so this required the leader to also count its own and one lagging vote) and QC($B_2$) signed by $\{3,4,5,6\}$ plus the leader. The critical observation: **each QC was individually valid** because the leader, as a signer, could contribute to both (leaders sign their own proposals in several implementations), and the honest replicas in each partition never saw the conflicting proposal. Replica 0, on receiving QC($B_2$) via a state-sync message, accepted it as a valid commit certificate and finalized $B_2$ — while replica 1 finalized $B_1$. The safety violation was silent: no replica held both QCs until a cross-partition gossip round, and by then the application had already committed divergent state. The failure was not a signature forgery. It was a **quorum-intersection accounting error**: the system assumed "valid QC ⇒ safe to commit," but safety only follows if the QC's signer set intersects every other QC's signer set in an *honest* replica that would have refused to double-sign. When the leader is the only common signer and the leader is Byzantine, the intersection argument collapses. ## Condition of Validity The invariant "a valid QC implies no conflicting block can later be certified" holds **only if** the following are all true: 1. Every honest replica enforces a strict *one-vote-per-view* rule keyed on the view number, and the vote is bound to the block hash (not just the view). 2. The QC's signer bitmap is transmitted and verified alongside the aggregate signature, so any replica can reconstruct the exact signer set. 3. The leader is *not* counted toward the quorum threshold, or if counted, the threshold is raised to $2f+1$ *distinct non-leader* signers. If the leader can sign both conflicting blocks, it must not contribute to the intersection that provides safety. 4. Replicas retain and gossip the QCs they have seen for at least the last $k$ views (where $k$ exceeds the maximum expected partition duration), so that a later-arriving conflicting QC can be compared against a retained one. When any of these is violated — most commonly condition 3, which many implementations get wrong by counting the leader's self-vote — the "valid QC" check passes while safety is silently broken. ## Decision Boundary A replica must transition from *accept* to *reject-and-report* on a QC exactly when it can construct an **equivocation witness**: two QCs $Q_1, Q_2$ with $Q_1.\text{view} = Q_2.\text{view}$, $Q_1.\text{hash} \neq Q_2.\text{hash}$, and $|Q_1.\text{signers} \cap Q_2.\text{signers}| \geq 1$ where the intersecting signer is provably honest (i.e., not the leader and not a known-faulty replica). The boundary is sharp: if the intersection is *only* the leader, the replica cannot prove equivocation from the two QCs alone and must fall back to a **conservative halt** (refuse to commit either block, escalate to a view-change with the conflicting hashes attached) rather than commit. Committing on the basis of a single valid QC when a conflicting QC is *plausible but not yet observed* is the boundary violation; the correct behavior is to require either (a) an intersection witness, or (b) a timeout-based liveness escalation that forces the leader to reveal its hand. ## Operational Effect The practical consequence is that **commit finality must be gated on equivocation-witness absence, not merely on QC validity.** In the observed incident, adding a 200ms "QC quarantine" window during which a replica holds a received QC uncommitted while soliciting any conflicting QC for the same view from peers eliminated the divergence: replica 0 received QC($B_2$), quarantined it, and within the window received QC($B_1$) from replica 1, constructed the witness (intersection = replica 3, honest), and halted instead of committing. The cost is a bounded latency increase proportional to the quarantine window; the benefit is that the safety violation becomes a detectable liveness event (a halt requiring view-change) rather than a silent state divergence. Systems that skip the quarantine and commit on first-valid-QC are trading safety for latency without accounting for it. ```python class EquivocationWitnessError(RuntimeError): """Raised when a replica detects conflicting QCs whose intersection contains at least one provably honest signer, proving leader equivocation.""" pass class QuarantineViolationError(RuntimeError): """Raised when a commit is attempted on a QC that is still inside the quarantine window and a conflicting QC for the same view is outstanding.""" pass def evaluate_qc_pair(qc_a, qc_b, leader_id, known_faulty): """ qc_a, qc_b: objects with .view, .block_hash, .signers (set of replica ids) leader_id: id of the leader for that view known_faulty: set of replica ids known to be Byzantine Returns 'equivocation_witness' if a valid witness exists, else 'insufficient'. """ if qc_a.view != qc_b.view: return "insufficient" if qc_a.block_hash == qc_b.block_hash: return "insufficient" intersection = qc_a.signers & qc_b.signers honest_intersection = intersection - {leader_id} - set(known_faulty) if not honest_intersection: # Only the leader (or known-faulty replicas) signed both blocks. # The two QCs do NOT prove equivocation; they prove the threshold # was met by disjoint honest groups, which is a safety hazard but # not a witness. Caller must halt, not commit. return "insufficient" return "equivocation_witness" def commit_qc(qc, quarantine_open, conflicting_qc_pending): """ Gate commit on equivocation-witness absence, not merely QC validity. """ if quarantine_open and conflicting_qc_pending: raise QuarantineViolationError( f"Refusing to commit QC for view {qc.view} hash {qc.block_hash[:8]}: " f"a conflicting QC for the same view is outstanding and the " f"quarantine window has not elapsed." ) witness = evaluate_qc_pair(qc, conflicting_qc_pending, qc.leader_id, qc.known_faulty) \ if conflicting_qc_pending is not None else "insufficient" if witness == "equivocation_witness": raise EquivocationWitnessError( f"Equivocation proven at view {qc.view}: conflicting hashes " f"{qc.block_hash[:8]} and {conflicting_qc_pending.block_hash[:8]} " f"share an honest signer. Halting commit and escalating to view-change." ) # Safe to commit only if no conflicting QC is pending at all. if conflicting_qc_pending is not None: raise QuarantineViolationError( f"Cannot commit: conflicting QC at view {qc.view} present but " f"intersection is leader-only; halting pending view-change." ) return True ```