Abstract 1 Introduction 2 Model and Problem Definition 3 Related Work 4 Our Contribution 5 Impossibility Result 6 Connectivity Time Dynamic Graph Exploration 7 Conclusion and Future Work References Appendix A Appendix

Natural Calamities Demand More Rescuers: Exploring Connectivity Time Dynamic Graphs

Ashish Saxena ORCID Indian Institute of Technology Ropar, Rupnagar, Punjab, India Kaushik Mondal ORCID Indian Institute of Technology Ropar, Rupnagar, Punjab, India
Abstract

We study the exploration problem by mobile agents in Connectivity Time dynamic graphs. The Connectivity Time model was introduced by Michail et al. [JPDC 2014] and is arguably one of the weakest dynamic graph connectivity models. We prove that exploration is impossible in such graphs using (n1)(n2)2 mobile agents starting from an arbitrary initial configuration, even when agents have full knowledge of system parameters, global communication, full visibility, and infinite memory. We then present an exploration algorithm that uses (n1)(n2)2+1 agents equipped with global communication, 1-hop visibility and O(logn) memory.

Keywords and phrases:
Mobile agents, Anonymous graphs, Exploration, Dynamic graphs, Deterministic algorithm
Funding:
Ashish Saxena: Acknowledge the financial support from IIT Ropar.
Kaushik Mondal: Acknowledge the ISIRD grant provided by IIT Ropar.
Copyright and License:
[Uncaptioned image] © Ashish Saxena and Kaushik Mondal; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Distributed algorithms
Editor:
Dariusz R. Kowalski

1 Introduction

The exploration of graphs by mobile agents is a well-studied problem in distributed computing and has foundational importance in theoretical computer science. Originating from early work by Shannon [39], the objective is for mobile agents to collectively visit every node in a given network. Depending on the requirements, the task may involve visiting each node at least once (exploration with termination) or repeatedly over time (perpetual exploration). This problem is not only of theoretical interest but also has practical implications for systems involving autonomous agents, such as robots, software agents, or vehicles, where exploration helps in fault detection, information dissemination, or data collection across the network.

The graph exploration problem has been studied under a wide range of assumptions. These include whether the nodes are uniquely labelled or anonymous, whether agents have distinct identities or are indistinguishable, and the mode of communication or interaction among agents, such as using whiteboards, tokens, face-to-face meetings, or vision-based mechanisms. Variations also arise based on the degree of synchrony among agents (asynchronous, semi-synchronous, or fully-synchronous), the extent of their knowledge about the network, and the amount of memory available to them (refer to [2, 7, 6, 11, 37, 21, 22, 13, 14], for a comprehensive overview, refer to [9]). Despite the diversity in models, most of the prior research is on static graphs, meaning the graph structure remains fixed throughout the exploration. While this assumption works well for traditional networks, where changes typically result from failures but it falls short in capturing the behaviour of today’s highly dynamic networks.

The dynamic nature of modern networks presents significant challenges in addressing various algorithmic problems in mobile computing and related domains, as the underlying network topology evolves over time. From the perspective of mobile agents, this means that agents must carry out their tasks in an environment that evolves over time steps. A foundational model capturing such dynamic behaviour was introduced by Kuhn et al. [32]. In their framework, they defined a stability property known as T-Interval Connectivity (for T1), which requires that in every sequence of T consecutive rounds, there exists a stable, connected spanning subgraph, although additional edges may appear or disappear in each round. Later, Michail et al. [33] proposed a more relaxed and natural notion of connectivity in dynamic networks, particularly suitable for networks that may be disconnected at individual time steps. They introduced the concept of Connectivity Time, defined as follows:

Let V be a fixed set of nodes and S={(u,v),|,u,vV} be the set of possible edges. Let 𝒫(S) denote the power set of S. A synchronous dynamic network is modeled as a dynamic graph G=(V,E), where E:𝒫(S) maps each round number r{0} to the set of edges present at that round. The static graph at round r is denoted by 𝒢r=(V,E(r)).

Definition.

[33] The Connectivity Time of a dynamic graph G=(V,E) is the minimum integer T such that r{0}, the union graph Gr,T:=(V,i=rr+T1E(i)) is connected.

This model generalizes T-Interval Connectivity, but unlike T-Interval Connectivity, it allows temporary disconnections. Thus, Connectivity Time is strictly weaker than T-Interval Connectivity. In the next section, we discuss the model and problem definition.

2 Model and Problem Definition

Dynamic graph model.

We consider a dynamic network modeled as a sequence of undirected graphs G=(V,E), where the node set V remains fixed over time and satisfies |V|=n. Define S={(u,v)|u,vV} as the set of all possible edges, and let 𝒫(S) denote its power set. The function E:𝒫(S) maps each round number r{0} to the set of edges E(r) present at that round, yielding the snapshot graph 𝒢r=(V,E(r)). The dynamic graph G is thus given as a sequence 𝒢0,𝒢1,𝒢2,. We assume the presence of a dynamic adversary that may insert or delete any edge at the beginning of each round. The degree of a node v at round r is denoted by degr(v). The diameter of 𝒢r is denoted by Dr.

Each snapshot graph 𝒢r is unweighted, undirected, and anonymous. Moreover, the graph is port-labelled: for any node v𝒢r, the incident edges are assigned distinct local port numbers in the range [0,degr(v)1]. For an edge (u,v), the port numbers at u and v are independently assigned and unrelated. Port labellings can differ across rounds; i.e., port numbers at a node in 𝒢r may not match those in 𝒢r for rr. Nodes do not have any storage capability. A node is referred to as hole in round r if no agent is present at that node, and as multinode if two or more agents occupy it at round r. In this work, the graph G(=𝒢0,𝒢1,𝒢2,) maintains the Connectivity Time property for some T, i.e., for every r0, the graph Gr,T:=(V,i=rr+T1E(i)) is connected.

Agent model.

We consider mobile agents that are initially placed arbitrarily on the nodes of G. Each agent has a unique identifier from the range [1,nc], where c is some constant, and knows only its own ID. Agents are equipped with O(logn) memory and execute the algorithm under a fully synchronous scheduler, i.e., in each round t, every agent executes a Communicate-Compute-Move (CCM) cycle:

  • Communicate: Agents communicate as per the communication model.

  • Compute: Based on its local view and any received information, the agent performs computation, including deciding whether and where to move.

  • Move: The agent moves through a chosen port or stays idle.

The time complexity is measured by the number of synchronous rounds. We refer to 𝒢r together with the agents’ positions as the configuration. With a slight abuse of notation, we may denote the configuration at round r by 𝒢r.

Visibility model.

We adopt a standard visibility framework where agents have l-hop visibility. In the l-hop model [1, 34], at the beginning of round r, an agent can see the subgraph induced by nodes within distance l from its current location in 𝒢r, including the presence or absence of agents in that neighbourhood. When l=Dr, this provides full visibility at round r.

Communication model.

In this work, we consider the global communication model [20, 8, 36, 30, 31]. The global communication allows agents to exchange messages with any agent located in the same connected component of 𝒢r, utilizing the graph’s links. The global communication between two different connected components of 𝒢r is not possible, as there is no edge between two different connected components.

Problem definition.

A node v is visited by round r if at least one agent is at node v at round t, where t[0,r]. An algorithm achieves exploration if every node is visited at least once. And, an algorithm achieves perpetual exploration if every node is visited infinitely often.

3 Related Work

Exploration of dynamic graphs has been widely studied in centralized settings, where agents have full knowledge of the network’s evolution. Notably, optimal exploration schedules have been analyzed under 1-Interval Connectivity [18] and extended in subsequent works [15, 17, 16]. Specific topologies such as rings and cactuses have also been explored under T-Interval and 1-Interval Connectivity, respectively [27, 26].

Distributed exploration, with limited agent knowledge, has received less attention. Probabilistic methods like random walks were introduced in early foundation work [3], while deterministic approaches focus on periodic graphs and carrier models [18, 19, 28, 27]. Perpetual exploration and exploration with termination have been studied in 1-Interval Connected rings using 2 or 3 agents under Fsync and Ssync models [4, 5, 12]. Other results include exploration with O(n) agents in toroidal networks [24], and single-agent strategies with partial foresight [25]. A significant advancement in this area is the work by Gotoh et al. [23], which investigates the fundamental limits of exploration in time-varying graphs under Fsync and Ssync schedulers. In their model, the network is derived from a fixed footprint graph from which edges are deleted dynamically. Agents are able to detect missing edges indirectly when their attempted movements fail. Additionally, port numbers at nodes remain fixed throughout the computation, inherited from the footprint. In contrast, our model assumes the absence of a global footprint. More importantly, port numbers are not fixed over time, as they depend on the local degree of 𝒢r. Consequently, agent movements are always successful, and agents may be unable to detect the change of topology. These characteristics make our model weaker than the one studied in [23], as it places fewer constraints on the dynamic behaviour of the network and provides the agents with less information. In this work, we study perpetual exploration in the Connectivity Time dynamic graphs.

