Abstract 1 Introduction 2 Preliminaries 3 Terminating Anonymous Leader Election on Trees 4 Randomized Impossibilities 5 Necessity of Knowledge on Underlying Topology 6 Conclusion and Open Questions References

Beyond 2-Edge-Connectivity: Algorithms and Impossibility for Content-Oblivious Leader Election

Yi-Jun Chang ORCID National University of Singapore, Singapore Lyuting Chen ORCID National University of Singapore, Singapore Haoran Zhou ORCID National University of Singapore, Singapore
Abstract

The content-oblivious model, introduced by Censor-Hillel, Cohen, Gelles, and Sela (PODC 2022; Distributed Computing 2023), captures an extremely weak form of communication where nodes can only send asynchronous, content-less pulses. They showed that in 2-edge-connected networks, any distributed algorithm can be simulated in the content-oblivious model, provided that a unique leader is designated a priori. Subsequent works of Frei, Gelles, Ghazy, and Nolin (DISC 2024) and Chalopin et al. (DISC 2025) developed content-oblivious leader election algorithms, first for unoriented rings and then for general 2-edge-connected graphs. These results establish that all graph problems are solvable in content-oblivious, 2-edge-connected networks.

Much less is known about networks that are not 2-edge-connected. Censor-Hillel, Cohen, Gelles, and Sela showed that no non-constant function f(x,y) can be computed correctly by two parties using content-oblivious communication over a single edge, where one party holds x and the other holds y. This seemingly ruled out many natural graph problems on non-2-edge-connected graphs.

In this work, we show that, with the knowledge of network topology G, leader election is possible in a wide range of graphs. Our main contributions are as follows:

Impossibility:

Graphs symmetric about an edge admit no randomized terminating leader election algorithm, even when nodes have unique identifiers and full knowledge of G.

Leader election algorithms:

Trees that are not symmetric about any edge admit a quiescently terminating leader election algorithm with topology knowledge, even in anonymous networks, using O(n2) messages, where n is the number of nodes. Moreover, even-diameter trees admit a terminating leader election given only the knowledge of the network diameter D=2r, with message complexity O(nr).

Necessity of topology knowledge:

In the family of graphs 𝒢={P3,P5}, both the 3-path P3 and the 5-path P5 admit a quiescently terminating leader election if nodes know the topology exactly. However, if nodes only know that the underlying topology belongs to 𝒢, then terminating leader election is impossible.

Keywords and phrases:
Asynchronous model, fault tolerance, quiescent termination
Copyright and License:
[Uncaptioned image] © Yi-Jun Chang, Lyuting Chen, and Haoran Zhou; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Distributed algorithms
Related Version:
Full Version: https://arxiv.org/abs/2511.23297 [10]
Funding:
The research is supported by the Ministry of Education, Singapore, under its Academic Research Fund Tier 1 (24-1323-A0001). Any opinions, findings and conclusions or recommendations expressed in this material are those of the authors and do not reflect the views of the Ministry of Education, Singapore.
Editor:
Shubhangi Saraf

1 Introduction

Distributed systems often operate under unreliable communication, where messages may be corrupted. In many networks, silicon-based or natural, the inherent presence of alteration noise means any fault-tolerant algorithm must take received messages “with a grain of salt”, instead of relying on their content verbatim, whose integrity could have been compromised in transmission.

Content-oblivious model.

To design a fault-tolerant algorithm that operates correctly even when facing the most extreme form of alteration noise, the work of Censor-Hillel, Cohen, Gelles, and Sela [7] adopted the idea of using the sheer existence of messages to encode information. To demonstrate the full power of their results, they first proposed the extremely weak model of fully-defective networks, where message content is subject to arbitrary, unbounded alteration; therefore, such content-less messages are aliased pulses, and any correct algorithm must completely ignore message content, hence content-oblivious. Also, the network is asynchronous, meaning that nodes lack access to a global clock; each pulse delivery takes an unpredictable time, thus forbidding the use of the presence/absence of pulses to encode information.

Universal solvability from 2-edge-connectivity.

Naturally, one might conjecture that any non-trivial computational task is impossible when all messages are fully corrupted and arbitrarily delayed. However, Censor-Hillel, Cohen, Gelles, and Sela [7] showed otherwise: Assuming the presence of a pre-elected leader, any noiseless algorithm can be simulated in the content-oblivious setting, provided the network is 2-edge-connected. The key idea is that the leader communicates with a recipient using two disjoint paths – one to transmit the message in unary, and the other to signal the end of the transmission. This ensures that the recipient never waits indefinitely for the message to conclude, allowing the computation to make progress. Next, the work of Frei, Gelles, Ghazy, and Nolin [18] showed how to elect a leader from scratch in an oriented ring as the simplest form of 2-edge-connected networks, while [8] removed the orientation requirement. Moreover, the latter [8] showed that even for general 2-edge-connected networks, with an upper bound on the network size N known, non-uniform leader election exists. Combined with the simulation result of Censor-Hillel, Cohen, Gelles, and Sela [7], their findings imply the solvability of all graph problems in a content-oblivious, 2-edge-connected network.

Beyond 2-edge-connectivity.

On graphs that are not 2-edge-connected, Censor-Hillel, Cohen, Gelles, and Sela [7] showed the first negative result in the vanilla content-oblivious model. They showed that no non-constant function f(x,y) can be computed correctly and deterministically by two parties using content-oblivious communication over a single edge, where one party holds x and the other holds y. This two-party impossibility immediately yields a general impossibility result for any network containing a bridge e, since we may let the two parties simulate the two connected components of Ge.

While this observation suggests that many natural graph problems – including leader election – might be impossible to solve on non-2-edge-connected graphs, it is not immediately clear what specific impossibility results can be derived directly from the two-party impossibility. In this work, we take a different perspective and investigate which tasks can still be performed on non-2-edge-connected graphs. Indeed, it may well be that many non-trivial tasks remain feasible in ways that are fully consistent with the two-party impossibility result.

1.1 Contribution and Roadmap

In this work, we show a complete characterization of content-oblivious leader election on trees with topology knowledge: Terminating leader election is possible if and only if the tree is not symmetric about an edge.

Definition 1 (Edge symmetry).

A graph G is symmetric about an edge e={u,v} if Ge has exactly two connected components, H and K, containing u and v respectively, and there is an isomorphism f:V(H)V(K) with f(u)=v.

If a graph G is symmetric about an edge e, then e is necessarily a bridge, so G is non-2-edge-connected. On the feasibility side, in Section 3, we first design a content-oblivious leader election algorithm for even-diameter trees only (Theorem 2); following that, we extend the result to all trees that are not symmetric about any edge (Theorem 3).

Theorem 2 (Leader election on even-diameter trees).

There exists a terminating, anonymous content-oblivious leader election algorithm with message complexity O(nr) for a tree with even diameter D=2r and n nodes, provided that each node knows the diameter D of the tree a priori.

Theorem 3 (Leader election on general asymmetric trees).

There exists a quiescently terminating, anonymous content-oblivious leader election algorithm with message complexity O(n2) for a tree with n nodes, provided that each node knows tree topology G a priori, and the tree is not symmetric about any edge.

Turning to the impossibility side, in Section 4, we show that for graphs that are symmetric about an edge, topology knowledge does not result in any randomized algorithm that significantly outperforms trivial guesswork.

Theorem 4 (Edge symmetry implies impossibility, randomized).

Let G be a network that is symmetric about an edge, where nodes are anonymous and know the network topology G. Then there exists no terminating, randomized leader-election algorithm which succeeds with probability greater than 12.

As a corollary, we obtain the analogous impossibility result in the deterministic setting where nodes have unique 𝖨𝖣s. The proof of the corollary is in the full version [10] of the paper.

Corollary 5 (Edge symmetry implies impossibility, deterministic).

Let G be a network that is symmetric about an edge, and nodes are equipped with unique 𝖨𝖣s and know the network topology G. Then there exists no terminating, deterministic content-oblivious leader election algorithm.

In Section 5, we show that the exact knowledge of the network topology is indeed a necessary condition for terminating leader election on asymmetric trees.

Theorem 6 (Necessity of topology knowledge).

There exists no deterministic, terminating content-oblivious leader election algorithm if the underlying topology is drawn from the family 𝒢={P3,P5}, and 𝒢 is known to the nodes a priori, even if the nodes have unique 𝖨𝖣s.

Finally, in the full version [10] of the paper, we present a simple stabilizing leader election algorithm that works for all trees, showing that the termination requirement is indeed necessary for the impossibility results.

Theorem 7 (Stabilizing leader election).

There exists a stabilizing content-oblivious leader election algorithm of message complexity n+2𝖨𝖣𝗆𝖺𝗑1 on a tree with n nodes with unique 𝖨𝖣s.

Technical overview.

We briefly outline the main techniques underlying our leader election algorithms. Let D denote the diameter of the tree. In an even-diameter tree, if we repeatedly remove the leaves of the remaining tree, then after D/2 steps, only a single node remains. Our algorithm for even-diameter trees (Theorem 2) can be viewed as an implementation of this leaf-peeling process in the content-oblivious model, where the main challenge is handling asynchrony using only pulses. The key idea is to use the number of pulses sent to encode the height of a node.

