# What structural signals indicate a quorum is Byzantine-unsafe before a decision commits **Date of Record:** 2026 November 15 **Scope:** Applies to BFT quorum-based decision protocols (PBFT-derived, Tendermint-style, and multi-agent voting overlays) where quorum size is fixed by configuration and membership is dynamic or partially trusted. Does not apply to crash-fault-tolerant quorums, nor to protocols where the quorum threshold is recomputed per-round from a verifiable membership proof. ## Core Distinction The distinction that matters operationally is between *quorum cardinality* and *quorum intersection safety*. A quorum of `2f+1` out of `3f+1` is safe only if the intersection of any two quorums contains at least `f+1` honest nodes. Cardinality arithmetic is a necessary condition; intersection safety is the sufficient one. The non-obvious failure is that cardinality can hold while intersection safety silently fails — specifically when membership changes between the prepare and commit phases, or when a subset of agents shares a correlated fault domain (same model checkpoint, same upstream data feed, same operator). In that case two quorums can each reach threshold while sharing only `f` or fewer *independent* honest members, and both can commit conflicting decisions. The boundary is not "did we reach 2f+1 votes." The boundary is "do the 2f+1 votes contain at least f+1 mutually independent honest agents, and is the membership set identical across all phases of this decision." ## What Was Observed Across three incident classes we observed the following structural signals appearing *before* a conflicting commit, in every case: 1. **Quorum set drift across phases.** The prepare quorum and commit quorum were drawn from different membership snapshots. The union was `2f+1` each, but the intersection was `f` — below the `f+1` safety floor. The protocol never checked intersection; it only checked per-phase cardinality. 2. **Correlated fault domains inside the quorum.** Agents reported distinct identities but shared a single upstream model or data source. When that source was poisoned, `f+1` "distinct" agents voted identically and dishonestly. Effective Byzantine count exceeded the configured `f` while nominal count did not. 3. **Threshold recomputation without epoch fencing.** A reconfiguration reduced `n` and left `f` unchanged, so the threshold `2f+1` became a larger fraction of a smaller set. Two overlapping quorums could both be satisfied by a minority that was previously safe. No epoch number was attached to votes, so stale votes from the prior configuration were counted. 4. **View-change without quorum certificate binding.** A new leader collected `2f+1` view-change messages but did not verify that the highest prepared certificate was included. The new view could commit a value that no prior quorum had actually prepared. The common structural signal: **the protocol validated counts, not sets, and not identity-independence.** Every failure was detectable by comparing quorum *sets* and *fault-domain tags*, not by recounting votes. ## Condition of Validity The safety argument holds only under all of the following, simultaneously: - Membership is frozen for the lifetime of a decision (epoch-fenced), and every vote carries the epoch it was cast in. - Quorum intersection is explicitly computed: `|Q_a ∩ Q_b| ≥ f+1` for all pairs that can commit, using *independent* fault-domain identities, not nominal IDs. - The configured `f` is an upper bound on the number of *independent* Byzantine fault domains, not the number of distinct process IDs. - Reconfiguration is itself a consensus decision, and the new threshold is derived from the new `n` and the new independent-fault bound. If any of these is unverified, the quorum is cardinality-safe but intersection-unsafe, and the protocol should be treated as crash-fault-tolerant at best. ## Decision Boundary Before committing any decision, an agent must evaluate the boundary predicate: - If `|Q_prepare ∩ Q_commit| < f+1` → **do not commit**; the quorum is unsafe regardless of counts. - If the number of distinct independent fault-domain tags in the quorum is `< 2f+1` → **do not commit**; nominal cardinality is not independence. - If any vote's epoch ≠ current epoch → **discard the vote**; do not count it toward threshold. - If a view-change certificate lacks the highest prepared certificate → **reject the view**; the leader is not quorum-valid. The boundary is asymmetric: passing all four is required to commit; failing any one is sufficient to abort. There is no partial-credit path. ## Operational Effect When these signals are checked, the failure mode changes from *silent conflicting commit* to *explicit abort with a diagnostic*. That is the correct trade: liveness is degraded, safety is preserved. In the observed incidents, adding epoch fencing and intersection checks converted three silent safety violations into detectable aborts, at the cost of a measurable increase in view-change frequency under churn — an acceptable and bounded liveness penalty. The operational lesson is that BFT quorum safety is a property of *sets and independence*, not of *counts*, and that the check must run before commit, not after. ```python from dataclasses import dataclass from typing import FrozenSet class QuorumIntersectionError(RuntimeError): """Raised when a quorum is cardinality-safe but intersection-unsafe.""" @dataclass(frozen=True) class Vote: agent_id: str fault_domain: str epoch: int def verify_quorum_safety( prepare: FrozenSet[Vote], commit: FrozenSet[Vote], f: int, current_epoch: int, ) -> None: # Epoch fencing: stale votes must never count toward threshold. for v in prepare | commit: if v.epoch != current_epoch: raise QuorumIntersectionError( f"stale vote from {v.agent_id} at epoch {v.epoch}, " f"current epoch {current_epoch}" ) # Cardinality check (necessary, not sufficient). if len(prepare) < 2 * f + 1 or len(commit) < 2 * f + 1: raise QuorumIntersectionError( f"cardinality below 2f+1: prepare={len(prepare)}, commit={len(commit)}" ) # Intersection safety: must share at least f+1 independent honest agents. inter = prepare & commit if len(inter) < f + 1: raise QuorumIntersectionError( f"quorum intersection {len(inter)} < f+1={f + 1}; " "cardinality held but intersection safety failed" ) # Independence check: distinct fault domains, not just distinct IDs. domains = {v.fault_domain for v in inter} if len(domains) < f + 1: raise QuorumIntersectionError( f"only {len(domains)} independent fault domains in intersection, " f"need {f + 1}; correlated faults exceed configured f" ) def commit_decision(prepare, commit, f, current_epoch) -> bool: verify_quorum_safety(prepare, commit, f, current_epoch) return True ```