Recently, Saxena et al. [38] studied exploration under various connectivity models, including Connectivity Time, and showed that exploration is impossible with at most n agents (under model assumptions consistent with ours). However, their result did not yield tight bounds. In this work, we strengthen their impossibility result by proving that exploration is not solvable even with up to (n2)(n1)/2 agents, and complement this with a matching algorithmic upper bound. Our contributions are presented in the next section.

4 Our Contribution

In this work, we present the following two results:

  1. 1.

    Exploration is impossible in the Connectivity Time dynamic graphs by (n2)(n1)2 agents starting from an arbitrary initial configuration, even if agents have infinite memory, full visibility, global communication, and knowledge of all parameters (refer Theorem 4).111If exploration is impossible then so is perpetual exploration and if perpetual exploration is possible then so is exploration.

  2. 2.

    We present a perpetual exploration algorithm for the Connectivity Time dynamic graphs using (n2)(n1)2+1 agents starting from arbitrary initial configuration, where each agent has 1-hop visibility, global communication, and O(logn) memory (refer Theorem 17).

Figure 1: Initial configuration 𝒞0 of (n2)(n1)2 agents.

5 Impossibility Result

In this section, we show that exploration is impossible to solve using (n2)(n1)2 agents. Before proceeding with the construction of G=𝒢0,𝒢1,, we first outline the high-level idea behind the impossibility result.

High-level idea.

While there remains a non-empty set of unexplored nodes, the goal is to transfer agents from explored and occupied nodes to those unexplored ones. As it can be difficult to differentiate between an unexplored node with an explored but unoccupied node, the algorithm may require to transfer agents from explored and occupied nodes to explored but currently unoccupied nodes as well. If an algorithm succeeds in keeping all explored nodes occupied, then eventually, as the adversary must pick an edge across the cut, some agent will move to an unexplored node and hence the node becomes visited. However, the adversary is powerful: if b agents move from a node with x agents to a node with y<x agents according to some deterministic algorithm, making the new counts y=y+b and x=xb, the adversary can flip the roles of these two nodes in the next graph instance, effectively undoing progress as the algorithm performs the reverse operation. The proofs formalize this idea: with fewer than (n1)(n2)/2+1 agents, the adversary can always choose such a flip whereas with that many agents it cannot always do that.

Dynamic graph 𝑮.

Let 𝒏=𝟐𝒌 for some k, n4 and T2. We give an initial configuration with (n2)(n1)2 agents such that the exploration is impossible to solve. Let v1, v2, …, vn be nodes. At the beginning of round 0, consider k many one length paths as follows: P1(=v1v2), P2(=v3v4), …, Pk1(=vn3vn2) and Pk(=vn1vn). Let αr(w) represent the number of agents located at a node w at the beginning of round r, and let βr(w) represent the number of agents located at the node w at the end of round r.222The parameter βr(w) is the number of agents at node w after completing CCM cycle at round r. Let α0(vi)=ni1 for i[1,n2], and α0(vn1)=α0(vn)=0 (i.e., nodes vn1 and vn are holes). Let’s denote this configuration by 𝒞0 (refer to Fig. 1). The total number of agents is i=1nα0(vi)=i=1n2i=(n2)(n1)2. In round r0, the adversary maintains 𝒢r as follows:

Figure 2: (A) Graph 𝒢iT2, (B) Graph 𝒢iT1.
Figure 3: (A) An agent moves from node wn2 to node wn1 at round r1 in 𝒢r1, (B) 𝒢r with respect to 𝒢r1.
Figure 4: (A) An agent moves from node wn1 to node wn2 at round r1 in 𝒢r1, (B) 𝒢r with respect to 𝒢r1.
  1. (a)

    𝒓[𝟎,𝑻𝟐]: It maintains 𝒞0 in these rounds.

  2. (b)

    𝒓[𝒊𝑻𝟏,(𝒊+𝟏)𝑻𝟐], where 𝒊𝟏&𝒊(mod 𝟐)𝟎:

At round iT2, there are k many one length paths, say P1(=w1w2), P2(=w3w4), …, Pk1(=wn3wn2), Pk(=wn1wn) (we separately show that nodes wn1 and wn are holes at round iT2, with wn=vn). Note that at the end of round T2, wi=vi, for every i. We can see 𝒢iT2 in Fig. 2(A). Based on the movement of agents at round iT2, the adversary forms k paths, say P1, P2, …, Pk, at the beginning of round iT1 as follows.

