Mobility Matters
Home›Mobile agents on graphs›Exploration›Graph exploration by a single agent›Map construction

Map construction

Agents must not only visit every node but output a map of the anonymous graph, up to isomorphism.

Problem statement and measurescollapse
12121231the agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapthe agent's mapStart: an unknown anonymous graph; the map holds the start nodeCross the edge at an untried port, drop the markerStep back and search the mapped nodes for the markerMarker not found: a new node; pick it up, add it to the mapCross the edge at an untried port, drop the markerStep back and search the mapped nodes for the markerMarker not found: a new node; pick it up, add it to the mapCross the edge at an untried port, drop the markerStep back and search the mapped nodes for the markerMarker found: the edge leads to a node already in the mapCross the edge at an untried port, drop the markerStep back and search the mapped nodes for the markerFinal: the last node is new; every port tried, the map is complete
Map construction with one movable marker Dudek et al. 1991 (simplified), a setting of the problem of Chalopin et al. 2010: the agent crosses the edge at an untried port, drops the marker, steps back and tours the nodes of its map. If it finds the marker on a node already in the map, the edge leads there; otherwise the node is new, and the agent fetches the marker and adds the node and the edge to the map. Left: the unknown graph with its ports; right: the map, with the agent's position circled. One frame per move.

Agents explore an unknown anonymous port-labelled graph and must output a map: a port-labelled graph, kept in the agent's memory, that is isomorphic to the explored graph (with the ports), with the agent's current node indicated. Time is the number of moves.

Measures: Cost, moves until the map is built.

A first look

the basic problem, a simple algorithm and why some things cannot be done, for a newcomer

Imagine an explorer dropped into a maze of identical rooms joined by corridors, with no compass and no way to tell rooms apart; it must draw a correct map of the maze. Here the maze is a graph with \(n\) nodes (the rooms) and \(m\) edges (the corridors; each edge joins two nodes), and the explorer is an agent that walks from node to node along edges; one crossing of one edge is a move. The nodes are anonymous: they have no names the agent can read. At each node the edges at that node are numbered \(1, 2, \dots\) (these numbers are ports), so the agent can choose which edge to take and sees through which port it arrived. One agent starts at some node, its start node; it must walk around and finally output a map: a graph with port numbers, kept in the agent's memory, that is the same as the real graph up to renaming of the nodes, with the node where the agent stands indicated. We count the moves. In the basic catalogued version the agent cannot leave anything on a node, but it knows upper bounds on \(n\) and on the maximum degree \(\Delta\) (the degree of a node is the number of edges at it).

1AlgorithmDrop a marker to recognise a node One agent with a marker → Dudek et al. 1991

The agent carries one marker, an object that it can put down on a node and pick up again (a simplified description of Dudek et al. 1991).

  1. Keep a map of the nodes seen so far; at first it holds only the start node.
  2. Choose a node of the map with a port that has not been tried yet. Walk to that node of the graph, following the map, and cross the edge at that port.
  3. Put the marker down on the node of the graph just reached, step back across the same edge, and visit every node of the graph that is in the map (walking along edges of the map).
  4. If the marker is found on the node of the graph that a node \(u\) of the map stands for, the new edge leads to \(u\): record that edge in the map, pick up the marker, and go to step 2.
  5. If the marker is not found anywhere, the node is new: cross the edge again, pick up the marker, and add the node and the edge to the map.
  6. Stop when every port of every node in the map has been tried.
Why it works and what it costs. Each edge is tried once from each end, so there are at most \(2m\) tests. One test costs a walk to the edge plus a tour of the nodes in the map, and both are \(O(n)\) moves if the agent walks along a tree inside its map. In total this is \(O(mn)\) moves; Dudek et al. 1991 count the moves precisely: with one marker, at most \(7mn - 3n^2\) plus lower-order moves, and fewer with more markers. This is the current best bound recorded in the catalogue for the marker setting.

Why it matters. It showed that a single movable marker turns an unsolvable task into a polynomial one, and it started the study of how much marking or knowledge map construction needs.

2ImpossibilityGraphs that look the same from inside One agent, no marking → Chalopin et al. 2010