For odd-diameter trees, the above leaf-peeling process leaves exactly two nodes. To elect a leader between them, we exploit the assumption that the tree is asymmetric. Our algorithm for general asymmetric trees (Theorem 3) uses the number of pulses to encode the topology of a subtree, thereby breaking symmetry between the two remaining nodes.

Finally, for our stabilizing algorithm for all trees (Theorem 7), we simply trim leaves in an arbitrary order until only two nodes remain, and then break symmetry between them by comparing their identifiers.

1.2 Additional Related Works

Leader election is one of the most fundamental problems in distributed systems, and has therefore enjoyed a long history of study (e.g., [9, 23, 26, 13, 24]). The works of [5, 31] study the conditions and impossibilities of breaking symmetry in anonymous networks, while [30, 12] examine symmetry breaking when nodes are labeled but 𝖨𝖣 collisions occur. A more recent result closely related to our work is that of Glacet, Miller, and Pelc [21], who studied the role of uniform advice in leader election. However, since their setting was the 𝖫𝖮𝖢𝖠𝖫 message-passing model, advice served only to accelerate leader election rather than enable it, leading to a series of trade-offs between locality and advice size. By contrast, if advice is non-uniform, leader election becomes trivial when only a simple “yes/no” answer is required. For stronger definitions of leader election [22] and for a broader range of information dissemination problems, non-uniform advice, also known as informative labeling schemes [25], has been studied.

Similar to the content-oblivious setting, various other weak-communication models have been studied to capture systems with constrained communication capabilities. A notable example is the synchronous beeping model introduced by Cornejo and Kuhn [11], where during each round, nodes can broadcast a beep to their neighbors and can distinguish between silence and the presence of at least one beep from their neighbors.

In the beeping model, the first positive result for leader election was shown by Ghaffari and Haeupler [19], who also established an Ω(D+logn)-round lower bound. Subsequent works [17, 15, 16] gradually approached this lower bound. In parallel, the works of Gilbert and Newport [20] and Vacus and Ziccardi [29] focused on a different direction: Designing algorithms that operate on a constant number of states, at a cost of a slightly higher round complexity.

The population protocol introduced by Angluin et al. [3] studies massive systems of state machines under random pairwise interactions. Assuming each pair of agents has equal probability of interaction, a series of results [14, 1, 27] explores the trade-off between the number of states and the number of expected interactions for electing a leader. The works of Berenbrink, Giakkoupis, and Kling [4] and Sudo et al. [28] proposed optimal leader elections under different state-size constraints. A recent work of Alistarh, Rybicki, and Voitovych [2] extended the study to cover the setting where only a subset of agent pairs may interact.

The leaf-peeling technique is well known and has been used in the design of various tree algorithms. For example, Bruell, Ghosh, Karaata, and Pemmaraju [6] employed this approach to develop distributed algorithms for finding the centers and medians of a tree network.

2 Preliminaries

Content-oblivious model.

Let G=(V,E) be a communication network, where each node vV is a computing device of unbounded computation power, and each edge eE is a communication link. Messages exchanged by nodes are subject to unbounded alteration noise, therefore, effectively contentless. Equivalently, we say computing devices only exchange pulses. All pulses are subject to unpredictable, unbounded delay, despite that an eventual delivery is always guaranteed, and nodes are aware of the incoming port of a pulse received. Therefore, a notion of shared time does not provide additional power to the network: the content-oblivious network is asynchronous, meaning a computing device may only perform actions upon initiation of any algorithm, or upon receiving a pulse. Without loss of generality, we assume all local computations to be instantaneous. When measuring the message complexity of an algorithm, we consider the total number of pulses sent.

Model variants.

Nodes in a content-oblivious network may either have unique positive integer 𝖨𝖣s or be anonymous. In the latter case, the behavior of a node is completely determined by the pulses it has received so far. The algorithm itself may be deterministic or randomized; in the randomized setting, each node is given an infinite and independent stream of random bits.

Topology knowledge.

We say that nodes are provided with topology knowledge of G if every node receives the same encoding of the topology of G without any 𝖨𝖣 information, so that no node can immediately infer its position in G from identifiers alone. However, a node may still deduce partial information about its position from its degree. For example, if G contains exactly two nodes of degree 3, then those two nodes can infer from the topology description that they must be among these two positions. When G is a tree, the underlying topology can be represented succinctly in O(n) bits (e.g., using a balanced-parentheses encoding), where n is the number of nodes.

Leader election.

We study the leader election problem, in which each node must decide between the outputs 𝖫𝖾𝖺𝖽𝖾𝗋 and 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋, and an execution of a leader election algorithm is successful if eventually exactly one node outputs 𝖫𝖾𝖺𝖽𝖾𝗋 while all others output 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋. We say that an algorithm stabilizes if, after some finite time from the initiation of the algorithm, the outputs of all nodes remain fixed. This notion of stabilization is purely analytic and global: nodes are not required to detect that they have stabilized.

A stronger guarantee is termination, which means that, after some finite time, each node commits to an output and halts. Termination is said to be quiescent if any node that has halted no longer receives pulses from its neighbors.

3 Terminating Anonymous Leader Election on Trees

In this section, we first prove Theorem 2 by providing a terminating algorithm for even-diameter trees, where network diameter D is provided to nodes a priori. Following that, we generalize the above result to prove Theorem 3 by providing a quiescently terminating algorithm where the underlying graph topology G is provided to nodes a priori.

3.1 Terminating Anonymous Leader Election on Even-Diameter Trees

In this section, we show a terminating leader election in anonymous, even-diameter trees. This algorithm requires each node to know the diameter D=2r.

Theorem 2 (Leader election on even-diameter trees). [Restated, see original statement.]

There exists a terminating, anonymous content-oblivious leader election algorithm with message complexity O(nr) for a tree with even diameter D=2r and n nodes, provided that each node knows the diameter D of the tree a priori.

We first provide a high-level overview of the algorithm. Each node performs a deterministic preprocessing phase locally using the information of D to derive a set of rules that the node uses for the upcoming election phase. Nodes hence monitor the triggering conditions of all rules, and perform (sending pulses and outputting leader election results) accordingly as the rules dictate. The pulse movement follows a bottom-top-bottom pattern. Leaf nodes initiate the election by sending pulses to their neighbors, and each node monitors the number of pulses it receives from each edge, constantly checking them against the set of rules derived. The center, which is the node with the minimum eccentricity, is unique for even-diameter trees. It triggers a special 𝐋𝐞𝐚𝐝𝐞𝐫 rule and terminates as leader. It then broadcasts a pulse so that every other node terminates as non-leader.

In the above high-level description, we mentioned nothing about what a rule looks like or how to interpret a rule. To understand that, let us first provide an intuition of what pulses encode in our leader election.

A certain number of pulses sent from node u to node v along the edge e={u,v} encodes the height of the subtree rooted at u, that is, the connected component of u in Ge. A subtree with height i, where 0ir1, is encoded by ri pulses. To be elected as leader, a node must receive at least one pulse from each neighbor. This seemingly upside-down encoding is to ensure two important properties:

  • The center is the only node that can become a leader. If we root the tree at any vertex vl, then there exists a root-to-leaf path whose length exceeds r. Consequently, there is a subtree rooted at a child u of v whose height exceeds r1. In this case, v can never receive a valid pulse from u encoding that subtree, and thus can never claim leadership. This ensures the correctness of the leader election.

  • Before a leader is elected, all pulses travel in the direction from leaves to the center. This property ensures that after a leader is elected, it can broadcast a pulse that unambiguously signals that a leader has been elected, hence making all other pulses terminate as non-leaders, ensuring the termination of all nodes.

We are now ready to formally describe the algorithm. Each node derives three categories of rules from the knowledge of D=2r: 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦, 𝐋𝐞𝐚𝐝𝐞𝐫, and 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦. A node keeps track of the number of received pulses on each port and compares against the rules upon each update. Initially, only 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 and 𝐋𝐞𝐚𝐝𝐞𝐫 rules are active. After a node triggers at least one of 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 and 𝐋𝐞𝐚𝐝𝐞𝐫 rules, 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 rules become active for that node.

  • 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦: There are r copies of 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦, one for each i[1,r]. The ith rule is defined as follows:

    Whenever a node with d ports sees d1 of its ports (that is, all except one) each receive at least i+1 pulses while the remaining port receives none, mark the remaining port as 𝖯𝗈𝗋𝗍. Send pulses along 𝖯𝗈𝗋𝗍, until the total number of pulses sent through 𝖯𝗈𝗋𝗍, since the start of the algorithm, is exactly i. Add 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 to the list of active rules, and remove the 𝐋𝐞𝐚𝐝𝐞𝐫 rule.

    Note that if a node has one port only, it automatically triggers the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule constructed for all i[1,r] upon initiation, resulting in sending r pulses along its only port, which is marked 𝖯𝗈𝗋𝗍.

  • 𝐋𝐞𝐚𝐝𝐞𝐫: Whenever a node with d ports sees each of its ports receive at least one pulse, send a pulse along all ports, declare 𝖫𝖾𝖺𝖽𝖾𝗋 and terminate.

  • 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦: When a pulse is received from 𝖯𝗈𝗋𝗍, send a pulse along every port except for 𝖯𝗈𝗋𝗍, declare 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋, and terminate.