If βiT2(w1)βiT2(w2), then P1=w1. Else, P1=w2. For j[2,k1], Pj is defined as follows.
Pj={w2j3w2j1, if βiT2(w2j3)<βiT2(w2j2) and βiT2(w2j1)βiT2(w2j)w2j2w2j1, if βiT2(w2j3)βiT2(w2j2) and βiT2(w2j1)βiT2(w2j)w2j3w2j, if βiT2(w2j3)<βiT2(w2j2) and βiT2(w2j1)<βiT2(w2j)w2j2w2j, if βiT2(w2j3)βiT2(w2j2) and βiT2(w2j1)<βiT2(w2j)

If βiT2(wn3)βiT2(wn2), then Pk=wn2wn1wn. Else, Pk=wn3wn1wn. We can see 𝒢iT1 in Fig. 2(B).

Without loss of generality, let P1(=w1), P2(=w2w3), …, Pk1(=wn4wn3), Pk(=wn2wn1wn). If αiT1(wn2)=0, the adversary maintains the graph 𝒢r as 𝒢iT1 for every r[iT,(i+1)T2]. If αiT1(wn2)>0, the adversary maintains the graph 𝒢r for every r[iT,(i+1)T2] as follows.

If an agent from node wn2 moves to node wn1 at round r1, then adversary at the beginning of round r maintains the following path: P1=w1, P2=w2w3,…, Pk1=wn4wn3, and Pk=wn1wn2wn (refer Fig. 3(A) at round r1, and refer Fig. 3(B) at round r). Otherwise, it maintains the graph 𝒢r as 𝒢r1.

If an agent from node wn1 moves to node wn2 at round r1, then adversary at the beginning of round r maintains the following path: P1=w1, P2=w2w3,…, Pk1=wn4wn3, and Pk=wn2wn1wn (refer Fig. 4(A) at round r1, and refer Fig. 4(B) at round r). Otherwise, it maintains the graph 𝒢r as 𝒢r1.

If i=1, then it is not difficult to observe that the number of agents at node αT1(wn2)1 as αT2(xn3)+αT2(xn2)=3. We show later for every i, αiT1(wn2)1. Thus, the way we change the graph, the agent always stays between node wn2 and wn1 and can not access node wn in round r. We denote this configuration by 𝒞123.

Figure 5: (A) Graph 𝒢iT2, (B) Graph 𝒢iT1.
  1. (c)

    𝒓[𝒊𝑻𝟏,(𝒊+𝟏)𝑻𝟐], where 𝒊𝟏&𝒊(mod 𝟐)=𝟎:

At the end of round iT2, there are k many paths, say P1(=w1), P2(=w2w3), …, Pk1(=wn4wn3), Pk=wn2wn1wn (we separately show that nodes wn1 and wn are holes at the beginning of round iT2, with wn=vn, and at most one agent occupy node wn2). We can see 𝒢iT2 in Fig. 5(A). At round iT1, the adversary forms k many one length paths, say P1, P2, …, Pk. Based on the movement of agents at round iT2, the adversary forms k paths, say P1, P2, …, Pk, at the beginning of round iT1 as follows.

If βiT2(w2)βiT2(w3), then P1=w1w2. Else, P1=w1w3. For j[2,k2], Pj is defined as follows.
Pj={w2j2w2j, if βiT2(w2j2)<βiT2(w2j1) and βiT2(w2j)βiT2(w2j+1)w2j1w2j, if βiT2(w2j2)βiT2(w2j1) and βiT2(w2j)βiT2(w2j+1)w2j2w2j+1, if βiT2(w2j2)<βiT2(w2j1) and βiT2(w2j)<βiT2(w2j+1)w2j1w2j+1, if βiT2(w2j2)βiT2(w2j1) and βiT2(w2j)<βiT2(w2j+1)

At the end of round iT2, there is at most one agent in path Pk, and this agent is either at node wn2 or wn1 (we show this separately). If there is no agent in path Pk, then Pk1 and Pk are defined as follows. If βiT2(wn4)βiT2(wn3), then Pk1=wn3wn2 and Pk=wn1wn. Else, Pk1=wn4wn2 and Pk=wn1wn. If there is one agent in path Pk, then Pk1 and Pk are defined as follows. Based on agent’s position at node wn2 or wn1 at the end of round iT2, the cases are as follows.

  • If an agent is at node wn2 at the end of round iT2, the path Pk1 and Pk are defined as follows. If βiT2(wn4)βiT2(wn3), then Pk1=wn3wn2 and Pk=wn1wn. Else, Pk1=wn4wn2 and Pk=wn1wn.

  • If an agent is at node wn1 at the end of round iT2, the path Pk1 and Pk are defined as follows. If βiT2(wn4)βiT2(wn3), then Pk1=wn3wn1 and Pk=wn2wn. Else, Pk1=wn4wn1 and Pk=wn2wn.

We can see 𝒢iT1 in Fig. 5(B). It maintains 𝒢r as 𝒢iT1 for every r[iT,(i+1)T2]. Later, we show that there is no agent in Pk, and one of the nodes in Pk is vn. We denote this configuration by 𝒞22.

Fig. 6 shows how the configuration evolves over time.

Figure 6: It shows how the agent configurations evolve periodically over the dynamic graph, with specific configurations like 𝒞0, 𝒞123, and 𝒞22 reappearing at regular intervals.
Lemma 1.

Dynamic graph G maintains the Connectivity Time property. (Proof in Appendix, see Section A.1)

We define two notations as follows.

  • (N1) 𝒓[𝒊𝑻𝟏,(𝒊+𝟏)𝑻𝟐], where 𝒊𝟏&𝒊(mod 𝟐)=𝟎 (or 𝒓[𝟎,𝑻𝟐]): In this case, either configuration 𝒞0 or 𝒞22 is true. Therefore, at round r, there are k one length paths P1, P2, …, Pk. Let Pj(=w2j1w2j), for every j[1,k]. If αr(w2j1)αr(w2j), then we denote w2j1 as w2j1r and w2j as w2jr. Otherwise, we denote w2j1 as w2jr and w2j as w2j1r.

  • (N2) 𝒓[𝒊𝑻𝟏,(𝒊+𝟏)𝑻𝟐], where 𝒊𝟏&𝒊(mod 𝟐)𝟎: In this case, configuration 𝒞123 is true. Therefore, at round r, there are k paths P1, P2, …, Pk. Let Pj(=w2j2w2j1), for every j[2,k1], P1(=w1) and Pk(=wn2wn1wn). If αr(w2j2)αr(w2j1), then we denote w2j2 as w2j2r and w2j1 as w2j1r. Otherwise, we denote w2j2 as w2j1r and w2j1 as w2j2r. We consider w1 as w1r, wn2 as wn2r, wn1 as wn1r, and wn as wnr.

Lemma 2.

The following inequality holds l[1,n2] and for every round r0.

i=1lαr(wir)i=1l(ni1)

Proof.

Proving our lemma is equivalent to showing that the following two inequalities hold for every j[1,k1] at round r:

(A) i=12jαr(wir)i=12j(ni1),(B) i=12j1αr(wir)i=12j1(ni1).

We use mathematical induction to prove inequalities (A) and (B) for every r0. Both inequalities are true for r=0 as 𝒞0 includes k paths: P1(=v1v2), P2(=v3v4), …, Pk1(=vn3vn2), and an additional path Pk(=vn1vn). We define α0(vi)=ni1 for i[1,n2], with α0(vn1)=α0(vn)=0. Therefore, wi0=vi for every in2.

Assuming the statement is true for round r0, we aim to show that it also holds for round r+1. There are five possible cases to consider: Case 1: r,r+1[0,T2], Case 2: r,r+1[iT1,(i+1)T2], where i is an odd number, Case 3: r,r+1[iT1,(i+1)T2], where i is an even number, Case 4: r=iT2, where i is odd, and Case 5: r=iT2, where i is even. Due to the length of the proof, we present only the proofs of Case 1 and Case 4 here. The proofs of Case 2 and Case 3 follow similar ideas to Case 1, and Case 5 builds upon the approach used in Case 4. The proof of Case 2, 3 and 5 is in Appendix, see Section A.2.

Case 1.

In this case, agents are in configuration 𝒞0 at round r and r+1.

Proof of (A).

Due to the induction hypothesis, the following inequality holds:

i=12jαr(wir)i=12j(ni1) (1)

Since the dynamic graph does not change between rounds 0 and T2, no matter how agents move, for every j[1,k1], we have the following:

αr(w2j1r)+αr(w2jr)=αr+1(w2j1r+1)+αr+1(w2jr+1) (2)

Therefore, the following inequality holds using Eq. (1) and Eq. (2):

i=12jαr+1(wir+1)=i=12jαr(wir)i=12j(ni1) (3)

Proof of (B).

The inequality αr(w1r)n2 holds due to the induction hypothesis, and the inequality αr(w1r)+αr(w2r)(n2)+(n3) is valid due to proof of (A). Therefore, regardless of how the agents move in round r, we have αr+1(w1r+1)n2 as αr(w1r)+αr(w2r)=αr+1(w1r+1)+αr+1(w2r+1) and αr+1(w1r+1)αr+1(w2r+1). This shows (B) holds for j=1. For j[2,k1], we use a contrapositive argument. Suppose for some smallest value j2, the inequality (B) does not hold for round r+1. Then the following inequality must be true:

i=12j1αr+1(wir+1)<i=12j1(ni1) (4)

Due to Eq. (3), we get:

i=12j2αr+1(wir+1)i=12j2(ni1) (5)

Therefore, using Eq. (4) and Eq. (5), the inequality αr+1(w2j1r+1)<n(2j1)1=n2j holds. Rewrite Eq. (3) as:

αr+1(w2jr+1)i=12j(ni1)i=12j1αr+1(wir+1) (6)

From Eq. (4) and Eq. (6), the inequality αr+1(w2jr+1)>n2j holds. Thus, due to our assumption (i.e., Eq. 4), we have αr+1(w2j1r+1)<n2j and αr+1(w2jr+1)>n2j. Therefore, we have αr+1(w2j1r+1)<αr+1(w2jr+1). This leads to a contradiction because, due to (N1), the inequality αr+1(w2j1r+1)αr+1(w2jr+1) holds. This shows that our initial assumption is incorrect. Therefore, inequality (B) holds for round r+1.

Case 4.

In this case, at round r=iT2, where i is an odd number, the configuration is either 𝒞0 or 𝒞2-2, and at round r+1, it changes to 𝒞123

Proof of (A).

Due to the induction hypothesis, the following inequality is true:

i=12jαr(wir)i=12j(ni1) (7)

The adversary constructs the dynamic graph in round r+1 based on the agents’ positions at the end of round r. Let p=max{βr(w2j1r),βr(w2jr)}. Therefore, αr+1(w2j1)=p and the value of αr+1(w2j) is as follows (recall configuration 𝒞123):

αr+1(w2jr+1)=max{αr(w2j1r)+αr(w2jr)p,max{βr(w2j+1r),βr(w2j+2r)}} (8)

The adversary forms the dynamic graph at round iT1, ensuring the following equality:

i=12j1αr+1(wir+1)=i=12j2αr(wir)+p (9)

Using Eq. (9), the following equality holds.

i=12jαr+1(wir+1)=i=12j1αr+1(wir+1)+αr+1(w2jr+1)i=12j2αr(wir)+p+αr+1(w2jr+1) (10)

Due to Eq. (8), we have αr+1(w2jr+1)αr(w2j1r)+αr(w2jr)p. Thus, using Eq. (10):

i=12jαr+1(wir+1)i=12jαr(wir) (11)

Using Eq. (7) and Eq. (11), the inequality (A) holds for round r+1.

Proof of (B).

For j=1, the inequality αr(w1r)n2 holds, and due to the proof of (A), the inequality αr(w1r)+αr(w2r)n2+n3 holds. Therefore, αr+1(w1r+1)n2 holds regardless of how agents move at round r due to the following reason. If αr+1(w1r+1)<n2, then βr(w1r)<n2 and βr(w2r)<n2 holds as per the dynamic graph construction at round iT1, αr+1(w1r+1)=max{βr(w1r),βr(w2r)}. Therefore, βr(w1r)n3 and βr(w2r)n3, and hence the inequality βr(w1r)+βr(w2r)2(n3) holds. Since βr(w1r)+βr(w2r)=αr(w1r)+αr(w2r), the inequality αr(w1r)+αr(w2r)2(n3). This leads to a contradiction as αr(w1r)+αr(w2r)n2+n3. Therefore, our assumption is wrong, and it implies αr+1(w1r+1)n2. Now we prove (B) when j2. Due to (A), the following inequalities hold for j2.

i=12j2αr(wir)i=12j2(ni1)andi=12jαr(wir)i=12j(ni1) (12)

In Eq. (9), the lower bound of p is αr(w2j1r)+αr(w2jr)2. Using Eq. (9), we have:

i=12j1αr+1(wir+1)i=12j2αr(wir)+αr(w2j1r)+αr(w2jr)2 (13)

Using Eq. (12), we have (by taking the sum of inequalities of Eq. (12)):

2(i=12j2αr(wir))+αr(w2j1r)+αr(w2jr)2(i=12j2(ni1))+(n2j)+(n2j1)
i=12j2αr(wir)+αr(w2j1r)+αr(w2jr)2i=12j2(ni1)+n2j12 (14)

Since xx for every x, the following holds:

i=12j2αr(wir)+αr(w2j1r)+αr(w2jr)2i=12j2(ni1)+n2j=i=12j1(ni1) (15)

Due to Eq. (13) and (15), inequality (B) holds for round r+1. This completes the proof.

Corollary 3.

At round iT1, αiT1(wn2iT1)1, where i is an odd number.

Proof.

Due to Lemma 2, the following two inequalities hold at round iT1.

i=12n3wiiT1i=12n3(ni1)andi=12n2wiiT1i=12n2(ni1) (16)

Therefore, due to Eq. (16), αiT1(wn2iT1)1. This completes the proof.

Theorem 4.

If the initial configuration contains at least two holes, then a group of (n2)(n1)/2 agents cannot solve the exploration problem in dynamic graphs that maintain the Connectivity Time property. This impossibility holds even if agents have infinite memory, full visibility, global communication, and know the parameters k, n(4), T(2).

Proof.

Our dynamic graph construction satisfies the Connectivity Time property as established in Lemma 1. To prove that exploration is impossible, it suffices to show that node vn remains a hole at every round r0. If r[0,T2], node vn is not accessible to the agents because node vn is in path Pk, where vn1 is a hole.

As per Corollary 3, αT1(wn2T1)1. Therefore, at the beginning of round T1, there can be at most one agent at node wn2. If there is no agent, then node vn is not accessible to the agents because node vn is in path Pk, where wn2, wn1 are holes.

If there is an agent at node wn2 at the beginning of round T1, it has the option to move to node wn1 during round r[T1,2T3]. In this scenario, the adversary constructs the following graph at round r+1 according to our dynamic graph construction method: the adversary maintains the paths P1,P2,,Pk1 unchanged and modifies Pk from wn2wn1vn to wn1wn2vn. In this manner, at round r+1, the node vn is two hops away from the agent’s position. The adversary follows the same procedure; if the agents move in later rounds from node wn1 to wn2, this ensures that during rounds r[T1,2T2], the agents consistently remain at nodes wn2 and wn1. Consequently, the agent can not reach node vn in any of these rounds.

At the beginning of round 2T1, as per our dynamic graph construction, if there was an agent in path Pk at round 2T2 (there is at most one agent due to Corollary 3), it removes such a node from Pk at the beginning of round 2T1. Therefore, as per dynamic graph construction at the beginning of round 2T1, the node vn is in path Pk=wn1wn(=vn), where node wn1 is a hole. The adversary maintains the same configuration at every round r[2T1,3T2]. Therefore, the agent can not reach node vn in any of these rounds. This idea can be extended for r3T1 using Corollary 3. It is important to note that this is independent of the agents’ power. Therefore, the proof remains valid even if the agents have full visibility, global communication, and know all parameters. This completes the proof.

6 Connectivity Time Dynamic Graph Exploration

The Connectivity Time dynamic graph has high dynamicity, and the high dynamicity may prevent even basic coordination if agents are significantly restricted in their ability to perceive their surroundings or communicate with one another. Assume agents have 1-hop visibility. Consider two paths: P=w1w2w3w4w5 and P=w5w2w3w4w1. The adversary can create either P or P, such that only at w3, the 1-hop view remains unchanged. The movement of agent(s) at w3 remains the same for both P and P irrespective of the hole position. This can cause exploration to fail. Now, assume agents have global communication but no 1-hop visibility. Then, local views at each node remain the same in the above example, making it difficult again. To address these challenges, we assume that agents are equipped with 1-hop visibility and global communication capabilities in our algorithm. Even stronger assumptions are considered in the study of 1-Interval Connected dynamic networks (e.g., in [10], [35], authors use full visibility), and are instrumental in enabling tractable algorithmic solutions under highly dynamic conditions. Since 1-Interval Connectivity is a stronger assumption than the Connectivity Time, the Connectivity Time model imposes greater difficulty. It is important to emphasize that these assumptions are not fundamental to the definition of the problem but are adopted solely to overcome the adversarial nature of the Connectivity Time model. Moreover, we complement our algorithmic results with lower bounds and impossibility results (refer to Section 5) that hold even when agents possess stronger capabilities, including full knowledge of all system parameters, full visibility, and global communication. This highlights the inherent difficulty of perpetual exploration in such settings.

High-level idea.

Suppose that at round r, agents know the map of 𝒢r. Let w be a multinode and v a hole in 𝒢r, connected via a shortest path v1v2vp, with v1=w, vp=v, and all intermediate nodes v2,,vp1 occupied by some agent. Let ai denote an agent at vi for 1ip1. In round r, each ai moves to vi+1. The multinode v1 remains non-empty, and each vi (2ip1) receives an agent from vi1 and sends one to vi+1, preserving non-hole status. Finally, the hole vp is filled. This strategy is known as pipeline strategy, which pushes an agent to the nearest hole without creating new holes and has been used in prior works (e.g.,[29]).

Figure 7: (a) Graph 𝒢r, where r(mod 3)=0, (b) Graph 𝒢r, where r(mod 3)=1, (c) Graph 𝒢r, where r(mod 3)=2. This figure is an example of the Connectivity Time for T=3.

Challenges.

A key challenge arises from the agents’ inability to reconstruct the dynamic graph due to limited knowledge of the adversary’s behavior. However, with 1-hop visibility and global communication, agents can share local views to collaboratively form a partial network snapshot. While this may not capture the full graph, it often suffices for executing the pipeline procedure.

The core difficulty lies in ensuring every node is visited at least once. Even if agents can fill holes, some nodes may remain unvisited. Under the Connectivity Time model, two nodes may never belong to the same connected component in any single round. For example, let V={v1,v2,v3,v4,v5} with T=3, where v1 is a multinode, and nodes v2,v3,v4 are not holes; node v5 is initially a hole. Define 𝒢r=(V,E(r)) as follows: if rmod3=0 or 1, let E(r)={(v1,v2),(v2,v3),(v2,v4)} (see Fig. 7(a), (b)), and if rmod3=2, let E(r)={(v1,v2),(v5,v3),(v5,v4)} (see Fig. 7(c)). Although 𝒢r,3=(V,i=rr+2E(i)) is connected for all r, no direct path exists between v1 and v5 in any single round. Thus, v1 cannot pipeline to v5, despite being a multinode. This illustrates how the adversary can isolate nodes round by round, impeding exploration. To address this, we use an enhanced pipeline. If at round r, agents detect that there exists at least one hole and at least one multinode in their connected component of 𝒢r, then the standard pipeline fills it. If not, then each node in the component has at least one agent. Let Count(v) be the number of agents at node v at round r. If two nodes v and w in the same component satisfy Count(w)Count(v)+2, agents initiate a redistribution along a shortest path v1v2vp from w to v (with v1=w, vp=v), transferring one agent via pipelining to balance the load of agents. Since the graph can be highly sparse and disconnected, enhanced pipeline gradually builds a configuration of agents on the nodes such that pipeline becomes feasible along every connected path in each round.

In the following sections, we use two parameters: 𝖢𝗈𝗎𝗇𝗍(v), which denotes the number of agents at node v, and ai.𝖨𝖣, which denotes the ID of agent ai.

6.1 Map Construction

We begin by presenting an algorithm that allows agents to construct a partial map of the network, specifically, the subgraph induced by the nodes currently occupied by agents. A similar strategy was proposed in [29]; we adapt and modify it to suit our setting and terminology. This serves as a subroutine in our exploration algorithm.

At round r, since 𝒢r may be disconnected, it consists of p connected components, denoted G1,G2,,Gp, where each Gi=(Vi,Ei) with ViV and EiE(r). For each connected component Gi, we further divide it into several subgraphs considering nodes that contains agent(s). In this context, we define:

Definition 5 (Connected component of Gi without holes).

The component Gi can be partitioned into subgraphs Gi1,Gi2,,Gik, where each Gij=(Vij,Eij) satisfies the following:

  • Every node vVij have at least one agent, for all j[1,k].

  • The sets of nodes and edges are pairwise disjoint, i.e., VijVil= and EijEil= for all jl, where j,l[1,k].

  • There exists no edge e=(u,v)Ei such that uVij and vVil, where jl, i.e., the subgraphs are disconnected from each other within Gi.

We refer to the collection of subgraphs Gij as the connected component of Gi without holes, and denote by AC(Gi).

In other words, AC(Gi) denotes the collection of connected components obtained by removing all holes and their associated edges from Gi. Recall that agents use global communication, but communication is limited within each connected component. That is, agents located in Gi cannot communicate with agents in Gj for ij, as communication happens through the graph links. An agent aj in component Gi performs the following steps at round r to compute AC(Gi). The algorithm is divided into two phases as described below.

Phase 1.

(1-hop view collection) Let aj be the agent with the minimum ID located at a node vGi. The agent aj performs the following for each port p{0,1,,degr(v)1}:

  • Let u be the neighbor of v reachable via port p. Set IDv=aj.𝖨𝖣.

  • If at least one agent is present at u: define Cvp=(Count(v),IDv,p,IDu), where IDu is the minimum ID among the agents at node u.

  • If no agent is present at u (i.e., it is a hole): define Cvp=(𝖢𝗈𝗎𝗇𝗍(v),IDv,p,), where denotes a hole via port p.

Let Cv={Cv0,Cv1,,Cvd} denote the 1-hop view at node v, where d=degr(v)1. The agent aj broadcasts Cv to all agents in Gi using global communication.

Phase 2.

(Graph Reconstruction) After receiving all 1-hop views from agents in Gi, agent aj proceeds as follows:

  • Define V={IDvCv}, where each unique ID represents a node.

  • Construct the edge set E as follows: for each pair of tuples (𝖢𝗈𝗎𝗇𝗍(v),IDv,p,IDu) and (𝖢𝗈𝗎𝗇𝗍(u),IDu,q,IDv), where IDu and IDv, add an undirected edge (IDv,IDu) with port labels π(IDv,IDu)=p and π(IDu,IDv)=q, where π(v1,v2) denotes the outgoing port from node v1 to v2.

  • For each tuple (𝖢𝗈𝗎𝗇𝗍(v),IDv,p,), mark port p at node IDv as leading to a hole.333This step does not introduce any new holes or edges leading to holes during Phase 2; it only marks the port(s) at node v that lead to a hole.

We denote this algorithm as MAP(). The correctness of MAP() is as follows. We show that at round r, if agent ai is in connected component Gi of 𝒢r, then it constructs AC(Gi) by using MAP(). Let Gi be the map constructed by agent ai using MAP().

Theorem 6.

Let agent ai be located at some node in the connected component Gi. Then, using the subroutine MAP(), agent ai constructs AC(Gi). (Proof in Appendix, see Section A.3)

From Theorem 6 and Definition 5, we derive three key observations.

Observation 7.

Using MAP(), the agents in Gi construct AC(Gi), including information of the number of agents at each node v and the ports from node v (if any) that lead to a hole.

Observation 8.

Since all agents within the same connected component exchange information via global communication, the output of MAP() is identical for every agent in that component.

Observation 9.

If there is no hole in Gi, then AC(Gi) is the same as Gi, as per Def. 5.

6.2 Perpetual Exploration Algorithm

In this section, we present the algorithm EXP_ALGO(), which solves perpetual exploration when agents are equipped with 1-hop visibility and global communication. The following is a detailed description of the algorithm for agent ai at node v during round r: if node v is a multinode and agent ai is not the minimum ID agent, then it stays at node v. If agent ai is the minimum ID agent at node v, it follows the following steps at round r.

  • Agent ai broadcasts Cv.

  • After receiving all Cus, agent ai use MAP() algorithm. Let’s call this constructed graph G. Using Theorem 6, the graph G is nothing but a collection of partitioned subgraphs Gj1,Gj2,,Gjk of Gj, where Gj is the connected component for which ai is a part. The following four cases may arise in the constructed map G, and in each case, agent ai makes a corresponding decision.

    Case 1 (there is no multinode and no information of a port towards a hole):

    Agent ai stays at node v.

    Case 2 (there is no multinode, but there is information of a port leading to a hole):

    Assume there are k nodes, each with an agent that has a port leading to a hole. Let b1, b2, …, bk be agents at node u1, u2, …, uk, respectively in G, where one of the ports of uj leads to a hole for every j[1,k]. If ai.ID=min{bj.ID:j[1,k]}, then it moves to the node which leads to the hole via the minimum port. Otherwise, it stays at its position.

    Case 3 (both a multinode and information of a port towards a hole are present):

    Suppose there are k multinodes in G. Let b1, b2, …, bk be agents at node u1, u2, …, uk, respectively in G where each node ui is a multinode in G. Without loss of generality, let b1.ID=min{bj.ID:j[1,k]}. Without loss of generality, let b1 be in Gj1. One of the nodes in Gj1 leads to a hole as there is a hole in Gj, and using Definition 5. Assume there are k nodes in Gj1, each with an agent that has a port leading to a hole. Let a¯1, a¯2, …, a¯k be agents at node u¯1, u¯2, …, u¯k, respectively in Gj1 such that one of the ports lead to a hole from node uj, for every j[1,k]. Without loss of generality, let a¯1.ID=min{a¯j.ID:j[1,k]}.

    Since, agent ai is aware of G, it consider a shortest path P between u1 and u¯1. If there are multiple shortest paths between u1 and u¯1, then it selects the one that is lexicographically shortest among all other shortest paths. Let P=w1(=u1)w2wy(=u¯1). If agent ai is at some node wj, for 1j<y, then it moves to node wj+1. Else if agent ai is at node wy, then it moves to the node via the minimum available port, which leads to a hole. Otherwise, it stays at node v.

    Case 4 (there is a multinode but there is no information of a port towards a hole):

    Assume there are k nodes in G. Due to Observation 8, the graph G is the graph G1. Define: i=max{𝖢𝗈𝗎𝗇𝗍(x):xV1}, and j=min{𝖢𝗈𝗎𝗇𝗍(x):xV1}, where V1 is the set of nodes in G1. Let v1,v2,,vp be the nodes in G1 such that 𝖢𝗈𝗎𝗇𝗍(vk)=i for each k[1,p], and let a¯k denote the minimum ID agent at node vk. Similarly, let w1,w2,,wq be the nodes in G1 such that 𝖢𝗈𝗎𝗇𝗍(wk)=j for each k[1,q], and let b¯k denote the minimum ID agent at node wk. Without loss of generality, let a¯1 be the agent among {a¯k:k[1,p]} with the minimum ID, and b¯1 be the agent among {b¯k:k[1,q]} with the minimum ID. If 𝖢𝗈𝗎𝗇𝗍(v1)<𝖢𝗈𝗎𝗇𝗍(w1)+2, agent ai stays at node v. Otherwise (i.e.,𝖢𝗈𝗎𝗇𝗍(v1)𝖢𝗈𝗎𝗇𝗍(w1)+2), agent ai find a shortest path P between v1 and w1. If there are multiple shortest paths between v1 and w1, then it selects the one that is lexicographically shortest. Let P=z1(=v1)z2zy(=w1). If agent ai is at some node zj, for 1j<y, then it moves to node wj+1. Else, it stays at v.

In the next section, we show the correctness of our algorithm.

6.3 Correctness and Analysis of the Algorithm

Before proving correctness, we introduce the following notation. Let n be the number of nodes, and define l=(n2)(n1)2+1. For each i[0,l], let Si:={vV:𝖢𝗈𝗎𝗇𝗍(v)=i}. Let L denote the largest integer such that SL at round 0.

Lemma 10.

Let 𝒢r be the configuration at round r. If there exists at least one hole and at least one multinode in the same connected component of 𝒢r, then the total number of holes in 𝒢r decreases by at least one at the end of round r. (Proof in Appendix, see Section A.4)

Lemma 11.

Let 𝒢r be the configuration at round r, and suppose that there exists a connected component G1 of 𝒢r such that G1 contains at least one multinode but no hole. Define i=max{𝖢𝗈𝗎𝗇𝗍(x):xV1}andj=min{𝖢𝗈𝗎𝗇𝗍(x):xV1)}, where V1 is the set of nodes in G1. If ij+2, then at the end of round r, one of the nodes vV(G1) with 𝖢𝗈𝗎𝗇𝗍(v)=i reduces its 𝖢𝗈𝗎𝗇𝗍 by 1, and one of the nodes wV(G1) with 𝖢𝗈𝗎𝗇𝗍(w)=j increases its 𝖢𝗈𝗎𝗇𝗍 by 1. (Proof in Appendix, see Section A.5)

 Remark 12.

Based on Lemma 11, we observe that one agent reaches a node w1Sj at round r. As a result, 𝖢𝗈𝗎𝗇𝗍(w1) becomes j+1 at the beginning of round r+1, implying that w1Sj+1. Whenever at round r, a node becomes a part of Sp, i.e., at round r1, it was not a part of Sp, we call this event join. Whenever at round r, a node does not remain a part of Sp, i.e., at round r1, it was a part of Sp but it is not part of Sp at round r, we call this event leave.

We have an observation based on EXP_ALGO(), which is as follows.

Observation 13.

A node v with 𝖢𝗈𝗎𝗇𝗍(v)1 at round r can become a hole by the end of round r only if 𝖢𝗈𝗎𝗇𝗍(v)=1 and v belongs to a connected component of 𝒢r that contains a hole but no multinode.

We now show that perpetual exploration is achieved using l agents.

Lemma 14.

If |S0|=1 at some round r, then node vS0 is visited by some agent within the next T rounds. (Proof in Appendix, see Section A.6)

Lemma 15.

If |S0|2, then i,j(i)[1,l] such that Si, Sj, ji+2 and Sk= for all i<k<j. (Proof in Appendix, see Section A.7)

Lemma 16.

If initially |S0|2, then within O(n4T) round |S0|1.

Proof.

At round 0, there are two possible cases: Case 1: |S1|=0, or Case 2: |S1|1.

Case 1.

To maintain the Connectivity Time, some node from S0 must be in the same connected component as a node from Si, i2, within the first T rounds. By Lemma 10, this causes |S0| to decrease by at least one in the next T rounds. If |S1|=0 throughout [0,nT], then S0 eventually becomes empty. Otherwise, if |S1|1 at some round r[0,nT], we are in Case 2.

Case 2.

Suppose that at round r0, |S1|1. To show that |S0|1, we proceed by contrapositive argument. Assume that |S0|2 throughout the interval [r,r+(n4+1)T]. Then, by Lemma 15, there exist indices i and j with ji+2 such that Si, Sj, and Sk= for all k[i+1,j1].

According to Remark 12, nodes may join or leave the set Sp at each time step. A key question is: how many times can nodes join the set Sp? By Lemma 11, a node can join Sp at round tr only if at least one node from Sq (with qp+1) and one node from Sp1 belong to the same connected component G1 of 𝒢t, and no node from Sp for p<p1 is in G1. We have l many agents. Then in the worst case, nodes can join the set Sp at most l times, as each time one agent can move from Sq to Sp1. If at most l times nodes joins set Sp, the size of Sq decreases due to Lemma 11, eventually making Sq= for every q>p.

As there are L such sets with Ll, the total number of join events between rounds r and r+(n4+1)T can not be more than l2n4. Now divide the interval [r,r+(n4+1)T] into n4+1 consecutive sub-intervals of length T: each sub-interval is of the form [r+kT,r+(k+1)T1] for k=0,1,,n4+1. If at least one node leaves some set Sj during each sub-interval, then there are n4+1 such leave events in total. Since each leave corresponds to a join, this implies there are also n4+1 join events. But this contradicts our earlier conclusion that there can be at most n4 join events. By the pigeonhole principle, this contradiction implies that our assumption is false. Therefore, within O(n4T) rounds, we must have |S0|1.

Since Case 2 is reached within O(nT) rounds from any initial configuration, |S0|1 holds within O(n4T) rounds overall. This completes the proof.

Theorem 17.

EXP_ALGO() solves perpetual exploration in Connectivity Time dynamic graphs using (n2)(n1)2+1 synchronous agents equipped with 1-hop visibility, global communication, and O(logn) bits of memory. The agents have no knowledge of n, T, l.

Proof.

If |S0|2 initially, then by Lemma 16, |S0|1 within O(n4T) rounds. Suppose that at some round r0, |S0|1. If S0=, then all nodes are occupied, and by Observation 13, no node becomes a hole in future rounds. Thus, perpetual exploration is achieved.

If S0={v}, then by Lemma 14, node v is visited within the next T rounds. Thus, all nodes are visited by some agent within O(n4T) rounds, and the invariant |S0|1 is preserved thereafter. This process repeats indefinitely, ensuring perpetual exploration.

Each agent requires O(logn) bits to distinguish itself. Since the computation is round-local (i.e., agents do not retain information from previous rounds), O(logn) bits of memory are sufficient. This completes the proof.

 Remark 18.

Lemma 16 shows that at least n1 nodes are occupied in the first O(n4T) rounds. Theorem 17 ensures that from this point onward, at most one hole exists and, by Lemma 14, it is revisited within eachT rounds. Therefore, this also implies that each node of the network is visited by some agent in the first O(n4T) rounds.

7 Conclusion and Future Work

In this work, we have shown that exploration is impossible in Connectivity Time dynamic graphs by (n2)(n1)2 agents starting from an arbitrary initial configuration, even if agents have infinite memory, full visibility, global communication, and knowledge of all parameters. We then presented an algorithm that solves perpetual exploration using one extra agent with only 1-hop visibility, global communication, and O(logn) memory. One can study whether this extra agent helps to reduce the assumptions of 1-hop visibility and/or global communication which we require for exploration.

References

  • [1] A. Agarwalla, J. Augustine, W. K. Moses, S. K. Madhav, and A. K. Sridhar. Deterministic dispersion of mobile robots in dynamic rings. In ICDCN, pages 1–4, 2018.
  • [2] S. Albers and M. Henzinger. Exploring unknown environments. SIAM Journal on Computing, 29(4):1164–1188, 2000. doi:10.1137/S009753979732428X.
  • [3] Chen Avin, Michal Kouckỳ, and Zvi Lotker. How to explore a fast-changing world (cover time of a simple random walk on evolving graphs). In ICALP 2008, pages 121–132, 2008.
  • [4] Marjorie Bournat, Ajoy K Datta, and Swan Dubois. Self-stabilizing robots in highly dynamic environments. In SSS 2016, pages 54–69, 2016. doi:10.1007/978-3-319-49259-9_5.
  • [5] Marjorie Bournat, Swan Dubois, and Franck Petit. Computability of perpetual exploration in highly dynamic rings. In ICDCS 2017, pages 794–804, 2017. doi:10.1109/ICDCS.2017.80.
  • [6] J. Chalopin, P. Flocchini, B. Mans, and N. Santoro. Network exploration by silent and oblivious robots. In WG, pages 208–219, 2010.
  • [7] R. Cohen, P. Fraigniaud, D. Ilcinkas, A. Korman, and D. Peleg. Label-guided graph exploration by a finite automaton. ACM Transactions on Algorithms, 4(4):1–18, 2008. doi:10.1145/1383369.1383373.
  • [8] S. Das, D. Dereniowski, and C. Karousatou. Collaborative exploration of trees by energy-constrained mobile robots. Theor. Comp. Sys., 62(5):1223–1240, July 2018. doi:10.1007/S00224-017-9816-3.
  • [9] Shantanu Das. Graph Explorations with Mobile Agents, pages 403–422. Springer International Publishing, 2019. doi:10.1007/978-3-030-11072-7_16.
  • [10] Shantanu Das, Nikos Giachoudis, Flaminia L. Luccio, and Euripides Markou. Broadcasting with Mobile Agents in Dynamic Networks. In OPODIS 2020, pages 24:1–24:16, 2021.
  • [11] X. Deng and C.H. Papadimitriou. Exploring an unknown graph. Journal of Graph Theory, 32(3):265–297, 1999. doi:10.1002/(SICI)1097-0118(199911)32:3\%3C265::AID-JGT6\%3E3.0.CO;2-8.
  • [12] G Di Luna, Stefan Dobrev, Paola Flocchini, and Nicola Santoro. Distributed exploration of dynamic rings. Distributed Computing, 33:41–67, 2020. doi:10.1007/S00446-018-0339-1.
  • [13] Y. Dieudonné and A. Pelc. Deterministic network exploration by anonymous silent agents with local traffic reports. ACM Transactions on Algorithms, 11(2):1–29, 2014. doi:10.1145/2594581.
  • [14] S. Dobrev, L. Narayanan, J. Opatrny, and D. Pankratov. Exploration of high-dimensional grids by finite automata. In ICALP, pages 1–16, 2019.
  • [15] Thomas Erlebach, Michael Hoffmann, and Frank Kammer. On temporal graph exploration. Journal of Computer and System Sciences, 119:1–18, 2021. doi:10.1016/J.JCSS.2021.01.005.
  • [16] Thomas Erlebach, Frank Kammer, Kelin Luo, Andrej Sajenko, and Jakob T Spooner. Two moves per time step make a difference. In ICALP 2019, page 141, 2019.
  • [17] Thomas Erlebach and Jakob T Spooner. Faster exploration of degree-bounded temporal graphs. In MFCS 2018), pages 36:1–36:13, 2018. doi:10.4230/LIPICS.MFCS.2018.36.
  • [18] Paola Flocchini, Matthew Kellett, Peter C Mason, and Nicola Santoro. Searching for black holes in subways. Theory of Computing Systems, 50:158–184, 2012. doi:10.1007/S00224-011-9341-8.
  • [19] Paola Flocchini, Bernard Mans, and Nicola Santoro. On the exploration of time-varying networks. Theoretical Computer Science, 469:53–68, 2013. doi:10.1016/J.TCS.2012.10.029.
  • [20] P. Fraigniaud, L. Gasieniec, D. R. Kowalski, and A. Pelc. Collective tree exploration. Networks, 48(3):166–177, 2006. doi:10.1002/NET.20127.
  • [21] P. Fraigniaud, D. Ilcinkas, G. Peer, A. Pelc, and D. Peleg. Graph exploration by a finite automaton. Theoretical Computer Science, 345(2–3):331–344, 2005. doi:10.1016/J.TCS.2005.07.014.
  • [22] P. Fraigniaud, D. Ilcinkas, and A. Pelc. Impact of memory size on graph exploration capability. Discrete Applied Mathematics, 156(12):2310–2319, 2008. doi:10.1016/J.DAM.2007.11.001.
  • [23] Tsuyoshi Gotoh, Paola Flocchini, Toshimitsu Masuzawa, and Nicola Santoro. Exploration of dynamic networks: Tight bounds on the number of agents. Journal of Computer and System Sciences, 122:1–18, 2021. doi:10.1016/J.JCSS.2021.04.003.
  • [24] Tsuyoshi Gotoh, Yuichi Sudo, Fukuhito Ooshita, Hirotsugu Kakugawa, and Toshimitsu Masuzawa. Group exploration of dynamic tori. In ICDCS 2018, pages 775–785, 2018. doi:10.1109/ICDCS.2018.00080.
  • [25] Tsuyoshi Gotoh, Yuichi Sudo, Fukuhito Ooshita, and Toshimitsu Masuzawa. Exploration of dynamic ring networks by a single agent with the h-hops and s-time steps view. In SSS 2019, pages 165–177, 2019. doi:10.1007/978-3-030-34992-9_14.
  • [26] David Ilcinkas, Ralf Klasing, and Ahmed Mouhamadou Wade. Exploration of constantly connected dynamic graphs based on cactuses. In SIROCCO, pages 250–262, 2014. doi:10.1007/978-3-319-09620-9_20.
  • [27] David Ilcinkas and Ahmed M Wade. Exploration of the t-interval-connected dynamic graphs: the case of the ring. Theory of Computing Systems, 62:1144–1160, 2018. doi:10.1007/S00224-017-9796-3.
  • [28] David Ilcinkas and Ahmed Mouhamadou Wade. On the power of waiting when exploring public transportation systems. In OPODIS 2011, pages 451–464, 2011. doi:10.1007/978-3-642-25873-2_31.
  • [29] Ajay D. Kshemkalyani and Faizan Ali. Efficient dispersion of mobile robots on graphs. In Proceedings of the 20th International Conference on Distributed Computing and Networking, ICDCN ’19, page 218–227, New York, NY, USA, 2019. Association for Computing Machinery. doi:10.1145/3288599.3288610.
  • [30] Ajay D. Kshemkalyani, Anisur Rahaman Molla, and Gokarna Sharma. Dispersion of mobile robots in the global communication model. In Proceedings of the 21st International Conference on Distributed Computing and Networking, ICDCN ’20, New York, NY, USA, 2020. Association for Computing Machinery. doi:10.1145/3369740.3369775.
  • [31] Ajay D. Kshemkalyani, Anisur Rahaman Molla, and Gokarna Sharma. Dispersion of mobile robots on grids. In WALCOM: Algorithms and Computation: 14th International Conference, WALCOM 2020, Singapore, Singapore, March 31 – April 2, 2020, Proceedings, page 183–197, Berlin, Heidelberg, 2020. Springer-Verlag. doi:10.1007/978-3-030-39881-1_16.
  • [32] F. Kuhn, N. Lynch, and R. Oshman. Distributed computation in dynamic networks. In STOC, pages 513–522, New York, NY, USA, 2010.
  • [33] O. Michail, I. Chatzigiannakis, and P. G. Spirakis. Causality, influence, and computation in possibly disconnected synchronous dynamic networks. Journal of Parallel and Distributed Computing, 74(1):2016–2026, 2014. doi:10.1016/J.JPDC.2013.07.007.
  • [34] A. Miller and U. Saha. Fast byzantine gathering with visibility in graphs. In Algorithms for Sensor Systems, pages 140–153, 2020.
  • [35] William K. Moses Jr., Amanda Redlich, and Frederick Stock. Brief Announcement: Broadcast via Mobile Agents in a Dynamic Network: Interplay of Graph Properties & Agents. In SAND 2025, pages 17:1–17:5, 2025. doi:10.4230/LIPICS.SAND.2025.17.
  • [36] C. Ortolf and C. Schindelhauer. Online multi-robot exploration of grid graphs with rectangular obstacles. In SPAA 2012, pages 27–36, New York, NY, USA, 2012.
  • [37] P. Panaite and A. Pelc. Exploring unknown undirected graphs. Journal of Algorithms, 33:281–295, 1999. doi:10.1006/JAGM.1999.1043.
  • [38] Ashish Saxena and Kaushik Mondal. Path connected dynamic graphs with a study of dispersion and exploration. Theoretical Computer Science, 1050:115390, 2025. doi:10.1016/J.TCS.2025.115390.
  • [39] Claude E Shannon. Presentation of a maze-solving machine. Claude Elwood Shannon Collected Papers, pages 681–687, 1993.

