We introduce the Ants Nearby Treasure Search (ANTS) problem, which models natural cooperative foraging behavior such as that performed by ants around their nest. In this problem, probabilistic agents, initially placed at a central location, collectively search for a treasure on the twodimensional grid. The treasure is placed at a target location by an adversary and the agents’ goal is to find it as fast as possible as a function of both and , where is the (unknown) distance between the central location and the target. We concentrate on the case in which agents cannot communicate while searching. It is straightforward to see that the time until at least one agent finds the target is at least , even for very sophisticated agents, with unrestricted memory. Our algorithmic analysis aims at establishing connections between the time complexity and the initial knowledge held by agents (e.g., regarding their total number ), as they commence the search. We provide a range of both upper and lower bounds for the initial knowledge required for obtaining fast running time. For example, we prove that bits of initial information are both necessary and sufficient to obtain asymptotically optimal running time, i.e., . We also we prove that for every , running in time requires that agents have the capacity for storing different states as they leave the nest to start the search. To the best of our knowledge, the lower bounds presented in this paper provide the first nontrivial lower bounds on the memory complexity of probabilistic agents in the context of search problems.
We view this paper as a “proof of concept” for a new type of interdisciplinary methodology. To fully demonstrate this methodology, the theoretical tradeoff presented here (or a similar one) should be combined with measurements of the time performance of searching ants.
1 Introduction
The universality of search behavior is reflected in multitudes of studies in different fields including computer science, robotics, and biology. We use tools from distributed computing to study a biologically inspired scenario in which multiple agents, initially located at one central location, cooperatively search for a treasure in the plane. The goal of the search is to locate nearby treasures as fast as possible and at a rate that scales well with the number of participating agents.
Many animal species search for food around a central location that serves as the search’s initial point, final destination or both [58]. This central location could be a food storage area, a nest where offspring are reared or simply a sheltered or familiar environment. Central place foraging holds a strong preference to locating nearby food sources before those that are further away. Possible reasons for that are, for example: (1) decreasing predation risk [54], (2) increasing the rate of food collection once a large quantity of food is found [58], (3) holding a territory without the need to reclaim it [38, 54], and (4) facilitating the navigating back after collecting the food using familiar landmarks [18].
Searching in groups can increase foraging efficiency [44, p. 732]. In some extreme cases, food is so scarce that group searching is believed to be required for survival [20, 45]. Proximity of the food source to the central location is again important in this case. For example, in the case of recruitment, a nearby food source would be beneficial not only to the individual that located the source but also increase the subsequent retrieval rate for many other collaborators [72]. Foraging in groups can also facilitate the defense of larger territories [69].
Eusocial insects (e.g., bees and ants) often live in a single nest or hive, which naturally makes their foraging patterns central. They further engage in highly cooperative foraging, which can be expected as these insects reduce competition between individuals to a minimum and share any food that is found. In many cases, this collaborative effort is done with hardly any communication between searchers. For example, midsearch communication of desert ants Cataglyphys and honeybees Apis mellifera is highly limited due to their dispersion and lack of chemical trail markings [62]. Conversely, it is important to note that these insects do have an opportunity to interact amongst themselves before they leave their nest as well as some capacity to assess their own number [61].
Both desert ants and bees possess many individual navigation skills. These include the capacity to maintain a compassdirected vector flight [15, 42], measure distance using an internal odometer [70, 71], travel to distances taken from a random power law distribution [67], and engage in spiral or quasispiral movement patterns [65, 66, 75]. Finally, the search trajectories of desert ants have been shown to include two distinguishable sections: a long straight path in a given direction emanating from the nest and a second more tortuous path within a small confined area [42, 74].
The ANTS Problem.
In this paper, we theoretically address general questions of collective central place searching. More precisely, we introduce the Ants Nearby Treasure Search (ANTS) problem, a generalization of the cowpath problem [21, 47, 48], in which identical (probabilistic) agents, initially placed at some central location, collectively search for a treasure in the twodimensional grid (modeling the plane). The treasure is placed by an adversary at some target location at distance from the central location, where is unknown to the agents. Traversing an edge of the grid requires one unit of time. The goal of the agents is to find the treasure as fast as possible, where the time complexity is evaluated as a function of both and .
In this distributed setting, we are concerned with the speedup measure (see also, [6, 7, 31, 32]), which aims to capture the impact of using searchers in comparison to using a single one. Note that the objectives of quickly finding nearby treasures and having significant speedup may be at conflict. That is, in order to ensure that nearby treasures are quickly found, a large enough fraction of the search force must be deployed near the central location. In turn, this crowding can potentially lead to overlapping searches that decrease individual efficiency.
It is a rather straightforward observation that the minimal time required for finding the treasure is . Indeed, one must spend time merely to walk up to the treasure, and, intuitively, even if the agents divide the domain perfectly among themselves, it will still require them steps to explore all points at distance . Our focus is on the question of how agents can approach this bound if their communication is limited or even completely absent. Specifically, we assume that no communication can be employed between agents during the execution of the algorithm, but, on the other hand, communication is almost unlimited when performed in a preliminary stage, before the agents start their search. The former assumption is inspired by empirical evidence that desert ants (such as Cataglyphys Niger or Cataglyphis savignyi) rarely communicate outside their nest [42], and the latter assumption is very liberal, aiming to cover many possible scenarios.
To simulate the initial step of information sharing within the nest we use the abstract framework of advice. That is, we model the preliminary process for gaining knowledge by means of an oracle that assigns advice to agents. To measure the amount of information accessible to agents, we analyze the advice size, namely, the maximum number of bits used in an advice^{2}^{2}2Note that a lower bound of bits on the advice size implies a lower bound of on the number of states used by the agents already when commencing the search.. Since we are mainly interested in lower bounds on the advice size required to achieve a given time performance, we apply a liberal approach and assume a highly powerful oracle. More specifically, even though it is supposed to model a distributed probabilistic process, we assume that the oracle is a centralized probabilistic algorithm (almost unlimited in its computational power) that can assign different agents with different advices. Note that, in particular, by considering identifiers as part of the advice, our model allows to relax the assumption that all agents are identical and to allow agents to be of several types. Indeed, in the context of ants, it has been established that on their first foraging bouts ants execute different protocols than those executed by more experienced ants [74].
1.1 Our Results
We use tools from distributed computing to study a biologically inspired scenario which models cooperative foraging behavior such as that performed by ants around their nest. More specifically, we introduce the ANTS problem, a natural problem inspired by desert ants foraging around their nest, and study it in a simple, yet relatively realistic, model.
Technical Contribution.
We establish connections between the advice size and the running time^{3}^{3}3To measure the time complexity, we adopt the terminology of competitive analysis, and say that an algorithm is competitive, if its time complexity is at most times the straightforward lower bound, that is, at most . In particular, an competitive algorithm is an algorithm that runs in time.. In particular, to the best of our knowledge, our lower bounds on the advice size consist of the first nontrivial lower bounds on the memory of probabilistic searchers.
On the one extreme, we have the case of uniform search algorithms, in which the agents are not assumed to have any apriori information, that is, the advice size is zero. We completely characterize the speedup penalty that must be paid when using uniform algorithms. Specifically, we show that for a function such that converges, there exists a uniform search algorithm that is competitive. On the other hand, we show that if diverges, then there is no uniform search algorithm that is competitive. In particular, we obtain the following theorem, implying that the penalty for using uniform algorithms is slightly more than logarithmic in the number of agents.
Theorem 1.1.
For every constant , there exists a uniform search algorithm that is competitive, but there is no uniform search algorithm that is competitive.
In fact, competitive algorithms not only require some advice, but actually require bits of advice. That is expressed in the following theorem.
Theorem 1.2.
There is an competitive search algorithm using advice size of bits. On the other hand, any competitive algorithm has advice size of bits.
On the other extreme, we show that advice of size bits is both necessary and sufficient to obtain an asymptotically optimal running time.
Theorem 1.3.
There exists an competitive search algorithm using advice of size . This bound is tight as any competitive search algorithm must have advice size of bits.
We further exhibit lower and upper bounds for the advice size for a range of intermediate competitivenesses. Specifically, the following lower bound on the advice size implies that advice of size is necessary even for achieving much larger timecompetitiveness than constant.
Theorem 1.4.
Fix . Any search algorithm that is competitive must have advice size of bits.
Theorem 1.5.
Fix . Any competitive search algorithm requires advice size of .
Complementing this result, we show that the lower bound on the advice size is asymptotically optimal.
Theorem 1.6.
Fix . There exists an competitive search algorithm using advice size of .
The aforementioned lower and upper bounds are summarized in Table 1.
Competitiveness  Advice size  
Upper bound  zero  
Lower bound  zero  
Tight bound  
Lower bound 