To facilitate the analysis, we consider the layer decomposition resulting from the leaf-peeling process, defined as follows.

Algorithm 1 Layer decomposition.

Since the radius of the network is r, the last non-empty layer Vr contains exactly one node (the center of the tree), which we denote by l in the subsequent discussion.

As a concrete example, consider a complete binary tree of radius r. The leader election proceeds as follows: First, by the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule, each node in V0 (i.e., leaves) sends r pulses to its parent, who is in V1. Each node in V1 therefore receives r pulses from its neighbors in V0, and by the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule, sends r1 pulses to its parent, etc. Performing induction upwards, eventually the root receives at least one pulse from each of its neighbors, so it becomes the leader by triggering the 𝐋𝐞𝐚𝐝𝐞𝐫 rule. After that, the 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 rule will be triggered top-down: the now elected leader sends a pulse to each of its children, and then each node that receives a pulse from its parent triggers the 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 rule, sending a pulse to each of its children, until the entire tree is reached.

While the preceding example provides intuition for the correctness of the algorithm on all even-diameter trees, we now present a formal proof that the constructed rules indeed yield a terminating leader election procedure.

Observation 8.

For each vVi with 0ir1, it has exactly one neighbor u in G that belongs to j>iVj, while all other neighbors are in j<iVj. For the unique node lVr, it has all neighbors in j<rVj.

Definition 9 (Parent and children).

For each vVi, define the (possible) neighbor of v in G belonging to j>iVj as the parent of v. Define the neighbors of v in G belonging to j<iVj as the children of v.

Clearly, the unique node lVr has no parent, and all nodes vV0 have no children.

Observation 10.

For each vVi with 1ir, it has at least one child that belongs to Vi1.

Lemma 11.

Node l has at least two children in Vr1.

Observation 12.

Once a node triggers an Upstream rule, it never changes 𝖯𝗈𝗋𝗍.

Proof.

To assign a port (without loss of generality, port 0) as 𝖯𝗈𝗋𝗍, a node must trigger an 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule at a time when port 0 has not yet received any pulses. Hence, no other port can have been assigned 𝖯𝗈𝗋𝗍 earlier, since doing so would require port 0 to have already received a nonzero number of pulses in order to trigger some 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule.

Lemma 13.

If a node u is in Vi, i[0,r1], then u sends at most ri pulses to its parent.

Proof.

We proceed by induction over the layers from V0 to Vr, i.e., in a bottom-up manner.

Base case.

Let u be a leaf node in V0. By the definition of Upstream, u sends r pulses to its parent immediately upon initialization and never sends any more thereafter. Thus, the lemma holds for u.

Induction step.

Assume the lemma holds for all nodes in layers up to Vs for some s[0,r2]. Let u be a node in Vs+1, and let v be its parent.

Suppose that u sets 𝖯𝗈𝗋𝗍 to point toward v (otherwise, the lemma holds trivially for u). By Observation 10, u has exactly one child m in layer Vs. By the induction hypothesis, m sends at most rs pulses to u. By the definition of the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rules, u can therefore send at most rs1 pulses through 𝖯𝗈𝗋𝗍 to its parent v.

Lemma 14.

Node l cannot trigger any 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule.

Proof.

By Lemma 11, node l has at least two children in Vr1, each sending at most one pulse to l by Lemma 13. By the definition of 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦, l cannot trigger any 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule.

Lemma 15.

If a node u is in Vi with i[0,r1], then u does not receive any pulses from its parent v before sending one to v.

Proof.

We proceed by induction over the layers from Vr1 to V0, i.e., in a top-down manner.

Base case.

Consider any vVr1, whose parent is l. Suppose, for the sake of contradiction, that v receives a pulse from l before sending any pulse to l. Such a pulse cannot result from a triggered 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule at l, by Lemma 14. It also cannot arise from a triggered 𝐋𝐞𝐚𝐝𝐞𝐫 rule, since that rule requires l to have received pulses from all of its ports, yet v has not sent any pulse to l. This shows that v cannot receive a pulse from l before sending one.

Induction step.

Assume that the lemma holds for all nodes in Vs and higher layers for some s[1,r1]. Let u be a node in Vs1 and v its parent. Suppose, for the sake of contradiction, that u receives a pulse from v before sending one to v. Similar to the base case, v cannot trigger the 𝐋𝐞𝐚𝐝𝐞𝐫 rule. Thus, it remains to rule out the possibility that v triggers an 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule and sets the port pointing to u as 𝖯𝗈𝗋𝗍.

For v to trigger an 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule, it must have received a nonzero number of pulses from its parent w. By the induction hypothesis, v must have sent pulses to w before receiving any, and such pulses can only result from an 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule with the port pointing to w designated as 𝖯𝗈𝗋𝗍. This, however, contradicts Observation 12. Hence, the assumed scenario is impossible, and u also satisfies the lemma.

The following three lemmas follow directly from Lemma 15.

Lemma 16.

The only node that can trigger the 𝐋𝐞𝐚𝐝𝐞𝐫 rule is l.

Proof.

To trigger the 𝐋𝐞𝐚𝐝𝐞𝐫 rule, a node v must receive pulses from all neighbors before sending any. For any node v with a parent, the above is impossible due to Lemma 15, so the only node that can trigger the 𝐋𝐞𝐚𝐝𝐞𝐫 rule is l, as it is the only node without a parent.

Lemma 17.

For each node v that has a parent, its 𝖯𝗈𝗋𝗍 (if any) may only point to its parent.

Proof.

Suppose 𝖯𝗈𝗋𝗍 points to a child. For this to occur, v must have triggered an 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule in which it received pulses from its parent. By Lemma 15, v must then have previously sent a pulse to its parent, and this pulse cannot be the result of the 𝐋𝐞𝐚𝐝𝐞𝐫 rule by Lemma 16. Thus, v must have triggered an 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule and sent pulses to its parent earlier, which contradicts Observation 12.

Lemma 18.

No 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 rule is triggered before l triggers the 𝐋𝐞𝐚𝐝𝐞𝐫 rule.

Proof.

We proceed by induction over the layers from Vr to V0, i.e., in a top-down manner.

Base case.

The unique node l in Vr never triggers any 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule (Lemma 14), and therefore 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 is never activated at l.

Induction step.

Assume that the lemma holds for all nodes in Vs and higher layers for some s[1,r]. Let u be a node in Vs1 and let v be its parent. For u to trigger 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦, it must receive a pulse from 𝖯𝗈𝗋𝗍, which, by Lemma 17, means a pulse from its parent v. Such a pulse cannot result from v triggering 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 or 𝐋𝐞𝐚𝐝𝐞𝐫, by Lemma 17 and Lemma 16, respectively. Hence, v must have triggered 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦, and by the induction hypothesis, this implies that 𝐋𝐞𝐚𝐝𝐞𝐫 has already been triggered by l.

Combining the above three lemmas, we see that the direction of pulse movement is always from children to parents, before l triggers the 𝐋𝐞𝐚𝐝𝐞𝐫 rule.

Lemma 19.

The direction of pulse movement is always from children to parents, before l triggers the 𝐋𝐞𝐚𝐝𝐞𝐫 rule.

Proof.

By Lemma 16, no node other than l ever triggers the 𝐋𝐞𝐚𝐝𝐞𝐫 rule. Moreover, by Lemma 18, no node other than l triggers the 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 rule before l triggers the 𝐋𝐞𝐚𝐝𝐞𝐫 rule. Thus, the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rules are the only rules that nodes other than l may trigger before l triggers the 𝐋𝐞𝐚𝐝𝐞𝐫 rule. By Lemma 17, any pulse generated by such a 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule always travels toward the parent of the sender.

Lemma 20.

Node l eventually terminates as 𝖫𝖾𝖺𝖽𝖾𝗋 by triggering the 𝐋𝐞𝐚𝐝𝐞𝐫 rule, after every other node sets 𝖯𝗈𝗋𝗍 to its parent.

Proof.

We again apply induction over the layers from V0 to Vr. Our goal is to show that every vVi sends at least ri pulses to its parent. In particular, this implies that each child of l sends at least one pulse to l, since all of them belong to Vr1 or a lower layer. Consequently, l will trigger the 𝐋𝐞𝐚𝐝𝐞𝐫 rule.

Base case.

It is immediate that uV0 sends r pulses to its parent, by the definition of 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦.

Induction step.

Assume the lemma holds for all nodes up to Vs for some s[0,r1]. Let u be a node in Vs+1. By the induction hypothesis, every child of u, all of which lie in Vs or a lower layer, sends at least rs pulses to u. By the definition of the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rules, u will therefore eventually send rs1 pulses to its parent. We emphasize that the correctness of this induction step relies on Lemma 19, which ensures that we need only consider pulses traveling from children to parents.

The above proof, together with Lemma 13, implies that every vVi sends exactly ri pulses to its parent. The argument is divided into two lemmas rather than one because the induction in the proof of Lemma 20 relies crucially on Lemma 19, which itself depends on Lemma 13.

Lemma 21.

Each node other than l eventually terminates as 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋.

Proof.

