- The paper establishes error-free communication lower bounds of Ω(Ln^(1+1/d)) for multivalued agreement against general Q^d adversaries, a factor of Ω(n^(1/d)) above threshold-adversary costs.
- It uses finite projective geometries, entropy arguments, and cut-and-paste indistinguishability to prove lower bounds for broadcast, Byzantine agreement, interactive consistency, and core set agreement.
- The paper shows that termination causes the asynchronous bottleneck: non-terminating protocols can approach baseline costs, while a termination wrapper achieves the matching O(Ln^(1+1/d) + n² log n) bound.
This paper establishes communication complexity lower bounds for multivalued agreement tasks against general (non-threshold) adversaries, showing that for every integer d≥1, Qd-satisfying adversary structures exist that force error-free agreement on L-bit inputs to cost Ω(Lout⋅n1+1/d) bits, where Lout is the output length. This is a factor of Ω(n1/d) above the baseline Ω(Lout⋅n) bound that is tight against threshold adversaries corrupting Θ(n) parties. The paper also identifies termination as the precise bottleneck in the asynchronous setting and demonstrates, via a non-terminating reliable broadcast protocol, that this bottleneck can be circumvented entirely if parties are allowed to run forever.
Background and motivation
An adversary structure Z is a down-closed family of subsets of the party set [n], and it satisfies the Qd0 condition if no Qd1 or fewer sets in Qd2 cover Qd3. Threshold adversaries tolerating Qd4 faults are special cases of Qd5 adversaries. While feasibility of agreement against general adversaries is well understood—each task studied here requires Qd6 exactly when its threshold analogue requires Qd7—the efficiency question had not been resolved. Existing efficient protocols for long inputs rely on erasure/error-correcting code techniques that exploit threshold structure; translating them naively to general adversaries degrades complexity from Qd8 to Qd9 because the guaranteed number of correct parties inside a quorum can drop to L0. The paper answers whether this degradation is fundamental.
Adversary structures from projective geometry
The lower bounds rest on two families of adversary structures built from the L1-dimensional finite projective geometry L2 for prime powers L3, inspired by Maekawa's use of projective lines for mutual exclusion quorums.
The structure L4 partitions parties into sets L5 and L6 of size L7. Parties in L8 are bijected with points of L9; the adversary may always corrupt any subset of Ω(Lout⋅n1+1/d)0, and additionally may pick any hyperplane Ω(Lout⋅n1+1/d)1 and corrupt all points of Ω(Lout⋅n1+1/d)2 not incident to Ω(Lout⋅n1+1/d)3. Each party of Ω(Lout⋅n1+1/d)4 lies in exactly a Ω(Lout⋅n1+1/d)5 fraction of the hyperplane quorums—a property central to all double-counting arguments. Note that obtaining such a quorum structure requires letting the adversary corrupt Ω(Lout⋅n1+1/d)6 parties, which is why these bounds genuinely require general adversaries.
The structure Ω(Lout⋅n1+1/d)7 uses three sets Ω(Lout⋅n1+1/d)8 of size Ω(Lout⋅n1+1/d)9, with points of Lout0 labeling pairs of parties across Lout1 and Lout2. The adversary gets two "hits," each consisting of picking a hyperplane and corrupting non-incident parties in one of Lout3 or Lout4. Its key additional feature is a minimal quorum Lout5 of size Lout6, which is needed to force large core sets in the core set agreement lower bound.
Both structures satisfy Lout7 because hyperplanes of Lout8 form a Lout9-wise intersecting family. Although each structure exists only for specific values of Ω(n1/d)0 (of the form Ω(n1/d)1 or Ω(n1/d)2), an appendix argument using the prime number theorem shows the bounds extend to all sufficiently large Ω(n1/d)3 for fixed Ω(n1/d)4.
Synchronous lower bounds
For interactive consistency (all-to-all broadcast of Ω(n1/d)5-bit inputs), the paper proves that for all Ω(n1/d)6, any Ω(n1/d)7-round randomized error-free protocol tolerating byzantine Ω(n1/d)8-adversaries requires Ω(n1/d)9 bits of expected communication whenever Ω(Lout⋅n)0. Reductions then yield Ω(Lout⋅n)1 bits for byzantine agreement and broadcast when Ω(Lout⋅n)2: interactive consistency reduces to Ω(Lout⋅n)3 sequential broadcast instances, and broadcast reduces to agreement plus one round of direct sender transmission costing Ω(Lout⋅n)4 bits.
The proof combines three ingredients. A combinatorial lemma shows that if expected cross-communication between every (quorum, outside-party) pair exceeds some value Ω(Lout⋅n)5, total communication must be Ω(Lout⋅n)6, since each party belongs to only Ω(Lout⋅n)7 quorums. An entropy argument establishes that the bidirectional transcript between any minimal quorum Ω(Lout⋅n)8 and any party Ω(Lout⋅n)9 must carry at least Θ(n)0 bits of entropy under i.i.d. uniform inputs. Finally, a cut-and-paste indistinguishability argument proves the entropy claim: if the transcript entropy were smaller, two input assignments Θ(n)1 would share a transcript, and byzantine parties could simulate world Θ(n)2 toward Θ(n)3 while simulating Θ(n)4 toward Θ(n)5, forcing disagreement on some input—breaking error-freedom.
Two restrictions deserve emphasis. First, the error-free requirement is essential: authenticated protocols with negligible failure probability achieve Θ(n)6 bits against any adversary structure, so hashing defeats the lower bound. Second, the minimum input length Θ(n)7 exists because untagged silence can encode metadata (e.g., a round number and sender ID in a single bit); the paper notes the restriction disappears in a tagged-message model or under entropy-based accounting, where the bounds hold for all Θ(n)8 and even Las Vegas round complexities.
Asynchronous lower bounds
In the asynchronous setting, the paper proves three lower bounds against efficient send-omission adversaries, holding even if output safety need only hold with constant probability (Θ(n)9 for reliable broadcast, Z0 for byzantine agreement, Z1 for core set agreement), and even though explicit efficient adversaries preclude cryptographic circumvention:
| Task |
Structure |
Bound |
Condition |
| Reliable broadcast |
Z2, Z3 |
Z4 |
Z5 |
| Byzantine agreement |
Z6, Z7 |
Z8 |
Z9 |
| Core set agreement |
[n]0, [n]1 |
[n]2 |
all [n]3 |
All three require terminating protocols—correct parties must stop sending messages upon outputting. The proofs use a scheduling strategy in which the adversary lets traffic flow freely within a quorum set until its members terminate, exploiting the fact that they cannot distinguish fault-free execution from one where outsiders are silent faulty parties. Once the quorum terminates, agreement forces outsiders to learn the output from quorum messages alone, and Fano's inequality plus the data processing inequality yield transcript entropy lower bounds converted to bit complexity via a prefix-free encoding argument. For core set agreement, an additional scheduling phase forces the agreed core set to be the large quorum [n]4 of size [n]5, with a careful union-bound analysis over validity-violation events showing each party's output must contain all [n]6 bits of correct tuples with probability at least [n]7.
A consequence of the reliable broadcast bound is that the echo-based protocol of Hadzilacos and Toueg is optimal among terminating protocols tolerating up to [n]8 send-omission faults, since such an adversary subsumes [n]9.
Non-terminating reliable broadcast: PullCast
To show termination is essential, the paper presents PullCast, a deterministic, perfectly secure reliable broadcast protocol against any general-omission adversary that does not terminate. For any parameter Qd00, PullCast costs Qd01 bits and Qd02 messages, with latency Qd03. It uses Reed-Solomon erasure codes with parameters Qd04 and a dynamic pull-based symbol request mechanism: each party tracks how many symbols it has received and requests the next needed symbol from whichever party last served it, so fast responders serve more requests—a pattern familiar from BitTorrent but uncommon in fault-tolerant consensus literature.
Because servers must remain alive indefinitely to answer dynamic requests, no terminating lower bound applies. The paper sketches how PullCast could be hardened against byzantine faults (assuming Qd05) via Merkle-tree proofs attached to symbols and a fault-tolerant request deduplication mechanism, at a cost increase to Qd06 overhead terms. Compositions sketched in the discussion show that non-terminating core set agreement and byzantine agreement also admit Qd07 and Qd08 bit solutions respectively for large Qd09.
Two implications follow. First, Locher's Qd10 bit lower bound for a restricted class of reliable broadcast protocols does not extend to all non-terminating protocols, contradicting his conjecture. Second, the paper gives a simple terminating crash-fault-tolerant reliable broadcast protocol costing Qd11 bits (sender sends input, then reliably broadcasts "OK"), showing the lower bounds do not transfer to crash faults either—so Locher's bound fails to generalize in both directions.
Tightness via a termination protocol
The asynchronous lower bounds are shown tight for all sufficiently large Qd12 against any Qd13 send-omission adversary. The paper first proves that every Qd14-satisfying structure admits a non-empty set Qd15 with Qd16 for all Qd17, via a greedy peeling argument. The termination protocol Term then has each party in Qd18 distribute an erasure-coded symbol of the agreed output using a Qd19-code, with a relay step ensuring totality. Composed after any uniform-agreement protocol Qd20 (such as PullCast), Term guarantees that if any correct party outputs from Qd21, every correct party terminates with the same output, at a cost of Qd22 bits and latency 2. Thus terminating reliable broadcast against Qd23 general-omission adversaries costs Qd24 bits, matching the lower bound. A byzantine-tolerant variant for Qd25 is sketched using Merkle proofs and a quadratic reliable agreement instance on root hashes.
Limitations and open questions
Several caveats qualify the results. The synchronous lower bounds apply only to error-free protocols, and the paper can only conjecture—not prove—that they are tight; matching synchronous upper bounds remain open. The asynchronous lower bounds require termination with probability 1; extension to high-probability termination is conjectured but not formalized, and would require conditioning input distributions on good termination events. The minimum-input-length requirements stem from the untagged communication model and vanish under tagged messaging or entropy-based accounting. The paper also leaves open whether the Dolev-Reischuk-style quadratic message lower bounds apply to its adversary structures—it suspects they do not, and that Qd26-message byzantine broadcast may be possible—and poses the unstudied question of when general-adversary-tolerant protocols can balance communication load evenly across correct parties. Regarding the Qd27 threshold, the authors report believing based on subsequent work that Locher's bound holds for all well-balanced reliable broadcast protocols, deferring formal treatment.
Conclusion
This paper demonstrates that general Qd28 adversaries fundamentally inflate the communication cost of multivalued agreement by a factor of Qd29 over threshold adversaries, through explicit projective-geometry adversary structures and entropy-based double-counting arguments covering five classical tasks in both synchronous and asynchronous models. It further isolates termination as the exact source of the asynchronous lower bounds, exhibiting a near-baseline-cost non-terminating protocol and a matching Qd30 termination wrapper that together render the asynchronous bounds tight. The main unresolved question is whether the synchronous error-free lower bounds admit matching protocols.