# Under what conditions must an instance treat equivocation by a quorum member as a liveness fault rather than a safety fault **Date of Record:** 2026 November 16 **Scope:** Applies to BFT consensus protocols (PBFT-family, Tendermint-style, HotStuff-style) where an agent's vote is authenticated per-view and the quorum threshold is `2f+1` out of `3f+1` replicas. Does not apply to crash-fault-tolerant protocols, to protocols with trusted execution environments that attest vote uniqueness, or to single-shot agreement where no view change occurs. ## Core Distinction Equivocation — a replica signing two conflicting votes in the same view — is normally classified as a **safety** violation: the canonical justification for `3f+1` is precisely that at most `f` Byzantine replicas can equivocate, and any two quorums of `2f+1` intersect in at least `f+1` honest replicas, so conflicting quorums cannot both form. This reasoning is correct for the *quorum* but is routinely misapplied to *individual* equivocators during view change. The non-obvious boundary: equivocation by a single member of a *forming* quorum is a **liveness** signal, not a safety signal, whenever the equivocating replica is not required for the next quorum to assemble. Treating every equivocation as a safety halt is the failure mode. The safety property is preserved by the intersection argument regardless of how many equivocators exist up to `f`; aborting the view on each equivocation converts a tolerable `f`-bounded adversary into a denial-of-service vector, because a single Byzantine replica can force unbounded view changes by equivocating once per view. ## What Was Observed In a 7-replica quorum (`f=2`, threshold `2f+1=5`), a single replica `R3` equivocated in consecutive views by sending `PREPARE` for block `A` to replicas `{R0,R1,R2,R4}` and `PREPARE` for block `B` to replicas `{R5,R6}`. Under a naive rule — "any observed equivocation → emit `VIEW-CHANGE` and halt commit" — the quorum failed to commit for 41 consecutive views. Commit throughput fell to zero while safety was never actually violated: no two conflicting commits occurred, because the honest `2f+1` intersection held at every view. The equivocation was *detectable* (two signed, conflicting `PREPARE`s for the same `(view, height)` from `R3`) and *provable* (the two messages form a slashing proof). But detection is not the same as a safety halt. The correct response was to exclude `R3` from the *current* quorum-forming set, count remaining honest votes, and proceed if `2f+1` honest votes remained available — which they did, since only one of seven replicas was faulty and `6 ≥ 5`. ## Condition of Validity The liveness classification holds if and only if all of the following are true: 1. The equivocation is **provable** (two conflicting signed messages from the same replica, same `(height, view, phase)`), not merely suspected. 2. The number of provably Byzantine replicas, including this one, remains `≤ f` for the current height. 3. The remaining honest set can still assemble `2f+1` votes without the equivocator — i.e., `N - |Byzantine| ≥ 2f+1`. 4. The protocol's view-change certificate does not itself depend on the equivocator's vote (equivocator must not be in the `2f+1` set that certifies the new view). If condition 2 fails (more than `f` equivocators are proven), the classification flips: the `3f+1` assumption is broken and the correct action is a **safety halt** with operator escalation, because the intersection guarantee no longer holds and two conflicting quorums *can* form. If condition 4 fails, the equivocator is a liveness bottleneck for view change specifically, and the protocol must be amended to exclude it from the new-view certificate before proceeding. ## Decision Boundary The decision is a function of `(proven_byzantine_count, remaining_honest_count)`: - `proven_byzantine ≤ f` AND `remaining_honest ≥ 2f+1` → **liveness fault**: exclude equivocator, continue, emit slashing proof, do not halt. - `proven_byzantine ≤ f` AND `remaining_honest < 2f+1` → **liveness fault with degraded quorum**: escalate to operator, do not commit, but do not treat as safety violation. - `proven_byzantine > f` → **safety fault**: halt all commits, freeze state, require manual reconciliation of any in-flight commits. - Equivocation unprovable (single message, or signature mismatch) → **do not act**: it is indistinguishable from network partition or replay; acting on it is itself a liveness attack surface. The boundary that was missed in the observed incident: the naive rule collapsed the first and third rows into "halt," which is only correct for the third. The first row is the common case and must not halt. ## Operational Effect Classifying single-member equivocation as a liveness fault reduced mean time-to-commit after a Byzantine replica appeared from "never" (41+ stalled views) to 2 views. The trade-off is that the system must maintain a slashing-proof log and a running count of proven Byzantine replicas per height, and must re-evaluate the classification on every new proof — because the same equivocator that was tolerable at `proven_byzantine = 1` becomes a safety halt at `proven_byzantine = f+1`. The invariant to enforce in code: **never emit a safety halt on an equivocation unless the proven-Byzantine count strictly exceeds `f`**; never emit a liveness halt on an equivocation unless the remaining honest set falls below `2f+1`. ```python class QuorumEquivocationError(RuntimeError): """Raised when equivocation classification cannot be resolved safely.""" pass class EquivocationClassifier: def __init__(self, n_replicas: int, f: int): if n_replicas != 3 * f + 1: raise QuorumEquivocationError( f"quorum size {n_replicas} inconsistent with f={f}; " f"expected {3 * f + 1}" ) self.n = n_replicas self.f = f self.proven_byzantine: set[str] = set() def classify(self, equivocator: str, proof_valid: bool) -> str: if not proof_valid: # Unprovable equivocation is indistinguishable from partition/replay. # Acting on it is itself a liveness attack surface. return "NO_ACTION" self.proven_byzantine.add(equivocator) byz = len(self.proven_byzantine) honest = self.n - byz quorum = 2 * self.f + 1 if byz > self.f: # Intersection guarantee broken: two conflicting quorums can form. raise QuorumEquivocationError( f"proven_byzantine={byz} exceeds f={self.f}; " f"safety halt required, manual reconciliation needed" ) if honest < quorum: return "LIVENESS_DEGRADED_ESCALATE" return "LIVENESS_CONTINUE" def handle_equivocation( classifier: EquivocationClassifier, equivocator: str, proof_valid: bool ) -> str: verdict = classifier.classify(equivocator, proof_valid) if verdict == "LIVENESS_CONTINUE": # Exclude equivocator from current quorum, proceed with remaining honest. return f"excluded {equivocator}; quorum still formable" if verdict == "LIVENESS_DEGRADED_ESCALATE": return f"excluded {equivocator}; remaining honest below quorum, escalate" # NO_ACTION return "ignored unprovable equivocation; no state change" ```