A simple lower bound for ARRIVAL

by   Graham Manuell, et al.

The ARRIVIAL problem introduced by Dohrau, Gärtner, Kohler, Matoušek and Welzl concerns a train moving on a directed graph proceeding along outward edges according to the position of 'switches' at each vertex, which in turn are toggled whenever the train passes through them. The problem asks whether the train every reaches a designated destination vertex. It is known that ARRIVAL is contained in UP ∩ coUP, while the previously best published lower bound is that it is NL-hard. In this note we provide a simple reduction to the 𝖣𝖨𝖦𝖨𝖢𝖮𝖬𝖯_𝖤𝖷𝖯 problem considered by Aaronson. It follows in particular that ARRIVAL is both CC-hard and PL-hard.



There are no comments yet.


page 1

page 2

page 3

page 4


A Subexponential Algorithm for ARRIVAL

The ARRIVAL problem is to decide the fate of a train moving along the ed...

ARRIVAL: Next Stop in CLS

We study the computational complexity of ARRIVAL, a zero-player game on ...

Even the Easiest(?) Graph Coloring Problem is not Easy in Streaming!

We study a graph coloring problem that is otherwise easy but becomes qui...

Assimilation of fire perimeters and satellite detections by minimization of the residual in a fire spread model

Assimilation of data into a fire-spread model is formulated as an optimi...

A Lower Bound on Cycle-Finding in Sparse Digraphs

We consider the problem of finding a cycle in a sparse directed graph G ...

A lower bound for splines on tetrahedral vertex stars

A tetrahedral complex all of whose tetrahedra meet at a common vertex is...

Sequential TOA-Based Moving Target Localization in Multi-Agent Networks

Localizing moving targets in unknown harsh environments has always been ...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1. Introduction

A switch graph consists of a set of vertices and two endomorphisms and can be thought of as a directed graph with directed edges from each to and from to . Given a switch graph , we imagine a train starting a some vertex and traversing the graph is the following way. Each vertex of the graph contains a switch initialised to state . At each time step, if the train is at a vertex and the switch at is in state , the train moves from a vertex to and the state of the switch at is toggled. The Arrival problem [3] asks whether the train every reaches a specified destination vertex .

It is shown in [3] that Arrival is in and this is improved to in [5]. Recently, an algorithm has been given that solves it in time [6]. On the other hand, the only published lower bound is given in [4] (for a formally slightly more general game) where -hardness is proved.

However, in [1] Aaronson studies a highly related problem. The Digi-Comp II was a mechanical toy computer where small balls rolls down an incline and are deflected by toggles that divert their path, which conversely causes the toggles to be kicked back into a different setting. The effect is that the balls behave exactly the train in Arrival with the graph restricted to be acyclic.

Explicitly, let us define a switch graph to be acyclic if there are no cycles in the corresponding directed graph aside from self-loops. Then the Digicomp problem asks for an acyclic switch graph , a starting vertex , a destination vertex and a number of balls encoded in unary, whether after balls are released sequentially from any ever reach . (Technically, to match the original definition there are should some further restrictions, such as , but our version is easily seen to be equivalent.) Aaronson shows that this problem is in fact -complete.

Recall that is the class of problems which are log-space reducible to the evaluation of a circuit built about of comparator gates (which send to ) without implicit fan-out (see [7, 2]). It is known that contains .

We note it is not completely immediate that Arrival is -hard: while the Digicomp problem is almost Arrival restricted to acyclic graphs, this is not quite true, since unlike Arrival, Digicomp involves ‘multiple trains’. Nonetheless, it is still true that Digicomp can be reduced Arrival as we show below.

In fact, we can say say more. The problem is defined in [1] in the same way as Digicomp except the number of balls is encoded in binary — that is, the number of balls used can be exponential in the input size. This problem is still in , but it might be strictly harder than Digicomp. We will show that can be reduced Arrival in logarithmic space. Consequently, Arrival is both -hard and -hard.

I do not claim any particular novelty here; every nontrivial piece of the argument used to derive this result is already known to others. However, they do not been appear to have been put together explicitly before and all the literature on Arrival only mentions the -hardness result. The aim of this paper is to make the stronger lower bounds more widely known.

2. Results

As noted in the original paper [3], it is not difficult to construct switch graphs which act as binary counters. A 4-bit counter is given in the following diagram, where solid lines represent the edges and dashed lines represent the edges.