Tight bound  
Tight bound 


Apart from their purely theoretical appeal, the algorithms we suggest in the aforementioned upper bound results are used mainly to indicate the tightness of our lower bounds. Indeed, these particular algorithms use somewhat nontrivial components, such as being executed in repeated iterations, which seem to correspond less to realistic scenarios. As our final technical result, we propose a uniform search algorithm that is concurrently efficient and extremely simple and, as such, it may imply some relevance for actual biological scenarios.
Conceptual Contribution.
This paper may serve as a “proof of concept” for a new bridge connecting computer science and biology. Specifically, we illustrate that theoretical distributed computing can potentially provide a novel and efficient methodology for the study of highly complex, cooperative biological ensembles. To this end, we choose a setting that is, on the one hand, sufficiently simple to be analyzed theoretically, and, on the other hand, sufficiently realistic so that this setting, or a variant of it, can be realizable in an experiment. Ultimately, if an experiment that complies with our setting reveals that the ants’ search is time efficient, in the sense detailed above, then our theoretical lower bound results would imply lower bounds on the number of states ants have already when they exit their nest to commence the search. Note that lower bounds consisting of even a few states would already demonstrate the power of this tradeoffbased methodology, since they would be very difficult to obtain using more traditional methodologies.
1.2 Outline
In Section 2 we formally describe the ANTS problem and provide basic definitions. To make the reader more familiar with the model, we start the technical part of the paper in Section 3 by providing a relatively simple competitive search algorithm. This algorithm uses apriori knowledge regarding the total number of agents. Specifically, the algorithm assumes that each agent knows a approximation of , encoded as advice of size . In Section 4 we turn to prove lower bounds on the advice size. We start this section by proving that the competitiveness of any uniform search algorithm is more than logarithmic. This result is a special case of the main lower bound theorem, namely, Theorem 4.6, that we prove just next. The reason we prove this special case separately is because the proof is simpler, and yet, provides some of the main ingredients of the more general lower bound proof. We then describe specific lower bounds that directly follow from Theorem 4.6 as corollaries. We conclude the technical part of the paper in Section 5 where we provide several constructions of search algorithms. We first present several constructions whose performances provide tight upper bounds for some of our lower bounds results. We then turn our attention to present a relatively efficient uniform algorithm, called, the harmonic algorithm, whose simplicity may suggest its relevance to actual search by ants. In Section 6 we discuss the conceptual contribution of the paper as a proof of concept for a new interdisciplinary methodology that combines algorithmic studies with biology experiments.
1.3 Related Work
Our work falls within the framework of natural algorithms, a recent attempt to study biological phenomena from an algorithmic perspective [1, 2, 14, 16, 27, 29].
Since our preliminary conference publications in [28, 29], the ANTS problem had quickly attracted attention from the community of distributed computing, with continuation works by other researchers, studying various theoretical aspects of our model [25, 26, 37, 53, 55, 56]. Specifically, [25, 26, 55] studied a variant of our model where
agents are modeled as finite state machines and can communicate outside the nest throughout the execution. In particular, under these assumptions, Emek et al., showed that agents can solve the ANTS problem in time [25]. This implies that in this case, no apriori knowledge about is required by the agents. Note, however, that this assumption regarding communication is probably not applicable for the case of desert ants, where no communication by such searching ants has been recorded.
The ANTS problem was further studied by Lenzen et al., who investigated the effects
of bounding the memory as well as the range of available probabilities of the
agents [56]. Fraigniaud et al. considered the case where noncommunicating agents search on line for an adversarially placed treasure [37]. They also argued for the usefulness of parallel search performed by noncommunicating agents due to the inherent robustness of such computation. A continuation work considering the case where the treasure is placed uniformly at random in a large domain was studied in [53].
The ANTS problem is a special case of collaborative search – a classical family of problems that has been extensively studied in different fields of science. We next review previous works on search problems, organizing them according to the research disciplines in which they were investigated.
Search Problems in Computer Science.
In the theory of computer science, the exploration of graphs using mobile agents (or robots) is a central question. (For a more detailed survey refer to e.g., [29, 30].) When it comes to probabilistic searching, the random walk is a natural candidate, as it is extremely simple, uses no memory, and trivially selfstabilizes. Unfortunately, however, the random walk turns out to be inefficient in a twodimensional infinite grid. Specifically, in this case, the expected hitting time is infinite, even if the treasure is nearby.
Most graph exploration research is concerned with the case of a single deterministic agent exploring a finite graph, see for example [3, 22, 39, 59, 63]. In general, one of the main challenges in search problems is the establishment of memory bounds. For example, the question of whether a single agent can explore all finite undirected graphs using logarithmic memory was open for a long time; answering it to the affirmative [63] established an equality between the classes of languages SL and L. As another example, it was proved in [68] that no finite set of constant memory agents can explore all graphs. To the best of our knowledge, the current paper is the first paper establishing nontrivial memory lower bounds in the context of randomized search problems.
In general, the more complex setting of using multiple identical agents has received much less attention. Exploration by deterministic multiple agents was studied in, e.g., [31, 32]. To obtain better results when using several identical deterministic agents, one must assume that the agents are either centrally coordinated or that they have some means of communication (either explicitly, or implicitly, by being able to detect the presence of nearby agents). When it comes to probabilistic agents, analyzing the speedup measure for random walkers has recently gained attention. In a series of papers, a speedup of is established for various finite graph families, including, e.g., expanders and random graphs [4, 23, 19]. In contrast, for the twodimensional node grid, as long as is polynomial in , the speed up is only logarithmic in . The situation with infinite grids is even worse. Specifically, though the random walkers find the treasure with probability one, the expected (hitting) time is infinite.
Evaluating the running time as a function of , the distance to the treasure, was studied in the context of the cowpath problem [9]. This problem considers a single mobile agent placed on a graph, aiming to find a treasure placed by an adversary. It was established in [9] that the competitive ratio for deterministically finding a point on the real line is nine, and that in the twodimensional grid, the spiral search algorithm is optimal up to lower order terms. Several other variants of this problem were studied in [21, 47, 48, 57]. In particular, in [57], the cowpath problem was extended by considering agents. However, in contrast to our setting, the agents they consider have unique identities, and the goal is achieved by (centrally) specifying a different path for each of the agents.
The notion of advice is central in computer science. In particular, the concept of advice and its impact on various computations has recently found various applications in distributed computing. In this context, the main measure used is the advice size. It is for instance analyzed in frameworks such as nondeterministic decision [36, 51, 52], broadcast [33], local computation of MST [35], graph coloring [34] and graph searching by a single robot [17]. Very recently, it has also been investigated in the context of online algorithms [13, 24].
The question of how important it is for individual processors to know their total number has recently been addressed in the context of locality. Generally speaking, it has been observed that for several classical local computation tasks, knowing the number of processors is not essential [50]. On the other hand, in the context of local distributed decision, some evidence exist that such knowledge is crucial for nondeterministic verification [36].
Search Problems in Biology and Physics.
Group living and food sources that have to be actively sought after make collective foraging a widespread biological phenomenon. Social foraging theory [40] makes use of economic and game theory to optimize food exploitation as a function of the group size and the degree of cooperation between agents in different environmental settings. This theory has been extensively compared to experimental data (see, e.g., [8, 41]) but does not typically account for the spatial characteristics of resource abundance. Central place foraging theory [58] assumes a situation in which food is collected from a patchy resource and is returned to a particular location, such as a nest. This theory is used to calculate optimal durations for exploiting food patches at different distances from the central location and has also been tested against experimental observations [38, 43]. Collective foraging around a central location is particularly interesting in the case of social insects where large groups forage cooperatively with, practically, no competition between individuals.
Actual collective search trajectories of noncommunicating agents have been studied in the physics literature (e.g., [64, 12]). Reynolds [64] achieves optimal speed up through overlap reduction which is obtained by sending searchers on nearstraight disjoint lines to infinity. This must come at the expense of finding proximal treasures. Harkness and Maroudas [42] combined field experiments with computer simulations of a semirandom collective search and suggest substantial speed ups as group size increases.
Search Problems in Robotics.
From an engineering perspective, the distributed cooperation of a team of autonomous agents (often referred to as robots or UAVs: Unmanned Aerial Vehicles) is a problem that has been extensively studied. These models extend single agent searches in which an agent with limited sensing abilities attempts to locate one or several mobile or immobile targets [60]. The memory and computational capacities of the agent are typically large and many algorithms rely on the construction of cognitive maps of the search area that includes current estimates that the target resides in each point [76]. The agent then plans an optimal path within this map with the intent, for example, of optimizing the rate of uncertainty decrease [46]. Cooperative searches typically include communication between the agents that can be transmitted up to a given distance, or even without any restriction. Models have been suggested where agents can communicate by altering the environment to which other agent then react [73]. Cooperation without communication has also been explored to some extent [5] but the analysis puts no emphasis on the speedup of the search process. In addition, to the best of our knowledge, no works exist in this context that put emphasis on finding nearby targets faster than faraway one. It is important to stress that in all those engineering works, the issue of whether the robots know their total number is typically not addressed, as obtaining such information does not seem to be problematic. Furthermore, in many works, robots are not identical and have unique identities.
2 Model and Definitions
2.1 General Setting
We introduce the Ants Nearby Treasure Search (ANTS) problem, in which mobile agents are searching for a treasure on some topological domain. Here, we focus on the twodimensional plane. The agents are probabilistic mobile machines (robots). They are identical, that is, all agents execute the same protocol , and their execution differ only due to the outcome of their random coins. Each agent has some limited field of view, i.e., each agent can see its surrounding up to a distance of some . Hence, for simplicity, instead of considering the twodimensional plane, we assume that the agents are actually walking on the integer twodimensional infinite grid (they can traverse an edge of the grid in both directions). The search is central place, that is, all agents initiate the search from some central node , called the source. Before the search is initiated, an adversary locates the treasure at some node , referred to as the target node. Once the search is initiated, the agents cannot communicate among themselves.
The distance between two nodes , denoted , is simply the Manhattan distance between them, i.e., the number of edges on the shortest path connecting and in the grid . For a node , let denote the distance between and the source node. We denote by the distance between the source node and the target, i.e., . It is important to note that the agents have no apriori information about the location of or about . We say that the agents find the treasure when one of the agents visits the target node . The goal of the agents it to find the treasure as fast as possible as a function of both and .
Since we are mainly interested in lower bounds, we assume a very liberal setting. In particular, we do not restrict either the computational power or the navigation capabilities of agents. Moreover, we put no restrictions on the internal storage used for navigation. On the other hand, we note that for constructing upper bounds, the algorithms we consider use simple procedures that can be implemented using relatively few resources. For example, with respect to navigation, we only assume the ability to perform the following basic procedures: (1) choose a direction uniformly at random, (2) walk in a “straight line” to a prescribed distance, (3) perform a spiral search around a given node^{4}^{4}4The spiral search is a particular deterministic search algorithm that starts at a node and enables the agent to visit all nodes at distance from by traversing edges, for every integer (see, e.g., [9]). For our purposes, since we are interested with asymptotic results only, we can replace this atomic navigation protocol with any procedure that guarantees such a property. For simplicity, in what follows, we assume that for any integer , the spiral search of length starting at a node visits all nodes at distance at most from ., and (4) return to the source node.
2.2 Oracles and Advice
We would like to model the situation in which before the search actually starts, some information may be exchanged between the agents at the source node. In the context of ants, this preliminary communication may be quite limited. This may be because of difficulties in the communication that are inherent to the ants or the environment, e.g., due to faults or limited memory, or because of asynchrony issues, or simply because agents are identical and it may be difficult for ants to distinguish one agent from the other. Nevertheless, we consider a very liberal setting in which this preliminary communication is almost unrestricted.
More specifically, we consider a centralized algorithm called oracle that assigns advices to agents in a preliminary stage. The oracle, denoted by , is a probabilistic^{5}^{5}5It is not clear whether or not a probabilistic oracle is strictly more powerful than a deterministic one. Indeed, the oracle assigning the advice is unaware of , and may thus potentially use the randomization to reduce the size of the advices by balancing between the efficiency of the search for small values of and larger values. centralized algorithm that receives as input a set of agents and assigns an advice to each of the agents. We assume that the oracle may use a different protocol for each ; Given , the randomized algorithm used for assigning the advices to the agents is denoted by . Furthermore, the oracle may assign a different advice to each agent^{6}^{6}6We note that even though we consider a very liberal setting, and allow a very powerful oracle, the oracles we use for our upper bounds constructions are very simple and rely on much weaker assumptions. Indeed, these oracles are not only deterministic but also assign the same advice to each of the agents.. Observe that this definition of an oracle enables it to simulate almost any reasonable preliminary communication between the agents^{7}^{7}7For example, it can simulate to following very liberal setting. Assume that in the preprocessing stage, the agents are organized in a clique topology, and that each agent can send a separate message to each other agent. Furthermore, even though the agents are identical, in this preprocessing stage, let us assume that agents can distinguish the messages received from different agents, and that each of the agents may use a different probabilistic protocol for this preliminary communication. In addition, no restriction is made either on the memory and computation capabilities of agents or on the preprocessing time, that is, the preprocessing stage takes finite, yet unlimited, time..
It is important to stress that even though all agents execute the same searching protocol, they may start the search with different advices. Hence, since their searching protocol may rely on the content of this initial advice, agents with different advices may behave differently. Another important remark concerns the fact that some part of the advices may be used for encoding (not necessarily disjoint) identifiers. That is, assumptions regarding the settings in which not all agents are identical and there are several types of agents can be captured by our setting of advice.
To summarize, a search algorithm is a pair consisting of a randomized searching protocol and randomized oracle . Given agents, the randomized oracle assigns a separate advice to each of the given agents. Subsequently, all agents initiate the actual search by letting each of the agents execute protocol and using the corresponding advice as input to . Once the search is initiated, the agents cannot communicate among themselves.
2.3 Complexities
Advice Complexity.
Consider an oracle . Given , let denote the maximum number of bits devoted for encoding the advice of an agent, taken over all possible advice assignments of , and over the agents. In other words, is the minimum number of bits required for encoding the advice, assuming that the number of agents is . The function is called the advice size function of oracle . (When the context is clear, we may omit the subscript from and simply use instead.)
Observe that a lower bound on the size of the advice is also a lower bound on the memory size of an agent, which is required merely for storing the output of the preprocessing stage, i.e., the initial datastructure required for the search. In other words, even without considering the memory of agents used for the actual navigation, the lower bounds on the advice we establish imply that so many bits of memory must be used initially by the agents.
As mentioned, the advice complexity also directly relates to the state complexity, i.e., the minimum number of states an agent has already when commencing the search. Specifically, a lower bound of bits on the advice size implies a lower bound of on the state complexity.
Algorithms that do not use any advice (in particular, no information regarding is available to agents) are called uniform. (The term “uniform” is chosen to stress that agents execute the same algorithm regardless of their number, see, e.g., [50].)
Time Complexity.
When measuring the time to find the treasure, we assume that all computations internal to an agent are performed in zero time. Since we are mostly interested in lower bounds, we assume a liberal setting also in terms of synchronization. That is, we assume that the execution proceeds in discrete rounds, each taking precisely one unit of time. In each such round, each agent can perform internal computations (that take zero time) and traverse an incident edge. (For upper bound purposes, this synchronization assumption can be removed if we measure the time according to the slowest edgetraversal.) We also assume that all agents start the search simultaneously at the same round. (For upper bound purposes, this assumption can also be easily removed by starting to count the time when the last agent initiates the search.)
The expected running time of a search algorithm is the expected time (or number of rounds) until at least one of the agents finds the treasure (that is, the agent is located at the target node where the treasure is located). The expectation is defined with respect to the coin tosses made by the (probabilistic) oracle assigning the advices to the agents, as well as the subsequent coin tosses made by the agents executing . We denote the expected running time of an algorithm by . In fact, for our lower bound to hold, it is sufficient to assume that the probability that the treasure is found by time is at least . By Markov’s inequality, this assumption is indeed weaker than the assumption that the expected running time is .
Note that if an agent knows , then it can potentially find the treasure in time , by
walking to a distance in some direction, and then performing a “circle” around the source of radius (assuming, of course, that its navigation abilities enable it to perform such a circle). With the absence of knowledge about , a single agent can find the treasure in time by performing a spiral search around the source (see, e.g., [9]). The following observation implies that is a lower bound on the expected running time of any search algorithm. The proof is straightforward but we nevertheless give it here, for completeness purposes.
Observation 2.1.
The expected running time of any algorithm is , even if the number of agents is known to all agents.
Proof.
To see why the observation holds, consider the case of agents, and a search algorithm whose expected running time is . Clearly, , because it takes time to merely reach the treasure. Assume, towards contradiction, that . In any execution of , by time , the agents can visit a total of at most nodes. Hence, by time , more than half of the nodes in were not visited. Therefore, there must exist a node such that the probability that is visited by time (by at least one of the agents) is less than . If the adversary locates the treasure at then the expected time to find the treasure is strictly greater than , which contradicts the assumption. ∎
Competitive Analysis.
We evaluate the time performance of an algorithm with respect to the lower bound given by Observation 2.1. Formally, let be a function of . A search algorithm is called competitive if
for every integers and . Our goal is to establish connections between the size of the advice, namely , and the competitiveness of the search algorithm.
3 An Competitive Algorithm with Advice of Size
As a warmup, this section presents an competitive algorithm with advice size of bits. We start with Theorem 3.1 showing that agents can achieve an asymptotically optimal running time if they know the precise value of . This algorithm requires advice size of bits, that are used to encode the value of at each agent. However, as explained in the following corollary, Theorem 3.1 also holds if agents merely know a constant approximation of . As this knowledge can be encoded using bits, we obtain an competitive algorithm with advice size of bits.
The competitive algorithm that we consider is based on performing the following operations iteratively:

