Vertex Traversal Rendezvous (VTR)

• Vertex Traversal Rendezvous (VTR) is a set of distributed coordination tasks where mobile agents converge on specified vertices in graphs or geometric networks.
• Strong rendezvous models leverage structured exploration, label transformations, and waiting strategies to break symmetry and ensure meetings occur at nodes.
• Variants of VTR address dynamic and adversarial scenarios, highlighting the impact of scheduler, synchrony, and resource movement on convergence.

Vertex Traversal Rendezvous (VTR) denotes a class of distributed coordination tasks in which mobile agents must satisfy a vertex-level motion objective on a graph or geometric network. In the arXiv literature, the term is not used uniformly. One line of work uses it in the strong-rendezvous sense: agents must meet at a node, not merely cross inside an edge. Another line defines VTR as a prescribed traversal pattern on a regular hexagon: each robot must move to the opposite diagonal vertex and then return exactly once. Closely related papers study adversarial blockers or a moving meeting point rather than a static rendezvous vertex, but these models address the same core issue of forcing vertex-level convergence under symmetry, limited memory, and scheduler constraints (Bouchard et al., 2017, Bhagat et al., 2022, Naito et al., 27 Aug 2025, Fomin et al., 2021, Goswami et al., 2023).

1. Terminological scope and formal variants

The literature represented here supports a broad but technically precise view of VTR as a family of vertex-constrained coordination tasks. The common denominator is that correctness is stated in terms of occupancy of vertices and graph-respecting motion, while the main variations concern whether the target is a meeting node, an adversarially blocked graph, a moving resource, or a designated geometric vertex on a regular polygon.

Paper	Setting	VTR-related objective
(Bouchard et al., 2017)	Anonymous undirected graph, two labeled agents, arbitrary fixed per-edge traversal times	Strong rendezvous at a node
(Bhagat et al., 2022)	Infinite trees, two labeled agents, synchronous rounds	Deterministic rendezvous at the same node
(Naito et al., 27 Aug 2025)	Three robots on a regular hexagon	Move to the diagonal vertex and return exactly once

A terminological caution is necessary. The paper on adversarial rendezvous games explicitly does not use the term “Vertex Traversal Rendezvous” and instead formulates an equivalent adversarial rendezvous model on graphs; the finite-grid paper on a moving resource is described as “very close in spirit to Vertex Traversal Rendezvous” rather than as a paper using the label itself (Fomin et al., 2021, Goswami et al., 2023). This suggests that VTR is best treated not as a single universally fixed benchmark, but as a cluster of graph- and geometry-based rendezvous specifications sharing a vertex-centric objective and a sensitivity to symmetry breaking, observability, and synchrony.

2. Strong node rendezvous in anonymous graphs

In anonymous undirected graphs, the strongest version of rendezvous requires two agents to meet at a node; meetings inside an edge do not count. This strong scenario is the focus of "Deterministic Rendezvous at a Node of Agents with Arbitrary Velocities" (Bouchard et al., 2017). The model is a simple, connected, anonymous undirected graph with locally numbered ports. Two agents have distinct positive integer labels, know only their own label, have unlimited memory, cannot mark nodes or edges, and may be awakened at different times. The adversary assigns each agent and each edge a positive traversal time, denoted $t_1(e)$ and $t_2(e)$, with the crucial restriction that for a fixed agent and a fixed edge, every traversal of that edge takes the same time.

The paper distinguishes weak rendezvous, where agents may meet either at a node or inside an edge, from strong rendezvous, where they must meet at a node. Its central result is that strong rendezvous is achievable under this restricted asynchrony, even though in standard asynchronous network models strong rendezvous is impossible even in the two-node graph. The algorithm, StrongRV, alternates exploration and waiting in phases with parameters $h=1,2,4,8,\dots$. Each phase invokes a universal exploration subroutine Explo(h), derived from Reingold’s theorem, which visits all nodes and returns to the start for graphs of size at most $h$, with polynomial exploration cost $P(h)$.