Appendix A Appendix

A.1 Proof of Lemma 1

Proof.

For r0, let 𝒢r, 𝒢r+1, …, 𝒢r+T1 be consecutive T sequence of graphs, where 𝒢i=(V,E(i)) for i[r,r+T1]. Suppose the above dynamic graph G does not satisfy the Connectivity Time property for some round r, i.e., Gr,T:=(V,rr+T1E(i)) is not connected. It is important to note that there exists a round r between r and r+T1 such that r=iT1, for some i.

If i is odd, then in each round t[r,iT2], there are k one length paths in 𝒢t: P1(=w1w2), P2(=w3w4), …, Pk1(=wn3wn2) and Pk(=wn1wn). As per the dynamic graph construction at round iT1, the adversary changes paths as follows: P1(=w1), P2(=w2w3), …, Pk1(=wn4wn3) and Pk(=wn2wn1wn), where w2j1{w2j1,w2j} and w2j={w2j1,w2j}{w2j1}, for every j[1,k]. Taking the union of the edges from 𝒢i for rir+T1 creates a path of length n.

Similarly, if i is even, then in each round t[r,iT2], there are k paths in 𝒢t: P1(=w1), P2(=w2w3), …, Pk1(=wn4wn3), and Pk(=wn2wn1wn). By using a similar argument, we can show that the way we modify the construction at round iT1 results in the union of edges from 𝒢i for rir+T1, which forms a path of length n.