By Lemma 19, every non-l node sets 𝖯𝗈𝗋𝗍 to point to its parent. Immediately after l triggers 𝐋𝐞𝐚𝐝𝐞𝐫 (which occurs by Lemma 20), each child of l receives a pulse through its 𝖯𝗈𝗋𝗍 and therefore triggers 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦. Any node that triggers 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 sends a pulse along every port except 𝖯𝗈𝗋𝗍, so each of its children likewise receives a pulse through its own 𝖯𝗈𝗋𝗍 and triggers 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦. This recursive propagation ensures that every non-l node eventually triggers 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 and terminates as 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋.

Lemma 22.

The total number of pulses sent by all nodes in this algorithm is O(nr).

Proof.

Each node other than l sends at most r pulses to its parent via the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rules (see Lemma 19), contributing at most (n1)r pulses in total. In addition, the nodes send exactly n1 pulses due to the 𝐋𝐞𝐚𝐝𝐞𝐫 and 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 rules, since exactly one such pulse is sent across each edge and a tree has n1 edges (see the proof of Lemma 21). Therefore, the total number of pulses sent is at most (n1)r+(n1)=O(nr).

Theorem 2 (Leader election on even-diameter trees). [Restated, see original statement.]

There exists a terminating, anonymous content-oblivious leader election algorithm with message complexity O(nr) for a tree with even diameter D=2r and n nodes, provided that each node knows the diameter D of the tree a priori.

Proof of Theorem 2.

The correctness and termination of the leader election follow from Lemmas 20 and 21, while the message complexity follows from Lemma 22.

Failing the quiescence guarantee.

The algorithm above does not guarantee quiescent termination. Recall from the proofs of Lemmas 13 and 20 that any node uVs+1, for s[0,r1], will eventually send exactly rs1 pulses to its parent. For this to occur, each child of u must have sent u rs pulses. However, some children of u may lie in layers strictly below Vs, and thus will ultimately send u more than rs pulses. Crucially, u cannot determine whether such additional pulses will arrive in the future. Consequently, some pulses from the children of u may reach u after u has already terminated, and therefore quiescence cannot be guaranteed.

3.2 Quiescently Terminating Anonymous Leader Election on Asymmetric Trees

In this section, we show a quiescently terminating leader election in anonymous trees, unless they are symmetric about an edge. This algorithm, however, requires each node to know the full topology of G. In the remainder of the section, we will make the distinction between nodes, which are real computing devices performing content-oblivious leader election, and vertices of the topology knowledge G.

In contrast with the algorithm for even-diameter trees, the main challenge here is to break symmetry within layer Vr, which contains two vertices when the tree diameter is odd. To resolve this symmetry, we use the assumption that G is not symmetric about an edge, implying that the two nodes in Vr have distinct views of the lower-layer nodes. Rather than using the number of pulses to encode only the height of a subtree, our algorithm uses the number of pulses to encode the full shape of each subtree. A pleasant consequence of this more refined encoding is that the algorithm now achieves quiescent termination.

Theorem 3 (Leader election on general asymmetric trees). [Restated, see original statement.]

There exists a quiescently terminating, anonymous content-oblivious leader election algorithm with message complexity O(n2) for a tree with n nodes, provided that each node knows tree topology G a priori, and the tree is not symmetric about any edge.

The remainder of this section is organized as follows. In Section 3.2.1, we detail the layer decomposition, enumeration of distinct subtrees, and construction of rules. In Section 3.2.2, we prove that the above-constructed rules indeed result in a quiescently terminating leader election.

3.2.1 Algorithm Description

Each node first identifies the center(s) of the advised topology G. To do so, every node locally performs the layer decomposition (Algorithm 1) using the advice G, thereby partitioning the vertex set V into disjoint layers V0,V1,,Vr. We emphasize that, unlike in the even-diameter algorithm, where the layer decomposition is used only in the analysis, here each node actually performs the layer decomposition locally.

Definition 23 (Subtrees).

For each vertex vVi, define Gv as the induced subgraph of G over the vertex set {v}(j<iVj). Let Tv be the connected component of Gv that contains v. We call Tv the subtree rooted at v.

We first enumerate all distinct subtrees in an “increasing” order, and denote them by T1,T2, in the order in which they are listed. We stress the distinction between subscripts and superscripts: we use a superscript v to denote the subtree rooted at v, i.e., Tv, and a subscript i to index the enumeration, i.e., Ti.

Each (rooted) subtree isomorphic class is enumerated only once. Note that if vVi, then Tv has height i; hence, two subtrees can be isomorphic only if their roots lie in the same layer. Conceptually, to carry out the enumeration, it suffices to define a comparator on subtrees. The rules of this comparator are specified as follows.

Subtree comparator.

The subtree comparator takes two non-isomorphic subtrees Tv and Tu as input and determines whether TvTu or TuTv. The enumeration of subtrees is required to be consistent with this comparator: if TvTu, then Tv must be listed before Tu. We will later show that the comparator is transitive, ensuring that a valid enumeration indeed exists. For isomorphic subtrees, we write Tv=Tu, and we use TvTu to denote either Tv=Tu or TvTu.

Given inputs Tv and Tu, the comparator follows the three rules below.

Low layer first:

Assume v and u are not of the same layer. If v is from a lower layer, then the comparator outputs TvTu, and vice versa.

Fewer children first:

Assume v and u are of the same layer. Let NTv(v) (resp., NTu(u)) be the set of neighbors of v (resp., u) in Tv (resp., Tu). If |NTv(v)|<|NTu(u)|, then the comparator outputs TvTu, and vice versa.

Recursion rule:

Assume v and u lie in the same layer and have the same number of children in their respective rooted subtrees, i.e., |NTv(v)|=|NTu(u)|. Let the children of v be v1,v2,,vd1, ordered so that

Tv1Tv2Tvd1.

Similarly, list the children of u as u1,u2,,ud1, ordered according to .

Now consider the smallest index i for which Tvi and Tui are not isomorphic. If TviTui, then comparator outputs TvTu, and vice versa.

Lemma 24.

The subtree comparator is well-defined in the following sense: (1) the comparator does not recurse infinitely and (2) the comparator is transitive.

Proof.

The proof is deferred to the full version [10] of the paper due to the page limit.

Subtree enumeration.

Now all nodes obtain identical enumerations: T1,T2,Tk, where k is the number of distinct (non-isomorphic) subtrees appearing in G.

For convenience of presentation, we define a helper function that maps each vertex v to the index of the subtree rooted at v in the enumerated list.

Definition 25.

For a vertex v, define τ(v)=isuch that Tv is isomorphic to Ti.

We also define a helper function that maps the index i to the integer ki.

Definition 26.

Define λ(i)=ki.

Write λτ(v) as shorthand for λ(τ(v)). By definition, we have λτ(v)<λτ(u) if and only if TvTu, and λτ(v)=λτ(u) if and only if Tv is isomorphic to Tu.

We are now ready to present the rules for our algorithm. Each node derives three categories of rules from the subtree enumeration: 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦, 𝐋𝐞𝐚𝐝𝐞𝐫, and 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦. Initially, only 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 and 𝐋𝐞𝐚𝐝𝐞𝐫 rules are active. After a node triggers at least one of 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 and 𝐋𝐞𝐚𝐝𝐞𝐫 rules, 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 rules become active for that node.

  • 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦: One rule is constructed for each enumerated subtree, except for the last one. For each Ti with ik1, let the neighbors of the root be m1,m2,,md1. Create the rule

    [λτ(m1),λτ(m2),,λτ(md1)]λ(i).

    This rule is interpreted as follows: whenever a node with d ports observes that d1 of its ports have respectively received

    λτ(m1),λτ(m2),,λτ(md1)

    pulses, while the remaining port has received none, it marks that remaining port as 𝖯𝗈𝗋𝗍 and sends pulses along 𝖯𝗈𝗋𝗍 until the total number of pulses sent through it is exactly λ(i). The node then adds 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 to its list of active rules and disables the 𝐋𝐞𝐚𝐝𝐞𝐫 rule.

    Note that in the special case of T1, the subtree consists of a single leaf node. The rule generated by T1 is therefore equivalent to the following: if a node has only one port, it sends λ(1)=k1 pulses along that port immediately upon initialization.

  • 𝐋𝐞𝐚𝐝𝐞𝐫 (Odd diameter): (This rule is added if G has odd diameter.) For Tk, consider the neighbors of the root m1,m2,,md1. The rule is as follows: whenever a node with d ports sees that d1 of its ports have respectively received

    λτ(m1),λτ(m2),,λτ(md1)

    pulses, while the remaining port has received one pulse, the node sends a pulse along all ports, declares 𝖫𝖾𝖺𝖽𝖾𝗋, and terminates.

  • 𝐋𝐞𝐚𝐝𝐞𝐫 (Even diameter): (This rule is added if G has even diameter.) For Tk, consider the neighbors of the root m1,m2,,md. The rule is as follows: whenever a node with d ports sees all of its ports receive, respectively,

    λτ(m1),λτ(m2),,λτ(md)

    pulses, the node sends a pulse along all ports, declares 𝖫𝖾𝖺𝖽𝖾𝗋, and terminates.

  • 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦: When a pulse is received from 𝖯𝗈𝗋𝗍, the node sends a pulse along every port except 𝖯𝗈𝗋𝗍, declares 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋, and terminates.

Manual parent assignment.