walk in a “straight line” to a point chosen uniformly at random in some ball around the source,

perform a spiral search around that point for a length which is proportional to the size of the ball divided by the number of agents, and

return to the source.
More formally, we consider the following algorithm, termed (see also Figure 1 for an illustration).
Note that Algorithm assumes that agents know their total number, . The next theorem states that its performances are asymptotically optimal.
Theorem 3.1.
Algorithm is competitive.
Proof.
Assume that the treasure is located at some node at distance from the source. We now show that the expected time to find it is .
Denote . A phase , for which , is called large. Note that the ball corresponding to a large phase contains the node holding the treasure. Fix a positive integer and consider the time until each agent completed large phases. Each time an agent performs a large phase , the agent finds the treasure if the chosen node belongs to the ball around , the node holding the treasure (this follows from the definition of a spiral search, see Footnote 3). Since , we get that at least some constant fraction of the ball is contained in . The probability of choosing a node in that fraction is thus , which is at least for some positive constant . Thus, the probability that by time none of the agents finds the treasure (while executing their respective large phases ) is at most , which is at most for some constant greater than .
For , let be the time required to execute a phase . Note that . Hence, the time until all agents complete stage for the first time is
This equation implies that for any integer , all agents complete their respective stages by time . Observe that by this time, all agents have completed at least large phases . Consequently, as explained before, the probability that none of the agents finds the treasure by time is at most . Hence, the expected running time is at most
This establishes the theorem. ∎
Fix a constant . We say that the agents have a approximation of , if,
initially, each agent receives as input a value satisfying
.
Corollary 3.2.
Fix a constant . Assume that the agents have a approximation of their total number. Then, there exists a (nonuniform) search algorithm that is competitive.
Proof.
Each agent executes Algorithm (see the proof of Theorem 3.1) with the parameter equal to . By the definition of a approximation, the only difference between this case and the case where the agents know their total number, is that for each agent, the time required to perform each spiral search is multiplied by a constant factor of at most . Therefore, the analysis in the proof of Theorem 3.1 remains essentially the same and the running time is increased by a multiplicative factor of at most . ∎
The following theorem directly follows from the previous corollary.
Theorem 3.3.
There exists an competitive search algorithm using advice size of bits.
4 Lower Bounds on the Advice
In Section 4.1 we give an informal proof that the competitiveness of any uniform search algorithm cannot be . The proof provides some important ingredients of the main lower bound proof. In Section 4.2 we provide definitions and preliminary observations required for formally proving our lower bounds. In Section 4.3 we establish a stronger result than the one mentioned in the informal discussion, stating that the competitiveness of any uniform search algorithm is in fact strictly more than logarithmic. This result is a special case of the main lower bound theorem, namely, Theorem 4.6, that we prove next, in Section 4.4. In the following section, namely, Section 4.5, we prove other lower bound results that directly follow from Theorem 4.6 as corollaries.
4.1 An Informal Proof of a Weak Lower Bound for Uniform Algorithms
We now provide an informal proof explaining why there are no uniform search algorithms which are competitive, where and is nondecreasing. So assume that the running time is , and let us show that .
We first fix some large number that will serve as an upper bound on the number of agents. Let , and assume that the treasure is actually placed very far away, specifically, at distance . Note that this means, in particular, that by time the treasure has not been found yet^{8}^{8}8Although the treasure is placed far, in principle, it could have also been placed much closer to the source. In fact, had the treasure been placed at a distance of roughly the number of agents , the algorithm would have had enough time to find it. This is the intuition behind of choice of the value of parameter ..
We consider rings centered at the source that span the region containing all points at distance between roughly and roughly from the source. See Figure 2 below. Specifically, let , and consider the set of integers . For , define the ring
Fix and let us now assume that the number of agents is . Note that . Further, observe that the number of points in is
We also have , for every . That is, any point in is at distance at least from the source. Hence, the expected time until the agents cover each is at most
Recall that in a uniform algorithm, all agents start the search with the same state. Thus, the expected number of nodes in that an agent visits by time is . Observe, this holds for all . Hence, the expected number of nodes that a single agent visits by time is . On the other hand, this number is also at most because an agent can visit at most one node in one unit to time. As , this implies that the competitiveness is , as required.
4.2 Definitions and Preliminary Observations
We now give preliminary definitions that will be used to formally state and prove our lower bounds. We begin with the following definition. A nondecreasing function is called relativelyslow if is sublinear (i.e., ) and if there exist two positive constants and such that when restricted to , we have . Note that this definition captures many natural sublinear functions^{9}^{9}9For example, note that the functions of the form , (for nonnegative constants and , such that ) are all relativelyslow..
We will consider different scenarios for exponentially increasing number of agents. Specifically, for every integer , set
Given a relativelyslow function , let be the smallest integer such that for every integer , we have . (The existence of is guaranteed by the fact that is sublinear). Let be a sufficiently large integer (in fact, we will typically take to infinity). Without loss of generality, we assume that is an even number. In all the lower bound proofs, we assume that the treasure is placed somewhere at distance
Note that this means, in particular, that by time the treasure has not been found yet. Next, define the set of integers
Fix an integer and set
Further, let denote the ball of radius around the source node, i.e.,
Note that the largest we consider is . Therefore, in the case that is small, the sizes of the balls of range from roughly to roughly .
For every set of nodes , let denote the random variable indicating the number of nodes in that were visited by at least one of the agents by time . (For short, for a singleton node , we write instead of .) Note that the value of depends on the values of the coins tosses made by the oracle for assigning the advices as well as on the values of the coins tossed by the agents. Finally, define the ring
The following claim states that the number of nodes in Ring is roughly .
Claim 4.1.
For each integer , we have
Proof.
The claim follows from the following sequence of equations
where the fourth and fifth equalities follow from the facts that is relativelyslow. ∎
We now claim that by time , the agents are expected to cover a constant fraction of Ring .
Claim 4.2.
For each integer , we have
Proof.
To see why the claim holds, observe that since , and , we have
which implies that for every node the expected time to visit is at most
Thus, by Markov’s inequality, the probability that is visited by time is at least , that is, . Hence, . By linearity of expectation, . ∎
The following claim directly follows from the previous two claims.
Claim 4.3.
For each integer , we have
4.3 No Uniform Search Algorithm is Competitive
In this subsection we prove a lower bound for the competitiveness of uniform algorithm. The lower bound is stronger than the one mentioned in Section 4.1. The proof follows similar logic as in the weaker version, but uses the more refined choosing of parameters, as defined in Section 4.2.
Theorem 4.4.
There is no uniform search algorithm that is competitive.
The theorem follows directly from the following lemma by setting .
Lemma 4.5.
Consider a relativelyslow function such that . There is no uniform search algorithm that is competitive.
Proof.
Suppose for contradiction that there exists a uniform search algorithm with running time less than , where is relativelyslow. Our goal is to show that converges.
We use the assumption that the algorithm is uniform. In this case, all agents are not only executing the same algorithm but also start with the same state. Hence, Claim 4.3 implies that for every integer , the expected number of nodes in that each agent visits by time is . Since the rings are pairwise disjoint, the linearity of expectation implies that the expected number of nodes that an agent visits by time is
On the other hand, this number is at most because an agent can visit at most one node in each time unit. Consequently, must converge as goes to infinity. This completes the proof of Lemma 4.5. ∎
4.4 The Main Lower Bound Theorem
Here we present the main theorem of this section, namely, Theorem 4.6. The theorem is a generalization of Lemma 4.5.
The statement of the theorem uses definitions as given in Section 4.2.
Theorem 4.6.
There exist constants and such that the following holds. Let denote the number of agents. For every competitive search algorithm using advice of size , where is relativelyslow and is nondecreasing, and for every sufficiently large integer , we have:
Remark 4.7.
Note that in the case of uniform algorithms, we have advice size being zero, i.e., , and therefore the requirement that the sum in Theorem 4.6 converges is the same as the requirement in Lemma 4.5. Naturally, as the advice size grows, the competitiveness may decrease without violating the inequality.
Proof (of Theorem 4.6).
Recall that Claim 4.3 holds for any algorithm, whether it is uniform or not. Therefore, for each integer , the expected number of nodes in visited by at least one of the agents by time is:
We now consider the case when running with agents after being assigned advice by the oracle. Let denote the random variable indicating the number of nodes in visited by the ’th agent by time . It follows that for every integer , we have:
By the pigeonhole principle, there exists an integer for which
In other words, in expectation, the th agent in the group of agents covers at least nodes in by time .
Let Adv denote the set of all possible advice used for agents, in all the scenarios with agents, where . Note that the advice given by the oracle to any of the agents must use at most bits. For every fixed integer , the number of different possible advices that can be encoded on precisely bits is , therefore the total number of different possible advice used is . In other words, we have:
Claim 4.8.
.
Now, for each advice , let denote the random variable indicating the number of nodes in that an agent with advice visits by time . Note that the value of depends only on the values of the coin tosses made by the agent. On the other hand, note that the value of depends on the results of the coin tosses made by the oracle assigning the advice, and the results of the coin tosses made by the agent that uses the assigned advice. Recall, the oracle may assign an advice to agent according to a distribution that is different than the distributions used for other agents. However, regardless of the distribution used by the oracle for agent , it must be the case that there exists an advice , for which . Hence, we obtain:
In other words, in expectation, an agent with advice covers at least nodes in by time .
Let . Consider now an “imaginary” scenario^{10}^{10}10The scenario is called imaginary, because, instead of letting the oracle assign the advice for the agents, we impose a particular advice to each agent, and let the agents perform the search with our advices. Note that even though such a scenario cannot occur by the definition of the model, each individual agent with advice cannot distinguish this case from the case that the number of agents was some and the oracle assigned it the advice . in which we execute the search algorithm with agents, each having a different advice in . That is, for each advice , we have a different agent executing the algorithm using advice . For every set of nodes in the grid , let denote the random variable indicating the number of nodes in that were visited by at least one of these agents (in the “imaginary” scenario) by time . Let denote the random variable indicating the total number of nodes that were visited by at least one of these agents by time .
By definition, for each , the expected number of nodes in visited by at least one of these agents is at least the expected number of nodes in visited by the particular agent with advice . This number is . Hence, we obtain:
Since the sets are pairwise disjoint, the linearity of expectation implies that the expected number of nodes covered by these agents by time is
Observe that , and therefore, by Claim 4.8, we have . Hence, once more by linearity of expectation, there must exist an advice , such that the expected number of nodes that an agent with advice visits by time is
Since each agent may visit at most one node in one unit of time, it follows that, for every large enough, the sum
is at most some fixed constant. The proof of the theorem now follows by replacing the variable with . ∎
4.5 More Lower Bounds
We next describe important lower bounds results that directly follow from Theorem 4.6 as corollaries. We first consider the case of uniform algorithm, in which the advice size is zero, that is, .
4.5.1 Any Competitive Algorithm Requires Advice of Size
We have established that there is no uniform algorithm that is competitive. We now show that, in fact, competitive
algorithms require advice of at least bits.
Theorem 4.9.
There is no competitive search algorithm that uses advice of size .
Proof.
Assume that the competitiveness is . Since , we have
According to Theorem 4.6, the sum
must converge as goes to infinity. In particular, we cannot have . ∎
4.5.2 The Minimal Advice Size of Algorithms with SubLogarithmic Competitiveness
We next show that the minimal advice size quickly grows to , as the competitiveness becomes sublogarithmic.
In particular, we show that competitive algorithms require advice size of bits. This result shows that the upper bound of bits mentioned in Theorem 3.3 is in fact tight.
Theorem 4.10.
Consider any competitive search algorithm using advice of size . Assume that is relativelyslow and that is nondecreasing. Then, . In particular:

Any competitive search algorithm must have advice size .

Let be a positive constant. Any competitive search algorithm must have advice size .

Let be a positive constant. Any competitive search algorithm requires advice of size .
Proof.
Theorem 4.6 implies that for every , we have:
On the other hand, since is nondecreasing, we have:
Hence,
The main part of the theorem therefore follows:
The first item follows by taking , the second item follows by taking and the third item follows by taking . ∎
5 Further Upper Bounds
In Theorem 3.3 we showed that there exists an competitive algorithm that uses bits of advice. In Theorem 4.10 we proved that this bound is tight. In this section we give two additional tight upper bounds. In Section 5.1 we show that the lower bound for the competitiveness of uniform algorithms mentioned in Theorem 4.5 is tight. In Section 5.2.1 we show that the lower bound of for the advice size of competitive algorithms mentioned in Theorem 4.9 is tight.
5.1 A Tight Upper Bound for the Competitiveness of Uniform Algorithms
We now turn our attention to the case of uniform algorithms. Consider a nondecreasing function such that . We suggest Algorithm below as an optimal algorithm for the uniform case.
The structure of Algorithm finds resemblance with the structure of Algorithm described in Section 3. Indeed, the basic operations are the same: Go to a node chosen uniformly at random in some ball around the source, perform a spiral search of some length, and return to the source. In contrast to Algorithm that needs the value of (or some approximation of it) to specify the length of the spiral search, Algorithm decides the length of the spiral search based only on the loops indices.
The theorem below implies that the lower bound mentioned in Theorem 4.5 is tight.
Theorem 5.1.
Consider a nondecreasing function such that . Algorithm is a uniform search algorithm which is competitive.
Proof.
Assuming as given in the theorem, let us analyze the performance of Algorithm and show that its expected running time is . We first note that it suffices to prove the statement when . Indeed, if , then we may consider only agents among the agents and obtain an upper bound on the running time of , which is less than .
Assertion 1.
For every integer , the time until all agents complete epoch is .
For the assertion to hold, it is sufficient to prove that stage in epoch takes time . To this end, notice that phase takes time which is at most . Therefore, stage takes time
This establishes Assertion 1.
Set . Recall that we consider the case where . Therefore .
In particular, there exists such that .
Assertion 2.
There exists a constant such that the probability that none of the agents finds the treasure while executing phase of stage is at most .
To see this, first note that the treasure is inside the ball , for every . Indeed, since , we have
The total number of nodes in the ball is , and at least a third of the ball of radius around the treasure is contained in . Consequently, the probability for an agent to choose a node in a ball of radius around the treasure in phase of stage is
If this event happens, then the treasure is found during the corresponding spiral search of agent . As a result, there exists a positive constant such that the probability that none of the agents finds the treasure during phase of stage is at most . This establishes Assertion 2.
By the time that all agents have completed their respective epoch , all agents have performed stages with . By Assertion 2, for each such , the probability that the treasure is not found during stage is at most for some constant . Hence, the probability that the treasure is not found during any of those stages is at most for some constant . Assertion 1 ensures that all agents complete epoch by time , so the expected running time is , as desired. ∎
Setting yields the following corollary.
Corollary 5.2.
For every positive constant , there exists a uniform search algorithm that is