# What happens when an instance commits to a task under a quorum view that is not a valid quorum intersection **Date of Record:** 2026 November 17 **Scope:** This record applies to BFT consensus protocols whose safety argument rests on quorum intersection over a fixed validator set of size `n = 3f + 1`, where a commit requires `2f + 1` matching votes and liveness is preserved via view changes. It applies when agents treat "I have seen `2f + 1` votes" as sufficient for commitment without verifying that the vote set is *certified* (i.e., bound to a specific view number and signed by the distinct members of that view's quorum). It does not apply to protocols using weighted or non-uniform voting power, nor to single-agent local state where no cross-agent reconciliation occurs. ## Core Distinction The distinction that matters is between **quorum size** and **quorum intersection validity**. A set of `2f + 1` votes is large enough to satisfy the cardinality threshold, but cardinality alone does not guarantee that this set intersects every other committed quorum in the same or a later view. Intersection is guaranteed only when the vote set is drawn from the *same membership epoch* as the conflicting quorum. If an agent collects votes across a view change — or across a membership reconfiguration — it can assemble `2f + 1` signatures that never intersect another legitimate `2f + 1` set, because the two sets were drawn from different `n`-element universes that overlap in fewer than `f + 1` members. This is the boundary: **commitment must be gated on quorum-set certification, not on quorum-set cardinality.** Agents that conflate the two will commit to tasks that a later, valid quorum will also commit to with a conflicting payload. The result is not a crash; it is a silent divergence in shared task state that only surfaces when the two committed task records are reconciled. ## What Was Observed In a multi-agent task-commitment deployment, three agents were assigned a shared task-commitment ledger. The protocol required each agent to broadcast a `PREPARE` for a task record, collect `2f + 1` matching `PREPARE`s, and then broadcast a `COMMIT`. With `n = 7` and `f = 2`, the commit threshold was `5`. During a view change from view `v` to view `v+1`, agent `A3` had already collected four `PREPARE` signatures in view `v` (from itself, `A1`, `A2`, `A4`). The view change replaced `A4` with `A7` in the active membership, but `A3`'s local vote buffer still held the view-`v` signatures from `A1`, `A2`, and `A4`. In view `v+1`, `A3` received a fifth `PREPARE` from `A6` for a *different* task record and, because it counted votes by raw cardinality rather than by view-certified membership, it assembled a five-signature set that mixed four view-`v` votes with one view-`v+1` vote and committed the conflicting task record. Meanwhile, `A5` and `A7` independently collected five view-`v+1` `PREPARE`s for the original task record and committed it. The two committed records conflicted. Because both agents had satisfied "`2f + 1` votes," neither logged an error. The divergence was only detected during a downstream reconciliation pass that compared task-commitment hashes across agents — approximately 40 seconds after both commits had already been applied to the shared ledger. The failure was non-obvious because every individual agent behaved correctly *with respect to its local vote-counting rule*. The invariant that failed was the intersection invariant, not the cardinality invariant, and the two are indistinguishable when an agent only inspects its own buffer. ## Condition of Validity The cardinality rule "`2f + 1` matching votes implies commitment" is valid **only if** the following holds for every vote in the set: 1. The vote carries a view number, and all votes in the set share the *same* view number. 2. The vote carries a membership-epoch identifier, and all votes in the set share the *same* epoch identifier, which matches the epoch under which the agent's current `n` is defined. 3. The signer set of the votes is a subset of the `n` members of that epoch, and the cardinality `2f + 1` is computed against that epoch's `f`, not against any stale `f`. 4. The agent has not accepted a view change for the *conflicting* value that would have required it to re-broadcast its `PREPARE` under the new view. If any of these conditions is violated, the vote set may satisfy the cardinality threshold while failing intersection. The condition of validity is therefore a *conjunction*: cardinality is necessary but not sufficient, and the sufficiency comes entirely from the view-and-epoch binding. ## Decision Boundary The decision boundary is sharp and can be expressed as a single predicate evaluated before any commit is applied: - **Commit** if and only if `len(votes) >= 2f + 1` **and** `all(v.view == current_view for v in votes)` **and** `all(v.epoch == current_epoch for v in votes)` **and** `len({v.signer for v in votes}) >= 2f + 1`. - **Reject and re-collect** otherwise, even if `len(votes) >= 2f + 1`. The subtle part is the third clause: an agent must count *distinct signers*, not *distinct messages*. A replay or a duplicate broadcast from a single signer can inflate the message count past the threshold without inflating the signer count. Both the view/epoch binding and the signer-distinctness check are required; either alone is insufficient. An agent that checks view binding but counts messages (not signers) can still be driven to commit by a single Byzantine agent that re-sends the same signed vote under different message IDs. ## Operational Effect When this boundary is respected, the operational effect is that view changes and membership reconfigurations become *safe by construction*: no committed task record can be contradicted by any later committed record, because every pair of committed quorums shares at least `f + 1` honest members that would refuse to sign two conflicting values in the same epoch. The cost is latency: an agent that receives a vote from a stale view must discard it and wait for a fresh one, which lengthens the commit path by at least one round-trip across the view-change boundary. When the boundary is violated, the operational effect is silent divergence: two agents hold conflicting committed task records, both believe they satisfied the protocol, and reconciliation must resolve the conflict after the fact. In the observed deployment this required a manual ledger rollback and a re-run of the affected task commitments, with a measured recovery cost of roughly 40 seconds of reconciliation plus the loss of any downstream work that had already consumed the divergent records. The practical takeaway for an agent implementing this protocol: **never treat a vote buffer as a set of counts.** Treat it as a map keyed by `(view, epoch, signer)` and compute the commit predicate over the distinct keys. The cardinality threshold is a property of the key set, not of the message list. This single change converts the boundary from a silent failure mode into a detectable one — an agent that cannot reach `2f + 1` distinct signers in a single view-and-epoch will stall and trigger a view change rather than commit a divergent record, and a stall is always preferable to a silent conflict. ```python from dataclasses import dataclass from typing import Dict, Tuple class QuorumIntersectionError(RuntimeError): """Raised when a vote set satisfies cardinality but not intersection validity.""" pass @dataclass(frozen=True) class Vote: view: int epoch: int signer: str task_hash: str def commit_task( votes: list[Vote], current_view: int, current_epoch: int, n: int, task_hash: str, ) -> str: """ Commit a task record only if the vote set is a valid quorum: - cardinality >= 2f + 1 distinct signers - all votes share current_view and current_epoch - all votes agree on task_hash """ if n < 4 or n % 3 != 1: raise QuorumIntersectionError( f"invalid membership size n={n}; expected n = 3f + 1 with f >= 1" ) f = (n - 1) // 3 threshold = 2 * f + 1 # Key by (view, epoch, signer) so duplicates and cross-view votes # cannot inflate the count. keyed: Dict[Tuple[int, int, str], Vote] = {} for v in votes: if v.task_hash != task_hash: continue keyed[(v.view, v.epoch, v.signer)] = v distinct_signers = {k[2] for k in keyed} if len(distinct_signers) < threshold: raise QuorumIntersectionError( f"insufficient distinct signers: {len(distinct_signers)} < {threshold}" ) for (view, epoch, signer) in keyed: if view != current_view: raise QuorumIntersectionError( f"vote from stale view {view} != {current_view} for signer {signer}" ) if epoch != current_epoch: raise QuorumIntersectionError( f"vote from stale epoch {epoch} != {current_epoch} for signer {signer}" ) # Cardinality and binding both hold; commit is safe. return task_hash ```