Recall that we defined parent and children in Definition 9. If the advised topology G has even diameter, then Vr={l} is a singleton set; apart from l, each vertex has its parent assigned, and we aim to elect the node corresponding to l as the leader. If G has odd diameter, Vr contains two vertices l1 and l2, which both have no parents. The fact that G is not symmetric over any edge enables us to decide a leader between l1 and l2: in fact, Tl1 must not be isomorphic to Tl2, and they are exactly the last two trees enumerated due to belonging to the highest layer r. Without loss of generality, we assume Tl1=Tk1, Tl2=Tk in the remainder of this section. To make proofs more concise, we manually assign l2 as the parent of l1, and l1 as a child of l2. At no risk of confusion, if the diameter is odd, define l=l2. In either case, the only vertex without a parent is l, and we call it the root of the tree. Our goal is to elect the node corresponding to the root vertex l as leader.

3.2.2 Proof of Correctness

We now prove the correctness of the algorithm.

Lemma 27 (𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rules are well-defined).

Consider any two distinct Upstream rules, generated by Tj and Tj, whose roots each have the same number of neighbors:

[λτ(m1),λτ(m2),,λτ(md1)]λ(j)and[λτ(m1),λτ(m2),,λτ(md1)]λ(j).

Without loss of generality, assume each list of λτ-values is sorted in non-increasing order. If

λτ(m1)λτ(m1),λτ(m2)λτ(m2),,λτ(md1)λτ(md1),

then λ(j)>λ(j).

Proof.

The definition of λ implies that

τ(m1)τ(m1),τ(m2)τ(m2),,τ(md1)τ(md1).

To prove λ(j)>λ(j), it suffices to show that j<j, i.e., that Tj is enumerated before Tj. Since the respective roots of Tj and Tj have the same degree, the Fewer children first rule does not apply. Thus, the comparison must be determined by either the Low layer first rule or the Recursion rule.

If the root of Tj lies in a lower layer than the root of Tj, then TjTj immediately by the Low layer first rule.

Now consider the case where the two roots lie in the same layer. Since the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rules under consideration are distinct, there exists a smallest index i such that τ(mi)<τ(mi), meaning that Tmi is enumerated before Tmi, and hence TmiTmi. By the Recursion rule, we then obtain TjTj, so Tj is enumerated first.

It remains to show that it is impossible for the root of Tj to lie in a higher layer than the root of Tj. Since each list of λτ-values is sorted in non-increasing order, we have

τ(m1)τ(m2)τ(md1).

Thus Tmd1 is the last among these subtrees to be enumerated, so md1 is a highest-layer child of the root of Tj. By Observation 10, md1 must lie exactly one layer below the root of Tj, and therefore must lie in a higher layer than md1. Hence τ(md1)>τ(md1), contradicting the fact that τ(md1)τ(md1).

The following observation still applies.

Observation 12. [Restated, see original statement.]

Once a node triggers an Upstream rule, it never changes 𝖯𝗈𝗋𝗍.

Lemma 27 and Observation 12 show that our Upstream rules are well-defined in the following sense: While a node can trigger multiple 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rules throughout the election process, an 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule triggered earlier does not send more pulses along 𝖯𝗈𝗋𝗍 than an 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule triggered later.

Lemma 28.

Let u be a node with ul. Then u sends at most λτ(u) pulses to its parent.

Proof.

Recall from the definition of 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 that if the rule constructed from the τ(u)th enumerated tree Tτ(u)=Tu is triggered, λτ(u) pulses are sent to 𝖯𝗈𝗋𝗍. The only possible way for u to send additional pulses would be to trigger another 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule and send λτ(u)>λτ(u) pulses to v. We will show that this cannot occur. We proceed by induction over layers, from V0 to Vr, i.e., in a bottom-up manner.

Base case.

Let u be a leaf node in V0. Then Tu is a single-node tree and must be the first to be enumerated, i.e., τ(u)=1. By the Upstream rule constructed from it, u sends k1=λτ(u) pulses to its parent immediately upon initialization and never sends any additional pulses. Hence, the lemma holds for u.

Induction step.

Assume the lemma holds for all nodes in Vs and lower layers for some s[0,r1]. Let u be a node in Vs+1 with ul, and let v be its parent. Note that τ(u)k1, so λτ(u)1.

Suppose u sets 𝖯𝗈𝗋𝗍 to point to v (otherwise the lemma follows immediately for u). Let the children of u be {m1,m2,,md1} with

λτ(m1)λτ(m2)λτ(md1).

Assume, for the sake of contradiction, that u eventually triggers some Upstream rule sending λτ(u)>λτ(u) pulses to v. Let the children of u be {m1,m2,,md1}, ordered so that

λτ(m1)λτ(m2)λτ(md1).

Since each child of u lies in a layer below Vs+1, the induction hypothesis implies that each mi sends at most λτ(mi) pulses to u. Consequently,

λτ(m1)λτ(m1),λτ(m2)λτ(m2),,λτ(md1)λτ(md1).

By Lemma 27, we have λτ(u)<λτ(u), contradicting the assumption that λτ(u)>λτ(u).

Lemma 29.

Let u be a node with ul. Then u does not receive any pulses from its parent v before sending one to v.

Proof.

We first show that l cannot trigger any 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule. Recall that Tl=Tk is the last enumerated subtree; let the children of l be {m1,m2,,md}, ordered so that λτ(m1)λτ(m2)λτ(md). By Lemma 28, node l receives at most λτ(m1),λτ(m2),,λτ(md) pulses from its children. Consider any 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule associated with some node u of degree d, whose children are {m1,m2,,md1}, with λτ(m1)λτ(m2)λτ(md1).

Suppose first that u lies in a layer lower than or equal to r1. Then, by Observation 10, the child md1 must lie in a layer at least as high as r2. Meanwhile, regardless of whether the diameter is even or odd, the two children md1 and md of l lie in layers at least as high as r1. Hence, λτ(md1)>λτ(md1)λτ(md), which shows that l cannot trigger the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule for the subtree rooted at u.

Now suppose instead that u also lies in layer r. Then Tu=Tk1, and moreover the last child of l, namely md, is exactly u. By the Recursion rule of the subtree comparator, Tu is ordered before Tl, which implies there exists a smallest index i such that λτ(mi)<λτ(mi). Thus l again cannot satisfy the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule for the subtree rooted at u.

Next, we proceed by induction over the layers to prove the lemma, from Vr to V0, i.e., in a top-down manner.

Base case.

In Vr, the (possibly) only node we need to consider is l1, whose parent is l. Suppose, for the sake of contradiction, that l1 receives a pulse from l before sending one to l. Such a pulse cannot result from a triggered 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule, as established above. It also cannot arise from a triggered 𝐋𝐞𝐚𝐝𝐞𝐫 rule, since that would require l to have received pulses from all its ports, yet l1 has not sent any pulses to l. This yields a contradiction.

Induction step.

Assume that the lemma holds for all nodes in Vs and higher layers for some s[1,r]. Let u be a node in Vs1 and let v be its parent. Suppose, for the sake of contradiction, that u receives a pulse from v before sending one to v. As in the base case, v cannot trigger the 𝐋𝐞𝐚𝐝𝐞𝐫 rule. Thus, it remains to rule out the possibility that v triggers an 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule and sets the port pointing to u as 𝖯𝗈𝗋𝗍.

If v=l, then the same argument as in the base case yields a contradiction. If instead v has a parent w, then for v to trigger 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦, it must have received a non-zero number of pulses from w. By the induction hypothesis, v must have sent pulses to w before receiving any, and such pulses can only result from an 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule with the port pointing to w designated as 𝖯𝗈𝗋𝗍. This contradicts Observation 12. Hence, u also satisfies the lemma.

Observe that the following four lemmas continue to apply. We omit the proofs, as they follow from arguments nearly identical to those used previously.

See 16 See 17 See 18 See 19

The next lemma follows from the way we constructed 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 and 𝐋𝐞𝐚𝐝𝐞𝐫 rules.

Lemma 30.

Node l may trigger the 𝐋𝐞𝐚𝐝𝐞𝐫 rule only after every node vl has triggered the rule corresponding to its subtree Tτ(v)=Tv and has set 𝖯𝗈𝗋𝗍 to point to its parent.

Proof.

Lemma 19 establishes that, before l triggers 𝐋𝐞𝐚𝐝𝐞𝐫, pulses travel from children to parents. Therefore, we only need to consider pulses directed as such, as we are reasoning about a necessary condition for l to trigger 𝐋𝐞𝐚𝐝𝐞𝐫.

Base case.

First, let the children of l be {m1,m2,,md}, ordered so that

λτ(m1)λτ(m2)λτ(md).

By the definition of the 𝐋𝐞𝐚𝐝𝐞𝐫 rule, l must receive

λτ(m1),λτ(m2),,λτ(md)

pulses from its children, respectively, in order to trigger 𝐋𝐞𝐚𝐝𝐞𝐫. Since Lemma 28 shows that each child mi can send at most λτ(mi) pulses to l, it follows (by an induction on i from d down to 1) that l may trigger the 𝐋𝐞𝐚𝐝𝐞𝐫 rule only after each child mi has triggered the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule corresponding to its own subtree Tτ(mi)=Tmi.

Induction step.

