Node Labels in Local Decision
Theoretical Computer Science Federation
CNRS and University Paris Diderot, France
Helsinki Institute for Information Technology HIIT,
Department of Computer Science, Aalto University, Finland
Helsinki Institute for Information Technology HIIT,
Department of Computer Science, Aalto University, Finland
Abstract. The role of unique node identifiers in network computing is well understood as far as symmetry breaking is concerned. However, the unique identifiers also leak information about the computing environment—in particular, they provide some nodes with information related to the size of the network. It was recently proved that in the context of local decision, there are some decision problems such that (1) they cannot be solved without unique identifiers, and (2) unique node identifiers leak a sufficient amount of information such that the problem becomes solvable (PODC 2013).
In this work we give study what is the minimal amount of information that we need to leak from the environment to the nodes in order to solve local decision problems. Our key results are related to scalar oracles that, for any given , provide a multiset of labels; then the adversary assigns the labels to the nodes in the network. This is a direct generalisation of the usual assumption of unique node identifiers. We give a complete characterisation of the weakest oracle that leaks at least as much information as the unique identifiers.
Our main result is the following dichotomy: we classify scalar oracles as large and small, depending on their asymptotic behaviour, and show that (1) any large oracle is at least as powerful as the unique identifiers in the context of local decision problems, while (2) for any small oracle there are local decision problems that still benefit from unique identifiers.
This work studies the role of unique node identifiers in the context of local decision problems in distributed systems. We generalise the concept of node identifiers by introducing scalar oracles that choose the labels of the nodes, depending on the size of the network —in essence, we let the oracle leak some information on to the nodes—and ask what is the weakest scalar oracle that we could use instead of unique identifiers. We prove the following dichotomy: we classify each scalar oracle as small or large, depending on its asymptotic behaviour, and we show that the large oracles are precisely those oracles that are at least as strong as unique identifiers.
1.1 Context and background
The research trends within the framework of distributed computing are most often pragmatic. Problems closely related to real world applications are tackled under computational assumptions reflecting existing systems, or systems whose future existence is plausible. Unfortunately, small variations in the model settings may lead to huge gaps in terms of computational power. Typically, some problems are unsolvable in one model but may well be efficiently solvable in a slight variant of that model. In the context of network computing, this commonly happens depending on whether the model assumes that pairwise distinct identifiers are assigned to the nodes. While the presence of distinct identifiers is inherent to some systems (typically, those composed of artificial devices), the presence of such identifiers is questionable in others (typically, those composed of biological or chemical elements). Even if the identifiers are present, they may not necessarily be directly visible, e.g., for privacy reasons.
The absence of identifiers, or the difficulty of accessing the identifiers, limits the power of computation. Indeed, it is known that the presence of identifiers ensures two crucial properties, which are both used in the design of efficient algorithms. One such property is symmetry breaking. The absence of identifiers makes symmetry breaking far more difficult to achieve, or even impossible if asymmetry cannot be extracted from the inputs of the nodes, from the structure of the network, or from some source of random bits. The role of the identifiers in the framework of network computing, as far as symmetry breaking is concerned, has been investigated in depth, and is now well understood [1, 2, 3, 4, 5, 6, 7, 9, 15, 16, 17, 19, 20, 21, 22, 23, 27, 28, 8, 18, 26].
The other crucial property of the identifiers is their ability to leak global information about the framework in which the computation takes place. In particular, the presence of pairwise distinct identifiers guarantees that at least one node has an identifier at least in -node networks. This apparently very weak property was proven to actually play an important role when one is interested in checking the correctness of a system configuration in a decentralised manner. Indeed, it was shown in prior work  that the ability to check the legality of a system configuration with respect to some given Boolean predicate differs significantly according to the ability of the nodes to use their identifiers. This phenomenon is of a nature different from symmetry breaking, and is far less understood than the latter.
More precisely, let us define a distributed language as a set of system configurations (e.g., the set of properly coloured networks, or the set of networks each with a unique leader). Then let be the class of distributed languages that are locally decidable. That is, is the set of distributed languages for which there exists a distributed algorithm where every node inspects its neighbourhood at constant distance in the network, and outputs yes or no according to the following rule: all nodes output yes if and only if the instance is legal. Equivalently, the instance is illegal if and only if at least one node outputs no. Let be defined as with the restriction the local algorithm is required to be identifier oblivious, that is, the output of every node is the same regardless of the identifiers assigned to the nodes. By definition, , but  proved that this inclusion is strict: there are languages in . This strict inclusion was obtained by constructing a distributed language that can be decided by an algorithm whose outputs depend heavily on the identifiers assigned to the nodes, and in particular on the fact that at least one node has an identifier whose value is at least .
The gap between and has little to do with symmetry breaking. Indeed, decision tasks do not require that some nodes act differently from the others: on legal instances, all nodes must output yes, while on illegal instances, it is permitted (but not required) that all nodes output no. The gap between and is entirely due to the fact that the identifiers leak information about the size of the network. Moreover, it is known that the gap between and is strongly related to computability issues: there is an identifier-oblivious non-computable simulation of every local algorithm that uses identifiers to decide a distributed language . Informally, for every language in , the unique identifiers are precisely as helpful as providing the nodes with the capability of solving undecidable problems.
One objective of this paper is to measure the amount of information provided to a distributed system via the labels given to its nodes. For this purpose, we consider the classes and enhanced with oracles, where an oracle is a function that provides every node with information about its environment.
We focus on the class of scalar oracles, which are functions over the positive integers. Given an , a scalar oracle returns a list of labels (bit strings) that are assigned arbitrarily to the nodes of any -node network in a one-to-one manner. The class (resp., ) is then defined as the class of distributed languages decidable locally by an algorithm (resp., by an identifier-oblivious algorithm) in networks labelled with oracle .
If, for every , the values in the list are pairwise distinct, then since the nodes can use the values provided to them by the oracle as identifiers. However, as we shall demonstrate in the paper, this pairwise distinctness condition is not necessary.
Our goal is to identify the interplay between the classes , , , and , with respect to any scalar oracle , and to characterise the power of identifiers in distributed systems as far as leaking information about the environment is concerned.
1.3 Our results
Our first result is a characterisation of the weakest oracles providing the same power as unique node identifiers. We say that a scalar oracle is large if, roughly, ensures that, for any set of nodes, the largest value provided by to the nodes in this set grows with (see Section 2.3 for the precise definition). We show the following theorem.
For any computable scalar oracle , we have if and only if is large.
Theorem 1 is a consequence of the following two lemmas. The first says that small oracles (i.e. non-large oracles) do not capture the power of unique identifiers. Note that the following separation result holds for any small oracle, including uncomputable oracles.
For any small oracle , there exists a language .
The second is a simulation result, showing that any local decision algorithm using identifiers can be simulated by an identifier-oblivious algorithm with the help of any large oracle, as long as the oracle itself is computable. Essentially large oracles capture the power of unique identifiers.
For any large computable oracle , we have .
Theorem 1 holds despite the fact that small oracles can still produce some large values, and that there exist small oracles guaranteeing that, in any -node network, at least one node has a value at least . Such a small oracle would be sufficient to decide the language presented in . However, it is not sufficient to decide all languages in .
Our second result is a complete description of the hierarchy of the four classes , , , and of local decision, using identifiers or not, with or without oracles. The pictures for small and large oracles are radically different.
For any large oracle , the hierarchy yields a total order:
The strict inclusion follows from . The second inclusion may or may not be strict depending on oracle .
For any small oracle , the hierarchy yields a partial order. We have as a consequence of Lemma 2. However, and are incomparable, in the sense that there is a language for any small oracle , and there is a language for some small oracles . Hence, the relationships of the four classes can be represented as the following diagram:
All inclusions (represented by arrows) can be strict.
1.4 Additional related work
In the context of network computing, oracles and advice commonly appear in the form of labelling schemes [14, 10]. A typical example is a distance labelling scheme, which is a labelling of the nodes so that the distance between any pair of nodes can be computed or approximated based on the labels. Other examples are routing schemes that label the nodes with information that helps in finding a short path between any given source and destination. For graph problems, one could of course encode the entire solution in the advice string—hence the key question is whether a very small amount of advice helps with solving a given problem.
In prior work, it is commonly assumed that the oracle can give a specific piece of advice for each individual node. The advice is localised, and entirely controlled by the oracle. Moreover, the oracle can see the entire problem instance and it can tailor the advice for any given task.
In the present work, we study a much weaker setting: the oracle is only given , and it cannot choose which label goes to which node. This is a generalisation of, among others, typical models of networks with unique identifiers: one commonly assumes that the unique identifiers are a permutation of , which in our case is exactly captured by the large scalar oracle
or that the unique identifiers are a subset of for some constant , which in our case is captured by a subfamily of large scalar oracles. Our model is also a generalisation of anonymous networks with a unique leader —the assumption that there is a unique leader is captured by the small scalar oracle
2 Model and definitions
2.1 Computational model
We deal with the standard LOCAL model  for distributed graph algorithms. In this model, the network is a simple connected graph . Each node has an identifier , and all identifiers of the nodes in the network are pairwise distinct. Computation proceeds in synchronous rounds. During a round, each node communicates with its neighbours in the graph, and performs some local computation. There are no limits to the amount of communication done in a single round. Hence, in communication rounds, each node can learn the complete topology of its radius- neighbourhood, including the inputs and the identifiers of the nodes in this neighbourhood. In a distributed algorithm, all nodes start at the same time, and each node must halt after some number of rounds, and produce its individual output. The collection of individual outputs then forms the global output of the computation. The running time of the algorithm is the number of communication rounds until all nodes have halted.
We consider local algorithms, i.e., constant-time algorithms . That is, we focus on algorithms with a running time that does not depend on the size of the graph. Any such algorithm, with running time , can be seen as a function from the set of all possible radius- neighbourhoods to the set of all possible outputs. An identifier-oblivious algorithm is an algorithm whose outputs are independent of the identifiers assigned to the nodes. Note that, from the perspective of an identifier-oblivious algorithm, the set of all possible radius- degree- neighbourhoods is finite. This is not the case for every algorithm since there are infinitely many identifier assignments to the nodes in a radius- degree- neighbourhood.
Although the LOCAL model does not put any restriction on the amount of individual computation performed at each node, we only consider algorithms that are computable.
2.2 Local decision tasks
We are interested in the power of constant-time algorithms for local decision. A labelled graph is a pair , where is a simple connected graph, and is a function assigning a label to each node of . A distributed language is a set of labelled graphs. Examples of distributed languages include:
2-colouring, the language where is a bipartite graph and for all such that whenever ;
parity, the language of graphs with an even number of nodes;
planarity, the language that consists of all planar graphs.
We say that algorithm decides if and only if the output of at every node is either yes or no, and, for every instance , satisfies:
Hence, for an instance , the algorithm must ensure that at least one node outputs no. We consider two main distributed complexity classes:
(for local decision) is the set of languages decidable by constant-time algorithms in the LOCAL model.
(for local decision oblivious) is the set of languages decidable by constant-time identifier-oblivious algorithms in the LOCAL model.
By definition, , and it is known  that this inclusion is strict: there are languages . The fact that we consider only computable algorithms is crucial here—without this restriction we would have .
2.3 Distributed oracles
We study the relationship of classes and with respect to scalar oracles. Such an oracle is a function that assigns a list of values to every positive integer , i.e.,
with . In essence, oracle can provide some information related to to the nodes. In an -node graph, each of the nodes will receive a value , . These values are arbitrarily assigned to the nodes in a one-to-one manner. Two different nodes will thus receive and with . Note that may or may not be different from for ; this is up to the choice of the oracle. The way the values provided by the oracles are assigned to the nodes is under the control of an adversary. One example of an oracle is , which provides the nodes with identifiers. Another example is , which provides no information to the nodes.
W.l.o.g., let us assume that for every . We use the shorthand for the th label provided by on input , that is, . For a fixed oracle , we consider two main distributed complexity classes:
is the set of languages decidable by constant-time algorithms in networks that are labelled with oracle .
is the set of languages decidable by constant-time indentifier-oblivious algorithms in networks that are labelled with oracle .
We will separate oracles in two classes, which play a crucial role in the way the four classes , , , and interact.
An oracle is said to be large if
An oracle is small if it is not large.
Hence, a large oracle satisfies that, for any value , there exists a large enough , such that, in every graph of size at least , for every set of nodes of size , oracle is providing at least one node of with a value at least as large as . In short: every large set of nodes must include at least one node that receives a large value.
Conversely, a small oracle satisfies that there exists a value such that, for every , we can find such that, in every -node graph , and for every set of nodes of size , there is an assignment of the values provided by such that every node in receives a value smaller that . In short: there are arbitrarily large sets of nodes which all receive a small value.
For example, oracles and are large, while oracles and are small. We emphasise that small oracles can output very large values.
3 Proof of the main theorem
In this section we give the proof of our main result that characterises the power of weak and large oracles with respect to identifier-oblivious local decision.
3.1 Small oracles do not capture the power of unique identifiers
Fraigniaud et al.  showed that there exists a language . We use a very similar Turing machine construction as in the proof of their Theorem 1. However, we must take into account the additional concern of the values that the oracle assigns to the nodes. We handle this by forcing any small oracle to always give many copies of the same constant label so that the adversary can cover the interesting parts of the construction with this unhelpful label . We can then use uncomputability arguments to show that if a certain language were in , then we could get a sequential algorithm for uncomputable problems. See Figure 1 for illustrations.
We assume that for each halting Turing machine and each locality parameter , there exists a labelled graph with the following properties:
There is an identifier-oblivious local checker that verifies that a given labelled graph is a equal to for some and .
The number of nodes in the graph is at least as large as the number of steps takes on an empty tape.
Given , an identifier-oblivious local checker with a running time of cannot decide if outputs or .
Each label of is a triple . The maximum degree of and the maximum size of are constants that only depend on .
The construction of Fraigniaud et al.  satisfies these properties. They show how to construct a labelled graph that encodes the execution table of a given Turing machine such that a local checker with running time cannot decide if halts with or . The original construction consists of three main parts.
The execution table of the Turing machine . Let be the number of steps takes on an empty tape. Then table is an grid, where node holds the contents of the tape at position after computation step , and its own coordinates modulo . Node also knows if the head is at position after step , and if so, what is the state of after step . Node representing the first position of the empty tape is called the pivot. The execution table exists essentially to guarantee 2.
The fragment collection . This is a collection of subgrids labelled with all syntactically possible ways that are consistent with being in some execution table of . The dimensions of the fragments are linear in and independent of . In each fragment, every subgrid is consistent with a state transition of . It is crucial to observe that there is a finite number of such fragments. Each fragment is connected to the pivot in a way that supports the local verification of the structure. The fragment collection is added to ensure 3. Informally, if we only had , then some node at the last row of the grid would be able to see the stopping state of ; however, will contain some fragments in which halts with output and some fragments in which halts with output , and the nodes at the last row of are locally indistinguishable from the nodes in such fragments.
Pyramid structure. This is added to the execution table and to the fragments to ensure 1. Without any additional structure, a grid with coordinates modulo is locally indistinguishable from, e.g., a grid that is wrapped into a torus. The pyramid structure guarantees that at least one node is able to detect invalid instances.
Finally, since all labellings can be made constant-size, we can ensure 4. In particular, for any , there are constantly many syntactically possible -neighbourhoods of . This is a crucial property as it guarantees that there is a sequential algorithm that on all inputs halts and, if halts, outputs all possible labelled -neighbourhoods of .
Let be the labelled path in which node is labelled with value . We augment the construction as follows: labelled graph consists of , plus , plus an edge between the pivot of and the first node of the path ; we call the tail of the construction. The structure of is still locally checkable in : any tail must eventually connect to the pivot, and the pivot can detect if there are multiple tails. The key property of the construction is that the nodes in the tail with large labels are far from the nodes of that are aware of .
We will separate and using the following language:
We have as there will be a node with which can simulate for steps and output no if does not output . Next we will argue that cannot be in for any small .
Let be a small oracle. For any and , we can choose a sufficiently large as follows. By definition, there exists a such that for all oracle outputs some label at least times on some . Moreover, we can find an infinite sequence of values such that the most common value is some fixed . We select w.l.o.g. the smallest and a suitable such that contains at least labels equal to . Let , and consider . Now the adversary can construct the following worst-case labelling: every node of receives the constant input ; all other labels as assigned to the nodes in .
It is known that separating the following languages is undecidable (see e.g. [24, p. 65]):
For the sake of contradiction, we assume that there is an -algorithm that decides . We will use algorithm and constant defined above to construct a sequential algorithm that separates and .
Let be the running time of , and consider the execution of on an instance for some and . It follows that each node in must always output yes. To see this, note that the claim is trivial if halts with . Otherwise we can always construct another instance such that halts with and both and have the same number of nodes. Hence the oracle and the adversary can assign the same labels to in both and . If any of these nodes would answer no in , then would also incorrectly reject the yes-instance .
Now given a Turing machine , algorithm proceeds as follows. Consider the subgraph , and assume the worst-case labelling of in which all nodes of have the constant label . Algorithm cannot construct ; indeed, might not halt, in which case would not even exist. However, can do the following: it can assume that halts, and then generate a collection that would contain all possible radius- neighbourhoods of the nodes in . Collection is finite, its size only depends on and , and the key observation is that is computable (in essence, enumerates all syntactically possible fixed-size fragments of partial execution tables of ).
Then will simulate in each neighbourhood of . If halts with , then , and therefore one of the nodes in has to output no; in this case outputs . If halts with , then , and therefore one of the nodes in has to output yes; in this case outputs . The key observation is that will always halt with some (meaningless) output even if we are given an input ; hence is a computable function that separates and . As such a cannot exist, cannot exist either. ∎
3.2 Large oracles capture the power of unique identifiers
In this section we will show that a computable large oracle is sufficient to have . This result holds even if only has access to an upper bound , and the adversary gets to pick an -subset of labels from . Note that the oracle has to be computable in order for us to invert it locally.
We begin by showing how to recover an oracle with , for all and , from a large oracle . We want to guarantee that each node receives a label if in the initial labelling it had the th smallest label.
By definition, it holds for large oracles that for each natural number there is a largest index such that ; we denote the index by . By assumption, a node with label can locally compute the value . We now claim that
has the property . To see this, assume that we have for an arbitrary . Seeing label , node knows that, in the worst case, its own label is the th smallest. Thus for every , the node with the th smallest label will compute a new label at least .
Now given , we can simulate any -round -algorithm as follows.
Each node with label locally computes the new label .
Each node gathers all labels in its -neighbourhood. Denote by the maximum value in the neighbourhood of .
Each node simulates on every unique identifier assignment to its local -neighbourhood from . If for some assignment outputs no, then outputs no, and otherwise it outputs yes.
Because of how the decision problem is defined, it is always safe to output no when some simulation of outputs no. It remains to be argued that it is safe to say yes, if all simulations say yes. This requires that some subset of simulations of , one for each node, looks as if there had been a consistent setting of unique identifiers on the graph. Now let id be one identifier assignment with for the with th smallest label, for all (breaking ties arbitrarily). Since by construction for all , there will be a simulation of for every node with local identifier assignment such that for all in the radius- neighbourhood of we have .
So far we have seen how to simulate any -algorithm with -algorithms. We can apply the same reasoning to simulate any -algorithm with -algorithms; the only difference is that each node in the simulation has now access to the original oracle labels as well. ∎
4 Full characterisation of , , , and
Our goal in this section is to complete the characterisation of the power of scalar oracles with respect to the classes and . We aim at giving a robust characterisation that holds also for minor variations in the definition of a scalar oracle. In particular, all of the key results can be adapted to weaker oracles that only receive an upper bound on the size of the graph.
4.1 Large oracles can be stronger than identifiers
Trivially, there is a large computable oracle such that
We will now show that there is also a large computable oracle such that
For a simple proof, we could consider the large oracle . Now the parity language that consists of graphs with an even number of nodes is clearly in but not in . However, this separation is not robust with respect to minor changes in the model of scalar oracles. In particular, if the oracle only knows an upper bound on , we cannot use the parity language to separate from .
In what follows, we will show that the upper bound oracle that labels all nodes with some upper bound on can be used to separate from . We resort again to computability arguments. The construction that we use in the proof has some elements that we do not need here (in particular, the fragment collection and the parameter ), but it enables us to directly reuse the same tools that we already introduced in the proof of Lemma 2.
For the upper bound oracle there exists a language such that .
The following language is not in but is in . Recall the Turing machine construction from Lemma 2. We augment it so that the pivot receives an extra label ; let us denote such a construction by . Let
First, observe that is in . Checking the structure of and hence is known to be in . Since the execution table of is contained in , it must halt within steps. Finally, since the pivot is guaranteed to receive an as its oracle label, it can simulate for at most steps and determine whether halts with output .
Next, we show that . Suppose otherwise. Fix a local verifier that decides , and let be the running time of . Consider a node that is within distance more than from the pivot. For such a node, algorithm must always output yes—otherwise we could change the input label so that an answer no is incorrect. Thus one of the nodes within distance from the pivot must be able to tell whether is a no instance.
Using , we can now design a sequential algorithm that solves the undecidable problem of separating the languages from (1). Given a Turing machine , algorithm :
constructs up to distance from the pivot,
assigns the unique identifiers arbitrarily in this neighbourhood,
simulates for each node within distance from the pivot.
Note that can essentially simulate for steps to construct up to distance from the pivot; the construction is correct if halts, and it terminates even if does not halt. Now is a no-instance if and only if halts with output . In this case one of the nodes within distance from the pivot has to output no; otherwise all of them have to output yes. In the former case outputs , otherwise it outputs . Clearly outputs for each . However, such an algorithm cannot exist. Therefore cannot exist, either, and we have . ∎
The construction that we use above has some additional elements that were not necessary (in particular, the fragment collection and parameter ). However, this construction made it possible to directly reuse the same tools that we already introduced in the proof of Lemma 2.
4.2 Small oracles and identifiers are incomparable
In the case of small oracles, we already know that for any small oracle by Lemma 2. Next we characterise the relationship of and . In essence, we show that these classes are incomparable.
There is a single small oracle so that each of the languages , , and shown in Figure 2 exist.
Let be the small oracle
where is an -bit string such that the th bit tells whether the th Turing machine halts. We construct the languages as follows:
Let denote the labelled path of length such that each node has two input labels: and the distance to a specified leaf node . The correct structure of is in . Now let
The node that receives the -bit oracle label can use it to decide whether the th Turing machine halts, and therefore . Conversely, we have ; otherwise we would have a sequential algorithm that solves the halting problem for each Turing machine by constructing the path with some fixed identifier assignment and simulating the local verifier.
Apply Lemma 2. ∎
We conclude by noting that Theorem 5 is also robust to minor variations in the definitions. In particular, the oracle does not need to know the exact value of ; it is sufficient that at least one node receives the bit string , where is some upper bound on .
Thanks to Laurent Feuilloley for discussions.
- Angluin  Dana Angluin. Local and global properties in networks of processors. In Proc. 12th Annual ACM Symposium on Theory of Computing (STOC 1980), pages 82–93. ACM Press, 1980. doi:10.1145/800141.804655.
- Boldi and Vigna  Paolo Boldi and Sebastiano Vigna. An effective characterization of computability in anonymous networks. In Proc. 15th International Symposium on Distributed Computing (DISC 2001), volume 2180 of Lecture Notes in Computer Science, pages 33–47. Springer, 2001. doi:10.1007/3-540-45414-4_3.
- Chalopin et al.  Jérémie Chalopin, Shantanu Das, and Nicola Santoro. Groupings and pairings in anonymous networks. In Proc. 20th International Symposium on Distributed Computing (DISC 2006), volume 4167 of Lecture Notes in Computer Science, pages 105–119. Springer, 2006. doi:10.1007/11864219_8.
- Czygrinow et al.  Andrzej Czygrinow, Michał Hańćkowiak, and Wojciech Wawrzyniak. Fast distributed approximations in planar graphs. In Proc. 22nd International Symposium on Distributed Computing (DISC 2008), volume 5218 of Lecture Notes in Computer Science, pages 78–92. Springer, 2008. doi:10.1007/978-3-540-87779-0_6.
- Diks et al.  Krzysztof Diks, Evangelos Kranakis, Adam Malinowski, and Andrzej Pelc. Anonymous wireless rings. Theoretical Computer Science, 145(1–2):95–109, 1995. doi:10.1016/0304-3975(94)00178-L.
- Emek et al. [2014a] Yuval Emek, Christoph Pfister, Jochen Seidel, and Roger Wattenhofer. Anonymous networks: randomization = 2-hop coloring. In Proc. 33rd ACM SIGACT-SIGOPS Symposium on Principles of Distributed Computing (PODC 2014), pages 96–105. ACM Press, 2014a. doi:10.1145/2611462.2611478.
- Emek et al. [2014b] Yuval Emek, Jochen Seidel, and Roger Wattenhofer. Computability in anonymous networks: revocable vs. irrecovable outputs. In Proc. 41st International Colloquium on Automata, Languages and Programming (ICALP 2014), volume 8573 of LNCS, pages 183–195. Springer, 2014b. doi:10.1007/978-3-662-43951-7_16.
- Fich and Ruppert  Faith Fich and Eric Ruppert. Hundreds of impossibility results for distributed computing. Distributed Computing, 16(2–3):121–163, 2003. doi:10.1007/s00446-003-0091-y.
- Fraigniaud et al.  Pierre Fraigniaud, Andrzej Pelc, David Peleg, and Stéphane Pérennes. Assigning labels in an unknown anonymous network with a leader. Distributed Computing, 14(3):163–183, 2001. doi:10.1007/PL00008935.
- Fraigniaud et al.  Pierre Fraigniaud, Cyril Gavoille, David Ilcinkas, and Andrzej Pelc. Distributed computing with advice: information sensitivity of graph coloring. In Proc. 34th International Colloquium on Automata, Languages and Programming (ICALP 2007), volume 4596 of Lecture Notes in Computer Science, pages 231–242. Springer, 2007. doi:10.1007/978-3-540-73420-8_22.
- Fraigniaud et al.  Pierre Fraigniaud, Amos Korman, and David Peleg. Local distributed decision. In Proc. 52nd Annual IEEE Symposium on Foundations of Computer Science (FOCS 2011). IEEE Computer Society Press, 2011. doi:10.1109/FOCS.2011.17.
- Fraigniaud et al.  Pierre Fraigniaud, Magnús M. Halldórsson, and Amos Korman. On the impact of identifiers on local decision. In Proc. 16th International Conference on Principles of Distributed Systems (OPODIS 2012), volume 7702 of Lecture Notes in Computer Science, pages 224–238. Springer, 2012. doi:10.1007/978-3-642-35476-2_16.
- Fraigniaud et al.  Pierre Fraigniaud, Mika Göös, Amos Korman, and Jukka Suomela. What can be decided locally without identifiers? In Proc. 32nd Annual ACM Symposium on Principles of Distributed Computing (PODC 2013), pages 157–165. ACM Press, 2013. doi:10.1145/2484239.2484264. arXiv:1302.2570.
- Gavoille and Peleg  Cyril Gavoille and David Peleg. Compact and localized distributed data structures. Distributed Computing, 16(2–3):111–120, 2003. doi:10.1007/s00446-002-0073-5.
- Göös et al.  Mika Göös, Juho Hirvonen, and Jukka Suomela. Lower bounds for local approximation. Journal of the ACM, 60(5):39:1–23, 2013. doi:10.1145/2528405. arXiv:1201.6675.
- Hasemann et al.  Henning Hasemann, Juho Hirvonen, Joel Rybicki, and Jukka Suomela. Deterministic local algorithms, unique identifiers, and fractional graph colouring. Theoretical Computer Science, 2014. To appear. doi:10.1016/j.tcs.2014.06.044.
- Hella et al.  Lauri Hella, Matti Järvisalo, Antti Kuusisto, Juhana Laurinharju, Tuomo Lempiäinen, Kerkko Luosto, Jukka Suomela, and Jonni Virtema. Weak models of distributed computing, with connections to modal logic. Distributed Computing, 28(1):31–53, 2015. doi:10.1007/s00446-013-0202-3. arXiv:1205.2051.
- Kranakis  Evangelos Kranakis. Symmetry and computability in anonymous networks: a brief survey. In Proc. 3rd Colloquium on Structural Information and Communication Complexity (SIROCCO 1996), pages 1–16. Carleton University Press, 1997.
- Lenzen and Wattenhofer  Christoph Lenzen and Roger Wattenhofer. Leveraging Linial’s locality limit. In Proc. 22nd International Symposium on Distributed Computing (DISC 2008), volume 5218 of Lecture Notes in Computer Science, pages 394–407. Springer, 2008. doi:10.1007/978-3-540-87779-0_27.
- Linial  Nathan Linial. Locality in distributed graph algorithms. SIAM Journal on Computing, 21(1):193–201, 1992. doi:10.1137/0221015.
- Mayer et al.  Alain Mayer, Moni Naor, and Larry Stockmeyer. Local computations on static and dynamic graphs. In Proc. 3rd Israel Symposium on the Theory of Computing and Systems (ISTCS 1995), pages 268–278. IEEE, 1995. doi:10.1109/ISTCS.1995.377023.
- Naor and Stockmeyer  Moni Naor and Larry Stockmeyer. What can be computed locally? SIAM Journal on Computing, 24(6):1259–1277, 1995. doi:10.1137/S0097539793254571.
- Norris  Nancy Norris. Classifying anonymous networks: when can two networks compute the same set of vector-valued functions? In Proc. 1st Colloquium on Structural Information and Communication Complexity (SIROCCO 1994), pages 83–98. Carleton University Press, 1995.
- Papadimitriou  Christos H. Papadimitriou. Computational Complexity. Addison-Wesley Publishing Company, 1994.
- Peleg  David Peleg. Distributed Computing: A Locality-Sensitive Approach. SIAM Monographs on Discrete Mathematics and Applications. Society for Industrial and Applied Mathematics, Philadelphia, 2000.
- Suomela  Jukka Suomela. Survey of local algorithms. ACM Computing Surveys, 45(2):24:1–40, 2013. doi:10.1145/2431211.2431223. http://www.cs.helsinki.fi/local-survey/.
- Yamashita and Kameda  Masafumi Yamashita and Tsunehiko Kameda. Computing on anonymous networks: part I—characterizing the solvable cases. IEEE Transactions on Parallel and Distributed Systems, 7(1):69–89, 1996. doi:10.1109/71.481599.
- Yamashita and Kameda  Masafumi Yamashita and Tsunehiko Kameda. Leader election problem on networks in which processor identity numbers are not distinct. IEEE Transactions on Parallel and Distributed Systems, 10(9):878–887, 1999. doi:10.1109/71.798313.