Take a ring (nodes joined in a circle, each node with two edges) and number the ports so that at every node port \(1\) goes clockwise and port \(2\) goes counterclockwise. Now compare a ring of \(3\) nodes with a ring of \(6\) nodes. An agent without a marker sees the same thing at every node of both rings: two ports, and whichever port it takes, it arrives through the other one. Every walk it can make produces exactly the same observations in the two rings. So it cannot tell the rings apart, and it cannot tell when it has seen every node.

Why it holds. In general, two nodes with the same view (everything an agent can observe on walks that start at the node: the ports it can take and the ports through which it arrives) cannot be told apart, and the most an agent can learn is the quotient graph, which merges the nodes with the same view into one node (here all nodes have the same view, so the quotient graph is a single node with one edge from the node to itself, port \(1\) at one end and port \(2\) at the other). Without a marked node, Chalopin et al. 2010 note that no algorithm can explore graphs of arbitrary size and stop, so the agent needs extra knowledge (bounds on \(n\) and \(\Delta\)) to stop, and then it builds the quotient graph, which equals the real graph only when all views are distinct.

Why it matters. It explains why every map construction algorithm needs something extra: a marker, a recognisable start node, or knowledge of the size.

3AlgorithmRecognise a node by walking home One agent, no marking → Chalopin et al. 2010

Suppose only the start node \(s\) is marked: the agent can recognise \(s\) when it stands on it, and nothing else.

  1. Build the map breadth-first: for every node \(u\) already in the map, store the list of ports of a path from \(u\) back to \(s\).
  2. To test a port that has not been tried yet, cross its edge and arrive at some node \(v\) of the graph.
  3. For each node \(u\) in the map: from \(v\), follow the stored port list of \(u\) and see whether the walk ends on the marked node \(s\); then walk back to \(v\).
  4. If some list ends at \(s\), then \(v\) is \(u\): record the edge in the map. Otherwise \(v\) is new, and the agent stores a path home for it (the edge it just crossed followed by the path of the node it came from).
  5. Stop when every port has been tested.
Why it works and what it costs. The test is correct because a list of ports, read backwards from \(s\), leads to exactly one node; if it leads home from both \(u\) and \(v\), then \(u = v\). There are at most \(n\Delta\) ports to test, each test tries up to \(n\) stored paths, and each path has fewer than \(n\) moves, so the cost is \(O(n^3\Delta)\) moves, the bound of Chalopin et al. 2010 (Proposition 9). This needs no knowledge of \(n\), and the output is an exact copy of the graph. Without any marked node the same paper needs known bounds and universal exploration sequences, with \(O(N^6\Delta^2\log N)\) moves, where \(N\) is the known upper bound on \(n\).

Why it matters. It shows that a marked start node, which cannot be moved, is already enough, which is much weaker than a marker the agent carries.

What is known

The best upper bound against the best lower bound in each catalogued setting. Open a setting for its results, proofs and notes, or see the progress map with the branch points.

tight near-optimal polynomial gap unknown impossible· one row per catalogued setting, in tree order; each cell: best upper bound vs lower bound, and what forces the lower bound
Setting
Cost
One agent, no marking standard
Knowing upper bounds on \(n\) and on the degree, one agent builds the quotient graph of an anonymous graph without marking anything, by following a universal exploration sequence.
unknown \(O(N^6\Delta^2\log N)\) vs —
One agent with a marker
An agent with \(k\ge1\) distinct markers it can drop and pick up builds the graph as it explores, in \(O(mn)\) moves.
unknown \(O(mn)\) vs —
Identical agents with whiteboards
Several identical agents with whiteboards build a common labelled map exactly when symmetry can be broken.
unknown \(\text{finite}\) vs \(\text{impossible}\) symmetry

What the community started looking at

Map construction started in robotics as exploration as graph construction with markers Dudek et al. 1991; in distributed computing the questions were feasibility for anonymous agents Das et al. 2007 and then the cost for a single agent without marks Chalopin et al. 2010, as surveyed in Das 2019.

Strengthening of Graph exploration by a single agent

Building an isomorphic map implies having visited every node, so map construction is exploration with more output; it is used to solve rendezvous and leader election Das 2019.

The assumption tree (3 settings, 2 branch points)