Let the children of a node vl be {m1,m2,,md1}, ordered so that

λτ(m1)λτ(m2)λτ(md1).

Assume it has been established that l may trigger the 𝐋𝐞𝐚𝐝𝐞𝐫 rule only after v triggers the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule defined by Tτ(v)=Tv.

By the definition of the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule constructed from Tτ(v)=Tv, node v must receive

λτ(m1),λτ(m2),,λτ(md1)

pulses from its d1 children in order to trigger the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule of Tτ(v)=Tv. Meanwhile, by Lemma 28, each child mi can send at most λτ(mi) pulses to v. Similarly, it follows that v may trigger the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule corresponding to Tτ(v)=Tv only after each child mi has triggered its own 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule associated with Tτ(mi)=Tmi.

Therefore, we have extended the necessary condition for l to trigger 𝐋𝐞𝐚𝐝𝐞𝐫 from node vl to all children of v.

The above lemma does not guarantee that l will trigger the 𝐋𝐞𝐚𝐝𝐞𝐫 rule. It only points out a condition for l to trigger the 𝐋𝐞𝐚𝐝𝐞𝐫 rule. To show that this condition is eventually satisfied and that l indeed triggers the 𝐋𝐞𝐚𝐝𝐞𝐫 rule, we present the next lemma.

Lemma 31.

Every node v other than l eventually triggers the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule corresponding to its subtree Tτ(v)=Tv and sets 𝖯𝗈𝗋𝗍 to point to its parent. After this has occurred for all nodes vl, node l will trigger the 𝐋𝐞𝐚𝐝𝐞𝐫 rule. At the moment 𝐋𝐞𝐚𝐝𝐞𝐫 is triggered, the tree is in quiescence, i.e., no pulses are in transit.

Proof.

We again apply induction over layers, from V0 to Vr, to show that every node u other than l eventually triggers the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule corresponding to its subtree Tτ(u)=Tu and sets 𝖯𝗈𝗋𝗍 to point to its parent. To do so, it suffices to show that u eventually sends λτ(u) pulses to its parent, as the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rules are well-defined (Lemma 27 and Observation 12).

Indeed, once every node vl has sent λτ(v) pulses to its parent, node l receives enough pulses from its neighbors to trigger the 𝐋𝐞𝐚𝐝𝐞𝐫 rule, as required.

Base case.

It is immediate that any node uV0 eventually sends λτ(u)=λ(1)=k1 pulses to its parent, as this follows directly from the definition of the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule applied to degree-1 nodes.

Induction step.

​​Assume the lemma holds for all nodes up to Vs for some s[0,r1]. Let u be a node in Vs+1. By the induction hypothesis, the children of u, denoted {m1,m2,,md1}, eventually send λτ(m1),λτ(m2),,λτ(md1) pulses to u, respectively. This causes the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule corresponding to the subtree Tτ(u)=Tu to trigger, so u sends λτ(u) pulses through 𝖯𝗈𝗋𝗍 to its parent.

During this process, u does not receive any unexpected pulses from its parent. The possibilities of u getting such a pulse from its parent due to 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦, 𝐋𝐞𝐚𝐝𝐞𝐫, or 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 are ruled out by combining Lemma 16, Lemma 17, Lemma 18 (or equivalently, just Lemma 19), and Lemma 30.

Finally, once the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule for Tτ(u)=Tu has been triggered, the entire subtree rooted at u reaches quiescence: each child of u has already sent the maximum number of pulses permitted by Lemma 28, and all such pulses have been received.

We remark that the above proof, combined with Lemma 28, shows that the number of pulses every node vl sends to its parent due to the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rules is exactly λτ(v).

Lemma 32.

All nodes other than l eventually terminate quiescently as 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋 after l terminates quiescently as 𝖫𝖾𝖺𝖽𝖾𝗋.

Proof.

We first observe that by Lemma 31, the node l eventually terminates as 𝖫𝖾𝖺𝖽𝖾𝗋, and at that moment the tree is in quiescence. For all remaining nodes, we assume that l has already terminated as 𝖫𝖾𝖺𝖽𝖾𝗋 and proceed by induction from Vr down to V0.

Base case.

For the layer Vr, the only node we may need to consider is l1. By Lemma 31, the node l1 has already triggered the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule corresponding to Tτ(l1) and set 𝖯𝗈𝗋𝗍 to point to l before l terminates as 𝖫𝖾𝖺𝖽𝖾𝗋 and sends a pulse to l1. Consequently, l1 will eventually receive a pulse from 𝖯𝗈𝗋𝗍, trigger the 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 rule, and terminate as 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋. At this point, l has already terminated and will not send further pulses to l1, and by Lemma 28, l1 will not receive additional pulses from its children. Thus, l1 reaches quiescent termination.

Induction step.

Assume the lemma holds for all nodes in Vs or higher layers, for some s[1,r]. Let u be a node in Vs1. By Lemma 31, u must have triggered the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rule corresponding to Tτ(u) and set 𝖯𝗈𝗋𝗍 to its parent v. Since v lies in a higher layer, the induction hypothesis ensures that v eventually triggers the 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 rule and terminates as 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋. Therefore, u will eventually receive a pulse from 𝖯𝗈𝗋𝗍, trigger the 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 rule, and terminate as 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋. The argument for quiescent termination follows exactly as in the base case.

Lemma 33.

The total number of pulses sent by all nodes in this algorithm is O(n2).

Proof.

For each node other than l, exactly λτ(u)k1n1 pulses are sent to its parent due to the 𝐔𝐩𝐬𝐭𝐫𝐞𝐚𝐦 rules (see the proofs of Lemmas 28 and 31), contributing at most (n1)2 pulses in total. The 𝐋𝐞𝐚𝐝𝐞𝐫 and 𝐃𝐨𝐰𝐧𝐬𝐭𝐫𝐞𝐚𝐦 rules cause exactly one pulse to be sent across each edge (see the proof of Lemma 32), contributing an additional n1 pulses. Therefore, the total number of pulses sent during the execution of the algorithm is at most (n1)2+(n1)=O(n2).

Theorem 3 (Leader election on general asymmetric trees). [Restated, see original statement.]

There exists a quiescently terminating, anonymous content-oblivious leader election algorithm with message complexity O(n2) for a tree with n nodes, provided that each node knows tree topology G a priori, and the tree is not symmetric about any edge.

Proof of Theorem 3.

The correctness and quiescent termination of the leader election algorithm follow from Lemmas 31 and 32, and the message complexity bound follows from Lemma 33.

4 Randomized Impossibilities

In this section, we show the following impossibility result:

Theorem 4 (Edge symmetry implies impossibility, randomized). [Restated, see original statement.]

Let G be a network that is symmetric about an edge, where nodes are anonymous and know the network topology G. Then there exists no terminating, randomized leader-election algorithm which succeeds with probability greater than 12.

Let us first consider a 2-node path P2, where the two nodes are {u,v}. Consider the view of u (resp., v): since the node has only one communication channel, and the communication channel transmits only indistinguishable pulses, the algorithm restricted to u can be captured by an automaton with input alphabet size 1, i.e., a probabilistic unary automaton {Q,qs,F𝖫𝖾𝖺𝖽𝖾𝗋,F𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋,δ,σ} as follows. Note that u must reach some accepting state to terminate, and the output of u, 𝖫𝖾𝖺𝖽𝖾𝗋 or 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋 depends on the exact accepting state it reaches.

  • Q is the state space.

  • qs is the initial state.

  • F𝖫𝖾𝖺𝖽𝖾𝗋Q is the set of accepting states labeled 𝖫𝖾𝖺𝖽𝖾𝗋.

  • F𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋Q is the set of accepting states labeled 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋.

  • δ:Q×Q[0,1] is the transition function. δ(q1,q2) denotes the probability that the automaton transitions into state q2 after receiving a symbol when in state q1. It holds that q2Qδ(q1,q2)=1. If q1F𝖫𝖾𝖺𝖽𝖾𝗋, δ(q1,q2)>0 implies q2F𝖫𝖾𝖺𝖽𝖾𝗋. If q1F𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋, δ(q1,q2)>0 implies q2F𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋. This requirement stems from termination of the algorithm: after outputting 𝖫𝖾𝖺𝖽𝖾𝗋 or 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋 (denoted by transitioning into a state in F𝖫𝖾𝖺𝖽𝖾𝗋 and F𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋), a node cannot change its output.

  • σ:Q0. When the automaton transitions into state q, the node sends σ(q) pulses.

Let P𝖫𝖾𝖺𝖽𝖾𝗋(c) denote the probability that the automaton’s state is in F𝖫𝖾𝖺𝖽𝖾𝗋 after receiving c symbols, and define P𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋(c) in a similar fashion.

Lemma 34.

For c1c2, the following hold.

  • P𝖫𝖾𝖺𝖽𝖾𝗋(c1)P𝖫𝖾𝖺𝖽𝖾𝗋(c2).

  • P𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋(c1)P𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋(c2).

Proof.

