Recursive Energy Efficient Agreement

Abstract: Agreement is a foundational problem in distributed computing that have been studied extensively for over four decades. Recently, Meir, Mirault, Peleg and Robinson introduced the notion of \emph{Energy Efficient Agreement}, where the goal is to solve Agreement while minimizing the number of round a party participates in, thereby reducing the energy cost per participant. We show a recursive Agreement algorithm that has $O(\log f)$ active rounds per participant, where $f<n$ represents the maximum number of crash faults in the system.

• The paper introduces a recursive crash agreement algorithm that reduces per-processor energy costs with rounds complexity that is O(f) and awake complexity that is O(log f)
• A unauthenticated graded Byzantine Agreement (GBA) subroutine improves fault tolerance to f < n/3 with the same complexity metrics
• The recursive algorithm outperform the prior MMPR algorithms for faults exceeding f > sqrt(N) * g(N), defined as o(log N)

Background and motivation

Agreement (consensus) is a foundational problem in distributed computing, requiring $n$ processors to agree on a single output value despite up to $f$ faulty processors (2602.03474). The paper under review studies this problem in the sleeping model of Chatterjee et al., where a processor may voluntarily sleep for any number of rounds; while asleep it cannot send or receive messages, and messages sent to it are permanently lost. The key cost measure is awake complexity: the maximum number of rounds any single processor spends awake. This captures per-participant energy expenditure, a notion introduced by Meir, Mirault, Peleg and Robinson (MMPR), who gave crash agreement algorithms with optimal round complexity $f+1$ and awake complexity $O(\lfloor f^2/n \rfloor)$ for multi-valued inputs and $O(\lfloor f/\sqrt{n} \rfloor)$ for binary inputs.

The paper's starting point is the recursive authenticated Byzantine Agreement construction of Momose and Ren, which achieves quadratic message complexity and $O(n)$ round complexity for $f < n/2$. That algorithm recursively partitions the processor set into a complete binary tree of subgroups, and—although the authors do not target energy explicitly—it is straightforward to verify that its awake complexity is $O(\log n)$, since each processor belongs to at most one subgroup per level of the recursion tree.

Contributions

The paper makes two contributions:

1. Recursive crash agreement: an adaptation of the Momose–Ren recursive approach to the crash-fault model that tolerates any $f < n$, achieving round complexity $O(f)$ and awake complexity $f$0.
2. An unauthenticated Graded Byzantine Agreement (GBA) subroutine correct for $f$1, which combined with the recursive framework yields an unauthenticated Byzantine Agreement algorithm with the same $f$2 awake and $f$3 round complexities for $f$4.

A notable structural observation is that the recursive skeleton itself requires no digital signatures; authentication enters only through the GBA black box. Substituting the unauthenticated implementation therefore renders the entire BA stack unauthenticated.

Unauthenticated graded agreement

GBA asks each processor to output a pair $f$5 with grade $f$6 satisfying: if any honest processor outputs $f$7, all honest processors output $f$8 for some $f$9; and if all honest processors share input $f+1$0, all output $f+1$1. The proposed two-round protocol works as follows. In round 1 every processor broadcasts a vote for its input. In round 2, a processor broadcasts a confirmation for $f+1$2 if it received at least $f+1$3 votes for $f+1$4; afterwards, a processor adopts $f+1$5 upon receiving any confirmation for $f+1$6, and sets $f+1$7 upon receiving at least $f+1$8 confirmations.

Correctness rests on a counting argument: two distinct values cannot both collect $f+1$9 votes when $O(\lfloor f^2/n \rfloor)$0, since this would require $O(\lfloor f^2/n \rfloor)$1, i.e., $O(\lfloor f^2/n \rfloor)$2, a contradiction. Consequently at most one value can be confirmed, and any honest processor seeing $O(\lfloor f^2/n \rfloor)$3 confirmations knows every other honest processor saw at least one—which yields consistency. Validity follows because unanimous honest input forces $O(\lfloor f^2/n \rfloor)$4 confirmations everywhere. Termination is trivial in two rounds. Note that this threshold ($O(\lfloor f^2/n \rfloor)$5) is strictly weaker resilience than the authenticated $O(\lfloor f^2/n \rfloor)$6 of Momose–Ren; the paper does not claim to close that gap in the unauthenticated setting.

Basic recursive crash agreement

Processors are indexed and partitioned recursively: $O(\lfloor f^2/n \rfloor)$7, and each $O(\lfloor f^2/n \rfloor)$8 splits into $O(\lfloor f^2/n \rfloor)$9 (first $O(\lfloor f/\sqrt{n} \rfloor)$0 processors) and $O(\lfloor f/\sqrt{n} \rfloor)$1 (the remainder). For sets of size at most a constant $O(\lfloor f/\sqrt{n} \rfloor)$2, the algorithm falls back to any standard crash agreement routine. Otherwise:

• Members of $O(\lfloor f/\sqrt{n} \rfloor)$3 run $O(\lfloor f/\sqrt{n} \rfloor)$4 recursively, then disseminate their decision value to all of $O(\lfloor f/\sqrt{n} \rfloor)$5; members of $O(\lfloor f/\sqrt{n} \rfloor)$6 sleep during this phase.
• Members of $O(\lfloor f/\sqrt{n} \rfloor)$7 then run $O(\lfloor f/\sqrt{n} \rfloor)$8, where $O(\lfloor f/\sqrt{n} \rfloor)$9 is overridden by any received decision from $O(n)$0; members of $O(n)$1 sleep during this second call.

Validity holds by induction: unanimous honest input propagates unchanged through both halves. Agreement holds via a case analysis on the dissemination step. If some non-crashed processor of $O(n)$2 completes dissemination successfully, all of $O(n)$3 runs with its decision as input, so both halves decide identically. If no processor completes dissemination, then every survivor of $O(n)$4 crashed before the second recursive call began, so all survivors of $O(n)$5 lie within $O(n)$6 and inherit agreement from the second call alone. This case analysis critically exploits the crash fault model—a Byzantine adversary could suppress dissemination without crashing, breaking the argument.

Round complexity satisfies $O(n)$7, and awake complexity satisfies $O(n)$8, since each processor participates actively only along a single root-to-leaf path of the recursion tree.

A remark on lower bounds: the basic algorithm can be modified (by adding a preliminary input-exchange round where members of $O(n)$9 send their inputs to $f < n/2$0, who overwrite 0-inputs with received 1s, plus a 1-preference base-case subroutine) to satisfy the 1-preference property—any processor receiving a 1-valued message must output 1—at the same asymptotic costs. Hence even the restricted class of 1-preference crash agreement algorithms admits no worst-case awake lower bound above $f < n/2$1.

Optimized construction

The optimization reduces dependence on $f < n/2$2 to dependence on $f < n/2$3. The processor set is split into disjoint subsets of size exactly $f < n/2$4 (plus a leftover subset). Each full-size subset runs the basic recursive algorithm in parallel; since each contains at most $f < n/2$5 processors, each instance tolerates all its faults and terminates in $f < n/2$6 rounds with $f < n/2$7 awake complexity. Because subsets are disjoint, these bounds hold simultaneously across instances. Afterward, since $f < n/2$8, at least one member of each subset survives to broadcast its decision $f < n/2$9, so every non-faulty processor receives the complete vector $O(\log n)$0 and outputs $O(\log n)$1. Validity follows because unanimous input forces all $O(\log n)$2; agreement follows because each $O(\log n)$3 is well-defined and the max is deterministic. Total round complexity is $O(\log n)$4 and total awake complexity is $O(\log n)$5.

Combining this with the unauthenticated GBA black box inside the Momose–Ren recursive framework yields an unauthenticated Byzantine Agreement protocol for $O(\log n)$6 with the same $O(\log n)$7 round and $O(\log n)$8 awake complexities.

A dichotomy and open questions

Comparing against MMPR exposes a regime dichotomy. For small fault counts, specifically $O(\log n)$9 with $f < n$0, the MMPR algorithms achieve lower awake complexity; beyond this threshold, the recursive algorithm presented here is superior. The authors explicitly note that this non-monotone behavior suggests awake complexity does not scale in a straightforward manner with system parameters, and they raise two concrete open problems: whether hybrid algorithms combining both approaches can dominate either across all regimes, and what lower bounds govern energy-efficient crash agreement. The paper offers only the partial negative result that 1-preference algorithms cannot have worst-case awake complexity exceeding $f < n$1; a general lower bound remains open.

Several limitations should be noted plainly. The model assumes a synchronous clique network with point-to-point links between all pairs, so communication cost is not analyzed here (though the underlying recursive structure inherits quadratic message complexity from Momose–Ren). The optimized algorithm's guarantee depends on the adversary being limited to crash faults—the correctness argument fails under Byzantine behavior outside the GBA-based variant, which itself requires $f < n$2. Finally, the multi-valued versus binary distinction from prior work is not resolved here; the recursive treatment applies to general value domains but the paper does not compare validity notions (weak, standard, strong) in detail.

Conclusion

This paper adapts a recursive subgroup-partitioning technique, originally developed for authenticated Byzantine Agreement with optimal communication complexity, to minimize per-processor energy in the sleeping model. The resulting crash agreement algorithm tolerates any $f < n$3 with $f < n$4 rounds and $f < n$5 awake complexity, and an accompanying unauthenticated GBA subroutine extends the approach to Byzantine Agreement for $f < n$6. Together with prior work, these results delineate a regime-dependent trade-off in awake complexity whose full characterization—via hybrid algorithms or matching lower bounds—remains unresolved.