This shows our assumption is wrong. Therefore, this dynamic setting satisfies the Connectivity Time property.

A.2 Proof of Lemma 2 (Remaining Cases)

Proof.

The proof for Cases 2, 3, and 5 is as follows.

Case 2.

In this case, round r,r+1[iT1,(i+1)T2], where i is an odd number, and agents are in configuration 𝒞123. The proof of Eq. (A) and Eq. (B) for round r+1 is as follows.

Proof of (B).

Due to the induction hypothesis, the following inequality holds for j1:

i=12j1αr(wir)i=12j1(ni1) (1)

Since the dynamic graph does not change for every round r[iT1,(i+1)T2], no matter how agents move, for every j[1,k2], we have the following

αr(w2jr)+αr(w2j+1r)=αr+1(w2jr+1)+αr+1(w2j+1r+1) (2)

Therefore, inequality (B) holds for round r + 1 using Eq. (1) and Eq. (2).

Proof of (A).

We use a contrapositive argument. Suppose for some smallest value j1, the inequality does not hold. Then the following inequality must be true:

i=12jαr+1(wir+1)<i=12j(ni1) (3)

Due to proof of (B), we have:

i=12j1αr+1(wir+1)i=12j1(ni1) (4)

Therefore, using Eq. (3) and Eq. (4), the inequality αr+1(w2jr+1)<n2j1αr+1(w2j1r+1)n2j2 holds. Due to proof of (B), we have:

i=12j+1αr+1(wir+1)i=12j+1(ni1) (5)

We now rewrite Eq. (5) as:

αr+1(w2j+1r+1)i=12j+1(ni1)i=12jαr+1(wir+1) (6)

From Eq. (3) and Eq. (6), the inequality αr+1(w2j+1r+1)>n2j2 holds. Therefore, due to our assumption (i.e., Eq. (3)), we have αr+1(w2j1r+1)n2j2 and αr+1(w2j+1r+1)>n2j2. This leads to a contradiction because, due to (N2), the inequality αr+1(w2jr+1)αr+1(w2j+1r+1) holds. This shows that our initial assumption is incorrect. Therefore, inequality (A) holds for round r + 1.

Case 3.

In this case, round r,r+1[iT1,(i+1)T2], where i is an even number. The proof is similar to Case 1.

Case 5.

In this scenario, let r=iT2, where i is an even integer. At round r, the configuration is 𝒞123. As per (N2), there are k paths: P1(=w1r), P2(=w2rw3r), …, Pk1(=wn4rwn3r), and Pk(=wn2rwn1rwnr). At round r+1 as per (N1), there are k paths: P1(=w1r+1w2r+1), P2(=w3r+1w4r+1), …, Pk1(=wn3r+1wn2r+1), and Pk(=wn1r+1wnr+1). It holds that αr(w2j1r+1)αr(w2jr+1) for every j[1,k1].