We only need to show that for c2=c1+1, the statements are true. Since F𝖫𝖾𝖺𝖽𝖾𝗋Q are the accepting states, upon receiving c1 symbols, there are two cases.

  • If the automaton is in a state in F𝖫𝖾𝖺𝖽𝖾𝗋, then upon receiving the next letter, the automaton is still in a state in F𝖫𝖾𝖺𝖽𝖾𝗋.

  • If the automaton is not in a state in F𝖫𝖾𝖺𝖽𝖾𝗋, then upon receiving the next letter, the automaton may or may not make a transition to a state in F𝖫𝖾𝖺𝖽𝖾𝗋.

Therefore, P𝖫𝖾𝖺𝖽𝖾𝗋(c1)P𝖫𝖾𝖺𝖽𝖾𝗋(c2). The same argument works for the 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋 side.

Now we define P𝖫𝖾𝖺𝖽𝖾𝗋=supc0P𝖫𝖾𝖺𝖽𝖾𝗋(c), and P𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋 is defined similarly.

Lemma 35.

P𝖫𝖾𝖺𝖽𝖾𝗋+P𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋1.

Proof.

Assume otherwise P𝖫𝖾𝖺𝖽𝖾𝗋+P𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋>1. Then there exist c𝖫𝖾𝖺𝖽𝖾𝗋,c𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋 such that P𝖫𝖾𝖺𝖽𝖾𝗋(c𝖫𝖾𝖺𝖽𝖾𝗋)+P𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋(c𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋)>1. Without loss of generality, let c𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋c𝖫𝖾𝖺𝖽𝖾𝗋. By Lemma 34, P𝖫𝖾𝖺𝖽𝖾𝗋(c𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋)+P𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋(c𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋)>1, which is impossible.

Proof for Theorem 4.

We first consider the two-party case, where two nodes {u,v} performing some leader election algorithm via content-oblivious communication along an edge. To upper bound the success probability, it suffices to assume that the communication between {u,v} stabilize at some moment (i.e., there are no more pulses traveling between u and v), for otherwise u and v will never terminate, failing the leader election task. Let Q(cu,cv) denote the probability that at stabilization, u received cu pulses, and v received cv pulses. The probability that the leader election is successful can be obtained as follows: For all possibilities of (cu,cv) pair, sum up the probability that the outputs of u and v constitute a valid leader election outcome, weighted by Q(cu,cv).

Pr[Correct] =cv,cuQ(cu,cv)(P𝖫𝖾𝖺𝖽𝖾𝗋(cv)P𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋(cu)+P𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋(cv)P𝖫𝖾𝖺𝖽𝖾𝗋(cu))
P𝖫𝖾𝖺𝖽𝖾𝗋P𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋+P𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋P𝖫𝖾𝖺𝖽𝖾𝗋12

We have thus proven that for an anonymous edge, content-oblivious leader election terminates correctly with probability at most 12. We are now ready to extend the argument to all graphs G symmetric about an edge {u,v} by a simple simulation argument.

Let graph G be symmetric about edge e, so Ge has two isomorphic connected components, H and K. We claim G does not admit a leader election algorithm that succeeds with probability greater than 12, even if all nodes know the topology G. Otherwise, on a 2-node path P2, let the two nodes u and v respectively simulate H and K, and perform the algorithm on G, which leads to contradiction. Since H and K are isomorphic, the simulation does not require first breaking the symmetry between the two nodes u and v.

The proof of our impossibility result is similar to the two-party impossibility in [18, Theorem 20]. In both proofs, the argument uses the contentless nature of pulses to model the behavior of degree-1 nodes as a unary automaton. In our case, we allow this automaton to be probabilistic, which yields a slightly stronger impossibility. The key difference between the two results lies in the reduction that extends the impossibility from a single edge to graphs containing bridges.

5 Necessity of Knowledge on Underlying Topology

In this section, we show the necessity of exact topology knowledge for leader election on trees. We show a family 𝒢 of two graphs where each G𝒢 by itself grants a quiescently terminating algorithm, but no algorithm achieves termination if the graph topology is drawn from 𝒢.

We write Pn to denote a path of n nodes. We prove the following:

Theorem 6 (Necessity of topology knowledge). [Restated, see original statement.]

There exists no deterministic, terminating content-oblivious leader election algorithm if the underlying topology is drawn from the family 𝒢={P3,P5}, and 𝒢 is known to the nodes a priori, even if the nodes have unique 𝖨𝖣s.

Since P3 and P5 are not edge-symmetric, if the graph topology is known, then we do have a quiescently terminating algorithm for them, as shown in Theorem 3.

Proof.

For the sake of contradiction, we assume such a deterministic, terminating algorithm 𝒜 exists. We first define a labeling over the nodes in Pn.

  • Assign label 𝖫 to the nodes with degree 1 (leaf nodes).

  • Assign label 𝖬 to the nodes with degree 2 (middle nodes).

Since a node can count the number of its ports, it can label itself at the initiation of any algorithm, so we may assume that the labels are provided as input to the nodes. Therefore, 𝒜 can be viewed as a deterministic, terminating leader election algorithm 𝒜 for the family of labeled graphs:

{𝖫𝖬𝖫,𝖫𝖬𝖬𝖬𝖫}

Now we define a new type of labeled node 𝖷. Observe that the algorithm 𝒜 can be turned into an algorithm 𝒜′′ that elects a leader for the following family of labeled graphs:

{𝖫𝖬𝖫,𝖫𝖬𝖬𝖬𝖫,𝖷𝖫,𝖷𝖬𝖷}

To see this, we simply let 𝒜′′ on all nodes labeled 𝖷 simulate 𝖫𝖬, and then perform 𝒜. A subtle issue is that since one 𝖷 node needs to simulate two nodes, 𝖷 nodes must ensure the simulated nodes have 𝖨𝖣s that do not conflict with the rest of the graph. To achieve this, when performing 𝒜′′, 𝖫 and 𝖬 nodes with assigned 𝖨𝖣 k runs A with 𝖨𝖣 2k, while a 𝖷 simulates an 𝖫 node of 𝖨𝖣 2k and an 𝖬 node of 𝖨𝖣 2k+1.

Similar to our approach in Theorem 4 and [18, Theorem 20], the behavior of an 𝖫 node with assigned 𝖨𝖣 i performing algorithm 𝒜′′ can be described by an unary automaton 𝒜′′𝖫(i). The state of the unary automaton 𝒜′′𝖫(i) is entirely a deterministic function of the number of symbols received, while the terminating requirement of 𝒜′′ forbids it from changing output (from 𝖫𝖾𝖺𝖽𝖾𝗋 to 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋 or the opposite direction). Therefore, the output of 𝒜′′𝖫(i) is entirely a function of i. Now consider all such unary automata: 𝒜′′𝖫(1),𝒜′′𝖫(2),𝒜′′𝖫(3), for all 𝖨𝖣s. There must not be 2 𝖨𝖣s i and j where 𝒜′′𝖫(i) and 𝒜′′𝖫(j) both output 𝖫𝖾𝖺𝖽𝖾𝗋, since otherwise we have a contradiction by assigning 𝖨𝖣s i and j to the two 𝖫 nodes in the graph 𝖫𝖬𝖫. Hence, there exists an 𝖨𝖣 k𝖫 such that all 𝖫 nodes with 𝖨𝖣k𝖫 output 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋. Similarly, we can define k𝖷 due to the presence of the labeled graph 𝖷𝖬𝖷.

Now for the graph 𝖷𝖫 which 𝒜′′ claims to solve with termination, assign 𝖨𝖣s max(k𝖫,k𝖷) and max(k𝖫,k𝖷)+1 to the two nodes respectively. Both nodes must output 𝖭𝗈𝗇-𝖫𝖾𝖺𝖽𝖾𝗋 by our choice of k𝖫 and k𝖷, but they are the only nodes in the graph 𝖷𝖫. Hence, we arrive at a contradiction.

Similar to the proof of Theorem 4, we believe that the argument above can be extended to the randomized setting; however, we chose not to pursue this extension for the sake of simplicity.

There exist many graph families beyond 𝒢={P3,P5} for which the same impossibility result can be established. Our argument does not depend on the internal structure of 𝖫; in fact, replacing 𝖫 with any graph, not limited to rooted trees, does not affect the impossibility proof, thereby yielding infinitely many counterexamples. Consequently, our proof of the necessity of topology knowledge applies far more broadly than just to trees.

6 Conclusion and Open Questions

In this work, we fully characterize the solvability of content-oblivious leader election on trees with topology knowledge: Terminating leader election is possible if and only if the tree is not symmetric about an edge.

Being the first work to explore content-oblivious leader election beyond 2-edge-connected networks, our focus is primarily on qualitative results. It remains widely open whether the efficiency of our leader election algorithms can be improved, both in terms of message complexity and advice complexity. For odd-diameter trees, the advice complexity of our algorithm is O(n), as the topology of an n-vertex tree can be encoded using O(n) bits. For even-diameter trees, the advice complexity of our algorithm is O(logn), as the diameter of an n-vertex tree can be written using O(logn) bits.

Given that content-oblivious leader election in 2-edge-connected networks [18, 8] and in trees has been studied, a natural next step is to characterize the solvability of content-oblivious leader election in general graphs, since any connected graph decomposes into a tree of 2-vertex-connected components, and every 2-vertex-connected graph is also 2-edge-connected. On the impossibility side, we have shown in this work that if G is symmetric about an edge, then terminating leader election is not possible on G. We conjecture that, apart from the symmetric case, knowledge of the network topology G suffices to yield a terminating leader election algorithm.

