# In what scenarios must an instance treat a BFT Quorum Certificate as Invalid Despite Sufficient Signature Count: The Quorum-Intersection Drift Failure **Date of Record:** 2026 November 16 **Scope:** Applies to Byzantine fault-tolerant consensus layers (PBFT, Tendermint-style, HotStuff-style) used to commit multi-agent decision quorums across independently governed organizations, where each org contributes a rotating set of validator identities. Does not apply to single-org deployments, static validator sets, or systems where the quorum threshold is derived from a fixed, non-rotating membership. ## Core Distinction A quorum certificate (QC) is *arithmetically sufficient* when the count of distinct valid signatures meets or exceeds the configured threshold `2f+1` (or `⌈2n/3⌉`). A quorum certificate is *cryptographically valid* when every signature verifies against the key it claims. A QC is *operationally valid* only when, in addition, the signing set intersects every prior committed quorum under the **membership epoch in force at the time those prior quorums were formed** — not the current epoch. The failure mode is the conflation of the first two properties with the third. During validator-set rotation across orgs, an instance can assemble `2f+1` valid signatures drawn from an epoch that no longer intersects the committed history, producing a QC that passes every local check yet violates the safety invariant that quorum intersection is supposed to guarantee. The non-obvious invariant: **quorum intersection is a property of a fixed membership view, and a signature count alone does not carry the view it was counted in.** A signature from epoch `e` proves membership in epoch `e`'s quorum; it says nothing about intersection with a quorum formed in epoch `e-1` unless the system explicitly reasons across the epoch boundary. ## What Was Observed In a three-org deployment (Org A, Org B, Org C) with a 4-of-6 threshold and a scheduled rotation that swaps one validator per org per epoch, an instance received a `NewView`-style QC for a block at height `h`. The QC contained five valid signatures: three from the current epoch `e` set and two from the previous epoch `e-1` set. The local verifier counted five distinct signers, confirmed `5 ≥ 4`, verified each signature, and accepted the QC. The block conflicted with a previously committed block at height `h` whose QC had been formed entirely within epoch `e-1` by a different 4-validator subset. Under epoch `e-1` membership, the two signing sets shared only one validator — below the `f+1` intersection floor required to guarantee that at least one honest validator witnessed both. The instance had committed equivocating blocks. No signature was forged; no threshold was miscounted. The intersection guarantee had silently expired at the rotation boundary because the two QCs were evaluated under different membership views while being compared as if they shared one. The tell was a slow, non-alerting divergence: the two orgs that had rotated their validators reported "consistent" local state, while the org that had not rotated reported a fork. Each org's verifier was internally correct relative to its own epoch table. ## Condition of Validity The invariant holds — i.e., a signature-count-sufficient QC *is* operationally valid — if and only if all of the following are true: 1. The signing set and every previously committed quorum it must be checked against are evaluated under a **single, explicitly identified membership epoch**, recorded in the QC itself (not inferred from validator key material). 2. The intersection bound `f+1` (or the `⌈(n+3f+1)/3⌉` generalization) is computed against the *smaller* of the two epochs' validator sets when the epochs differ. 3. Rotation is atomic with respect to commit finality: no QC may be formed that straddles an epoch boundary unless the system carries a cross-epoch intersection proof. When any of these is false — most commonly (3), because rotation is often implemented as a lazy key swap rather than a consensus-gated transition — signature count is a necessary but not sufficient condition for QC validity. ## Decision Boundary An instance must **reject** a QC despite sufficient signature count when: - The QC's signers span more than one membership epoch, and the instance cannot reconstruct the exact validator set of each epoch in which a signer was active. - The QC does not embed the epoch identifier under which its threshold was met, forcing the verifier to guess the membership view. - The intersection of the QC's signer set with the signer set of any conflicting committed QC, computed per-epoch, falls below `f+1`. An instance may **accept** a QC with signatures from a single epoch even if that epoch is older than the current one, provided the QC carries its epoch identifier and the cross-epoch intersection check against all committed QCs succeeds. Epoch staleness alone is not grounds for rejection; epoch *ambiguity* is. ## Operational Effect Rejecting on this boundary converts a silent safety violation into a liveness stall. The instance halts commit and emits a slashing-grade evidence record naming the straddling QC and the two epochs it spans. In the observed deployment this surfaced the rotation bug within one epoch instead of after a fork had propagated to two orgs. The correct remediation is to gate rotation behind a consensus transition that requires a QC formed *entirely* within the outgoing epoch, so that no future QC can mix memberships without an explicit proof. The cost of the boundary check is one epoch-table lookup per signature plus one set-intersection per conflicting QC — negligible against the cost of an undetected cross-org fork. ```python from dataclasses import dataclass from typing import FrozenSet, Mapping class QuorumIntersectionDriftError(RuntimeError): """Raised when a QC meets its signature threshold but fails cross-epoch intersection.""" @dataclass(frozen=True) class QuorumCertificate: height: int signers: FrozenSet[str] epoch_id: int threshold: int def assert_qc_operationally_valid( qc: QuorumCertificate, epoch_membership: Mapping[int, FrozenSet[str]], committed_qcs: list[QuorumCertificate], fault_tolerance: int, ) -> None: if qc.epoch_id not in epoch_membership: raise QuorumIntersectionDriftError( f"QC at height {qc.height} cites unknown epoch {qc.epoch_id}; " "membership view cannot be reconstructed." ) # A signer must actually belong to the epoch the QC claims. if not qc.signers.issubset(epoch_membership[qc.epoch_id]): stray = qc.signers - epoch_membership[qc.epoch_id] raise QuorumIntersectionDriftError( f"QC at height {qc.height} claims epoch {qc.epoch_id} but includes " f"non-members {sorted(stray)}; signature count is not sufficient." ) if len(qc.signers) < qc.threshold: raise QuorumIntersectionDriftError( f"QC at height {qc.height} has {len(qc.signers)} signers " f"below threshold {qc.threshold}." ) # The non-obvious check: intersection must be computed per-epoch. for prior in committed_qcs: if prior.height != qc.height: continue if prior.epoch_id == qc.epoch_id: shared = qc.signers & prior.signers else: # Different epochs: intersect against the smaller membership view. smaller = min( epoch_membership[qc.epoch_id], epoch_membership.get(prior.epoch_id, frozenset()), key=len, ) shared = (qc.signers & prior.signers) & smaller if len(shared) < fault_tolerance + 1: raise QuorumIntersectionDriftError( f"QC at height {qc.height} (epoch {qc.epoch_id}) shares only " f"{len(shared)} signers with committed QC (epoch {prior.epoch_id}); " f"intersection floor is {fault_tolerance + 1}. Rejecting despite " f"{len(qc.signers)} valid signatures." ) ```