A key combinatorial device is a transformed label $M(x)$ with the property that for any two labels $x,y$, neither $M(x)$ is a prefix of $M(y)$ nor vice versa. This prefix-freeness induces a schedule mismatch in some phase block. The correctness argument then forces one agent to spend a long waiting interval at a node while the other executes a complete graph exploration. Since the exploring agent visits every node, it eventually reaches the waiting agent’s node, and the meeting is necessarily at a node rather than inside an edge. The paper proves that rendezvous occurs by the time the first agent completes $\mathrm{Phase}(2a)$, where $t_2(e)$0 is the smallest power of two at least as large as the graph size $t_2(e)$1, the length of the smaller transformed label, and the maximum traversal time

$t_2(e)$2

The resulting execution time is polynomial in $t_2(e)$3, the shorter label length $t_2(e)$4, and $t_2(e)$5 (Bouchard et al., 2017).

3. Infinite trees and the role of orientation

For infinite trees, the dominant issue is whether rendezvous time can depend on the initial distance $t_2(e)$6 rather than on any notion of graph size. "Deterministic Rendezvous in Infinite Trees" studies exactly this question under synchronous rounds, distinct labels from $t_2(e)$7, unlimited memory, and either arbitrary or simultaneous wake-up timing (Bhagat et al., 2022). The paper separates two structural cases: unoriented regular trees and oriented trees with a distinguished root.

In unoriented regular trees, the main positive result is Algorithm URT, with rendezvous time

$t_2(e)$8

where $t_2(e)$9 is the number of nodes in the ball of radius $h=1,2,4,8,\dots$0. The algorithm requires no initial knowledge of $h=1,2,4,8,\dots$1 or $h=1,2,4,8,\dots$2 and works for arbitrary delay between wake-ups. Its mechanics are based on DFS explorations of expanding balls $h=1,2,4,8,\dots$3, using the procedure $h=1,2,4,8,\dots$4, and idle periods $h=1,2,4,8,\dots$5. The label transformation $h=1,2,4,8,\dots$6, obtained by substituting $h=1,2,4,8,\dots$7 and $h=1,2,4,8,\dots$8, guarantees a controlled pattern of zeros and ones so that at some critical stage one agent explores a sufficiently large ball while the other waits at a node inside that ball.

The negative result is equally sharp. Even with simultaneous start and even if agents know the exact values of $h=1,2,4,8,\dots$9 and $h$0, any rendezvous algorithm in an unoriented regular tree has time

$h$1

Combined with a classical lower bound, the paper states the overall lower bound

$h$2

For regular trees of degree $h$3, $h$4 is exponential in $h$5, so the high complexity is inherent.

Orientation changes the picture only under appropriate timing assumptions. For arbitrary delay, the lower bound

$h$6

still holds even in oriented regular trees. By contrast, for simultaneous start, orientation allows much faster algorithms. If agents know a polynomial upper bound $h$7 on $h$8, or a linear upper bound $h$9 on $P(h)$0, rendezvous can be achieved in

$P(h)$1

and this is stated to be optimal. Without extra knowledge, the paper gives an algorithm with running time

$P(h)$2

The improvement comes from replacing large-ball exploration by efficient root-oriented traversals such as $P(h)$3 and $P(h)$4, which align the agents on a common branch and then exploit a label mismatch to force meeting (Bhagat et al., 2022).

4. Adversarial and dynamic formulations

A major extension of the VTR viewpoint replaces a static meeting node by either adversarial blockers or a moving target. In "Can Romeo and Juliet Meet? Or Rendezvous Games with Adversaries on Graphs", the problem is formalized as a perfect-information game on a finite, undirected, connected graph $P(h)$5 (Fomin et al., 2021). Facilitator controls two agents, $P(h)$6 and $P(h)$7, starting at designated vertices $P(h)$8 and $P(h)$9, while Divider controls $M(x)$0 agents initially placed in $M(x)$1. No agent may move onto a vertex currently occupied by an adversary’s agent. Facilitator wins if $M(x)$2 and $M(x)$3 meet; Divider wins by preventing this forever. The time-bounded variant asks whether meeting can be ensured within $M(x)$4 steps.