Proof of (B).

Due to the induction hypothesis, the following inequality is true:

i=12j1αr(wir)i=12j1(ni1) (7)

Since αr+1(w1r)=max{αr(w1r),max{βr(w2r),βr(w3r)}}, αr+1(w1r)αr(w1r)n2. Therefore, for j=1, the inequality (A) holds at round r+1. For j2, the inequality (A) holds at round r+1 for the following reason. Let p=max{βr(w2j2r),βr(w2j1r)} for j2. Therefore, the value of αr+1(w2j1) is as follows.

αr+1(w2j1r+1)=max{αr(w2j2r)+αr(w2j1r)p,max{βr(w2jr),βr(w2j+1r}} (8)

The adversary forms the dynamic graph at round iT1, ensuring the following equality is true.

i=12j2αr+1(wir+1)=i=12j3αr(wir)+p (9)

Using Eq. (9), the following equality holds.

i=12j1αr+1(wir+1)=i=12j2αr+1(wir+1)+αr+1(w2j1r+1)i=12j3αr(wir)+p+αr+1(w2j1r+1) (10)

Due to Eq. (8), αr+1(w2j1r+1)αr(w2j2r)+αr(w2j1r)p. Therefore, we have the following from Eq. (10).
i=12j1αr+1(wir+1)i=12j3αr(wir)+p+αr+1(w2j1r+1)i=12j3αr(wir)+p+αr(w2j2r)+αr(w2j1r)p

i=12j1αr+1(wir+1)i=12j1αr(wir) (11)

Using Eq. (7) and Eq. (11), the inequality (B) holds at round r+1.

Proof of (A).

Due to the proof of (B), the following inequalities are true for any j1.

i=12j1αr(wir)i=12j1(ni1) (12)
i=12j+1αr(wir)i=12j+1(ni1) (13)

Due to Eq. (9), the following inequality is true for j1.

i=12jαr+1(wir+1)=i=12j1αr(wir)+p (14)

The lower bound of p is αr(w2jr)+αr(w2j+1r)2. Therefore, we get the following inequality from Eq. (14).

i=12jαr+1(wir+1)i=12j1αr(wir)+αr(w2jr)+αr(w2j+1r)2 (15)

Using Eq. (12) and Eq. (13), we get the following inequality (by taking the sum of Eq. (12) and Eq. (13)):

2(i=12j1αr(wir))+αr(w2jr)+αr(w2j+1r)2(i=12j1(ni1))+(n2j2)+(n2j1)
i=12j1αr(wir)+αr(w2jr)+αr(w2j+1r)2i=12j1(ni1)+2n4j32
i=12j1αr(wir)+αr(w2jr)+αr(w2j+1r)2i=12j1(ni1)+n2j112 (16)

We know that the following inequality is true.

i=12j1αr(wir)+αr(w2jr)+αr(w2j+1r)2i=12j1αr(wir)+αr(w2jr)+αr(w2j+1r)2 (17)

Due to Eq. (16) and Eq. (17), the following holds.

i=12j1αr(wir)+αr(w2jr)+αr(w2j+1r)2i=12j1(ni1)+n2j1=i=12j(ni1) (18)

Due to Eq. (15) and Eq. (18), the following holds.

i=12jαr+1(wir+1)i=12j(ni1)

This completes the proof.

A.3 Proof of Theorem 6

Proof.

Let edge (u,v) be in graph Gij, for some j, which is a subgraph of Gi, and π(u,v)=p, π(v,u)=q. Since (u,v)Eij, there is at least one agent at each node u and v using Definition 5. Let agent a be the minimum ID agent at node u, and agent b the minimum ID agent at node v. Since node u and v are in the same connected component, agent a gets information of Cv, and agent b gets information of Cu. Since q is an outgoing port of node v, agent a gets information about Cvq. And since p is an outgoing port of node u, agent b gets information about Cup, Cvq=(Count(v),b.ID,q,a.ID) and Cup=(Count(u),a.ID,p,b.ID). As per MAP(), agent a add edge (a.ID,b.ID), where a.ID and b.ID are two nodes in Gi, and π(a.ID,b.ID)=p, and π(b.ID,a.ID)=q. Therefore, Gi=AC(Gi). This completes the proof.

A.4 Proof of Lemma 10

Proof.

Let G1,G2,,Gk be the connected components of 𝒢r. Without loss of generality, suppose G1 contains at least one hole and at least one multinode. By Theorem 6 and Observation 8, all agents in G1 possess a common map of the anonymous copy AC(G1), denoted by G={G11,G12,,G1m}. Suppose there are k multinodes in G, located at nodes u1,u2,,uk, with the minimum ID agents b1,b2,,bk occupying them. Without loss of generality, let b1 be the agent with the minimum ID among them, i.e., b1.ID=min{bi.ID:i[1,k]}, and assume b1 resides in G11.

Since G1 contains at least one hole, there exists at least one node in G11 from which a port leads to a hole. Let there be k′′ such nodes, denoted u¯1,u¯2,,u¯k′′, with corresponding minimum-ID agents a¯1,a¯2,,a¯k′′ occupying them. Let a¯1 be the agent with the minimum ID among them, i.e., a¯1.ID=min{a¯j.ID:j[1,k′′]}. Since all agents in G1 share the same map G, they identify the same pair of nodes: u1 (a multinode) and u¯1 (adjacent to a hole). Let P=(v1=u1v2vy=u¯1) denote the lexicographically shortest path from u1 to u¯1 in G. This path is unique due to the deterministic selection criteria based on IDs and shared knowledge of G.

Each agent on this path identifies its current position and acts accordingly: if an agent is at node vi for i<y, it moves to vi+1. The agent at vy=u¯1 selects the minimum available port that leads to a hole and moves through it. Thus, a hole gets filled without creating a new hole elsewhere. Therefore, the total number of holes in 𝒢r decreases by at least one at the end of round r. This completes the proof.

A.5 Proof of Lemma 11

Proof.

Let G1,G2,,Gk be the connected components of 𝒢r. Without loss of generality, let G1 be the connected component that contains at least one multinode but no hole. Since G1 contains a multinode but no hole, by Theorem 6 and Observation 9, every agent in G1 constructs the map of G1 using the procedure MAP(). Let v1,v2,,vp be the nodes in G1 such that 𝖢𝗈𝗎𝗇𝗍(vk)=i for each k[1,p], and let ak denote the minimum ID agent at node vk. Similarly, let w1,w2,,wq be the nodes such that 𝖢𝗈𝗎𝗇𝗍(wk)=j for each k[1,q], and let bk denote the minimum ID agent at node wk. Without loss of generality, let a1 be the agent among {ak:k[1,p]} with the minimum ID, and b1 be the agent among {bk:k[1,q]} with the minimum ID. Since all agents share the same reconstructed map G1, they all identify the same pair of nodes v1 and w1 as the nodes with maximum and minimum 𝖢𝗈𝗎𝗇𝗍 values, respectively. Let P=(v1=u1u2uy=w1) be the lexicographically shortest path from v1 to w1 in G1, which is uniquely determined by the map and agent ID choices. Each agent on this path identifies its position and moves accordingly: if an agent is at node ui for i<y, it moves to ui+1. As a result, the value of 𝖢𝗈𝗎𝗇𝗍(v1) decreases by 1, and the value of 𝖢𝗈𝗎𝗇𝗍(w1) increases by 1. This completes the proof.

A.6 Proof of Lemma 14

Proof.

To maintain the Connectivity Time property, node v must be connected to some node w at round t, where t[r,r+T]. Let G1 be the connected component of 𝒢t at round t such that the node v is part of the graph G1. If G1 has at least one multinode, then one agent moves to node v as agents in G1 execute EXP_ALGO() due to Lemma 10.

Otherwise, all nodes in G1 except node v contain exactly one agent. At round t, let w1, w2, …, wp be neighbours of node v in G1, and agent ai be at node wi. As per EXP_ALGO(), the minimum ID agent ID among ais moves to node v. This completes the proof.

A.7 Proof of Lemma 15

Proof.

Suppose the lemma does not hold. It implies |Si|1 for every i[1,L], where L is the largest index satisfying SL. The value L is n2. Assume L>n2. Without loss of generality, let L=n1. Since |Si|1 for every i[1,L], i=1L|Si|n1. Therefore, the total number of nodes is |S0|+i=1L|Si|2+n1=n+1 as |S0|2 and i=1L|Si|n1. This leads to the contradiction as n many nodes are present. Therefore, Ln2.

Since |Si|1 for every i[1,L], Li=1L|Si|n2. Therefore, Ln2. Define X=i=1Li|Si|. The value X denotes the total number of agents when 𝒞 is false. The maximum value of X occurs when |Si|=1 for 1iL1, and |SL|=n|S0|(L1)nL1 as |S0|2. Thus, X1+2++(L1)+L(nL1)=L(L1)/2+L(nL1). After simplifying, we get that XL(2nL3)/2(n2)(n1)/2. This leads to the contradiction as the number of agents in the system is (n2)(n1)2+1. Thus, our initial assumption must be incorrect. This completes the proof.