The root assumes nothing. Going down, each edge adds the assumptions on its chips (+blue); a grey chip names the branch that leaves that axis unassumed while a sibling assumes something. Solid nodes are catalogued variants with their status per measure (Cost); dashed nodes are branch points with no catalogued variant, named after the axis on which their branches differ. Axis order: Graph dynamics › Edge direction › Timing › Agents › Knowledge › Markers › Whiteboards › Topology.

tight near-optimal polynomial gap unknown impossible no variant

Assumptions specific to this problem

Agents

0a single agent1several identical agents

Map construction began as a single-robot problem: Dudek, Jenkin, Milios and Wilkes framed robotic exploration as building a graph, with a robot carrying one or more markers Dudek et al. 1991. Das, Flocchini, Kutten, Nayak and Santoro posed the distributed version: \(k\) identical agents, initially dispersed among the nodes and communicating through whiteboards, must each build an identically labelled map Das et al. 2007 (abstract read). They note that it "is much more difficult than exploration by a single agent, because it involves achieving cooperation among multiple agents", and that it is deterministically unsolvable in some cases Das et al. 2007. The axis separates the single agent, whose difficulty is recognising nodes it has already seen, from the team, which must in addition break the symmetry between identical agents.

Formal definitions
0one agent
A single agent.
1several agents
\(k\ge2\) identical agents.

Knowledge

0nothing known1an upper bound on \(n\)

In an anonymous graph an agent that cannot mark nodes cannot tell a revisited node from a new one by looking at it, so it needs information from outside before it can commit to a map. The standard information is an upper bound on \(n\), which fixes how long a universal sequence must be followed; Chalopin, Das and Kosowski state the trade-off exactly: "in the model where no vertices of the graph are marked, for the task of map construction to be feasible, the agents must know some bound \(n\) on the number of nodes of the graph and some bound \(d\le n\) on its degree", and with these bounds they build the map by following universal exploration sequences; without any knowledge they instead assume that the starting node is marked, and then build the map in \(O(n^3\Delta)\) moves with \(O(n\Delta\log n)\) bits of memory Chalopin et al. 2010. The clearest measurement of what the bound is worth comes from directed graphs: Bender et al. map any strongly connected digraph with one pebble when an upper bound on \(n\) is known, while without it \(\Theta(\log\log n)\) pebbles are necessary and sufficient Bender et al. 2002.

Formal definitions
0nothing known
Nothing is known about \(G\).
1bound on \(n\)
An upper bound \(N\ge n\) is known.

Markers

0no markers1markers the agent carries

A marker lets a robot recognise one chosen node, which is exactly what an anonymous graph withholds. Dudek, Jenkin, Milios and Wilkes introduced the robot that carries \(k\ge1\) distinct markers and builds the graph as it explores; they show that without markers the task is unsolvable in general (regular graphs of the same degree look alike everywhere) and that their algorithm makes at most \((5+2/k)mn-3n^2\) plus lower-order moves, that is \(O(mn)\subseteq O(n^2\Delta)\) Dudek et al. 1991. Bender, Fernández, Ron, Sahai and Vadhan showed in "The power of a pebble" that one pebble also suffices to map a directed graph in polynomial time when an upper bound on \(n\) is known Bender et al. 2002. The axis keeps carried markers apart from whiteboards because a marker is a single movable bit, while a whiteboard stores information permanently at every node.

Formal definitions
0no markers
No markers.
1markers
The agent carries markers it can drop and pick up.

Whiteboards

0no whiteboards1whiteboards at the nodes

Whiteboards, a small memory at every node that visiting agents read and write in mutual exclusion, are the standard communication device in the work of Flocchini, Santoro and coauthors on asynchronous agents Dobrev et al. 2006 Flocchini et al. 2012. Das, Flocchini, Kutten, Nayak and Santoro used them for map construction by \(k\) identical agents, which communicate only through these "small public bulletin boards available at each node" Das et al. 2007 (abstract read). Flocchini, Ilcinkas and Santoro note that whiteboards also "allow to break symmetry among identical agents" Flocchini et al. 2012, which is what a team of identical agents needs in order to agree on one labelled map.

Formal definitions
0no whiteboards
No whiteboards.
1whiteboards
Each node has a whiteboard.

Know a better result, or found a mistake? Suggest a result · Report an error. Accepted contributions are acknowledged.