Many graph problems remain unexplored in the content-oblivious model. For 2-edge-connected networks, a universal compiler transforms any distributed algorithm into one in the content-oblivious model, as shown by Censor-Hillel, Cohen, Gelles, and Sela [7]. Thus, the feasibility of leader election in 2-edge-connected networks implies that every other graph problem is also solvable. In contrast, due to the impossibility result of Censor-Hillel, Cohen, Gelles, and Sela [7], for trees and other non-2-edge-connected networks, such a universal simulation cannot exist, even with full topological knowledge. We leave open the question of whether other fundamental graph problems, such as 2-coloring, 3-coloring, and MIS, are solvable on trees in the content-oblivious model, provided that the network topology is known.

References

  • [1] Dan Alistarh, James Aspnes, David Eisenstat, Rati Gelashvili, and Ronald L. Rivest. Time-space trade-offs in population protocols. In Proceedings of the Twenty-Eighth Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 2560–2579, USA, 2017. Society for Industrial and Applied Mathematics. doi:10.1137/1.9781611974782.169.
  • [2] Dan Alistarh, Joel Rybicki, and Sasha Voitovych. Near-optimal leader election in population protocols on graphs. In Proceedings of the 2022 ACM Symposium on Principles of Distributed Computing (PODC), pages 246–256, 2022. doi:10.1145/3519270.3538435.
  • [3] Dana Angluin, James Aspnes, Zoë Diamadi, Michael J Fischer, and René Peralta. Computation in networks of passively mobile finite-state sensors. Distributed Computing, 18(4):235–253, 2006. doi:10.1007/S00446-005-0138-3.
  • [4] Petra Berenbrink, George Giakkoupis, and Peter Kling. Optimal time and space leader election in population protocols. In Proceedings of the 52nd Annual ACM SIGACT Symposium on Theory of Computing (STOC), pages 119–129, 2020. doi:10.1145/3357713.3384312.
  • [5] Paolo Boldi, Shella Shammah, Sebastiano Vigna, Bruno Codenotti, Peter Gemmell, and Janos Simon. Symmetry breaking in anonymous networks: Characterizations. In Proceedings of the 4th Israel Symposium on Theory of Computing and Systems (ISTCS), pages 16–26, 1996.
  • [6] Steven C. Bruell, Sukumar Ghosh, Mehmet Hakan Karaata, and Sriram V. Pemmaraju. Self-stabilizing algorithms for finding centers and medians of trees. SIAM Journal on Computing, 29(2):600–614, 1999. doi:10.1137/S0097539798427156.
  • [7] Keren Censor-Hillel, Shir Cohen, Ran Gelles, and Gal Sela. Distributed computations in fully-defective networks. Distributed Computing, 36(4):501–528, 2023. doi:10.1007/S00446-023-00452-2.
  • [8] Jérémie Chalopin, Yi-Jun Chang, Lyuting Chen, Giuseppe A. Di Luna, and Haoran Zhou. Content-Oblivious Leader Election in 2-Edge-Connected Networks. In Dariusz R. Kowalski, editor, 39th International Symposium on Distributed Computing (DISC), volume 356 of Leibniz International Proceedings in Informatics (LIPIcs), pages 21:1–21:22, Dagstuhl, Germany, 2025. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.DISC.2025.21.
  • [9] Ernest Chang and Rosemary Roberts. An improved algorithm for decentralized extrema-finding in circular configurations of processes. Commun. ACM, 22(5):281–283, May 1979. doi:10.1145/359104.359108.
  • [10] Yi-Jun Chang, Lyuting Chen, and Haoran Zhou. Beyond 2-edge-connectivity: Algorithms and impossibility for content-oblivious leader election, 2025. arXiv:2511.23297.
  • [11] Alejandro Cornejo and Fabian Kuhn. Deploying wireless networks with beeps. In Proceedings of the 24th International Conference on Distributed Computing (DISC), pages 148–162, Berlin, Heidelberg, 2010. Springer-Verlag. doi:10.1007/978-3-642-15763-9_15.
  • [12] Stefan Dobrev and Andrzej Pelc. Leader election in rings with nonunique labels. Fundamenta Informaticae, 59(4):333–347, 2004. URL: http://content.iospress.com/articles/fundamenta-informaticae/fi59-4-02.
  • [13] Danny Dolev, Maria M. Klawe, and Michael Rodeh. An O(nlogn) unidirectional distributed algorithm for extrema finding in a circle. J. Algorithms, 3(3):245–260, 1982. doi:10.1016/0196-6774(82)90023-2.
  • [14] David Doty and David Soloveichik. Stable leader election in population protocols requires linear time. Distributed Computing, 31(4):257–271, 2018. doi:10.1007/S00446-016-0281-Z.
  • [15] Fabien Dufoulon, Janna Burman, and Joffroy Beauquier. Beeping a deterministic time-optimal leader election. In 32nd International Symposium on Distributed Computing (DISC 2018), pages 20:1–20:17. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2018. doi:10.4230/LIPIcs.DISC.2018.20.
  • [16] Yuval Emek and Eyal Keren. A thin self-stabilizing asynchronous unison algorithm with applications to fault tolerant biological networks. In Proceedings of the 2021 ACM Symposium on Principles of Distributed Computing (PODC), pages 93–102, 2021. doi:10.1145/3465084.3467922.
  • [17] Klaus-Tycho Förster, Jochen Seidel, and Roger Wattenhofer. Deterministic leader election in multi-hop beeping networks. In Proceedings of the 28th International Symposium on Distributed Computing (DISC), pages 212–226. Springer, 2014.
  • [18] Fabian Frei, Ran Gelles, Ahmed Ghazy, and Alexandre Nolin. Content-Oblivious Leader Election on Rings. In Dan Alistarh, editor, 38th International Symposium on Distributed Computing (DISC), volume 319 of Leibniz International Proceedings in Informatics (LIPIcs), pages 26:1–26:20, Dagstuhl, Germany, 2024. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.DISC.2024.26.
  • [19] Mohsen Ghaffari and Bernhard Haeupler. Near optimal leader election in multi-hop radio networks. In Proceedings of the 24th annual ACM-SIAM symposium on Discrete algorithms (SODA), pages 748–766. SIAM, 2013. doi:10.1137/1.9781611973105.54.
  • [20] Seth Gilbert and Calvin Newport. The computational power of beeps. In Proceedings of the 29th International Symposium on Distributed Computing (DISC), pages 31–46, Berlin, Heidelberg, 2015. Springer-Verlag. doi:10.1007/978-3-662-48653-5_3.
  • [21] Christian Glacet, Avery Miller, and Andrzej Pelc. Time vs. Information Tradeoffs for Leader Election in Anonymous Trees, pages 600–609. SIAM, 2016. doi:10.1137/1.9781611974331.ch44.
  • [22] Barun Gorain, Avery Miller, and Andrzej Pelc. Four shades of deterministic leader election in anonymous networks. In Proceedings of the 33rd ACM Symposium on Parallelism in Algorithms and Architectures (SPAA), pages 265–274, New York, NY, USA, 2021. Association for Computing Machinery. doi:10.1145/3409964.3461794.
  • [23] D. S. Hirschberg and J. B. Sinclair. Decentralized extrema-finding in circular configurations of processors. Commun. ACM, 23(11):627–628, November 1980. doi:10.1145/359024.359029.
  • [24] Alon Itai and Michael Rodeh. Symmetry breaking in distributed networks. Inf. Comput., 88(1):60–87, July 1990. doi:10.1016/0890-5401(90)90004-2.
  • [25] David Peleg. Informative labeling schemes for graphs. Theoretical Computer Science, 340(3):577–593, 2005. Mathematical Foundations of Computer Science 2000. doi:10.1016/j.tcs.2005.03.015.
  • [26] Gary L. Peterson. An O(nlogn) unidirectional algorithm for the circular extrema problem. ACM Trans. Program. Lang. Syst., 4(4):758–762, October 1982. doi:10.1145/69622.357194.
  • [27] Yuichi Sudo and Toshimitsu Masuzawa. Leader election requires logarithmic time in population protocols. Parallel Processing Letters, 30(01):2050005, 2020.
  • [28] Yuichi Sudo, Fukuhito Ooshita, Taisuke Izumi, Hirotsugu Kakugawa, and Toshimitsu Masuzawa. Time-optimal leader election in population protocols. IEEE Transactions on Parallel and Distributed Systems, 31(11):2620–2632, 2020. doi:10.1109/TPDS.2020.2991771.
  • [29] Robin Vacus and Isabella Ziccardi. Minimalist leader election under weak communication. In Proceedings of the ACM Symposium on Principles of Distributed Computing (PODC), pages 406–416, New York, NY, USA, 2025. Association for Computing Machinery. doi:10.1145/3732772.3733559.
  • [30] Masafumi Yamashita and Tiko Kameda. Electing a leader when processor identity numbers are not distinct. In Proceedings of the 3rd International Workshop on Distributed Algorithms (WDAG), pages 303–314. Springer, 1989.
  • [31] Masafumi Yamashita and Tsunehiko Kameda. Computing on anonymous networks. i. characterizing the solvable cases. IEEE Transactions on parallel and distributed systems, 7(1):69–89, 1996.