The central graph invariant is the dynamic separation number

$M(x)$5

to be compared with the classical separator value

$M(x)$6

The paper proves $M(x)$7, and for one Divider agent obtains the exact characterization

$M(x)$8

For larger values, the gap $M(x)$9 can be arbitrarily large, even on sparse planar graphs of treewidth at most $x,y$0. Algorithmically, both Rendezvous and Rendezvous in Time admit an $x,y$1 brute-force game-tree solution, but are co-W[2]-hard when parameterized by $x,y$2, and PSPACE-hard in general. For every fixed $x,y$3, $x,y$4-Rendezvous in Time is co-NP-complete. Polynomial-time solvability reappears on $x,y$5-free and chordal graphs, where

$x,y$6

and the bounded-time variant is fixed-parameter tractable when parameterized by neighborhood diversity and $x,y$7 (Fomin et al., 2021).

A different dynamic model is given by "Rendezvous on a Known Dynamic Point on a Finite Unoriented Grid" (Goswami et al., 2023). Here two fully synchronous $x,y$8 robots, with no agreement on coordinates, enter a finite $x,y$9 unoriented grid through a corner door vertex. A dynamic resource starts at an arbitrary non-door vertex $M(x)$0 and moves adversarially, one hop per round, until it becomes co-located with a robot. The objective is for both robots to gather at the current vertex of this resource. The paper names the problem “Rendezvous on a Known Dynamic Point,” but the formulation is explicitly described as VTR-like because the target vertex itself traverses the graph.

The algorithm, Dynamic Rendezvous, has three phases: Entry Phase, Boundary Phase, and Gather Phase. The first phase places the robots on the two vertices adjacent to the door corner. The second phase moves them along the door boundary while preserving boundary membership and avoiding corners, until an InitGather Configuration is reached. The third phase maintains this configuration while using a Containing Rectangle $M(x)$1 to trap the resource. The proof shows that the resource cannot cross key lines without colliding with a robot, never leaves $M(x)$2 without collision, and every $M(x)$3 rounds the height and/or width of $M(x)$4 decreases. The worst-case lower bound is

$M(x)$5

while the algorithm terminates within

$M(x)$6

If $M(x)$7, this is asymptotically time-optimal. The same paper proves that no algorithm can solve the problem under an SSYNC scheduler, establishing a sharp synchrony boundary (Goswami et al., 2023).

5. Hexagonal VTR in autonomous mobile robot models

The most explicit use of the label VTR (Vertex Traversal) in the supplied literature appears in "Separation of Three or More Autonomous Mobile Models under Hierarchical Schedulers" (Naito et al., 27 Aug 2025). In this paper, VTR is a coordination problem for three robots on a regular hexagon with vertices

$M(x)$8

under the restriction that the diagonal vertices are unoccupied initially. If a robot starts at $M(x)$9, its diagonal-opposite vertex is $M(y)$0. Each robot must move to a vertex on a diagonal and then return to its initial position exactly once.

The formal specification is expressed as a temporal predicate over the trajectory $M(y)$1 of a robot $M(y)$2. In prose, the condition requires that the robot remain at its starting vertex initially, traverse the segment $M(y)$3 toward the opposite diagonal vertex, stay there for some time, return along $M(y)$4, and finally remain at the starting vertex. The paper does not require a specific intermediate vertex other than the diagonal endpoint, but constrains the motion to that segment.

The classification theorem is unusually non-monotone in appearance: $M(y)$5 The impossibility in $M(y)$6 is an indistinguishability argument: if robots are oblivious or otherwise lack the necessary memory/observation structure, they cannot tell whether a snapshot corresponds to the initial state or to a later state requiring a different action. The impossibility in $M(y)$7 uses a scheduler-adversary argument in which a late-waking robot observes a configuration indistinguishable from the initial one and may therefore move according to the wrong geometric interpretation.

