Byzantine Gathering in Networks
aa r X i v : . [ c s . D C ] A p r Byzantine Gathering in Networks ∗ S´ebastien Bouchard , Yoann Dieudonn´e , Bertrand Ducourthial Laboratoire MIS & Universit´e de Picardie Jules Verne, Amiens, France. Heudiasyc, CNRS & Universit´e de Technologie de Compi`egne, Compi`egne, France.
Abstract
This paper investigates an open problem introduced in [14]. Two or more mobile agents start fromdifferent nodes of a network and have to accomplish the task of gathering which consists in getting alltogether at the same node at the same time. An adversary chooses the initial nodes of the agents andassigns a different positive integer (called label) to each of them. Initially, each agent knows its labelbut does not know the labels of the other agents or their positions relative to its own. Agents move insynchronous rounds and can communicate with each other only when located at the same node. Up to f of the agents are Byzantine. A Byzantine agent can choose an arbitrary port when it moves, can conveyarbitrary information to other agents and can change its label in every round, in particular by forging thelabel of another agent or by creating a completely new one. What is the minimum number M of good agents that guarantees deterministic gathering of all ofthem, with termination? We provide exact answers to this open problem by considering the case when the agents initiallyknow the size of the network and the case when they do not. In the former case, we prove M = f + 1 while in the latter, we prove M = f + 2 . More precisely, for networks of known size, we designa deterministic algorithm gathering all good agents in any network provided that the number of goodagents is at least f + 1 . For networks of unknown size, we also design a deterministic algorithm ensuringthe gathering of all good agents in any network but provided that the number of good agents is at least f + 2 . Both of our algorithms are optimal in terms of required number of good agents, as each of themperfectly matches the respective lower bound on M shown in [14], which is of f + 1 when the size ofthe network is known and of f + 2 when it is unknown.Perhaps surprisingly, our results highlight an interesting feature when put in perspective with knownresults concerning a relaxed variant of this problem in which the Byzantine agents cannot change theirinitial labels. Indeed under this variant M = 1 for networks of known size and M = f + 2 for networksof unknown size. Following this perspective, it turns out that when the size of the network is known, theability for the Byzantine agents to change their labels significantly impacts the value of M . However,the relevance for M of such an ability completely disappears in the most general case where the size ofthe network is unknown, as M = f + 2 regardless of whether Byzantine agents can change their labelsor not. Keywords: rendezvous, deterministic algorithm, mobile agent, Byzantine fault. ∗ Partially supported by the European Regional Development Fund (ERDF) and the Picardy region under Project TOREDY.
Introduction
Gathering is one of the most fundamental tasks in the field of distributed and mobile systems in the sensethat, the ability to gather is in fact a building block to achieve more complex cooperative works. Looselyspeaking, the task of gathering consists in ensuring that a group of mobile entities, initially located indifferent places, ends up meeting at the same place at the same time. These mobile entities, hereinaftercalled agents, can vary considerably in nature ranging from human beings and robots to animals and softwareagents. The environment in which the agents are supposed to evolve can vary considerably as well: it maybe a terrain, a network modeled as a graph, a three-dimensional space, etc. We can also consider that thesequences of instructions followed by the agents in order to ensure their gathering are either deterministicor randomized.In this paper, we consider the problem of gathering in a deterministic way in a network modeled as a graph.Thus, the agents initially start from different nodes of the graph and have to meet at the same node byapplying deterministic rules. We assume that among the agents, some are Byzantine. A Byzantine agent isan agent subject to unpredictable and arbitrary faults. For instance such an agent may choose to never stopor to never move. It may also convey arbitrary information to the other agents, etc. The case of Byzantinefault is very interesting because it is the worst fault that can occur to agents. As a consequence, gathering insuch a context is challenging.
The distributed system considered in this paper consists of a group of mobile agents that are initially placedby an adversary at arbitrary but distinct nodes of a network modeled as a finite, connected, undirectedgraph G = ( V, E ) . We assume that | V | = n . In the sequel n is also called the size of the network.Two assumptions are made about the labelling of the two main components of the graph that are nodes andedges. The first assumption is that nodes are anonymous i.e., they do not have any kind of labels or identifiersallowing them to be distinguished from one another. The second assumption is that edges incident to a node v are locally ordered with a fixed port numbering ranging from to deg ( v ) − where deg ( v ) is the degreeof v . Therefore, each edge has exactly two port numbers, one for each of both nodes it links. The portnumbering is not supposed to be consistent: a given edge ( u, v ) ∈ E may be the i -th edge of u but the j -thedge of v , where i = j . These two assumptions are not fortuitous. The primary motivation of the first oneis that if each node could be identified by a label, gathering would become quite easy to solve as it wouldbe tantamount to explore the graph (via e.g. a breadth-first search) and then meet in the node having thesmallest label. While the first assumption is made so as to avoid making the problem trivial, the secondassumption is made in order to avoid making the problem impossible to solve. Indeed, in the absence ofa way allowing an agent to distinguish locally the edges incident to a node, gathering could be proven asimpossible to solve deterministically in view of the fact that some agents could be precluded from traversingsome edges and visit some parts of the graph.An adversary chooses the starting nodes of the agents. The starting nodes are chosen so that there are nottwo agents sharing initially the same node. At the beginning, an agent has a little knowledge about its1urroundings: it does not know either the graph topology, or the number of other agents, or the positions ofthe others relative to its own. Still regarding agents’ knowledge, we will study two scenarios: one in whichthe agents initially know the parameter n and one in which the agents do not initially know this parameteror even any upper bound on it.Time is discretized into an infinite sequence of rounds. In each round, every agent, which has been previ-ously woken up (this notion is detailed in the next paragraph), is allowed to stay in place at its current nodeor to traverse an edge according to a deterministic algorithm. The algorithm is the same for all agents: onlythe input, whose nature is specified further in the subsection, varies among agents.Before being woken up, an agent is said to be dormant. A dormant agent may be woken up only in twodifferent ways: either by the adversary that wakes some of the agents at possibly different rounds, or as soonas another agent enters the starting node of the dormant agent. We assume that the adversary wakes up atleast one agent.When an agent is woken up in a round r , it is told the degree of its starting node. As mentioned above,in each round r ′ ≥ r , the executed algorithm can ask the agent to stay idle or to traverse an edge. In thelatter case, this takes the following form: the algorithm ask the agent, located at node u , to traverse the edgehaving port number i , where ≤ i < deg ( u ) − . Let us denote by ( u, v ) ∈ E this traversed edge. In round r ′ + 1 , the agents enters node v : it then learns the degree deg ( v ) as well as the local port number j of ( u, v ) at node v (recall that in general i = j ). An agent cannot leave any kind of tokens or markers at the nodes itvisits or the edges it traverses.In the beginning, the adversary also assigns a different positive integer (called label) to each agent. Eachagent knows its label but does not know the labels of the other agents. When several agents are at the samenode in the same round, they see the labels of the other agents and can exchange all the information theycurrently have. This exchange is done in a “shouting” mode in one round: all the exchanged informationbecomes common knowledge for agents that are currently at the node. On the other hand when two agentsare not at the same node in the same round they cannot see or talk to each other: in particular, two agentstraversing simultaneously the same edge but in opposite directions, and thus crossing each other on the sameedge, do not notice this fact. In every round, the input of the algorithm executed by an agent a is made up ofthe label of agent a and the up-to-date memory of what agent a has seen and learnt since its waking up. Notethat in the absence of a way of distinguishing the agents, the gathering problem would have no deterministicsolution in some graphs. This is especially the case in a ring in which at each node the edge going clockwisehas port number and the edge going anti-clockwise has port : if all agents are woken up in the sameround and start from different nodes, they will always have the same input and will always follow the samedeterministic rules leading to a situation where the agents will always be at distinct nodes no matter whatthey do.Within the team, it is assumed that up to f of the agents are Byzantine. The parameter f is known to allagents. A Byzantine agent has a high capacity of nuisance: it can choose an arbitrary port when it moves,can convey arbitrary information to other agents and can change its label in every round, in particular byforging the label of another agent or by creating a completely new one. All the agents that are not Byzantineare called good. We consider the task of f -Byzantine gathering which is stated as follows. The adversarywakes up at least one good agent and all good agents must eventually be in the same node in the same round,2imultaneously declare termination and stop, provided that there are at most f Byzantine agents. Regardingthis task, it is worth mentioning that we cannot require the Byzantine agents to cooperate as they may alwaysrefuse to be with some agents. Thus, gathering all good agents with termination is the strongest requirementwe can make in such a context.What is the minimum number M of good agents that guarantees f -Byzantine gathering?At first glance, the question might appear as not being really interesting since, after all, the good agentsmight always be able to gather in some node, regardless of the number of Byzantine agents evolving in thegraph. However, this is not the case as pointed out by the study that introduced this question in [14]. Morespecifically, when this size is initially known to the agents, the authors of this study described a deterministicalgorithm gathering all good agents in any network provided that there are at f + 1 of them, and gave alower bound of f + 1 on M by showing that if the number of good agents is not larger than f , then there aresome graphs in which the good agents are not able to gather deterministically with termination. When thesize of the network is unknown, they did a similar thing but with different bounds: they gave an algorithmworking for a team including at least f + 2 good agents, and showed a lower bound of f + 2 on M .However, the question of what the tight bounds are was left as an open problem. In this paper, we solve this open problem by proving that the lower bounds of f + 1 and f + 2 on M , shownin [14], are actually also upper bounds respectively when the size of the network is known and when it isunknown. More precisely, we design deterministic algorithms allowing to gather all good agents providedthat the number of good agents is at least f + 1 when the size of the network is initially known to agents,and at least f + 2 when this size is initially unknown.Perhaps surprisingly, our results highlight an interesting feature when put in perspective with results con-cerning a relaxed variant of this problem (also introduced in [14]) in which the Byzantine agents cannotchange their initial labels. Indeed under this variant M = 1 for networks of known size and M = f + 2 for networks of unknown size . Following this perspective, it turns out that when the size of the networkis known, the ability for the Byzantine agents to change their labels significantly impacts the value of M .However, the relevance for M of such an ability completely disappears in the most general case where thesize of the network is unknown, as M = f + 2 regardless of whether Byzantine agents can change theirlabels or not. Historically, the first mention of the gathering problem appeared in [28] under the appellation of rendezvousproblem. Rendezvous is the term which is usually used when the studied task of gathering is restricted toa team of exactly two agents. From this publication until now, the problem has been extensively studied sothat there is henceforth a huge literature about this subject. This is mainly due to the fact that there is a lot The proof that both of these values are enough, under their respective assumptions regarding the knowledge of the networksize, relies on algorithms using a mechanism of blacklists that are, informally speaking, lists of labels corresponding to agentshaving exhibited an “inconsistent” behavior. Of course, in the context of our paper, we cannot use such blacklists as the Byzantineagents can change their labels and in particular steal the identities of good agents.
3f alternatives for the combinations we can make when approaching the problem, e.g., by playing on theenvironment in which the agents are supposed to evolve, the way of applying the sequences of instructions(i.e., deterministic or randomized) or the ability to leave some traces in the visited locations, etc. Naturally, inthis paper we are more interested in the research works that are related to deterministic gathering in networksmodeled as graphs. This is why we will mostly dwell on this scenario in the rest of this subsection. However,for the curious reader wishing to consider the matter in greater depth, we invite him to consult [7, 1, 19] thataddress the problem in the plane via various scenarios, especially in a system affected by the occurrence offaults or inaccuracies for the last two references. Regarding randomized rendezvous, a good starting pointis to go through [2, 3, 21].Concerning the context of this paper, the closest work to ours is obviously [14]. Nonetheless, in similarsettings but without Byzantine agents, there are some papers that should be cited here. This is in particularthe case of [13] in which the author presented a deterministic protocol for solving the rendezvous problem,which guarantees a meeting of the two involved agents after a number of rounds that is polynomial in thesize n of the graph, the length l of the shorter of the two labels and the time interval τ between their wake-uptimes. As an open problem, the authors ask whether it is possible to obtain a polynomial solution to thisproblem which would be independent of τ . A positive answer to this question was given, independentlyof each other, in [20] and [29]. While these algorithms ensure rendezvous in polynomial time (i.e., a poly-nomial number of rounds), they also ensure it at polynomial cost since the cost of a rendezvous protocolis the number of edge traversals that are made by the agents until meeting and since each agent can makeat most one edge traversal per round. However, it should be noted that despite the fact a polynomial timeimplies a polynomial cost, the reciprocal is not always true as the agents can have very long waiting periodssometimes interrupted by a movement. Thus these parameters of cost and time are not always linked to eachother. This was highlighted in [25] where the authors studied the tradeoffs between cost and time for thedeterministic rendezvous problem. More recently, some efforts have been dedicated to analyse the impacton time complexity of rendezvous when in every round the agents are brought with some pieces of informa-tion by making a query to some device or some oracle, see, e.g., [11, 24]. Along with the works aiming atoptimizing the parameters of time and/or cost of rendezvous, some other works have examined the amountof memory that is required to achieve deterministic rendezvous e.g., in [16, 17] for tree networks and in [9]for general networks.All the aforementioned studies that are related to gathering in graphs take place in a synchronous scenarioi.e., a scenario in which the agents traverse the edges in synchronous rounds. Some efforts have been alsodedicated to the scenario in which the agents move asynchronously: the speed of agents may then vary andis controlled by the adversary. For more details about rendezvous under such a context, the reader is referredto [23, 10, 15, 18] for rendezvous in finite graphs and [4, 8] for rendezvous in infinite grids.Aside from the gathering problem, our work is also in conjunction with the field of fault tolerance via theassumption of Byzantine faults to which some agents are subjected. First introduced in [26], a Byzantinefault is an arbitrary fault occurring in an unpredictable way during the execution of a protocol. Due to itsarbitrary nature, such a fault is considered as the worst fault that can occur. Byzantine faults have beenextensively studied for “classical” networks i.e., in which the entities are fixed nodes of the graph (cf., e.g.,the book [22] or the survey [5]). To a lesser extend, the occurrence of Byzantine faults has been also studiedin the context of mobile entities evolving in the plane, cf. [1, 12]. Prior to our work, gathering in arbitrary4raphs in presence of Byzantine agents was considered only in [14]. As mentioned in the previous section,it is proven in [14] that the minimum number M of good agents that guarantees f -Byzantine gathering isprecisely for networks of known size and f + 2 for networks of unknown size, provided that the Byzantineagents cannot lie about their labels. The proof that both of these values are enough, under their respectiveassumptions regarding the knowledge of the network size, relies on algorithms using a mechanism of black-lists that are, informally speaking, lists of labels corresponding to agents having exhibited an “inconsistent”behavior. Of course, in the context of our paper, we cannot use such blacklists as the Byzantine agents canchange their labels and in particular steal the identities of good agents. Throughout the paper, the number of nodes of a graph is called its size. In this section we present twoprocedures, that will be used as building blocks in our algorithms. The aim of both of them is graphexploration, i.e., visiting all nodes of the graph by a single agent. The first procedure, based on universalexploration sequences (UXS), is a corollary of the result of Reingold [27]. Given any positive integer N ,this procedure allows the agent to traverse all nodes of any graph of size at most N , starting from any nodeof this graph, using P ( N ) edge traversals, where P is some polynomial. After entering a node of degree d by some port p , the agent can compute the port q by which it has to exit; more precisely q = ( p + x i )mod d , where x i is the corresponding term of the UXS of length P ( N ) .The second procedure [6] needs no assumption on the size of the network but it is performed by an agentusing a fixed token placed at a node of the graph. It works in time polynomial in the size of the graph. (Itis well known that a terminating exploration even of all anonymous rings of unknown size by a single agentwithout a token is impossible.) In our applications the roles of the token and of the exploring agent will beplayed by agents or by groups of agents. At the end of this second procedure, the agent has visited all nodesand determined a BFS tree of the underlying graph.We call the first procedure EXP LO ( N ) and the second procedure EST , for exploration with a stationarytoken . We denote by T ( EXP LO ( n )) the execution time of procedure EXP LO with parameter n (notethat T ( EXP LO ( n )) = P ( n ) + 1 ). We denote by T ( EST ( N )) the maximum time of execution of theprocedure EST in a graph of size at most N . This section aims at proving the following theorem
Theorem 3.1
Deterministic f -Byzantine gathering of k good agents is possible in any graph of known sizeif, and only if k ≥ f + 1 . As mentioned in Subsection 1.2, we know from [14] that:
Theorem 3.2 ([14])
Deterministic f -Byzantine gathering of k good agents is not possible in some graph ofknown size if k ≤ f . Thus, to prove Theorem 3.1, it is enough to show the following theorem.
Theorem 3.3
Deterministic f -Byzantine gathering of k good agents is possible in any graph of known sizeif k ≥ f + 1 . f + 1 of them.Before presenting the algorithm, we first give the high level idea which is behind it. Let us assume an idealsituation in which each agent would have as input, besides its label and the network size n , a parameter ρ = ( G ∗ , L ∗ ) corresponding to the initial configuration of the agents in the graph such that: • G ∗ represents the n -node graph with all port numbers, in which each node are assigned an identifierbelonging to { , · · · , n } . The node identifiers are pairwise distinct. Note that the representation G ∗ contains more information than there is in the actual graph G as it also includes node identifiers whichdo not exist in G . • L ∗ = { ( v , l ) , ( v , l ) , · · · , ( v k , l k ) } where ( v i , l i ) ∈ L ∗ iff there is a good agent having label l i which is initially placed in G at the node corresponding to v i in G ∗ . Remark that k ≥ f + 1 .Let us also assume that all the agents in the graph are woken up at the same time by the adversary. In suchideal situation, gathering all good agents can be easily achieved by ensuring that each agent moves towardsthe node v where the agent having the smallest label is located. Each agent can indeed do that by usingthe knowledge of ρ = ( G ∗ , L ∗ ) and its own label. Of course, all the good agents do not necessarily reachnode v at the same time. However, once at node v , each agent can estimate the remaining time which isrequired to wait in order to be sure that all good agents are at node v : again this estimation can be computedusing ρ = ( G ∗ , L ∗ ) and the fact that all agents are woken up in the same round. Unfortunately, the agentsare not in such ideal situation. First, every agent is not necessarily woken up by the adversary, and forthose that are woken by the adversary, this is not necessarily in the same round. Second, the agents donot have configuration ρ as input of the algorithm. In our algorithm we cope with the first constraint byrequiring the first action to be a traversal of the entire graph (using procedure EXP LO ( n ) ) which allowsto wake up all encountered agents that are still dormant. In this way, the agents are “almost synchronized”as the delay between the starting times of any two agents is at most T ( EXP LO ( n )) : the waiting timeperiods can be adjusted regarding this maximum delay. The second constraint i.e., the non-knowledge of ρ , is more complicated to deal with. To handle the lack of information about ρ , agents make successiveassumptions about it that are “tested” one by one. More precisely, let P be the recursively enumerable setof all the configurations ρ i = ( G ∗ i , L ∗ i ) such that G ∗ i is a connected n -node graph and | L ∗ i | ≥ f + 1 . Let Θ = ( ρ , ρ , ρ , · · · ) be a fixed enumeration of P (all good agents agree on this enumeration). Each agentproceeds in phases numbered , , , · · · . In each phase i , an agent supposes that ρ = ρ i and, similarly asin the ideal situation, tries to go to the node which is supposed to correspond to node v , where v is the nodewhere the agent having the smallest label is initially located (according to ρ i ). For some reasons detailedin the algorithm (refer to the description of state setup ), when ρ i = ρ some agents may be unable tomake such a motion. As a consequence, these agents will consider that, rightly, ρ i = ρ . On the other hand,whether ρ i = ρ or not, some other good agents may reach a node for which they had no reason to think it isnot v (and thus ρ i = ρ ). The danger here is that when reaching the supposed node v these successful agentscould see all the | L ∗ i | labels of ρ i (with the possible “help” of some Byzantine agents). At this point, it maybe tempting to consider that gathering is over but this could be wrong especially in the case where ρ i = ρ and some good agents did not reach a supposed node v in phase i . To circumvent this problem, the idea is6o get the good agents thinking that ρ i = ρ to fetch the (possible) others for which ρ i = ρ via a traversal ofthe entire graph using procedure EXP LO ( n ) (refer to the description of state tower ). To allow this, anagent for which ρ i = ρ will wait a prescribed amount of rounds in order to leave enough time for possiblegood agents to fetch it (refer to the description of state wait-for-a-tower ). For our purposes, it isimportant to prevent the agents from being fetched any old how by any group, especially those containingonly Byzantine agents. Hence our algorithm is designed in such a way that within each phase at most onegroup, called a tower and made up of at least f + 1 agents, will be unambiguously recognized as such andbe allowed to fetch the other agents via an entire traversal of the graph (this guarantee principally resultsfrom the rules that are prescribed in the description of state tower builder ). When a tower has finishedthe execution of procedure EXP LO ( n ) in some phase i , our algorithm guarantees that all good agents aretogether and declare gathering is over at the same time (whether the assumed configuration ρ i correspondsto the real initial configuration or not). On the other hand, in every phase i , if a tower is not created or“vanishes” (because there at not at least f + 1 agents inside of it anymore) before the completion of itstraversal, no good agent will declare that gathering is over in phase i . In the worst case, the good agentswill have to wait until assuming a good hypothesis about the real initial configuration, in order to witnessthe creation of a tower which will proceed to an entire traversal of the network (and thus declare gatheringis over).We now give a detailed description of the algorithm. Algorithm Byz-Known-Size with parameter n (know size of the graph)The algorithm is made up of two parts. The first part aims at ensuring that all agents are woken up beforeproceeding to the second part which is actually the heart of the algorithm. Part 1.
As soon as an agent is woken up by the adversary or another agent, it starts proceeding to a traversalof the entire graph and wakes up all encountered agents that are still dormant. This is done using procedure
EXP LO ( n ) where n is the size of the network which is initially known to all agents. Once the executionof EXP LO ( n ) is accomplished, the agent backtracks to its starting node by traversing all edges traversedin EXP LO ( n ) in the reverse order and the reverse direction. Part 2.
In this part, the agent works in phases numbered , , , · · · . During the execution of each phase,the agent can be in one of the following five states: setup , tower builder , tower , wait-for-a-tower , failure . Below we describe the actions of an agent A in each of the states as well as the transitions be-tween these states within phase i . We assume that in every round agent A tells the others (sharing the samenode as agent A ) in which state it is. In some states, the agent will be required to tell more than just itscurrent state: we will mention it in the description of these states. Moreover, in the description of every stateX, when we say “agent A transits to state Y”, we exactly mean agent A remains in state X until the end ofthe current round and is in state Y in the following round. Thus, in each round of this part, agent A is alwaysexactly in one state.At the beginning of phase i , agent A enters state setup . State setup .Let ρ i be the i -th configuration of enumeration Θ (refer to above). If the label l of agent A is not in ρ i , then7t transits to state wait-for-a-tower . Otherwise, let X be the set of the shortest paths in ρ i leadingfrom the node containing the agent having label l , to the node containing the smallest label of the supposedconfiguration. Each path belonging to X is represented as the corresponding sequence of port numbers. Let π be the lexicographically smallest path in X (the lexicographic order can be defined using the total orderon the port numbers). Agent A follows path π in the real network. If , following path π , agent A has toleave by a port number that does not exist in the node where it currently resides, then it transits to state wait-for-a-tower . In the same way, it also transits to state wait-for-a-tower if, following path π , agent A enters at some point a node by a port number which is not the same as that of path π . Once path π is entirely followed by agent A , it transits to state tower builder . State tower builder .When in state tower builder , agent A can be in one of the following three substates: yellow , orange , red . In all of these substates the agent does not make any move: it stays at the same nodedenoted by v . At the beginning, agent A enters substate yellow . By misuse of language, in the rest of thispaper we will sometimes say that an agent “is yellow ” instead of “is in substate yellow ”. We will alsouse the same kind of shortcut for the two other colors. In addition to its state, we also assume that in everyround agent A tells the others in which substate it is. Substate yellow
Let k be the number of labels in configuration ρ i . Agent A waits T ( EXP LO ( n )) + n rounds. If during thiswaiting period, there are at some point at least k orange agents at node v then agent A transits to substate red . Otherwise, if at the end of this waiting period there are not at least k agents residing at node v suchthat each of them is either yellow or orange , then agent A transits to state wait-for-a-tower , elseit transits to substate orange . Substate orange
Agent A waits at most T ( EXP LO ( n )) + n rounds to see the occurrence of one of the following twoevents. The first event is that there are not at least k agents residing at node v such that each of them is either yellow or orange . The second event is that there are at least k orange agents residing at node v . Notethat the two events cannot occur in the same round. If during this waiting period, the first (resp. second)event occurs, then agent A transits to state wait-for-a-tower (resp. substate red ). If at the end of thewaiting period, none of these events has occurred, then agent A transits to substate wait-for-a-tower . Substate red
Agent A waits T ( EXP LO ( n )) + n rounds. If at each round of this waiting period there are at least k red agents at node v , then at the end of the waiting period, agent A transits to state tower . Otherwise, there is around during the waiting period in which there are not at least k red agents at node v : agent A then transitsto state wait-for-a-tower as soon as it notices this fact. State tower .Agent A can enter state tower either from state tower builder or state wait-for-a-tower . Whilein this state, agent A will execute all or part of procedure EXP LO ( n ) . In both cases we assume that, in8very round, agent A tells the others the edge traversal number of EXP LO ( n ) it has just made (in additionto its state). We call this number the index of the agent. Below, we distinguish and detail the two cases.When agent A enters state tower from state tower builder , it starts executing procedure EXP LO ( n ) .In the first round, its index is . Just after making the j -th edge traversal of EXP LO ( n ) , its index is j .Agent A carries out the execution of EXP LO ( n ) until its term, except if at some round of the execution thefollowing condition is not satisfied, in which case agent A transits to state failure . Here is the condition:the node where agent A is currently located contains a group S of at least f + 1 agents in state tower having the same index as agent A . S includes agent A but every agent that is in the same node as agent A isnot necessarily in S . If at some point this condition is satisfied and the index of agent A is equal to P ( n ) ,which is the total number of edge traversals in EXP LO ( n ) (refer to Section 2), then agent A declares thatgathering is over.When agent A enters state tower from state wait-for-a-tower , it has just made the s -th edge traversalof EXP LO ( n ) for some s (cf. state wait-for-a-tower ) and thus, its index is s . Agent A executesthe next edge traversals i.e., the s + 1 -th, s + 2 -th, · · · , and then its index is successively s + 1 , s + 2 , etc.Agent A carries out this execution until the end of procedure EXP LO ( n ) , except if the same condition asabove is not fulfilled at some round of the execution of the procedure, in which case agent A also transits tostate failure . As in the first case, if at some point the node where agent A is currently located contains agroup S of at least f + 1 agents in state tower having an index equal to P ( n ) , then agent A declares thatgathering is over. State wait-for-a-tower .Agent A waits at most T ( EXP LO ( n )) + 4 n rounds to see the occurrence of the following event: the nodewhere it is currently located contains a group of at least f + 1 agents in state tower having the same index t . If during this waiting period, agent A sees such an event, we distinguish two cases. If t < P ( n ) , then itmakes the t + 1 -th edge traversal of procedure EXP LO ( n ) and transits to state tower . If t = P ( n ) , thenit declares that gathering is over.Otherwise, at the end of the waiting period, agent A has not seen such an event, and thus it transits to state failure . State failure . Agent A backtracks to the node where it was located at the beginning of phase i . Todo this, agent A traverses in the reverse order and the reverse direction all edges it has traversed in phase i before entering state failure . Once at its starting node, agent A waits T ( EXP LO ( n ))+9 n − p roundswhere p is the number of elapsed rounds between the beginning of phase i and the end of the backtrack ithas just made. At the end of the waiting period, phase i is over. In the next round, agent A will start phase i + 1 . The proof of correctness is made up of seven lemmas and two propositions. The validity of AlgorithmByz-Known-Size (and by extension Theorem 3.3) follows from Lemmas 3.6 and 3.7. However to proveboth these lemmas, we first need to establish the following two propositions and to prove the following fivelemmas. 9art 1 of Algorithm Byz-Known-Size consists in executing procedure
EXP LO ( n ) and then traversing alledges traversed in EXP LO ( n ) in the reverse order and the reverse direction. In view of the fact thatprocedure EXP LO ( n ) allows an agent to visit all nodes of the graph, we know that the delay between thestarting rounds of any two good agents is at most T ( EXP LO ( n )) . Hence we get the following proposition. Proposition 3.1
Let A and B be two good agents. The delay between the starting rounds of agents A and B is at most T ( EXP LO ( n )) . According to Part 1 of Algorithm Byz-Known-Size and the rules of state failure , we have the followingproposition.
Proposition 3.2
At the beginning of every phase it executes, a good agent is at the node where it was wokenup.
Lemma 3.1
Let Q ( n ) = 10 T ( EXP LO ( n )) + 9 n . For every good agent A and every positive integer i , ifat some point agent A starts executing the i -th phase of Algorithm Byz-Known-Size, then either it will spendexactly Q ( n ) rounds executing the i -th phase or it will declare that gathering is over after having spent atmost Q ( n ) rounds in the i -th phase. Proof.
Let A be an agent that starts executing the i -th phase of Algorithm Byz-Known-Size in round r andassume that agent A does not declare that gathering is over by round r + Q ( n ) − . To prove the lemma,it is then enough to prove that agent A starts executing the i + 1 -th phase of Algorithm Byz-Known-Size inround r + Q ( n ) .Let us first assume by contradiction that agent A declares gathering is over when executing the i -th phaseof Algorithm Byz-Known-Size. In view of the fact that agent A does not declare that gathering is over byround r + Q ( n ) − , we know that this declaration occurs in round r + Q ( n ) at the earliest. However,according to Algorithm Byz-Known-Size, and especially the maximum duration of each state within anygiven phase (in particular a good agent cannot spend more than n rounds in state setup of any given phasein view of Proposition 3.2), agent A cannot spend more than T ( EXP LO ( n )) + 8 n rounds in phase i without entering state failure . Hence agent A enters state failure of phase i before round r + Q ( n ) .But according to Algorithm Byz-Known-Size, once agent A is in state failure of phase i , it cannot reachthe states tower and wait-for-a-tower of phase i , which are the only two states wherein an agentcan declare that gathering is over. We then get a contradiction with the fact that agent A declares gatheringis over when executing the i -th phase of Algorithm Byz-Known-Size.As a consequence, we know that agent A does not declare gathering is over when executing the i -th phaseof Algorithm Byz-Known-Size. According to the algorithm, it then ends up entering state failure ofphase i after a finite number x of rounds which is upper bounded by T ( EXP LO ( n )) + 8 n as mentionedabove. When entering state failure , agent A starts backtracking to the node v where it was located atthe beginning of phase i . Since before switching to state failure of phase i , agent A follows a pathmade up of at most n − edges and can proceed to at most one (possibly truncated) execution of procedure EXP LO ( n ) , backtracking to v , in state failure of phase i , takes y ≤ T ( EXP LO ( n )) + n rounds.10hen the backtrack is done, agent A has spent p = x + y ≤ T ( EXP LO ( n )) + 9 n rounds in phase i and starts waiting T ( EXP LO ( n )) + 9 n − p rounds. The end of the waiting period is reached in someround r ′ when agent A has spent exactly T ( EXP LO ( n ))+ 9 n rounds in phase i : according to AlgorithmByz-Known-Size, agent A starts executing phase i + 1 in round r ′ + 1 , which proves the lemma. (cid:3) Before continuing, we need to introduce some slight additional notions in order to facilitate the presentationof other lemmas. For any positive integer i , we say that a good agent A t ests configuration ρ i when itexecutes the i -th phase of Algorithm Byz-Known-Size. We also say that there is a tower T j at node v inround t if, and only if, there are at least f + 1 agents, at node v in round t , which are in state tower andhave index j . The members that make up T j at node v in round t are then all the agents, which are at node v in round t , being in state tower and having index j . Remark 3.1
Since there are at least f + 1 agents in every tower, there is at least one good agent in everytower as there are at most f Byzantine agents in the network.
Lemma 3.2
Let T j be a tower located at node v in round t . There is at least one good agent in T j whichhas been in state tower since round t − j . Proof.
Assume by contradiction that there is no good agent in tower T j which has been in state tower sinceround t − j . By definition of a tower, every good agent, which is in tower T j , is in state tower and has index j in round t . Let A be a good agent in T j . Note that agent A exists in view of Remark 3.1. The last timeagent A decided to transit to state tower before round t was necessarily from state wait-for-a-tower .Indeed, if that was not the case, that would imply that the last round r < t when agent A decided to transit tostate tower was from state tower builder . However, according to Algorithm Byz-Known-Size, agent A would have entered state tower with index in round r + 1 and would have stayed in state tower untilround t in which it has index j . Hence, r + 1 = t − j and agent A would have been in state tower sinceround t − j , which would be a contradiction with our starting assumption.Denote by s ≤ t the last round when agent A enters state tower from state wait-for-a-tower .Without loss of generality, let us assume, for each good agent in T j , the last time s ′ ≤ t it enters state tower is such that s ≤ s ′ ≤ t . According to Algorithm Byz-Known-Size, agent A is in state tower and has index j − ( t − s ) in round s . Moreover, in round s − agent A decides to transit from state wait-for-a-tower to state tower because it is at a node in which there are at least f + 1 agents instate tower having index j − ( t − s ) − : among them there is necessarily a good agent B as there areat most f Byzantine agents. Still according to Algorithm Byz-Known-Size, agents A and B make togetherthe j − ( t − s ) -th edge traversal of EXP LO ( n ) and are in state tower with index j − ( t − s ) at the samenode v in round s . In round s , there are at least f + 1 agents in state tower having index j − ( t − s ) ,otherwise that would imply either there is no tower located at node v in round t if t = s , or agent A is instate failure in round s + 1 if s < t : in the former case we would get a contradiction with the existenceof tower T j , and in the latter case we would get a contradiction with the definition of round s . Thus, if s < t then we know from Algorithm Byz-Known-Size that agents A and B make together the j − ( t − s ) + 1 -th11dge traversal of EXP LO ( n ) and are in state tower with index j − ( t − s ) + 1 at the same node u inround s + 1 . Following a similar reasoning to that used above, we can prove that there are at least f + 1 agents in state tower having index j − ( t − s ) + 1 in round s + 1 at node u . So, if s + 1 < t , then we knowfrom Algorithm Byz-Known-Size that agents A and B make together the j − ( t − s ) + 2 -th edge traversalof EXP LO ( n ) and are in state tower with index j − ( t − s ) + 2 at the same node w in round s + 2 . Byinduction, we can then prove that agents A and B are together in round t and that agent B belongs to T j .However, in round t we know that agent B has been in state tower without interruption since at least round s − , which contradicts the fact that for each good agent in T j the last time s ′ ≤ t it enters state tower issuch that s ≤ s ′ ≤ t . Hence the last time agent A transited to state tower before round t was neither fromstate wait-for-a-tower nor from state tower builder . Since an agent can transit to state tower only from states wait-for-a-tower or tower builder , we get a contradiction with the existenceof A , and thus the lemma holds. (cid:3) Lemma 3.3
Let A be a good agent that is either orange , or red or in state tower in round r . Let ρ i be the configuration tested by agent A in round r . All good agents, which do not declare gathering is overbefore round r , test ρ i in round r . Proof.
Assume by contradiction there exists some round x (playing the role of round r in the statement ofthe lemma) such that the lemma does not hold. Without loss of generality, let us assume that x is the firstround for which this lemma is false.Let B be a good agent that does not declare gathering is over before round x .Since agent A is either orange , or red or in state tower , in round x it has already finished part 1 ofAlgorithm Byz-Known-Size which consists in executing procedure EXP LO ( n ) and then traversing alledges traversed in EXP LO ( n ) in the reverse order and the reverse direction. In view of the fact thatprocedure EXP LO ( n ) allows an agent to visit all nodes of the graph, we know that agent B is not dormantin round x .Since agent B is not dormant in round x , to prove the lemma it is then enough to show that in round x itcannot be in part 1 of Algorithm Byz-Known-Size or test a configuration ρ j such that j < i or j > i .First assume by contradiction that agent B tests a configuration ρ j in round x such that j < i . Let us considerthe case when agent A is orange in round x . Since agents A and B do not declare that gathering is overbefore round x , Lemma 3.1 implies that in round x agent B has spent at most T ( EXP LO ( n ))+ j ∗ Q ( n ) ≤ T ( EXP LO ( n )) + ( i − Q ( n ) rounds since its wake-up. In view of Lemma 3.1 and the period of T ( EXP LO ( n )) + n rounds which is necessary to wait in substate yellow to enter substate orange ,when in round x agent A has spent at least T ( EXP LO ( n )) + ( i − ∗ Q ( n ) + T ( EXP LO ( n )) + n rounds since its wake up. This implies that the delay between the starting rounds of agents A and B isgreater than T ( EXP LO ( n )) , which contradicts Proposition 3.1.Let us consider the case when agent A is in state tower in round x . If agent A is red or in state tower in round x − , then according to Algorithm Byz-Known-Size it also tests configuration ρ i in round x − .However, since agent B tests ρ j in round x , according to Algorithm Byz-Known-Size it is either in part 112f the algorithm, or also in phase j , or in phase j − (only if j > ). Hence if agent A is red or in state tower in round x − , then the lemma does not hold in round x − and we get a contradiction with the factthat x is the first round for which this lemma is false. So, assume that agent A is neither red nor in state tower in round x − . According to Algorithm Byz-Known-Size it is in state wait-for-a-tower inround x − . The reason for which it decides to transit to state tower in round x − is due to the fact thatthere is a tower T s in round x − for some index s . As for round x , agent A also tests configuration ρ i inround x − in view of Algorithm Byz-Known-Size. By assumption, the lemma holds in round x − , andthus there is at least a good agent in state tower belonging to T s in round x − which tests configuration ρ i . However, as mentioned above agent B cannot test configuration ρ i in round x − . As a consequence,the lemma does not hold in round x − and we get a contradiction with fact that x is the first round forwhich this lemma is false.Let us now consider the case when agent A is red in round x . According to Algorithm Byz-Known-Size italso tests configuration ρ i in round x − and there is a good agent C (not necessarily different from A ) thatis orange or red . Since the lemma holds in round x − , agent C also tests ρ i in round x − . From thispoint, using as above the fact that agent B does not test configuration ρ i in round x − , we know that thelemma does not hold in round x − and we obtain the same contradiction.Hence agent B does not test a configuration ρ j in round x such that j < i . In a similar way, we can provethat agent A cannot be in part 1 of Algorithm Byz-Known-Size in round x . So, it remains to prove that agent A does not test a configuration ρ j in round x such that j > i .Assume by contradiction agent B tests a configuration ρ j in round x such that j > i . According to AlgorithmByz-Known-Size and Proposition 3.2, if agent A is orange (resp. red ) in round x , we know that it hasspent at most T ( EXP LO ( n )) + 3 n (resp. T ( EXP LO ( n )) + 4 n ) rounds in phase i when in round x .Thus, in round x , if agent A is orange (resp. red ), agent A has spent at most T ( EXP LO ( n )) + ( i − ∗ Q ( n ) + 3 T ( EXP LO ( n )) + 4 n rounds since its wake up in view of Lemma 3.1. However accordingto Lemma 3.1, in round x agent B has spent at least T ( EXP LO ( n )) + i ∗ Q ( n ) = 2 T ( EXP LO ( n )) +( i − ∗ Q ( n ) + (10 T ( EXP LO ( n )) + 9 n ) rounds since its wake up. Hence, the delay between the startingrounds of agents A and B is greater than T ( EXP LO ( n )) , which contradicts Proposition 3.1. Thus agent A is necessary in state tower of phase i in round x . According to Algorithm Byz-Known-Size, this impliesagent A is red in round x − or there is a tower T j in round x − for some j ≤ T ( EXP LO ( n )) − . In thefirst case, we can show as above that the delay between the starting rounds of agents A and B is greater than T ( EXP LO ( n )) in round x − which is a contradiction with Proposition 3.1. So let us focus on the secondcase in which there is a tower T j in round x − . According to Algorithm Byz-Known-Size, agent A testsconfiguration ρ i in round x − . Since the lemma holds in round x − , we then know that all good agents oftower T j also test configuration ρ i in round x − : among them there is at least one good agent C that entersstate tower of phase i from substate red of phase i in some round x ′ ≤ x − in view of Lemma 3.2. Hencein round x − agent C has spent at most T ( EXP LO ( n )) + ( i − ∗ Q ( n ) + 3 T ( EXP LO ( n )) + 4 n + j ≤ T ( EXP LO ( n ))+( i − ∗ Q ( n )+4 T ( EXP LO ( n ))+4 n rounds since its wake up in view of Lemma 3.1,while agent B has spent at least T ( EXP LO ( n )) + ( i − ∗ Q ( n ) + (10 T ( EXP LO ( n )) + 9 n ) − . Asbefore, we get a contradiction with Proposition 3.1. Thus, agent B does not test a configuration ρ j in round x such that j > i .We then get a contradiction in all cases, which proves the lemma.13 Lemma 3.4
Let A be a good agent entering state tower from state tower builder in round r at node v . Let B be a good agent that does not declare that gathering is over before round r and that does not enterstate tower from state tower builder in round r at node v . Agent B is in state wait-for-a-tower in round r . Proof.
Assume by contradiction that there exists some round x (playing the role of round r in the statementof the lemma) such that the lemma does not hold. Without loss of generality, let us assume that x is the firstround for which this lemma is false. Let ρ i be the configuration that is tested by agent A in round x . Let k be the number of labels in configuration ρ i (recall that all the labels in configuration ρ i are distinct as theyare meant to represent only the labels of good agents). According to Lemma 3.3, we know that agent B alsotests configuration ρ i in round x . To get a contradiction, we will prove that agent B cannot be in any stateof phase i in round x except state wait-for-a-tower .Agent B cannot be in state setup of phase i in round x . Indeed, since agents A and B do not declarethat gathering is over before round x , in view of Lemma 3.1 and Proposition 3.1, we know that the delaybetween the two rounds in which they start testing configuration ρ i is at most T ( EXP LO ( n )) . However byProposition 3.2, agent B cannot spend more than n rounds in state setup of phase i , while agent A needsto spend at least T ( EXP LO ( n )) + n + 2 rounds in phase i before entering state tower of phase i . Henceagent B cannot be in state setup in round x , otherwise we would get a contradiction with the fact that thedelay between the two rounds in which they start testing configuration ρ i is at most T ( EXP LO ( n )) .In round x agent B cannot be in state tower of phase i . To show this, we first prove that in round x agent B cannot be in state tower of phase i with index (we will then prove it cannot be in this state even withany positive index). If in round x agent B is in state tower of phase i with index , then according toAlgorithm Byz-Known-Size agents A and B are red in round x − and enter state tower in round x . Inround x − , agents A and B are not at the same node, otherwise according to Algorithm Byz-Known-Sizethey are still together in round x and we then get a contradiction with the assumption that agent B does notenter state tower from state tower builder in the same round and at the same node as agent A . Hencein round x − agents A and B are red at distinct nodes and decide to transit to state tower : accordingto Lemma 3.3, they do so by testing the same configuration ρ i . According to Algorithm Byz-Known-Size,there are then at least k red agents in round x − : a group of at least k at the node where agent A islocated, and another group of at least k at the node of agent B . Since k ≥ f + 1 , there is at least k + 1 good agents that are red in round x − . Thus, according to Lemma 3.3, there are at least k + 1 goodagents that are red in round x − which test the same configuration ρ i . However, this implies that eachof these good red agents has its label in configuration ρ i (otherwise it would have been impossible for atleast one of them to transit to state tower builder of phase i according to the rules of state setup ):there are then at least k + 1 distinct labels in ρ i which contradicts the definition of k . Let us now prove thatin round x agent B cannot be in state tower and have an index j > . If agent B is in state tower ofphase i and has index j > in round x , then, in view of Lemma 3.2, there is a good agent C in state tower having index j − in round x − which has been in state tower since round x − j . Hence, in round x − j agent C would be in state tower with index , which means that agent C enters state tower from14tate tower builder in round x − j according to Algorithm Byz-Known-Size. Since index j cannotbe greater than T ( EXP LO ( n )) , we know from Algorithm Byz-Known-Size that agent A is red in round x − j as it necessarily spent T ( EXP LO ( n )) + n rounds as a red agents before entering state tower inround x . Hence in round x − j , there is an agent C that enters state tower while agent A is red in state tower builder : the lemma does not hold in round x − j , which contradicts the fact that x is the firstround when the lemma is false.Now that the cases setup and tower have been excluded, it remains to prove that in phase i , agent B cannot be either in state tower builder or in state failure .Let us first prove that agent B cannot be in state tower builder of phase i in round x . To prove this, itis enough to show that it cannot be either yellow , or orange , or red .If in round x agent B is yellow and tests configuration ρ i , it cannot be yellow and test configuration ρ i in round x − T ( EXP LO ( n )) − n − . Hence when in round x − T ( EXP LO ( n )) − n − , agent B hasspent at most T ( EXP LO ( n )) + ( i − ∗ Q ( n ) + n rounds since its wake up in view of Algorithm Byz-Known-Size, Proposition 3.2 and Lemma 3.1. However, according to Algorithm Byz-Known-Size, when inround x − T ( EXP LO ( n )) − n − , agent A is yellow or orange , tests configuration ρ i and sees at least k orange agents at its current node. From Lemma 3.3 and the fact that k ≥ f + 1 , there is a good agent C that is orange and tests configuration ρ i in round x − T ( EXP LO ( n )) − n − . When in this round,by Lemma 3.1 and Proposition 3.2, agent C has spent at least T ( EXP LO ( n )) + ( i − ∗ Q ( n ) + n + 1 rounds since its wake up (i.e. at least T ( EXP LO ( n )) + 1 rounds more than agent B ), which contradictsProposition 3.1.In round x agent B cannot be orange . Indeed, if agent B is orange in round x , then according toAlgorithm Byz-Known-Size and Lemma 3.3 we have the following fact: there are at least k agents such thateach of them is either yellow or orange in round x − which test the same configuration ρ i , and thereare at least k red agents in round x − which test the same configuration ρ i . Since k ≥ f + 1 , there are atleast k + 1 good agents that are in state tower builder in round x − which test the same configuration ρ i . However, this implies that each of these good agents has its label in configuration ρ i (otherwise it isimpossible to transit to state tower builder of phase i according to the rules of state setup ): there arethen at least k + 1 distinct labels in ρ i which contradicts the definition of k . In round x , agent B cannot be red . Indeed, if agent B is red in round x that means there is a round x − p ( p ≤ T ( EXP LO ( n )) + n ) inwhich it is in a group of at least k agents having a color belonging to { yellow, orange } while agent A is ina group of at least k red agents. From this point, using similar arguments to those used just above to proveagent B is not orange in round x , we get a contradiction with the definition of k .To end the proof, it remains to show that agent B is not in state failure of phase i in round x . Assumeby contradiction, it is in state failure of phase i in round x . Let x ′ < x be the last time agent B decidedto transit to state failure (recall that when an agent decides to transit from some state X to some stateY in some round t , the agent remains in state X in round t and is in state Y in round t + 1 ). In round x ′ ,agent B is either in state tower of phase i or in state wait-for-a-tower of phase i . If agent B isin state wait-for-a-tower of phase i and decides to transit to state failure in round x ′ , then byLemma 3.1, Proposition 3.2 and Algorithm Byz-Known-Size, when in round x agent B has spent at least T ( EXP LO ( n )) + ( i − Q ( n ) + 5 T ( EXP LO ( n )) + 4 n rounds since its wake up. However still by15emma 3.1, Proposition 3.2 and Algorithm Byz-Known-Size, when in round x agent A has spent at most T ( EXP LO ( n )) + ( i − Q ( n ) + 3 T ( EXP LO ( n )) + 4 n + 1 rounds since its wake up, which contradictsProposition 3.1. If agent B is in state tower of phase i with some index j ≥ in round x ′ , then inview of Lemmas 3.2 and 3.3 as well as Algorithm Byz-Known-Size, we know there is a good agent C (notnecessarily different from agent B ) that enters state tower of phase i from state tower builder ofphase i in round x ′ − j . Hence in view of Lemma 3.3 and the fact the lemma holds in all rounds prior toround x , in round x ′ − j agent A either also enters state tower of phase i from state tower builder of phase i , or is in state wait-for-a-tower of phase i . However in both these cases, it is then impossible foragent A to enter state tower of phase i from state tower builder of phase i in round x according toAlgorithm Byz-Known-Size, which is a contradiction.Thus, agent B can be only in state wait-for-a-tower of phase i in round x , which proves the lemma. (cid:3) Lemma 3.5
In any round there is at most one tower.
Proof.
Assume by contradiction there exists some round r when there are two distinct towers D j and T k .The members of D j (resp. T k ) are in state tower and all have index j (resp. index k ). Note that in the casewhere D j and T k are at the same node, indexes j and k are different from each other, otherwise we wouldhave D j = T k according to the definition of a tower. In the other case, index j is not necessarily different toindex k . Without loss of generality, we assume in the rest of this proof that j ≥ k . By Lemma 3.2, there isa good agent A ∈ D j (resp. B ∈ T k ) which has been in state tower since round r − j (resp. round r − k ).Let ρ i be the configuration tested by agent A in round r . By Lemma 3.3 agent B also tests configuration ρ i in round r . Hence, in view of the fact that agent A (resp. agent B ) is in state tower of phase i with index j (resp. index k ) in round r , agent A (resp. agent B ) enters state tower of phase i in round r − j (resp. round r − k ) from state tower builder of phase i . Denote by u the node occupied by agent A in round r − j .By Lemmas 3.3 and 3.4, in round r − j agent B is either in state wait-for-a-tower of phase i or alsoenters state tower of phase i from state tower builder at node u . The first case implies that agent B cannot enter state tower of phase i from state wait-for-a-tower of phase i in round r − k , which isa contradiction. The second case implies that agents A and B enter together state tower of phase i fromstate state tower builder in the same round r − j = r − k and at the same node, and thus belong tothe same tower in round r according to Algorithm Byz-Known-Size, which is also a contradiction and thusproves the lemma. (cid:3) We are now ready to prove Lemmas 3.6 and 3.7.
Lemma 3.6
If a good agent declares gathering is over at node v in round r , then all good agents are atnode v in round r and declare that gathering is over in round r . Proof.
Assume by contradiction there is a good agent A that declares gathering is over at node v in round r but there is a good agent B that does not make such a declaration at the same node and in the same round.16ithout loss of generality, we assume round r is the first round when an agent declares gathering is over.Thus, agent B does not declare gathering is over before round r .According to Algorithm Byz-Known-Size, there is a tower T P ( n ) in round r at node v : all agents belongingto T P ( n ) are in state tower and have index P ( n ) (which corresponds to the number of edge traversals ofprocedure EXP LO ( n ) ). By Lemma 3.2, there is a good agent C that proceeded to an entire execution of EXP LO ( n ) from round r − P ( n ) to round r . None of agents in T P ( n ) could be agent B because all goodagents belonging to T P ( n ) in round r declare gathering is over according to the rules of state tower . Inparticular agent C cannot be agent B . When agent C enters state tower in round r − P ( n ) , agent B is instate wait-for-a-tower , otherwise in view of Lemma 3.4 and Algorithm Byz-Known-Size, agents C and B both belong to T P ( n ) , which is a contradiction.If agent B does not enter state failure in some round of { r − P ( n ) + 1 , · · · , r } , then either agent B remains in state wait-for-a-tower from round r − P ( n ) to round r , or agent B enters state tower in some round x ∈ { r − P ( n ) + 1 , · · · , r } . In the former case, that means agent B is at node v in round r . Indeed, otherwise agent B shares with agent C the same node (because C makes an entire traversal asan agent in state tower ) in some round x ∈ { r − P ( n ) , · · · , r − } , and then transits to state tower inround x + 1 ≤ r (because agent C is always in a tower during its entire traversal), which is a contradiction.However due to the presence of a tower in round r at node v , agent B declares gathering is over in thesame round and at the same node according to the rules of state wait-for-a-tower , which is again acontradiction. In the latter case, agent B enters state tower in some round x ∈ { r − P ( n ) + 1 , · · · , r } . ByLemma 3.5 and the fact that agent C is always in state tower from round r − P ( n ) to r , agent B belongsto the same tower as agent C from rounds x to r . Thus agent B is included in tower T P ( n ) in round r , whichis a contradiction.Hence agent B enters state failure in some round x ∈ { r − P ( n ) + 1 , · · · , r } . By Lemma 3.3, agents A , B and C test the same configuration ρ i in round r for some positive integer i . According to AlgorithmByz-Known-Size, we know agent C also tests configuration ρ i in round x . Since agent C is in state tower in round x , agent B also tests configuration ρ i in round x , according to Lemma 3.3. Hence in view of thefact that agent B enters state failure by testing configuration ρ i in round x and the fact that it still testsconfiguration ρ i in round r , we know that agent B is in state failure of phase i in round r . However byLemma 3.1, Proposition 3.2 and Algorithm Byz-Known-Size, when in round r , agent B has spent at least T ( EXP LO ( n )) + ( i − ∗ Q ( n ) + 5 T ( EXP LO ( n )) + 4 n + 1 rounds since its wake up, while agent C has spent at most T ( EXP LO ( n )) + ( i − ∗ Q ( n ) + 4 T ( EXP LO ( n )) + 4 n rounds: we thus get acontradiction with Proposition 3.1. Hence agent B does not exist and the lemma holds. (cid:3) Lemma 3.7
There is at least one good agent that ends up declaring that gathering is over.
Proof.
Assume by contradiction no agent ends up declaring gathering is over. Let ρ i be a configuration,belonging to enumeration Θ , which corresponds to the initial configuration of all good agents in the graph.Configuration ρ i is said to be good. Let k be the number of labels in configuration ρ i : k ≥ f + 1 be-cause every tested configuration contains at least f + 1 labels. Since configuration ρ i is good, in view of17roposition 3.1, Lemma 3.1 and the fact that at least one good agent is woken up by the adversary, ev-ery good agent reaches state tower builder of phase i possibly in different rounds but at the samenode v corresponding to the node where the agent having the smallest label is initially located. De-note by A the first agent to enter state tower builder of phase i in some round r . Agent A is thus yellow in round r at node v . By Propositions 3.1 and 3.2, Lemma 3.1 and the fact that configuration ρ i is good, we know that each of all good agents enters substate yellow of phase i at node v in some round x ∈ { r, · · · , r + T ( EXP LO ( n )) + n − } . Note that if a good agent, which is in substate yellow ofphase i in round x ′ ∈ { r, · · · , r + T ( EXP LO ( n )) + n − } at node v , is no longer in substate yellow of phase i in round x ′ + 1 at node v , this implies that the good agent sees at least k orange agents atnode v in round x ′ . Among this group of at least k orange agents, at least one agent, call it C , is good as k ≥ f + 1 . By Lemma 3.3, agent C also tests configuration ρ i in round x ′ , and thus agent C entered state tower builder of phase i in round x ′ − T ( EXP LO ( n )) − n − < r at the latest, which contradictsthe definition of agent A . Hence, each of all good agents enters substate yellow of phase i at node v insome round x ∈ { r, · · · , r + T ( EXP LO ( n )) + n − } and remains in substate yellow of phase i at node v at least until round r + T ( EXP LO ( n )) + n − included. We have therefore the following claim. Claim 1.
All good agents are yellow at node v and test configuration ρ i in round r + T ( EXP LO ( n )) + n − .From Claim 1 and Algorithm Byz-Known-Size, the k good agents become red together before round r + 2 T ( EXP LO ( n )) + 2 n . From this point, we know the k good agents will then enter state tower of phase i in the same round at node v and make together an entire execution of procedure EXP LO ( n ) :according to the rules of state tower , agent A declares gathering is over at the end of this execution. So,we get a contradiction, and the lemma holds. (cid:3) From Lemmas 3.6 and 3.7, we know that Algorithm Byz-Known-Size and Theorem 3.3 are valid.
In this section, we consider the same problem, except we assume that the agents are not initially given thesize of the graph. Under this harder scenario, we aim at proving the following theorem.
Theorem 4.1
Deterministic f -Byzantine gathering of k good agents is possible in any graph of unknownsize if, and only if k ≥ f + 2 . As mentioned in Subsection 1.2, we know from [14] that:
Theorem 4.2 ([14])
Deterministic f -Byzantine gathering of k good agents is not possible in some graphsof unknown size if k ≤ f + 1 . In view of Theorem 4.2, it is then enough to show the following theorem in order to prove Theorem 4.1.
Theorem 4.3
Deterministic f -Byzantine gathering of k good agents is possible in any graph of unknownsize if k ≥ f + 2 . Hence, similarly as in Section 3, the rest of this section is devoted to showing a deterministic algorithm thatgathers all good agents, but this time in an arbitrary network of unknown size and provided there are at least f + 2 good agents. 18efore giving the algorithm, which we call Algorithm Byz-Unknown-Size , let us provide some intuitiveingredients on which our solution is based.The algorithm of this section displays a number of similarities with the algorithm of the previous section, butthere are also a number of changes to tackle the non-knowledge of the network size. Among the most notablechanges, there is firstly the way of enumerating the configurations. Previously, the agents were consideringthe enumeration
Θ = ( ρ , ρ , ρ , · · · ) of P where P is the set of every configuration corresponding toa n -node graph in which there are at least f + 1 robots with pairwise distinct labels. Now, instead ofconsidering Θ , the agents will consider the enumeration Ω = ( φ , φ , φ , · · · ) of Q where Q is the set ofall configurations corresponding to a graph of any size (instead of size n only) in which there are at least f + 2 agents (instead of at least f + 1 ) with pairwise distinct labels. Note that, as for set P , set Q is alsorecursively enumerable.Another change stems from the function performed by a tower, which we also find here. In AlgorithmByz-Known-Size, the role of a tower was to fetch all awaiting good agents (which know that the tested con-figuration is not good) via procedure EXP LO ( n ) : in the new algorithm, we keep the exact same strategy.However, to be able to use procedure EXP LO with a parameter corresponding to the size of the network,it is necessary, for the good agents that are members of a tower, to know this size. Hence, in our solution,before being considered as a tower and then authorized to make a traversal of the graph, a group of agentswill have to learn the size of the graph. To do this, at least each good agent of the group will be required tomake a simulation of procedure
EST by playing the role of an explorer and using the others as its token.To carry out these simulations, it is also required for the group of agents to contain initially at least f + 2 members (explorer + token), even if subsequently it is required for a group of agents forming a tower tocontain at least f + 1 members. Our algorithm is designed in such a way that if during the simulation ofprocedure EST by an agent playing the role of an explorer, we have the guarantee there are always at least f + 1 agents playing the role of its token, then the explorer will be able to recognize its own token withoutany ambiguity (and thus will act as if it performed procedure EST with a “genuine” token). Of course,the agents will not always have such a guarantee (especially due to the possible bad behavior of Byzantineagents when testing a wrong configuration) and will not be able to detect in advance whether they will haveit or not. Besides, some other problems can arise including, for example, some Byzantine explorer whichtakes too much time to explore the graph (or worse still, “never finishes” the exploration). However we willshow that in all cases, the good agents can never learn an erroneous size of the graph (even with the duplic-ity of Byzantine agents when testing a wrong configuration). We also show that good agents are assured oflearning the size of the network when testing a good configuration at the latest (as the creation of a group ofat least f + 2 agents and the aforementioned guarantee are ensured when testing a good configuration). Asfor Algorithm Byz-known-Size, in the worst case the good agents will have to wait until assuming a goodhypothesis about the real initial configuration, in order to declare gathering is over.Despite the fact Algorithm Byz-Unknown-Size has also a number of technical changes compared with Algo-rithm Byz-Known-Size (e.g., the duration of waiting periods that are adjusted according to the new context),it should be noted that some parts of Algorithm Byz-Unknown-Size are inevitably almost identical to someof those of Algorithm Byz-known-Size (this is particularly the case for the description of state tower ).However for easy readability, we made the choice of writing completely these parts instead of explainingthis or that part “is the same as in Algorithm Byz-Known-Size except that...”.19e now give a detailed description of the algorithm. Algorithm Byz-Unknown-Size
The agent works in phases numbered , , , · · · . During the execution of each phase, the agent can be in oneof the following seven states: setup , tower builder , token , explorer , tower , wait-for-a-tower , failure . Below we describe the actions of an agent A having label l A in each of the states as well as thetransitions between these states within phase i . As in Algorithm Byz-Known-Size, we assume that in everyround agent A tells the others (sharing the same node as agent A ) in which state it is. At the beginningof phase i , agent A enters state setup . We denote by Q the time spent by agent A executing AlgorithmByz-Unknown-Size before starting phase i . State setup .Let φ i be the i -th configuration of enumeration Ω = ( φ , φ , φ , · · · ) (refer to its description given inSection 4). Let n i be the number of nodes in configuration φ i . Agent A starts executing procedure EXP LO ( n i ) . Once the execution of EXP LO ( n i ) is accomplished, the agent backtracks to its startingnode by traversing all edges traversed in EXP LO ( n i ) in the reverse order and the reverse direction. Whenthe backtrack is done, the agent continues with this state via the following rules. If l A is not in φ i , thenit transits to state wait-for-a-tower . Otherwise, let X be the set of the shortest paths in φ i leadingfrom the node containing the agent having label l A , to the node containing the smallest label of the supposedconfiguration. Each of paths belonging to X is represented as the corresponding sequence of port numbers.Let π be the lexicographically smallest path in X (the lexicographic order can be defined using the totalorder on the port numbers). Agent A follows path π in the real network. If, following path π , agent A hasto leave by a port number that does not exist in the node where it currently resides, then it transits to state wait-for-a-tower . In the same way, it also transits to state wait-for-a-tower if, following path π , agent A enters at some point a node by a port number which is not the same as that of path π . Once path π is entirely followed by agent A , it transits to state tower builder . State tower builder .When in state tower builder , agent A can be in one of the following three substates: yellow , orange , red . In all of these substates the agent does not make any move: it stays at the same nodedenoted by v . At the beginning, agent A enters substate yellow . As for Algorithm Byz-Known-Size, wewill sometimes use a slight misuse of language by saying an agent “is yellow ” instead of “is in substate yellow ”. We will also use the same kind of shortcut for the two other colors. In addition to its state, wealso assume that in every round agent A tells the others in which substate it is. Substate yellow
Let k be the number of labels in configuration φ i . Agent A waits T ( EXP LO ( n i )) + n i + Q rounds. Ifduring this waiting period, there are at some point at least k orange agents at node v then agent A transits tosubstate red . Otherwise, if at the end of this waiting period there are not at least k agents residing at node v such that each of them is either yellow or orange , then agent A transits to state wait-for-a-tower ,else it transits to substate orange . Substate orange A waits at most T ( EXP LO ( n i )) + n i + Q rounds to see the occurrence of one of the following twoevents. The first event is that there are not at least k agents residing at node v such that each of them is either yellow or orange . The second event is that there are at least k orange agents residing at node v . Notethat the two events cannot occur in the same round. If during this waiting period, the first (resp. second)event occurs then agent A transits to state wait-for-a-tower (resp. substate red ). If at the end of thewaiting period, none of these events has occurred, then agent A transits to substate wait-for-a-tower . Substate red
Agent A waits T ( EXP LO ( n i )) + n i + T ( EST ( n i )) + Q rounds, and in every round of this waiting periodit tells the others the phase number i . If there is a round during the waiting period in which there are not atleast k red agents in phase i at node v : agent A then transits to state wait-for-a-tower as soon as itnotices this fact. Otherwise, at the end of the waiting period agent A transits either to state explorer , orto state token , or to state failure according to the following rule. Let H be the set of pairwise distinctlabels such that l ∈ H iff there is at least one red agent in phase i having label l at node v in the last roundof the waiting period. Let |H| be the cardinality of H . If |H| > n i then agent A transits to state failure .Otherwise |H| ≤ n i and agent A applies the following instruction: if l A is the smallest label in H then agent A transits to state explorer , else it transits to state token . State explorer .We first briefly describe the procedure
EST based on [6] that will be subsequently adapted to our needs. Inthis procedure, the agent constructs a BFS tree rooted at node r marked by the stationary token. In this treeit marks port numbers at all nodes. During the BFS traversal, some nodes are added to the BFS tree. In thebeginning, the agent adds the root r and then it makes the process of r . The process of a node w consistsin checking all the neighbors of w in order to determine whether some of them have to be added to the treeor not. When an agent starts the process of a node w , it goes to the neighbor reachable via port and thenchecks the neighbor.When a neighbor x of w gets checked, the agent verifies if x is equal to some node previously added tothe tree. To do this, for each node u belonging to the current BFS tree, the agent travels from x using thereversal q of the shortest path q from r to u in the BFS tree (the path q is a sequence of port numbers). If atthe end of this backtrack it meets the token, then x = u : in this case x is not added to the tree as a neighborof w and is called w - rejected . If not, then x = u . Whether node x is rejected or not, the agent then comesback to x using the path q . If x is different from all the nodes of the BFS tree, then it is added to the tree.Once node x is added to the tree or rejected, the agent makes an edge traversal in order to be located at w and then goes to a non-checked neighbor of w , if any. The order, in which the neighbors of w are checked,follows the increasing order of the port numbers of w .When all the neighbors of w are checked, the agent proceeds as follows. Let X be the set of the shortestpaths in the BFS tree leading from the root r to a node y having non-checked neighbors. If X is empty thenprocedure EST is completed. Otherwise, the agent goes to the root r , using the shortest path from w to r inthe BFS tree, and then goes to a node y having non-checked neighbors, using the lexicographically smallestpath from X . From there, the agent starts the process of y .We are now ready to give the description of state explorer .21hen entering this state, agent A executes the procedure EST ′ which corresponds to a simulation of proce-dure EST with the following three changes. The first change concerns meetings with the token. Consider averification if a node x , which is getting checked, is equal to some previously added node u . This verifica-tion consists in traveling from x using the reverse path q , where q is the path from the root r to u in the BFStree and checking the presence of the token. If at the end of the simulation of path q in EST ′ , agent A is ata node containing at least f + 1 agents in state token of phase i , then it acts as if it saw the token in EST ;otherwise it acts as if it did not see the token in
EST . The second change occurs during the constructionof the BFS tree: if at some point agent A has added more than n i nodes in the BFS tree or has spent morethan T ( EST ( n i )) rounds executing the current simulation, then it drops the simulation and transits to state failure . The third and final change occurs at the end of the simulation: if agent A has added less than n i nodes in the BFS tree, then it transits to state failure .Once the execution of procedure EST ′ is done, agent A backtracks to the node where it was located whenentering state explorer . To do this, the agent traverses all edges traversed during the execution of pro-cedure EST ′ in the reverse order and the reverse direction. When the backtrack is done, agent A has spentexactly T ( EST ( n i )) − t rounds in state explorer of phase i , for some integer t ≥ . From this point, agent A waits t rounds. At the end of the waiting period, if agent A does not share its current node with at least f + 1 agents in state token of phase i , then it transits to state failure . Otherwise agent A does share itscurrent node with at least f + 1 agents in state token of phase i : in this case, if l A is the largest label in set H (this set was determined when agent A was red in this phase) then agent A transits to state tower , elseit transits to state token . State token .While in this state, agent A remains at the same node v , and in every round it tells the others the phase num-ber i . Agent A can transit to state token either from state tower builder or from state explorer .Below, we distinguish both these cases. Let j be the number of labels of H that are smaller than l A . • Case 1: the last time agent A transited to state token was from state tower builder . In thiscase agent A waits j.T ( EST ( n i )) rounds. If there is a round during the waiting period in whichthere are not at least f + 1 agents in state token of phase i at node v : agent A then transits to state failure as soon as it notices this fact. Otherwise, at the end of the waiting period agent A transitsto state explorer . • Case 2: the last time agent A transited to state token was from state explorer . In this case agent A waits |H| − j − .T ( EST ( n i )) rounds. If there is a round during the waiting period in whichthere are not at least f + 1 agents in state token of phase i at node v : agent A then transits to state failure as soon as it notices this fact. Otherwise, at the end of the waiting period agent A transitsto state tower . State tower .Agent A can enter state tower either from state token , or state explorer or state wait-for-a-tower .While in this state, agent A will execute all or part of procedure EXP LO ( n i ) . In all cases we assume that,in every round, agent A tells the others the edge traversal number of EXP LO ( n i ) it has just made (in addi-22ion to its state). We call this number the index of the agent. Below, we distinguish and detail the case whenagent A enters state tower from state token or explorer , and the case when it enters state tower from state wait-for-a-tower .When agent A enters state tower from state token or explorer , it starts executing procedure EXP LO ( n i ) .In the first round, its index is . Just after making the j -th edge traversal of EXP LO ( n i ) , its index is j .Agent A carries out the execution of EXP LO ( n i ) until its term, except if at some round of the executionthe following condition is not satisfied, in which case agent A transits to state failure . Here is the condi-tion: the node where agent A is currently located contains a group S of at least f + 1 agents in state tower having the same index as agent A . S includes agent A but every agent that is in the same node as agent A isnot necessarily in S . If at some point this condition is satisfied and the index of agent A is equal to P ( n i ) ,which is the total number of edge traversals in EXP LO ( n i ) (refer to Section 2), then agent A declares thatgathering is over.When agent A enters state tower from state wait-for-a-tower , it has just made the s -th edge traversalof EXP LO ( n i ) for some s (cf. state wait-for-a-tower ) and thus, its index is s . Agent A executesthe next edge traversals i.e., the s + 1 -th, s + 2 -th, · · · , and then its index is successively s + 1 , s + 2 , etc.Agent A carries out this execution until the end of procedure EXP LO ( n i ) , except if the same condition asabove is not fulfilled at some round of the execution of the procedure, in which case agent A also transits tostate failure . As in the first case, if at some point the node where agent A is currently located contains agroup S of at least f + 1 agents in state tower having an index equal to P ( n i ) , then agent A declares thatgathering is over. State wait-for-a-tower .Agent A waits at most T ( EXP LO ( n i )) + 4 n i + (2 n i + 1) T ( EST ( n i )) + 4 Q rounds to see the occurrenceof the following event: the node where it is currently located contains a group of at least f + 1 agents in state tower having the same index t . If during this waiting period, agent A sees such an event, we distinguishtwo cases. If t < P ( n i ) , then it makes the t + 1 -th edge traversal of procedure EXP LO ( n i ) and transits tostate tower . If t = P ( n i ) , then it declares that gathering is over.Otherwise, at the end of the waiting period, agent A has not seen such an event, and thus it transits to state failure . State failure .Agent A backtracks to the node where it was located at the beginning of phase i . To do this, agent A traversesin the reverse order and the reverse direction all edges it has traversed in phase i before entering state failure . Once at its starting node, agent A waits T ( EXP LO ( n i )) + 9 n i + 2( n i + 1) T ( EST ( n i )) +7 Q − p rounds where p is the number of elapsed rounds between the beginning of phase i and the end of thebacktrack it has just made. At the end of the waiting period, phase i is over. In the next round, agent A willstart phase i + 1 . The purpose of this section is to prove that Algorithm Byz-Unknown-Size is correct and that by extensionTheorem 4.3 holds. 23or any positive integer i , we say that a good agent A tests configuration φ i when it executes the i -th phaseof Algorithm Byz-Unknown-Size. We denote by n i the size of the graph in configuration φ i and by n the(unknown) size of the network where the agents currently evolve. We assume that the smallest integer i suchthat n i ≥ n is α .According to state failure, we have the following proposition. Proposition 4.1
At the beginning of every phase it executes, a good agent is at the node where it was wokenup.
Lemma 4.1
Let A be a good agent which starts executing the i -th phase of Algorithm Byz-Unknown-Sizein some round r . Let Z ( n i ) = 16 T ( EXP LO ( n i )) + 9 n i + 2( n i + 1) T ( EST ( n i )) + 7 Q where Q is thenumber of rounds spent by agent A executing the algorithm before round r . The following two propertieshold. • Property 1. Agent A either spends exactly Z ( n i ) rounds executing the i -th phase or it will declarethat gathering is over after having spent at most Z ( n i ) rounds in the i -th phase. • Property 2. Let B be a good agent different from agent A which starts executing the i -th phaseof Algorithm Byz-Unknown-Size in some round r ′ (round r ′ is not necessarily different from round r ). Agent B has also spent exactly Q rounds executing Algorithm Byz-Unknown-Size before startingphase i . Proof.
Using similar arguments to those used in the proof of Lemma 3.1, we can prove that the first propertyholds. Concerning the second property, it is a corollary of the first property. (cid:3)
In view of Lemma 4.1, we know that for every integer i , the good agents that do not declare gathering isover before entering phase i , all spend the exact same time executing Algorithm Byz-Unknown-Size beforeentering phase i (whether they enter it in the same round or not). In the rest of this section, we denote by Q j the number of rounds spent before entering phase j by any agent that does not declare gathering is overbefore starting the j -th phase of Algorithm Byz-Unknown-Size. Proposition 4.2
Let A and B be two good agents such that agent A is woken up by the time agent B iswoken up. If agent A does not declare gathering is over before starting phase α , then the delay between thestarting rounds of agents A and B is at most Q α + T ( EXP LO ( n α )) . Proof.
If agent A is woken up in some round, it ends up starting phase α after having spent exactly Q α rounds. When entering phase α , agent A is in state setup and first execute procedure EXP LO ( n α ) according to Algorithm Byz-Unknown-Size. Since by definition n α ≥ n , then the propositions holds. (cid:3) Even if Algorithm Byz-Unknown-Size has several changes compared with Algorithm Byz-known-Size (inparticular the two extra states explorer and token to take into account here), we can prove Lemmas 4.2,4.3 and 4.4 by using similar arguments to those used in the proofs of Lemmas 3.2, 3.3 and 3.4.24 emma 4.2
Let T j be a tower located at node v in round t . There is at least one good agent in T j whichhas been in state tower since round t − j . Lemma 4.3
Let A be a good agent that is either orange , or red or in a state ∈ { tower , token , explorer } in round r . Let φ i be the configuration tested by agent A in round r . If i ≥ α , then all goodagents, which do not declare gathering is over before round r , test φ i in round r . Lemma 4.4
Let A be a good agent entering state explorer or token from state tower builder inround r at node v by testing a configuration φ i such that i ≥ α . Let B be a good agent that does not declarethat gathering is over before round r and that does not enter state explorer or token from state towerbuilder in round r at node v . Agent B is in state wait-for-a-tower in round r . Lemma 4.5
Let A be a good agent that tests configuration φ i in round r . If agent A enters state tower from state token or explorer in round r then n i = n . Proof.
Let us first consider the case where agent A enters state tower from state explorer in round r . Accordingto Algorithm Byz-Unknown-Size agent A computed a BFS tree T while in state explorer (just beforetransiting to state tower of phase i ). Before going any further, we need to prove the following claim. Claim 1.
The size m of T is such that m = n .If n i = n then the claim is true because according to Algorithm Byz-Unknown-Size agent A can transitfrom state explorer to state tower in round r only if m = n i . So let us focus on the case where n i = n .Denote by u the node of the graph corresponding to the root of T . Denote by T ′ the BFS tree rooted at anode corresponding to node u and that would result from the execution of procedure EST by an explorerhaving its own token at node u which cannot disappear and which cannot be confused with another token.The size of T ′ is therefore equal to n . If T is identical to T ′ , then m = n . However note that since n i = n ,we have m = n i and thus agent A cannot transit from state explorer to state tower in round r accordingto Algorithm Byz-Unknown-Size which is a contradiction with the definition of r .Therefore T is necessarily different from T ′ . There are only two possible incidents that can lead to such asituation, according to the definition of T . The first one is that at some point during the exploration of agent A , its token vanished i.e, there is a round during the exploration when there are not f + 1 agents at node u that claim being in state token of phase i . The other one is that at some point agent A confused its tokenwith another token i.e., it encountered during its exploration a group of at least f + 1 agents at a node v = u that claimed being in state token of phase i . However note that any execution of procedure EST ′ consistsof alternating periods of two different types. The first type corresponds to periods when the agent processesa node and the second type corresponds to those when the agent moves to the next node to process it. Duringthe periods of the second type, an agent does not use any token to move: it follows the same path regardlessof whether it meets some token or not on its path. Hence, each of the two possible incidents describe abovecan only have an impact on the BFS tree only if they occur during a period of the first type when verifyingwhether a node has to be rejected or not. So denote by t the first round in the construction of T via procedure25 ST ′ when agent A adds a node to its BFS tree T under construction that has to be rejected, or when agent A rejects a node that has to be added to its BFS tree T under construction. This round necessarily exists asotherwise T ′ could not be different from T according to the above explanations. We consider the only twopossible cases (each of them leading to a contradiction). Let k be the number of labels in configuration ρ i . • Case 1: in round t agent A rejects a node x that has to be added to its BFS tree T under construction.This can occur only if agent A encounters by round t during its exploration a group of at least f + 1 agents at a node v = u that claim being in state token of phase i . Among these agents there isnecessary at least one good agent B . Denote by t ′ the last round before round t such that agent A isnot in state explorer . According to Algorithm Byz-Unknown-Size, t ′ ≥ t − T ( EST ( n i )) − , andthus in round t ′ agent B is either in substate red of phase i (at node v ), or in state token of phase i (at node v ), or in state explorer of phase i . Now denote by t ′′ the last round such that t ′′ ≤ t ′ andsuch that agent A or B is in substate red of phase i . Let us first assume that agent B is in substate red of phase i in round t ′′ : in this round agent A is then either red (at node u ) or in state token (at node u ), and tests configuration φ i in view of Algorithm Byz-Unknown-Size. So still accordingto Algorithm Byz-Unknown-Size, there are at least k red agents that claim testing configuration φ i at node v in round t ′′ , while there are at least f + 1 agents (which are red or in state token ) thatclaim testing configuration φ i at node u in the same round t ′′ . Hence there are at least k + 1 goodagents which test the same configuration φ i in round t ′′ and such that each of them is either red orin state token . However, this implies that each of these good agents has its label in configuration φ i (otherwise it would have been impossible for at least one of them to be in substate red of phase i or in state token of phase i in round t ′′ according to the rules of state setup ): there are then atleast k + 1 distinct labels in φ i which contradicts the definition of k . Hence agent B cannot be insubstate red of phase i in round t ′′ . Let us now consider that agent A is in substate red of phase i in round t ′′ : in this round agent B is then either red (at node v ) or in state token (at node v ) orin state explorer in round t ′′ , and tests configuration φ i . If agent B tests configuration φ i and iseither red or in state token in round t ′′ , then similarly as above we can get a contradiction withthe definition of k . If agent B tests configuration φ i and is in state explorer in round t ′′ , then it iseither red or in state token at node v in round t ′′ − T ( EST ( n i )) − , while agent A is necessary red at node u in the same round in view of the definition of t ′′ and Algorithm Byz-Unknown-Size.Therefore similarly as above we can prove there are at least k + 1 good agents which test the sameconfiguration φ i in round t ′′ − T ( EST ( n i )) − and such that each of them is either red or in state token leading again to a contradiction with the definition of k . Hence Case 1 is impossible. • Case 2: in round t agent A adds a node to its BFS tree T under construction that has to be rejected.This can occur only if at some point during the exploration of agent A , there are not at least f + 1 agents at node u that claim being in state token of phase i . Since agent A adds a node x to its BFStree, we know that the execution of procedure EST ′ by agent A does not terminate in round t as itremains to make at least the process of node x . From round t on, if agent A does not meet any groupof at least f + 1 agents that claim being in state token of phase i during the current execution of EST ′ , then at some point it has spent more than T ( EST ( n i )) rounds executing EST ′ in phase i andtransits to state failure of phase i : we get a contradiction with that fact that agent A enters state tower of phase i from state explorer of phase i . So there is a round after round t , during its26xecution of EST ′ in phase i , where agent A meets a group of at least f + 1 agents that claim beingin state token of phase i . This group is located either on a node different from node u or on node u (in which case a ”new token” appears on node u after the disappearance of the first one): by usingsimilar arguments to those used above, we can also get a contradiction with the definition of k in boththese situations.So, n i cannot be different from n , and thus the claim follows.Now we can conclude the proof for the case where agent A enters state tower from state explorer in round r . Indeed, according to Claim 1, the BFS tree T computed by agent A before transiting to state token in round r is of size n . However, according to Algorithm Byz-Unknown-Size agent A can transitfrom state explorer of phase i to state token of phase i only if the size of T is equal to n i . Hence wenecessarily have n = n i in this case.To end the proof of this lemma, it remains to consider the case where agent A enters state tower from state token in round r . According to Algorithm Byz-Unknown-Size, agent A can make such a transition only ifit previously transited from state explorer of phase i to state token of phase i . Hence, still according toAlgorithm Byz-Unknown-Size, agent A computed a BFS tree D having size n i , while in state explorer of phase i . However in view of the claim below, the size of D is necessarily equal to n . Hence n = n i ,which proves the lemma also holds in the case where agent A enters state tower from state token inround r . Claim 2.
The size of D is n .If n i = n then the claim is true because agent A can transit from state explorer to state token in round r only if m = n i . Concerning the case where n i = n , similarly to what is done for this case in the proof ofClaim 1, we can get the same contradictions, which proves the claim. (cid:3) Lemma 4.6
In any round there is at most one tower.
Proof.
Assume by contradiction there exists some round r when there are two distinct towers D j and T k .The members of D j (resp. T k ) are in state tower and all have index j (resp. index k ). Note that in the casewhere D j and T k are at the same node, indexes j and k are different from each other, otherwise we wouldhave D j = T k according to the definition of a tower. In the other case, index j is not necessarily different toindex k .By Lemma 4.2, there is a good agent A ∈ D j (resp. B ∈ T k ) which has been in state tower since round r − j (resp. round r − k ). Since agent A (resp. agent B ) is in state tower with index j (resp. index k ) inround r , agent A (resp. agent B ) enters state tower in round r − j (resp. round r − k ) from state explorer or token . Let φ i be the configuration tested by agent A in round r . In round r − j , agent A enters statetower of phase i from state explorer of phase i or state token of phase i . So, by Lemma 4.5 we have n i = n , and then we know that i ≥ α . Hence according to Lemma 4.3 agent B also tests configuration27 i in round r , and according to Algorithm Byz-Unknown-Size it enters state tower of phase i from state explorer or token of phase i in round r − k . Let t be the last round before round r such that agent A or B is red in phase i . Without loss of generality, assume that in round t agent A is red and testsconfiguration φ i . According to Algorithm Byz-Unknown-Size agent A enters state explorer or token of phase i from state tower builder in round t + 1 at some node u . By Lemmas 4.3 and 4.4, in round t + 1 agent B is either in state wait-for-a-tower of phase i or also enters state explorer or token of phase i from state tower builder at node u . Let us first consider the first case in which agent B isin state wait-for-a-tower of phase i in round t + 1 . In this case, we cannot have r − k < t + 1 as itis impossible to transit directly or indirectly from state tower of phase i to state wait-for-a-tower of phase i . So, we necessarily have r − k ≥ t + 1 . However this implies that agent B cannot enter state tower of phase i from state explorer or token of phase i in round r − k because it is impossible toreach (directly or indirectly) state explorer or token of phase i from state wait-for-a-tower ofphase i . The first case is therefore impossible. Concerning the second case, it implies that agents A and B computed the same set H in round t at the same node u (i.e., during the last round of their waiting period as red agents of phase i ). Hence according to Algorithm Byz-Unknown-Size agents A and B enter togetherstate tower of phase i in round t + 2 | H | T ( EST ( n )) + 1 = r − j = r − k , and thus belong to the sametower in round r , which is a contradiction. (cid:3) Lemma 4.7
If a good agent declares gathering is over at node v in round r , then all good agents are atnode v in round r and declare that gathering is over in round r . Proof.
Assume by contradiction there is a good agent A that declares gathering is over at node v in round r but there is a good agent B that does not make such a declaration at the same node and in the same round.Without loss of generality, we assume round r is the first round when an agent declares gathering is over.Thus, agent B does not declare gathering is over before round r . Let φ i be the configuration tested by agent A in round r . Let k be the number of labels in configuration φ i .According to Algorithm Byz-Known-Size, there is a tower T P ( n i ) in round r at node v : all agents belongingto T P ( n i ) are in state tower and have index P ( n i ) (which corresponds to the number of edge traversal ofprocedure EXP LO ( n i ) ). By Lemma 4.2, there is a good agent C inside of tower T P ( n i ) which has been instate tower since round r − P ( n i ) . Thus agent C is in state tower and has index in round r − P ( n i ) .This implies that agent C enters state tower from state explorer or token in round r − P ( n i ) .Let φ j be the configuration tested by agent C in round r − P ( n i ) . By Lemma 4.5, we have n j = n , and thus j ≥ α . Moreover according to Algorithm Byz-Unknown-Size, agent C still tests configuration φ j in round r . Since agent A tests configuration φ i in round r and j ≥ α , by Lemma 4.3 we know i = j . Hence allgood agents in T P ( n i ) in round r test configuration φ i , which implies all good agents of T P ( n i ) declare thatgathering is over in round r according to Algorithm Byz-Unknown-Size. Agent B also tests configuration φ i in round r but it is not in state tower of phase i , as otherwise it would belong to T P ( n i ) by Lemma 4.6and thus it would also declare that gathering is over in round r , which contradicts the definition of agent B .As mentioned above we have j ≥ α , i = j and n = n j . Hence i ≥ α and n i = n .According to Lemmas 4.3 and 4.4, when agent C enters state explorer of phase i or state token of28hase i from state tower builder of phase i in round r − P ( n ) − | H | ∗ T ( EST ( n )) at some node u (for the definition of H , refer to the description of substate red in Algorithm Byz-Unknown-Size), then inthe same round agent B either also enters state explorer of phase i or state token of phase i from state tower builder of phase i at node u , or is in state wait-for-a-tower of phase i .Let us first consider the first situation. In this situation, agent B determined the same set H as agent C in thelast round as a red agent in phase i . According to Algorithm Byz-Unknown-Size, agent B also enters state tower of phase i at the same node and in the same round as agent C , or agent B enters state failure ofphase i by round r − P ( n ) . In the former case, agent B and C then belong to tower T P ( n i ) in round r andagent B declares that gathering is over in round r , which is a contradiction. The latter case in which agent B is in state failure of phase i by round r − P ( n ) requires a deeper analysis. According to AlgorithmByz-Unknown-Size, for each round of { r − P ( n ) − | H | ∗ T ( EST ( n )) , · · · , r − P ( n ) − } agent C iseither in state token of phase i or in state explorer of phase i . If agent B and C are in state token of phase i when agent B decides to transit to state failure of phase i , then agent C does the same thingaccording to Algorithm Byz-Unknown-Size and we get a contradiction with the fact that agent C declaresgathering is over in round r as an agent in state token of phase i (as it is impossible to reach state tower of phase i once in state failure of phase i ). If agent B is explorer while agent C is token when agent B decides to transit to state failure then that implies agent B computes a BFS tree of a size smallerthan n i = n . (Indeed agent B can compute a BFS tree of a size larger than n i only if at some point itstoken disappears, but that implies that agent C enters state failure of phase i and as above we get acontradiction with the definition of C . For the same reasons, agent B cannot spent more than T ( EST ( n i )) rounds to compute the BFS tree or decide to transit to state failure after having backtracked to its tokeni.e., after having traversed all edges traversed during the execution of procedure EST ′ in the reverse orderand the reverse direction). The only reason is that at some point agent B rejects a node x that has to beadded to its BFS tree under construction: similarly as in the proof of Claim 1 in the proof of Lemma 4.5we can get a contradiction with the definition of k . If agents A and B are in state explorer of phase i inthe same round we get a contradiction with the fact that they computed the same set H before leaving state tower builder of phase i . It remains to analyse the case in which agent B is token while agent C is explorer when agent B decides to transit to state failure of phase i in some round t < r − P ( n i ) .According to Algorithm Byz-Unknown-Size the token of agent C disappears in round t . Moreover similarlyas in the proof of Claim 1 in the proof of Lemma 4.5, we can argue that from round t on, agent C cannotmeet a group of at least f + 1 agents that claim being in state token of phase i . Hence when agent C verifies in round r − P ( n i ) − if it is with a group of at least f + 1 agents that claim being in state token of phase i (just before entering state tower in round r − P ( n i ) ), the condition cannot be fulfilled and thusagent C cannot enter state tower in round r − P ( n i ) , which is a contradiction. Since we get a contradictionin all cases, the first situation cannot occur.Let us now consider the second situation in which agent B is in state wait-for-a-tower of phase i inround r − P ( n ) − | H | ∗ T ( EST ( n )) , while C enters state explorer of phase i or state token of phase i from state tower builder of phase i in the same round. By using similar arguments to those used inthe latter two paragraphs of the proof of Lemma 3.6, we can distinguish the case in which agent B entersstate failure of phase i in some round of { r − P ( n ) − | H | ∗ T ( EST ( n )) + 1 , · · · , r } from the case inwhich it does not, and argue that we obtain a contradiction in both cases. Hence agent B does not exist andthe lemma holds. 29 Lemma 4.8
There is at least one good agent that ends up declaring that gathering is over.
Proof.
Assume by contradiction no agent ends up declaring gathering is over. Let φ i ∈ Ω a good configu-ration which corresponds to the initial configuration of all good agents in the graph. We then have n i = n .Let k be the number of labels in configuration φ i : by definition k ≥ f + 2 . Since configuration φ i is goodand i ≥ α , in view of Proposition 4.2 and Lemma 4.1 and the fact that at least one good agent is woken upby the adversary, every good agent reaches state tower builder of phase i possibly in different roundsbut at the same node v corresponding to the node where the agent having the smallest label is initially lo-cated. Similarly as in proof of Lemma 3.7 we can prove the following claim (by adjusting the waiting periodaccordingly and by using Propositions 4.1 and 4.2 as well as Lemmas 4.1 and 4.3 instead of respectivelyPropositions 3.2 and 3.1 as well as Lemmas 3.1 and 3.3). Round r is the first round when a good agentbecomes yellow in phase i . Claim 1.
All good agents are yellow at node v and test configuration φ i in round r + T ( EXP LO ( n )) + n + Q i − .From Claim 1 and Algorithm Byz-Unknown-Size, the k good agents become red together before round r + 2 T ( EXP LO ( n )) + 2 n + 2 Q i and decide in the same round to leave state tower builder (to enterstate tower or explorer ) after having waited exactly T ( EXP LO ( n )) + n + T ( EST ( n )) + Q i roundsas red agents of phase i . During the last round of this waiting period, all good agents compute the same set H which includes each of their labels (and possibly at most f forged labels of Byzantine agents). Note that H cannot be larger than n = n i as otherwise that would imply that there are more agents than nodes in thegraph. Hence H ≤ n and each of the k good agents enters state explorer or token in the same round,call it s , at node v . Since set H is the same for all good agents and no two of them have the same labels, inround s there is exactly at most one good agent A that enters state explorer of phase i , while the othergood agents enter state token of phase i . In fact if the smallest label in H corresponds to a label of a goodagent there is exactly one good agent A that enters state explorer of phase i , otherwise A does not existand all the good agents enters state token of phase i . According to the rules of state token , in each roundof { s, s + 1 , · · · , s + 2 T ( EST ( n )) − } there are at least f + 1 agents in state token of phase i at node v as there are at least k − ≥ f + 1 good agents in state token of phase i . As a result, during the executionof procedure EST ′ by agent A as an explorer (if it exists), its “token never disappears” and it cannotsee another token (i.e., a group of at least f + 1 agents in state token of phase i ) at a node u = v becausethere are at most f Byzantine agents and all the good agents different from explorer A are at node v . Henceagent A computes a BFS tree of size n within T ( EST ( n )) rounds, and then enters state token in round s + 2 T ( EST ( n )) after having backtracked to node v . Regardless of whether there was a good agent A ornot, in view of H and the rules of states explorer and token , there is at most one good agent A (whichhad not entered state explorer of phase i yet) that enters state explorer of phase i from state token inround s + 2 T ( EST ( n )) . More precisely, if the second smallest label in H corresponds to a label of a goodagent there is exactly one good agent A that enters state explorer of phase i in round s + 2 T ( EST ( n )) ,otherwise A does not exist and all good agents are in state token of phase i in round s + 2 T ( EST ( n )) .Moreover, in each round of { s + 2 T ( EST ( n )) , s + 2 T ( EST ( n )) + 1 , · · · , s + 4 T ( EST ( n )) − } there are30t least f + 1 agents in state token of phase i at node v as there are at least k − ≥ f + 1 good agents instate token of phase i (recall that if there was a good agent A , it is now in state token ). Thus, similarlyas before, we know that if agent A exists, it computes a BFS tree of size n within T ( EST ( n )) rounds, andis at node v with the other good agents in state token in round s + 4 T ( EST ( n )) − at the latest. Fromthis point, regardless of whether there was a good agent A or not, if H = 2 (by definition H ≥ ) then allthe good agents enters state tower of phase i (including A if any) in round s + 4 T ( EST ( n )) accordingto Algorithm Byz-Unknown-Size. Otherwise, in view of H and the rules of states explorer and token ,there is at most one good agent A (which had not entered state explorer of phase i yet) that enters state explorer of phase i from state token in round s + 4 T ( EST ( n )) , while agent A (if any) enters thestate in which the other good agents are i.e., state token of phase i . Again via similar arguments, we knowthat if H = 3 then all the good agents enters state tower (including A if any) in round s + 6 T ( EST ( n )) according to Algorithm Byz-Unknown-Size. Otherwise, by induction on the number of labels in H we canprove that all good agents enter state tower at node v in round s + 2 | H | T ( EST ( n )) . Hence, we know the k good agents will make together an entire execution of procedure EXP LO ( n ) : according to the rules ofstate tower , agent A declares gathering is over at the end of this execution. So, we get a contradiction, andthe lemma holds. (cid:3) From Lemmas 4.7 and 4.8, we know that Algorithm Byz-Unknown-Size and Theorem 4.3 are valid.
We provided a deterministic f -Byzantine gathering algorithm for arbitrary connected graphs of known size(resp. unknown size) provided that the number of good agents is at least f + 1 (resp. f + 2 ). By providingthese algorithms, we closed the open question of what minimum number of good agents M is required tosolve the problem, as each of our algorithms perfectly matches the corresponding lower bound on M statedin [14], which is of f + 1 when the size of the network is known and of f + 2 when it is unknown. Ourwork also highlighted the fact that the ability for the Byzantine agents to change their labels has no impactin terms of feasibility when the size of the network is initially unknown, since it was proven in [14] that M is also equal to f + 2 when the Byzantine agents do not have this ability.While we gave algorithms that are optimal in terms of required number of good agents, we did not tryto optimize their time complexity. Actually, the time complexity of both our solutions depends on theenumerations of the initial configurations, which clearly makes them exponential in n and the labels of thegood agents in the worst case. Hence, the question of whether there is a way to obtain algorithms that arepolynomial in n and in the labels of the good agents (with the same bounds on M ) remains an open problem. References [1] Noa Agmon and David Peleg. Fault-tolerant gathering algorithms for autonomous mobile robots.
SIAM J. Comput. , 36(1):56–82, 2006.[2] Steve Alpern. Rendezvous search: A personal perspective.
Operations Research , 50(5):772–795,2002. 313] Steve Alpern.
The theory of search games and rendezvous . International Series in Operations Researchand Management Science, Kluwer Academic Publishers, 2003.[4] Evangelos Bampas, Jurek Czyzowicz, Leszek Gasieniec, David Ilcinkas, and Arnaud Labourel. Al-most optimal asynchronous rendezvous in infinite multidimensional grids. In
Distributed Computing,24th International Symposium, DISC 2010, Cambridge, MA, USA, September 13-15, 2010. Proceed-ings , pages 297–311, 2010.[5] Michael Barborak and Miroslaw Malek. The consensus problem in fault-tolerant computing.
ACMComput. Surv. , 25(2):171–220, 1993.[6] J´er´emie Chalopin, Shantanu Das, and Adrian Kosowski. Constructing a map of an anonymous graph:Applications of universal sequences. In
Principles of Distributed Systems - 14th International Confer-ence, OPODIS 2010, Tozeur, Tunisia, December 14-17, 2010. Proceedings , pages 119–134, 2010.[7] Mark Cieliebak, Paola Flocchini, Giuseppe Prencipe, and Nicola Santoro. Distributed computing bymobile robots: Gathering.
SIAM J. Comput. , 41(4):829–879, 2012.[8] Andrew Collins, Jurek Czyzowicz, Leszek Gasieniec, and Arnaud Labourel. Tell me where I am soI can meet you sooner. In
Automata, Languages and Programming, 37th International Colloquium,ICALP 2010, Bordeaux, France, July 6-10, 2010, Proceedings, Part II , pages 502–514, 2010.[9] Jurek Czyzowicz, Adrian Kosowski, and Andrzej Pelc. How to meet when you forget: log-spacerendezvous in arbitrary graphs.
Distributed Computing , 25(2):165–178, 2012.[10] Jurek Czyzowicz, Andrzej Pelc, and Arnaud Labourel. How to meet asynchronously (almost) every-where.
ACM Transactions on Algorithms , 8(4):37, 2012.[11] Shantanu Das, Dariusz Dereniowski, Adrian Kosowski, and Przemyslaw Uznanski. Rendezvous ofdistance-aware mobile agents in unknown graphs. In
Structural Information and CommunicationComplexity - 21st International Colloquium, SIROCCO 2014, Takayama, Japan, July 23-25, 2014.Proceedings , pages 295–310, 2014.[12] Xavier D´efago, Maria Gradinariu, St´ephane Messika, and Philippe Raipin Parv´edy. Fault-tolerant andself-stabilizing mobile robots gathering. In
Distributed Computing, 20th International Symposium,DISC 2006, Stockholm, Sweden, September 18-20, 2006, Proceedings , pages 46–60, 2006.[13] Anders Dessmark, Pierre Fraigniaud, Dariusz R. Kowalski, and Andrzej Pelc. Deterministic ren-dezvous in graphs.
Algorithmica , 46(1):69–96, 2006.[14] Yoann Dieudonn´e, Andrzej Pelc, and David Peleg. Gathering despite mischief.
ACM Transactions onAlgorithms , 11(1):1, 2014.[15] Yoann Dieudonn´e, Andrzej Pelc, and Vincent Villain. How to meet asynchronously at polynomialcost. In
ACM Symposium on Principles of Distributed Computing, PODC ’13, Montreal, QC, Canada,July 22-24, 2013 , pages 92–99, 2013. 3216] Pierre Fraigniaud and Andrzej Pelc. Deterministic rendezvous in trees with little memory. In
Dis-tributed Computing, 22nd International Symposium, DISC 2008, Arcachon, France, September 22-24,2008. Proceedings , pages 242–256, 2008.[17] Pierre Fraigniaud and Andrzej Pelc. Delays induce an exponential memory gap for rendezvous in trees.
ACM Transactions on Algorithms , 9(2):17, 2013.[18] Samuel Guilbault and Andrzej Pelc. Gathering asynchronous oblivious agents with local vision inregular bipartite graphs.
Theor. Comput. Sci. , 509:86–96, 2013.[19] Taisuke Izumi, Samia Souissi, Yoshiaki Katayama, Nobuhiro Inuzuka, Xavier D´efago, Koichi Wada,and Masafumi Yamashita. The gathering problem for two oblivious robots with unreliable compasses.
SIAM J. Comput. , 41(1):26–46, 2012.[20] Dariusz R. Kowalski and Adam Malinowski. How to meet in anonymous network.
Theor. Comput.Sci. , 399(1-2):141–156, 2008.[21] Evangelos Kranakis, Danny Krizanc, and Sergio Rajsbaum. Mobile agent rendezvous: A survey. In
Structural Information and Communication Complexity, 13th International Colloquium, SIROCCO2006, Chester, UK, July 2-5, 2006, Proceedings , pages 1–9, 2006.[22] Nancy A. Lynch.
Distributed Algorithms . Morgan Kaufmann, 1996.[23] Gianluca De Marco, Luisa Gargano, Evangelos Kranakis, Danny Krizanc, Andrzej Pelc, and UgoVaccaro. Asynchronous deterministic rendezvous in graphs.
Theor. Comput. Sci. , 355(3):315–326,2006.[24] Avery Miller and Andrzej Pelc. Fast rendezvous with advice. In
Algorithms for Sensor Systems - 10thInternational Symposium on Algorithms and Experiments for Sensor Systems, Wireless Networks andDistributed Robotics, ALGOSENSORS 2014, Wroclaw, Poland, September 12, 2014, Revised SelectedPapers , pages 75–87, 2014.[25] Avery Miller and Andrzej Pelc. Time versus cost tradeoffs for deterministic rendezvous in networks.In
ACM Symposium on Principles of Distributed Computing, PODC ’14, Paris, France, July 15-18,2014 , pages 282–290, 2014.[26] Marshall C. Pease, Robert E. Shostak, and Leslie Lamport. Reaching agreement in the presence offaults.
J. ACM , 27(2):228–234, 1980.[27] Omer Reingold. Undirected connectivity in log-space.
J. ACM , 55(4), 2008.[28] Thomas Schelling.
The Strategy of Conflict . Oxford University Press, Oxford, 1960.[29] Amnon Ta-Shma and Uri Zwick. Deterministic rendezvous, treasure hunts, and strongly universalexploration sequences.