Mobility Matters
Home›Mobile agents on graphs›Exploration›Graph exploration by a single agent›Exploration of recolourable graphs

Exploration of recolourable graphs

A single agent with little or no memory must visit every node of an anonymous graph whose nodes carry colours it can read and rewrite; how many colours are needed, and how much does it help to recolour, to see neighbours or to have port numbers?

Problem statement and measurescollapse
s00000s10000s10000s12000s12000s12030s12030s12030s12033s12033s12033s12033s12233s12233Start: every node has colour 0Colour the start 1 (one more than its neighbours' largest)Colour each new node one more than its parent, mod 3No uncoloured neighbour: go to the unique neighbour of the previous colourBack at s: colour 1, no neighbour of colour 3, so it stops
Exploration with colourable nodes Böckenhauer et al. 2023: an oblivious agent on a tree without port numbers sees the colour of its node and of its neighbours. On an uncoloured node it recolours the node with one more than the largest neighbouring colour (cyclically 1, 2, 3), which is its depth mod 3 plus one; it moves to an uncoloured neighbour if there is one (the adversary picks which) and otherwise to its parent, the unique neighbour of the previous colour; it stops at the start, the only node of colour 1 without a neighbour of colour 3. The coloured rings show the colours of the nodes; the agent itself remembers nothing.

A single deterministic agent starts at a node \(s\) of a connected, simple, undirected, anonymous graph \(G=(V,E)\) with \(n\) nodes, \(m\) edges, maximum degree \(\Delta\) and diameter \(D\). Every node \(v\) holds a colour \(\psi(v)\) from a palette of \(c\) colours that persists between visits. In each step the agent at \(v\) observes \(\psi(v)\) (and, depending on the setting, \(\deg(v)\), port numbers, the entry port, and the multiset of its neighbours' colours), sets \(\psi(v)\) to a new colour (recolours \(v\)) if the setting allows it, and then moves to a neighbour or stops. In the main model Böckenhauer et al. 2023 there are no port numbers: the agent names a colour and the adversary moves it to any neighbour of that colour; the agent is oblivious (it keeps no memory between steps); all nodes start with the initial colour \(c_0\); and the agent must visit every node, return to \(s\) and stop there, from every start and against every adversary. Other settings fix the colours in advance (label-guided exploration), give port numbers, or ask only for perpetual exploration. Measures: the number of colours \(c\), counting \(c_0\) (the main measure); time, the number of moves (traversals of one edge) until termination (or until every node is visited, for perpetual exploration); and the agent's memory. All known results are for one agent.

Measures: Colours, number \(c\) of node colours, counting the initial colour \(c_0\) (for the rotor-router: per node); Time, moves until the agent stops (perpetual: until every node is visited); Memory, bits of agent memory; 0 for an oblivious agent.

A first look

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

Imagine exploring a town of identical squares joined by streets, with no street signs and no memory at all: after each step you forget everything. What you do have is a box of coloured flags, one flagpole on every square, and good eyes: standing on a square you see its flag and the flags on the squares next to it. You may change the flag where you stand, then name a colour and walk to a neighbouring square showing that colour; if several do, an adversary (an imagined opponent) picks which one. We model the town as a graph: squares are nodes, streets are edges, the flag on a square is the colour of that node, and you are the agent, which is oblivious (it remembers nothing between steps); \(n\) is the number of nodes. In the basic version every node starts with the same colour \(0\), the initial colour (a node that still has it is uncoloured), you may recolour the node where you stand (change its colour) as often as you like, and you must visit every node, come back to where you started and stop there. The question is how many colours \(c\) are needed for every possible graph.

1AlgorithmColour by depth mod 3 (trees) Once-colourable nodes on trees → Böckenhauer et al. 2023

For a graph without cycles (a tree):

  1. On an uncoloured node, recolour it with the colour one more than the largest colour among its neighbours, counting cyclically 1, 2, 3, 1, ... (at the start all neighbours are 0, so the start gets 1).
  2. If a neighbour is uncoloured, walk to one.
  3. Otherwise, if your node has colour 1 and no neighbour of colour 3, stop.
  4. Otherwise walk to the neighbour whose colour is one less than yours (cyclically): it is your parent, the neighbour one edge closer to the start.
Why it works and what it costs. A node at distance \(j\) from the start gets colour \((j \bmod 3)+1\), so its parent has the previous colour and its children the next one; in a tree the parent is the only neighbour with the previous colour, so the way back is never ambiguous. The start is the only node of colour 1 without a neighbour of colour 3. Each edge is walked once down and once up, so the walk has \(2(n-1)\) moves (one move is one traversal of one edge). Three colours plus the initial one are needed: on a path of seven nodes two colours (plus 0) always leave the agent unable to tell the way back Böckenhauer et al. 2023. With recolouring allowed, three colours in all suffice on trees Hiraoka et al. 2026.

Why it matters. Depth mod 3 is the basic trick of the whole area: a designer uses it in label-guided exploration Cohen et al. 2008, and the general eight-colour algorithm is this idea with a phase colour on top Böckenhauer et al. 2023.

2AlgorithmThe rotor-router: a pointer as the colour Rotor-router: a pointer in every node → Menc et al. 2017

Now the edges at each node are numbered \(1, \dots, d\), where \(d\) is the degree of the node (its number of edges); these numbers are ports. You are not told through which port you arrived. The colour of a node of degree \(d\) is a number \(\pi\) between 1 and \(d\).

  1. Leave through port \(\pi\).
  2. Before leaving, recolour the node to \(\pi + 1\) (and after \(d\) back to 1).
  3. Repeat forever.
Why it works and what it costs. Each node sends you out through its ports in turn, so no edge is neglected for long. Whatever the colours are at the start, after \(O(mD)\) moves (\(m\) edges, \(D\) the largest distance between two nodes) the walk follows a fixed tour that uses every edge once in each direction, so every node is visited Yanovski et al. 2003 Menc et al. 2017. A node of degree \(d\) needs \(d\) colours, since otherwise some port can never be chosen, and no oblivious rule without the arrival port is faster in the worst case, even with unlimited colours Menc et al. 2017.

Why it matters. It shows that memory can live entirely in the nodes, and that the colours can even start in a mess (self-stabilization).

3Lower boundColours that can never be changed cost \(n\) colours Once-colourable nodes, any graph → Böckenhauer et al. 2023

Suppose a colour, once set, stays forever. To return to the start the agent must always recognise which neighbour it came from. The adversary builds graphs with a long path whose nodes have extra edges between them, so that a node on the way back sees several coloured neighbours, and any repeated colour lets the adversary send the agent the wrong way or around in a loop.

Why it holds. Böckenhauer et al. turn this into a proof that for every \(n\) some \(n\)-node graph forces \(n\) colours, counting the initial one, and a depth-first search that gives each new node a colour larger than its coloured neighbours achieves it Böckenhauer et al. 2023. With recolouring the agent can erase and reuse colours, and six colours suffice for all graphs Takahashi et al. 2026; at least four are needed Hiraoka et al. 2026.

Why it matters. The gap between \(n\) and a constant is the measure of what the right to recolour is worth.

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
Colours
Time
Memory
Recolourable nodes, oblivious agent, any graph standard
An oblivious agent without port numbers explores every graph and returns with six colours; at least four are needed.
tight \(6\) vs \(4\) indistinguishable starts
unknown — vs \(\Omega(n)\) every node visited
tight \(0\) vs —
Recolourable nodes on cacti
Four colours explore every cactus in \(O(n)\) moves, and four are necessary.
tight \(4\) vs \(4\) indistinguishable starts
tight \(O(n)\) vs \(\Omega(n)\) every node visited
tight \(0\) vs —
Recolourable nodes on trees
Three colours explore every tree in \(O(n)\) moves; two colours cannot explore the path on three nodes.
tight \(3\) vs \(3\) indistinguishable starts
tight \(O(n)\) vs \(\Omega(n)\) every node visited
tight \(0\) vs —
Once-colourable nodes, any graph
If a coloured node can never be recoloured, \(n\) colours are necessary and sufficient.
tight \(n\) vs \(n\) predecessor identification
unknown — vs —
tight \(0\) vs —
Once-colourable nodes, \(n\) known
Knowing \(n\) saves one or two colours: \(n-1\) suffice and \(n-2\) are necessary.
tight \(n-1\) vs \(n-2\) predecessor identification
unknown — vs —
tight \(0\) vs —
Once-colourable nodes on trees
Colouring by depth modulo three explores every tree with four colours, and four are necessary.
tight \(4\) vs \(4\) predecessor identification
unknown — vs —
tight \(0\) vs —
Label-guided: colours fixed by a designer
If a designer colours the nodes with three colours, a finite automaton explores every graph and stops within \(20m\) moves.
tight \(3\) vs \(2\) trap graphs
unknown \(O(m)\) vs \(\Omega(n)\) every node visited
tight \(O(1)\) vs —
Label-guided, oblivious agent
Fixed colours cannot replace memory cheaply: an oblivious agent needs more than \(\lfloor\log\Delta\rfloor - 2\) designer colours.
unknown — vs \(\lfloor\log\Delta\rfloor-1\) port addressing
unknown — vs —
tight — vs —
Rotor-router: a pointer in every node
A node's colour is a pointer to one of its ports; an oblivious agent that follows and advances it explores any graph in \(O(mD)\) moves from arbitrary pointers, and no oblivious agent without the entry port is faster in the worst case.
tight \(\deg(v)\) vs \(\deg(v)\ \text{at each node } v\) port addressing
tight \(O(mD)\) vs \(\Omega(n^3)\) unknown inport
tight \(0\) vs —

Open questions 11

Recolourable nodes, oblivious agent, any graph

  1. Is the colour complexity of recolourable exploration of arbitrary graphs 4, 5 or 6 Takahashi et al. 2026 Hiraoka et al. 2026?
  2. Give a proof of the four-colour lower bound without computer assistance, or for a single graph Hiraoka et al. 2026.
  3. How many moves does a constant-colour algorithm need on general graphs? No bound is known; for graphs whose blocks are cliques or triangle-free, five colours and \(O(n\Delta)\) moves suffice Hiraoka et al. 2026.
  4. How many colours suffice if the agent has a constant number of bits, or even one bit, of memory, or may move at random Böckenhauer et al. 2023 Takahashi et al. 2026?
  5. Does forbidding recolouring back to \(c_0\) change the colour complexity, or only the algorithms Takahashi et al. 2026?

Recolourable nodes on cacti

  1. Is four colours enough for φ-free graphs, or for graphs of maximum degree three? Both lie between 4 and 5 Hiraoka et al. 2026.

Once-colourable nodes, any graph

  1. For graphs of circumference \(\mathrm{circ}(G) \le g\), close the gap between \(\min(2g-2, n)\) and \(\min(2g, n)\) colours Böckenhauer et al. 2023.

Once-colourable nodes, \(n\) known

  1. Is the colour complexity with known \(n\) equal to \(n-2\) or \(n-1\) Böckenhauer et al. 2023?

Label-guided: colours fixed by a designer

  1. Is there a 1-bit (two-colour) labeling with which a finite automaton explores every graph Cohen et al. 2008?

Label-guided, oblivious agent

  1. How many designer colours does an oblivious agent need to explore all graphs of maximum degree \(\Delta\) Cohen et al. 2008?

Rotor-router: a pointer in every node

  1. For which graphs (other than paths) is the rotor-router exactly time-optimal among oblivious agents without the entry port Menc et al. 2017?

What the community started looking at

A flag planted in the node. Picture every node with a flagpole. The flag shows one of \(c\) colours, and it stays up when the agent leaves: whoever arrives later, the same agent included, sees it, and in the main model an agent also sees the flags on the neighbouring nodes. Compare the three other ways the catalogue leaves information behind. A luminous robot's light is a flag on the robot's own mast: it moves with its owner and is a message to the robots in sight and a memory for the owner Das et al. 2016 (problem Exploration by luminous robots); here the flag stays in place and is a memory of the place, read by whoever comes by. A whiteboard is the same idea with an unbounded or \(O(\log n)\)-bit board Dobrev et al. 2006; a recolourable node is a whiteboard of \(\log_2 c\) bits with \(c\) a constant. A pebble or token is a marker the agent carries and drops Blum & Kozen 1978 Disser et al. 2019 Dobrev et al. 2013: there are few of them and they move, whereas every node has its own flag and none ever moves.

Where it started. Fixed flags came first: Cohen, Fraigniaud, Ilcinkas, Korman and Peleg let a designer colour the nodes in advance, and three colours (depth mod 3 from a root) let a finite automaton explore every graph Cohen et al. 2008, although no finite automaton explores all graphs without help Fraigniaud et al. 2005. The rotor-router, from the Eulerian walkers of physics Priezzhev et al. 1996 and the patrolling ants of Yanovski, Wagner and Bruckstein Yanovski et al. 2003, is a node colour that the agent rewrites by a fixed rule: a pointer to the next port to use, which explores any graph from any initial pointers in \(O(mD)\) moves, and no oblivious agent that is not told its entry port does better in the worst case Menc et al. 2017. Böckenhauer, Frei, Unger and Wehner then posed the problem in its present form: no port numbers, no memory, the agent colours nodes and sees its neighbours' colours. If each node can be coloured only once, \(n\) colours are necessary and sufficient, four for trees; with recolouring, eight suffice for every graph Böckenhauer et al. 2023. Takahashi, Kanaya, Hiraoka, Eguchi and Sudo brought this down to six with a depth-first search whose return path never has a chord Takahashi et al. 2026, and Hiraoka, Imori, Takahashi and Sudo proved the first lower bound, four colours, by a computer-checked argument, which is tight for cacti, and three colours for trees Hiraoka et al. 2026.

What the colours do. In every algorithm the colours give the agent a sense of direction that the anonymous graph lacks: depth mod 3 tells parent from child Cohen et al. 2008 Böckenhauer et al. 2023, a path colour marks the way back Takahashi et al. 2026, a pointer tells which port is next Menc et al. 2017. Recolouring is what makes the palette constant: a once-coloured node must keep a colour that distinguishes it forever, and that costs \(n\) colours Böckenhauer et al. 2023. All known results are for a single agent.

Variant of Graph exploration by a single agent

The same task for one agent (visit every node; with return, stop or perpetually), but every node holds a colour from a palette of \(c\) colours that the agent at the node reads and, unless the colours are fixed, overwrites; the agent itself may have no memory at all, and in the main model it has no port numbers and sees its neighbours' colours instead. With \(c = 1\) the colours carry nothing: an algorithm of the parent problem that uses no markers works here whenever this setting grants its ports, entry port and memory, and a lower bound of this problem proved for any number of colours holds for the parent setting with the same view. The parent's pebbles are movable markers carried by the agent Pattanayak & Pelc 2024 Disser et al. 2019; here the marks stay in the nodes and there is one per node.

Related problems

Exploration by luminous robots: Flag on the robot versus flag on the node: a luminous robot carries its coloured light with it and shows it to the robots in sight, whereas here the colour stays planted in the node and is read by whoever arrives.

Further reading

Papers on this problem that are not yet placed in a setting.

  • Bojko et al. 2022 Tree Exploration in Dual-Memory Model. Tree exploration with unknown entry port, constant agent memory and \(O(\log\deg)\) bits per node: linear time with clean node memory or one token; quadratic time on paths with one bit at the agent and one per node if node memory is dirty (arbitrary). Abstract and introduction read.
  • Inoue et al. 2023 Computational Power of a Single Oblivious Mobile Agent in Two-Edge-Connected Graphs. With \(O(\log\Delta)\) bits per node, an oblivious agent simulates a one-bit agent in two-edge-connected graphs with \(O(n^2)\) overhead; bridges are what separates them. Abstract read.
  • Sudo et al. 2026 Self-stabilizing graph exploration by a single agent. Self-stabilizing exploration by one agent from arbitrary agent and node memory, using whiteboards of \(O(\log)\) size; cover time \(O(m)\) expected (randomized) and \(O(m+nD)\) (deterministic). Not read; the arXiv versions state different memory bounds.
  • Shimoyama et al. 2022 One Bit Agent Memory is Enough for Snap-Stabilizing Perpetual Exploration of Cactus Graphs with Distinguishable Cycles. One bit of agent memory suffices for snap-stabilizing perpetual exploration of cacti with distinguishable cycles (title and description in Hiraoka et al. 2026). Not read.
  • Sudo et al. 2015 A Single Agent Exploration in Unknown Undirected Graphs with Whiteboards. Trade-offs between agent memory and whiteboard size for single-agent exploration. Not read.
  • Bampas et al. 2009 Euler Tour Lock-In Problem in the Rotor-Router Model. Rotor-router lock-in: \(\Theta(mD)\) when the adversary sets pointers and ports, \(O(m\min(\log m, D))\) when pointers are chosen first. Abstract and talk slides read.
  • Zhang et al. 2012 Label-Guided Graph Exploration with Adjustable Ratio of Labels. Label-guided exploration with 1-bit labels whose black/white ratio the designer can adjust, with \(O(\rho\log\Delta)\) bits of memory. Abstract read.
The assumption tree (9 settings, 4 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 (Colours, Time, Memory); dashed nodes are branch points with no catalogued variant, named after the axis on which their branches differ. Axis order: Graph dynamics › Edge direction › Port numbers › View › Agent memory › Recolouring › Initial colouring › Knowledge › Termination requirement › Network.

tight near-optimal polynomial gap unknown impossible no variant

Assumptions specific to this problem

Port numbers

0no port numbers: the agent names a colour, the adversary picks the neighbour1port numbers, entry port unknown2port numbers and the entry port

Port numbers are the usual way an agent tells the edges at a node apart Fraigniaud et al. 2005 Pelc 2019, and most exploration papers also give the agent the port by which it entered. The rotor-router drops the entry port: the agent only follows and advances a pointer stored at the node, which works from any initial pointers Yanovski et al. 2003 Menc et al. 2017. Menc, Pająk and Uznański call this model feature an unknown inport and prove that it costs time even with unbounded node memory Menc et al. 2017. Böckenhauer, Frei, Unger and Wehner removed the port numbers altogether: the agent names a colour and the adversary chooses among the neighbours of that colour, so the colours are the only way to address an edge Böckenhauer et al. 2023. Takahashi, Kanaya, Hiraoka, Eguchi and Sudo note that without port numbers "most commonly used techniques for graph exploration and related problems are no longer applicable" Takahashi et al. 2026. The scale runs from no ports, through ports without the entry port, to ports with it.

Formal definitions
0no ports
Edges carry no port numbers. To move, the agent at \(v\) names a colour \(x\); the adversary moves it to any neighbour \(u\) of \(v\) with \(\psi(u) = x\) (if the agent sees no neighbour colours, to any neighbour). The agent never learns by which edge it arrived.
1ports, no entry port
The edges at \(v\) carry port numbers \(1,\dots,\deg(v)\), assigned by an adversary independently at each endpoint (\(\mathrm{port}_v\)). The agent chooses the port by which it leaves, but on arrival it is not told the port by which it entered (unknown inport).
2ports + entry port
As for port numbers, and on arrival at \(v\) the agent also reads the port \(\mathrm{port}_v(e)\) of the edge \(e\) by which it entered. This is the standard convention of single-agent exploration.

View

0the agent sees its own node only1the agent also sees the colours of its neighbours

In label-guided exploration Cohen et al. 2008 and in the rotor-router Menc et al. 2017 the agent reads only the node it stands on, as in all of single-agent exploration. Böckenhauer, Frei, Unger and Wehner observe that colouring alone "is still utterly useless for an oblivious agent that has to return to the start vertex" when it cannot tell edges apart, and therefore let the agent see the colours of the neighbouring nodes Böckenhauer et al. 2023; every later paper on recolourable exploration keeps this one-hop view Takahashi et al. 2026 Hiraoka et al. 2026. It is the graph analogue of the one-hop visibility of myopic luminous robots, except that what is seen are flags in nodes, not robots.

Formal definitions
0own node
At node \(v\) the agent observes \(\psi(v)\), \(\deg(v)\) and nothing about its neighbours (and, where ports exist, what the port axis grants).
1neighbour colours
At node \(v\) the agent observes \(\psi(v)\) and the multiset \(\{\!\{\psi(u) : u \in N(v)\}\!\}\) of its neighbours' colours (hence also \(\deg(v)\)), without knowing which edge leads to which colour unless ports say so.

Agent memory

0oblivious (no memory, one state)1finite automaton (a constant number \(K\) of states)2\(O(\log n)\) bits of memory

How little memory an exploring agent needs is the oldest question of the area: no finite automaton explores all graphs Budach 1978 Fraigniaud et al. 2005, and the remedies are markers Blum & Kozen 1978 Disser et al. 2019 or help from a designer Cohen et al. 2008. Recolourable exploration pushes this to the extreme: the agent is oblivious and all memory lives in the nodes Böckenhauer et al. 2023, as in the rotor-router Menc et al. 2017 and the memoryless automaton with pebbles Pattanayak & Pelc 2024. Both later papers ask what a constant number of bits of agent memory would buy Böckenhauer et al. 2023 Takahashi et al. 2026; Inoue, Kitamura, Izumi and Masuzawa compare an oblivious agent with a one-bit agent when nodes hold \(O(\log\Delta)\) bits Inoue et al. 2023.

Formal definitions
0oblivious
The agent has no internal state: its action (new colour of \(v\), then a move, stay or stop) is a function of its current observation only. Called zero-memory, memoryless or a 1-state robot.
1finite automaton
The agent is a deterministic automaton with \(K\) states, \(K\) independent of the graph; its action and next state depend on its state and its observation.
2\(O(\log n)\) bits
The agent has \(b = O(\log n)\) bits of memory, enough to hold a counter up to a polynomial in \(n\). No variant is catalogued here yet.

Recolouring

0colours fixed: the agent reads but cannot change them1each node may be coloured once2recolourable: any colour, any number of times

Fixed colours are the label-guided exploration of Cohen, Fraigniaud, Ilcinkas, Korman and Peleg: a designer writes 2-bit labels at the nodes in advance and a finite automaton reads them Cohen et al. 2008. Böckenhauer, Frei, Unger and Wehner let the agent write the colour itself while exploring, once per node, and showed in a last section that allowing recolouring "radically changes our model": seven colours (eight with the initial one) then explore every graph, against \(n\) without it Böckenhauer et al. 2023. A recolourable node is a whiteboard of \(\log_2 c\) bits; the rotor-router is the special case in which the colour is a pointer that the agent advances on every visit Yanovski et al. 2003 Menc et al. 2017. Whether a colour may return to \(c_0\) matters for exact counts: Böckenhauer et al. intended that it may not, Takahashi et al. allow it, and their six-colour algorithm needs seven colours without it Takahashi et al. 2026.

Formal definitions
0fixed colours
The colouring \(\psi : V \to \{1,\dots,c\}\) never changes; the agent reads \(\psi(v)\) (and, with neighbour view, its neighbours' colours) but cannot write.
1colour once
Every node starts with the initial colour \(c_0\). The agent at \(v\) may change \(\psi(v)\) only while \(\psi(v) = c_0\); once \(v\) has a colour other than \(c_0\) it keeps it forever. This is the main model of Böckenhauer et al. 2023.
2recolourable
At every step the agent at \(v\) may set \(\psi(v)\) to any colour of the palette, including back to \(c_0\), any number of times (the convention of Takahashi et al. 2026 and Hiraoka et al. 2026).

Initial colouring

0arbitrary initial colours (chosen by the adversary)1uniform: every node has the initial colour \(c_0\)2colours chosen by a designer who knows the graph

The rotor-router is studied from arbitrary pointers, which makes it self-stabilizing Yanovski et al. 2003 Bampas et al. 2009 Menc et al. 2017; Bojko, Gotfryd, Kowalski and Pająk call arbitrary initial node memory dirty: with one bit at the agent and one bit per node it can force quadratic time on paths, whereas with clean (uniformly initialised) logarithmic node memory and constant agent memory trees are explored in linear time Bojko et al. 2022. Recolourable exploration starts from a uniform colouring: "at the start of exploration, all nodes are assigned a common initial color" Takahashi et al. 2026. A designer's colouring is the preprocessing of label-guided exploration Cohen et al. 2008. The scale is arbitrary < uniform < designer: an algorithm that works from every colouring works from the uniform one, and a designer may choose the uniform one.

Formal definitions
0arbitrary colours
The initial colouring \(\psi_0 : V \to \{1,\dots,c\}\) is chosen by the adversary; an algorithm must work from every \(\psi_0\) (as with a rotor-router whose pointers are set arbitrarily).
1uniform \(c_0\)
Initially \(\psi(v) = c_0\) for every node \(v\) (clean node memory). The colour \(c_0\) counts as one of the \(c\) colours.
2designer's colours
Before the agent starts, a designer who knows \(G\) (and the start node) chooses \(\psi_0\). Used with fixed colours this is label-guided exploration Cohen et al. 2008.

Knowledge

0nothing known about the graph1the exact number of nodes \(n\) is known

Böckenhauer, Frei, Unger and Wehner note that their general lower bound "relies heavily on the uniformity of the algorithm" and study algorithms that need only explore graphs of a given size \(n\), to see "how useful it is to know the size of the graph in our model" Böckenhauer et al. 2023. As in single-agent exploration, knowing the size is the classical way to let a walk end Aleliunas et al. 1979.

Formal definitions
0nothing known
The algorithm is the same for all graphs: it knows neither \(n\) nor \(\Delta\) nor any other parameter (a uniform algorithm in Böckenhauer et al. 2023).
1\(n\) known
The algorithm may depend on \(n\): it must explore every graph with exactly \(n\) nodes (a non-uniform algorithm).

Termination requirement

0explore, then stop at the start node1explore, then stop anywhere2visit every node; never required to stop

The three requirements are those of single-agent exploration Fraigniaud et al. 2005. Recolourable exploration asks for the hardest, return: "visit every vertex of the graph, return to the start vertex, and terminate" Böckenhauer et al. 2023 Takahashi et al. 2026 Hiraoka et al. 2026. Label-guided exploration asks the agent to stop Cohen et al. 2008, and the rotor-router never stops Yanovski et al. 2003.

Formal definitions
0return
The agent visits every node and then halts at its start node \(s\) (exploration with return).
1stop
The agent visits every node and then halts, at any node.
2perpetual
Every node is visited at least once (for the rotor-router: infinitely often); the agent never needs to halt.

Network

0arbitrary connected simple graph1cactus (every edge on at most one cycle)2tree

Colour counts depend strongly on the class of graphs: for once-colourable nodes trees need four colours and general graphs \(n\) Böckenhauer et al. 2023, and for recolourable nodes the bounds are organised by block structure, three colours for trees and cycles and four for cacti Hiraoka et al. 2026. This axis replaces the model's topology axis because it must order trees below cacti; the other classes studied (triangle-free, φ-free, graphs whose blocks are cycles, complete bipartite graphs or cliques, graphs of bounded circumference) are recorded in the notes.

Formal definitions
0any graph
A finite, simple, connected, undirected, anonymous graph \(G = (V,E)\) with \(n\) nodes.
1cactus
\(G\) is a cactus: every edge lies on at most one cycle (equivalently, every block is a cycle or a single edge).
2tree
\(G\) is a tree (a cactus without cycles).

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