The positive results depend on different mechanisms. Under $M(y)$8, the paper states that the circumscribed circle of the robots’ configuration is uniquely determined, hence the regular hexagon is uniquely determined, so each robot can compute the correct diagonal vertex. The associated protocol is a simple three-state scheme with

$M(y)$9

where activation in state $\mathrm{Phase}(2a)$0 sets the state to $\mathrm{Phase}(2a)$1 and chooses the diagonal vertex, and activation in state $\mathrm{Phase}(2a)$2 sets the state to $\mathrm{Phase}(2a)$3 and again chooses the diagonal vertex. Under semi-synchrony $\mathrm{Phase}(2a)$4, the paper uses lights with

$\mathrm{Phase}(2a)$5

and distinguishes two admissible initial configurations: $\mathrm{Phase}(2a)$6, a regular triangle configuration, and $\mathrm{Phase}(2a)$7, three robots on three consecutive vertices of a regular hexagon. State updates coordinated through the observed lights of clockwise- and counterclockwise-adjacent robots allow the robots to indirectly recognize their own number of activations and carry out the required traversal (Naito et al., 27 Aug 2025).

6. Cross-cutting principles, misconceptions, and significance

A recurrent misconception is that VTR is a single fixed problem. The literature here shows instead that the label covers at least two distinct objects: strong node rendezvous in anonymous graphs and trees, and a traversal-and-return problem on a regular hexagon. Closely related papers then generalize the same vertex-centric coordination theme to moving targets and blocker-controlled graphs (Bouchard et al., 2017, Bhagat et al., 2022, Naito et al., 27 Aug 2025, Fomin et al., 2021, Goswami et al., 2023). The technically stable content is not a unique benchmark instance, but a shared concern with graph-respecting motion, vertex occupancy constraints, and the interaction between symmetry and information.

A second misconception is that “more synchrony” or a seemingly “stronger” model should always make VTR easier. The results do not support such a naive monotonicity principle. In the hexagonal formulation, VTR is solvable in $\mathrm{Phase}(2a)$8 and $\mathrm{Phase}(2a)$9, but not in $t_2(e)$00 or $t_2(e)$01; in the dynamic-resource grid, FSYNC enables a correct algorithm while SSYNC yields impossibility; in anonymous graphs, fully adversarial asynchrony rules out strong rendezvous, yet the weaker-looking model of arbitrary but fixed per-edge traversal times admits a deterministic polynomial-time solution (Naito et al., 27 Aug 2025, Goswami et al., 2023, Bouchard et al., 2017). This suggests that atomicity structure, observability, and memory interact more subtly than a simple linear power hierarchy would indicate.

A third unifying theme is the role of structured traversal as a symmetry-breaking device. In anonymous graphs, repeated whole-graph exploration plus label-dependent waiting forces one agent to visit the other’s node. In infinite trees, DFS traversal of expanding balls is unavoidable in unoriented regular trees, while root orientation replaces ball exploration by much cheaper path traversal. In the dynamic grid, robots do not merely chase the resource; they constrain its admissible region until the containing rectangle collapses. In the adversarial graph game, the same intuition appears in complementary form: the complexity of rendezvous is captured by the minimum number of moving blockers needed to prevent all such forcing traversals (Bouchard et al., 2017, Bhagat et al., 2022, Goswami et al., 2023, Fomin et al., 2021).

A plausible implication is that VTR-style problems are best organized by three axes: how agents infer geometry, how schedulers expose or hide temporal order, and whether the rendezvous vertex is static, blocked, or moving. Under that reading, the major contribution of this body of work is not a single canonical specification, but a precise map of when vertex-level convergence can be forced, when it is impossible, and which structural properties of the graph or robot model determine the boundary.