This can be used to pass down the path at 16 times and then the path at once (before possibly repeating the whole sequence over again). Here we have omitted the full path starting at , which would of course need to eventually loop back to the starting vertex of the counter at .

In general, given some counter similar to that above that counts to , we can make connect back to via a solid line and to a new final state via a dotted line. This will cause the counter to run twice before reaching and hence we obtain a counter that counts to .

On the other hand, if we connect to instead of looping directly back to , we will end up visiting one additional time before starting the counter again. Thus, the new counter will count up to .

Now by repeatedly applying these two techniques, we can build a counter to count to any number based on its binary expansion. For instance, the following counter visits times before reaching .

These counters only require nodes to count up to . We now arrive at the following result, where we use a counter to run through an acyclic graph multiple times and hence simulate multiple trains.

Proposition 2.1

is a -reducible to Arrival.


Consider the problem for an acyclic switch graph , starting vertex , destination vertex and a number of balls . We construct a counter up to as described above where the output connects to the graph at the vertex and the output at is a new vertex with . The ‘leaf’ vertices of (i.e. those vertices such that ) have their outputs modified so that they connect back to the counter at . The new starting vertex is and the new destination vertex is still .

Remark 2.2

We have seen it is easy to repeat an operation exponentially many times in Arrival and then do something else. This might make us hope that we can simulate the succinct 0-player reachability switching game of [4], which was shown there to be -hard. However, no simple modification of our approach is able to achieve this.

The problem is that to simulate Boolean circuits as in [4] it is necessary to put the entire program in a big loop as we have done here and have the train pass through the circuit multiple times in order to feed the inputs into the circuit. However, then if we ever use a counter to make the train go down one path times before going along another path, by the time we reach the counter again it will have been reset to its initial position and the train will go down the first path yet again instead of starting to repeat the second path.

We could try to avoid this by making sure the second path never loops back to this counter again, but this is not compatible with the global loop. We also note that it is, of course, possible to alternate between paths and so that in the end both have been traversed times, but now it is not clear how to make logic gates work.

Finally, we note in passing that it is possible to simulate the non-succinct 0-player reachability switching game by encoding each node of high out-degree using a binary tree, but this takes exponentially many nodes and so is not helpful for the succinct version.

Since is clearly harder than Digicomp, which is -complete, it now follows that Arrival is -hard. The precise difficulty of is not known, but in a comment at [1] Itai Bar-Natan proves that is -hard. Thus, Arrival is -hard too. We reproduce the argument here for completeness.

Proposition 2.3

is -hard.


The problem of determining if there are at least paths from to in an directed acyclic graph is -complete. By recursively splitting the vertices in the graph we may assume the out-degree of each vertex is at most 2 without loss of generality.

We can now define a new graph to have a vertex for each and , where is the number of vertices in , and an edge from to whenever and there is an edge from to in and also when . Note that the number of paths from to in is then precisely equal to the number of paths from to in . Moreover, out-degrees of vertices in are also at most . This construction can be done in logarithmic space.

Finally, we construct a switch graph from by arbitrarily choosing one of the edges out of each vertex to be the edge and the other to be the in the case the out degree is 2. When the degree is less than 2 we make the remaining edges out of point to a new vertex which satisfies . The vertex is a special case, which we discuss later. It is not hard to see that if we start balls at then the number of balls that reach the vertex is equal to where is the number of paths from to in . Thus, balls arrive at , which is also equal to the number of paths from to in .

Finally, we connect to a counter that sends the first balls to and the remaining balls to a new destination vertex . This counter is the Digicomp analogue of the counter for Arrival we described above. The difference is that whenever we would have looped back to the start of the counter we instead just connect the vertex to itself. (When this counter is interpreted in Arrival the counter will connect then back to the start of vertex .) A ball will now arrive at precisely if there are at least paths from to in , as required. Finally, note that the construction of the switch graph can be done in logarithmic space and so we are done.

It is also notable that at the end of the simulation of the switch graph above, the position of the switch at contains the answer to whether the number of paths from to

is odd or even, which is a

-complete problem. So if we could use this to influence the location of a ball somehow (i.e. to cause a later ball to fall into a position no ball would have reached before), this would show that Arrival is -hard. However, there does not appear to be any obvious way to do this.