Recursed is not Recursive: A Jarring Result

Recursed is not Recursive: A Jarring Result


Recursed is a 2D puzzle platform video game featuring treasure chests that, when jumped into, instantiate a room that can later be exited (similar to function calls), optionally generating a jar that returns back to that room (similar to continuations). We prove that Recursed is RE-complete and thus undecidable (not recursive) by a reduction from the Post Correspondence Problem. Our reduction is “practical”: the reduction from PCP results in fully playable levels that abide by all constraints governing levels (including the room size) designed for the main game. Our reduction is also “efficient”: a Turing machine can be simulated by a Recursed level whose size is linear in the encoding size of the Turing machine and whose solution length is polynomial in the running time of the Turing machine.



1 Introduction

Recursed1 [POR16] is an indie puzzle platform video game by lone developer Portponky. The game’s main feature is having rooms contained within treasure chests, often recursively, inspired by functional programming; see Section 2 for details.

In this paper, we show that deciding whether a given Recursed level can be solved is RE-complete and thus undecidable (not recursive).2 We thus positively settle a player’s claim that Recursed is NP-hard [COM17] and another player’s conjecture that it is undecidable [EDD17]. Our proof is by a reduction from the Post Correspondence Problem (PCP); refer to Section 3 for a definition. We use the properties of PCP that the constraints are locally checkable and that the resolution of choices proceeds in only one direction (adding more words/dominoes to the string).

RE-completeness of a video game requires some source of arbitrarily unbounded state in the game. The unbounded state we use in Recursed stems only from the player’s ability to generate instances of rooms arbitrarily deeply through normal use of the game’s recursive chest mechanics (and by extension, its jar mechanics); see Section 2 for details. Each of the finitely many rooms resulting from our reduction has constant size — even fitting within the size of standard Recursed rooms — and contains only a constant number of objects and a constant amount of state. Indeed, the Recursed levels generated by our reduction are “practical”: they could, in principle, be solved by a human, provided they knew which PCP dominoes to place at each placement step. Using the custom level feature of Recursed, we have built a fully playable custom level demonstrating the reduction applied to a simple 2-domino PCP instance, which is available for download [DK20].

Our reduction is also efficient, meaning that it efficiently represents the execution of a Turing machine. The Recursed level size is linear in the number of dominoes in the PCP instance, and the Recursed solution length is where is the number of symbols in a solution to the PCP instance. Using the standard reduction from the Halting Problem to PCP [SIP12], the Recursed level size is linear in the encoding size of the Turing machine, and the Recursed solution length is where is the running time and is the space used by the Turing machine. As a consequence, deciding whether a Recursed level can be solved in a polynomial number of steps is NP-complete, and deciding whether a Recursed level can be solved in an exponential number of steps is NEXPTIME-complete.

Related Work. The first RE-completeness/undecidability result for a video game was for another indie puzzle game, Braid [HAM14], designed by Jonathan Blow. (The computational complexity of Blow’s other puzzle game, The Witness, has also been studied, with NP-, -, and PSPACE-completeness results for various aspects of the game [ABD+18].) To our knowledge, our result is the second RE-completeness/undecidability result for a (real-world) single-player video game.

The Braid reduction [HAM14] produces a Braid level of finite size. The unbounded state it exploits comes from the game’s ability to generate arbitrarily unbounded quantities of enemies and pack them into the same location, allowing the level to increment a counter arbitrarily high. Enemies prevent the player from getting to a location, allowing the player to detect when the counter is zero. In this way, the Braid reduction simulates a counter machine. Because the reduction from Turing machine to counter machine [MIN61] requires an exponential slowdown, the Braid reduction is not efficient: the resulting solution length is exponential in the running time of the Turing machine. Also, because the items in Recursed all help rather than hinder the player’s mobility, this type of approach cannot work for Recursed.

For two-player games, there is one undecidability result we are aware of: Magic: The Gathering is RE-hard/undecidable even for two players [CBH19], via an efficient Turing machine simulation. In fact, the players’ moves are all forced, so this result is arguably about a zero-player simulation (but only the two-player game is “real-world”). An earlier RE-hardness/undecidability proof [CHU12] simulated a counter machine, and thus was inefficient; it also required more players and a small tweak to the game rules.

Team multiplayer games are often RE-complete/undecidable even when the game’s state is finite; the source of unboundedness is the hypothetical game strategies built in the players’ heads [HD09]. Recently, this technique has been applied to prove RE-completeness/undecidability of real-world team video games, including Team Fortress 2, Super Smash Brothers: Brawl, and Mario Kart [CL18]. These reductions are naturally very different from Recursed, given the different source of unboundedness.

Roadmap. Section 2 gives an overview of the mechanics of Recursed relevant to our construction. Section 3 presents a proof of the result. Section 4 describes some open questions and conjectures regarding the complexity of subsets of Recursed.

2 Game Rules

This section covers the rules of Recursed insofar as they are needed for our construction in Section 3. For simplicity, we omit those objects and notions which we will not use.3

2.1 Basic Player Actions

We will call the player character Rico. By default, Rico can run horizontally and jump or fall vertically. Rico can jump up to a surface at most tiles higher than where they jumped from, but can fall arbitrarily far with no penalty. Rico can pick up objects they are standing next to (see below for an enumeration). Rico can only carry one object at a time, and cannot pick up further objects until releasing the one held. While holding an object, Rico can drop it, causing it to fall, or throw it. Thrown objects travel in a perfectly vertical or horizontal trajectory until hitting a solid tile (or reaching the apex, if thrown upwards), at which point they fall until landing on a floor tile, or falling off the bottom of the screen. Note that other objects do not impede the trajectory of a thrown object. If Rico is carrying an object, their jump height is lowered to at most blocks.

Typically, walls, floors, and ceilings are comprised of tiles, which are immovable and impassable, by Rico or any object. At any given time, Rico will be situated in a room of size at most (though sometimes smaller), which is what is shown to the player. Typically, rooms will have borders consisting of solid tiles (counting towards the size). It is possible for some walls, floor, or ceiling to be missing. If Rico falls off the edge, they bounce back up a few blocks, but we will not have any missing floors in our construction.

A level is comprised of a collection of rooms (see 2.3 for more details). Rico’s goal is to reach a purple crystal, of which exactly one exists in some room of each level.

There is one additional special environmental feature called a ledge (see Figure 1). Ledges are always oriented horizontally. Rico can jump upwards through a ledge, but cannot by any means traverse back downwards through a ledge. Thrown or dropped objects ignore ledges entirely in both directions.

2.2 Basic Objects

We depict all of the objects necessary for our construction in Figure 1. A description of each follows.

\contourblackdoor\contourblackrico\contourblackpink flame\contourblackblock\contourblackkey\contourblackring\contourblackchest\contourblackjar\contourblackgreen flame\contourblackgreen glow\contourblackcrystal\contourblackledge
Figure 1: A toy level containing a copy of each object used in our construction.

Blocks The primary use of blocks is for Rico to stand on and be able to jump higher. In particular, if Rico is standing on a block, they can jump to a height of above the ground ( if carrying another object), which would be otherwise impossible. Furthermore, blocks can be stacked arbitrarily high, and Rico can “climb” stacks of blocks, so with blocks, Rico can reach a height of .

Keys and doors Keys are carryable objects which open doors. Doors are static objects in the level which occupy a space 3 tiles high by 1 tile wide, generally preventing traversal from one side to the other. A key can be carried directly to a door, or thrown at it. In either case, the key and the door both disappear, allowing Rico to traverse the space previously occupied by the door. There is only one type of key and one type of door, so any key in the game can open any door.

Rings The only direct use of rings in-game is to trigger pre-scripted dialog when thrown against a wall. Therefore, they provide no particular use toward solving a level. Nevertheless, we will make use of rings in our construction as a generic object which specifically does nothing except lower Rico’s jump height to tiles when held. See Section 3.2.2.

2.3 Chests

Chests are the primary “gimmick” of Recursed. They were designed to emulate function calls (in the programming sense) to some degree. In Recursed, Chests do not contain objects, but rather entire rooms. Rico can jump into chests, thereby entering the room contained therein. The room contained in a chest is an immutable property of the chest itself—a particular chest will always contain a particular room, according to the specification of that chest. Different chests can contain the same room.

When Rico enters a room via a chest, they appear at a pre-specified entry point4, along with a pink flame, which we refer to interchangeably as an exit. The room will be generated freshly from its specification each time Rico enters a chest containing it regardless of whether Rico has previously visited and/or interacted with objects in the room. This follows the function call intuition of each invocation entering the function at the beginning with no local state.

While in a room contained in a chest (which is most of the time), Rico can freely interact with any objects present including other chests. Every room except for the initial room Rico begins the level in will necessary have a pink flame exit. If Rico returns to the exit of a room, they can choose to leave by interacting with the pink flame. In doing so, they will hop back out of the chest they initially came in, thus re-entering the “parent” room in the same state that it was when Rico jumped in the chest. Note the asymmetry between entering and exiting chests. Again, this emulates the function call behavior of saving the local state of the parent function when returning from a child function. Because any future entries to the chest room will re-generate the room anew, any state that room had when Rico leaves is entirely forgotten.

Rico can of course recursively enter chests (hence the name), thereby saving a “call history” in a stack-like fashion. Rico can even enter a room via a chest contained in that same room, reminiscent of a recursive function calling itself.

One final key property of chests is that when Rico jumps into a chest, or leaves via the pink flame, they can do so while carrying at most one object. Thus, provided that Rico can manage to get access to it, Rico can bring a block, a key, or another chest with them into or out of a chest. To demonstrate the impact of this ability, observe that on the one hand, if Rico carries, say, a block into a chest and then subsequently leaves the chest empty-handed, that block is lost forever. On the other hand, if Rico enters a chest empty-handed, but manages to leave while carrying a block, the parent room now has a block that in effect did not previously exist. In particular, Rico can repeat the same sequence of actions any number of times to produce an unbounded number of blocks in the parent room.

2.4 Green glow

Some objects in the game have a green glow (see Figure 1). These objects violate the “function call” rules of chests described above, in that the state of a green glowing object is saved no matter when or where it is interacted with. The simplest example is a green glowing door, since it cannot be moved, but only open. If a green glowing door in a room is opened by any key, it will always be open when Rico revisits that room, even if doing so by entering a chest and thus regenerating (the nonglowing parts of) the room.

Movable objects, including blocks, keys, and chests can also glow green. In this case, if the object moves around the room it begins the level in, then whenever Rico revisits that room the location of the object will be remembered. This is the only property we will make use of in the construction, but we note for posterity that green glowing objects can be moved between rooms and this will be remembered as well. Green glowing chests have even more interesting properties, but we encourage the reader to play the game and discover those for themselves!

2.5 Jars

Jars are similar to chests in that they contain rooms, but unlike chests, they are designed to emulate continuations (in the functional programming sense), rather than function calls. Jars can never be present in the initial state of a level. Rather, some rooms (other than the initial starting room) will have a green flame exit in addition to the standard pink flame exit (not to be confused with green glow above). The green flame can be located anywhere in the room and is independent of Rico’s initial point of entry. There can even be more than one (though not in our construction). If Rico exits a room via a green flame exit, they will hop back out of the containing chest, just like by the pink flame, except they will now be carrying a newly created jar. Note that Rico cannot be carrying any object when leaving via green flame exits in order to have space to carry the jar.

Rico can carry the jar around just like any other object. If, subsequently, Rico enters a jar, they will re-enter the room containing the green flame the jar was created with, at the location of the green flame, with the room in the same state that it was in when the jar was created, except that the green flame itself is now gone, so no further jars can be created from the same place. Thus, any doors previously opened or objects previously moved or placed will be just where they were when Rico used the green flame. Importantly, when Rico later exits a room after entering it from a jar, they will reappear in the parent room just as if they had used a chest, and may even be carrying an object, but the jar will be destroyed. Thus, any particular jar can only be entered once.

3 Main Result

Theorem 3.1.

Recursed is RE-complete.

Containment is straightforward: the game can obviously be simulated, given an initial state and sequence of player inputs. Thus, with a recursively enumerable Turing machine, one can enumerate every input string frame-by-frame and check whether any such string solves the level.

The hardness reduction is from the Post Correspondence Problem (PCP). Originally shown undecidable by Post in [POS46], we follow Sipser’s description of the problem [SIP12]. Given a set of dominoes each with a string on the top half and a string on the bottom half, denoted . We are tasked with laying such dominoes next to each other (copying dominoes as much as necessary) such that the concatenation of the top halves equals the concatenation of the bottom halves. We will enforce that the first domino must be which will simplify the initial part of the construction. (Forcing the first domino to be of a specified type clearly does not make the problem decidable, since if it did there is a trivial nondeterministic decision algorithm which guesses the first domino and then calls the hypothesized decision oracle).

We will implement a (nondeterministic) algorithm to solve PCP in Recursed. The algorithm is as follows:

  1. Nondeterministically choose a domino to add to the solution, or stop and skip to 3.

  2. Push onto stack and onto stack .

  3. Pop and and check whether the popped symbols are equal; REJECT if not.

  4. Repeat 3 until one stack empties, then check if the other stack is also empty; if yes, ACCEPT, else REJECT.

3.1 High-level overview

Rico initially spawns in a room next to a block and a chests, with another chest and a locked door past a ledge, shown in Figure 2. On the other side of the locked door is the goal crystal, but it is 6 tiles above the ground, one tile too high for Rico to jump to reach unaided5. The chest next to the door is a Global-Lock chest, which, once unlocked, will provide the key to this very door. All Rico has to do is open the Global-Lock gadget and get the block to the other side of the locked door! Of course, it will not be so easy…

The reduction is demonstrated with a fully playable level [DK20] for a PCP instance with , , whose (shortest) solution is of course .

Figure 2: The initial room.

The high level structure of the construction is as follows: We will store in the “call history” of chests Rico has jumped into and we will store in a chain of jars. For each symbol , there will be one corresponding room in our call history. For each symbol , there will be one corresponding room in our chain of jars. Rico will need to carry the top level jar around pretty much all the time, unless changing the state of another gadget. The very last jar at the bottom of the chain representing will contain a single block6 which, if retrieved in the crystal room, Rico can use to jump on and reach the crystal.

The intended solution path which Rico must follow is comprised of two phases: a “Domino Selection” phase, and a “Popping” phase. During the Domino Selection phase, Rico will push symbols to via the explicit chest stack, and to by building the chain of jars (i.e., the outermost jar Rico is carrying contains machinery corresponding to the top symbol of as well as a second jar which itself contains machinery corresponding to the next symbol of , etc.). During the popping phase, Rico will need to traverse back up the history of chests and prove that each room corresponding to a symbol at the top of matches the symbol corresponding to the room contained in the outermost jar, i.e. at the top of , and “popping” both off their stacks. Rico can reach the crystal only if they reach the starting room (thereby having emptied ) when is also exactly empty, at which point Rico will be carrying the initial block rather than a jar.

3.2 Gadgets

In this section, we will enumerate a collection of gadgets which will be used in the overall construction. A gadget is a template for a section of a level with specific properties. We first describe the One-Way, Proof-of-Holding, and One-Time-Traversal gadgets which are simple and useful subcomponents we will use repeatedly. Section 3.2.4 describes the Prove-Verifygadget which has one entrance which can only be traversed if another entrance has previously been traversed. It is the main component in our ability to record state in our construction. Finally, Section 3.3 has multiple parts which detail how dominoes in the PCP are constructed using separate gadgets for the choice of domino placement (Section 3.3.1), the top symbol (Section 3.3.2), and the bottom symbols (Section 3.3.3).


A One-Way gadget allows Rico to pass from one side of the gadget to another, but not back in the opposite direction. Our One-Way gadgets have the additional property that Rico is not able to throw an object through one without traversing it themself.

The traversability requirement can be trivially implemented with two “stair steps”, each two blocks high, followed by a four block drop. Rico can only jump at most 3 blocks, so after jumping down from the ledge, they cannot get back up. One-Ways can also be implemented with a ledge: Rico can jump up onto the ledge but then is unable to get back down. We use both implementations, governed by desired layout.

The latter ledge implementation trivially satisfies the thrown object requirement, since objects always pass through ledges. The stair step implementation requires one extra feature, which is to make sure the floor below the four block cliff is a ledge, so that any object dropped over the edge will fall through the ledge and become inaccessible, either by getting trapped in an unreachable pit, or by falling off the bottom of the screen, depending on placement. Further, we add a multi-block ‘stalactite’ over the ledge to ensure that any item thrown from above the stairs will hit this wall and fall below the ledge.

The ledge One-Way can be seen on the far left sides of Figures 7 and 8. The stair implementation can be seen once in the bottom of Figure 7 and in triplet in the bottom of Figure 8.


The Proof-of-Holding gadget (H) is a simple gadget which is traversable if and only if Rico is carrying an object. See Figure 2(a). It makes use of the fact that while carrying something Rico’s jump height is lower. If Rico is not carrying anything, the gadget is set up so that Rico will bump their head while trying to cross a gap and fall, but Rico can cross the gap while carrying any object.


The One-Time-Traversal (1O) is what it says on the tin. Rico can traverse it one time in one direction, after which it cannot be traversed in that direction again. See Figure 2(b). It is implemented by forcing Rico to be holding an object (we use a ring so as not to bestow any other abilities) in order to jump up a small step, without irreversibly getting stuck on the ledge 3 blocks up. If Rico is not holding the ring while jumping up the step, getting stuck on the ledge is unavoidable. The gap below the ring’s tile is to allow Rico to throw a held object over to the other side of the gadget to be retrieved after traversal. The reason the gadget is one-time use is because (1) once the ring is removed it is impossible to get it or any other object up to the tile where the ring is initially and (2) the gadget is only possible to traverse from left to right if there is an object present precisely on that tile.

It is easy to see (1) by recalling that Rico cannot jump to a height of 3 blocks while holding an object, nor is there anyway to throw an object upwards with any horizontal velocity, so Rico can neither carry nor throw an object up to the ring’s starting tile. Given (1), (2) becomes clear because there is no way Rico can be carry an object while standing on the lower ledge except by grabbing one off the ring’s starting tile.

For notational convenience, and because we always want to force Rico to prove that the jar is never dropped, we will always combine One-Time-Traversal with Proof-of-Holding gadgets, to get a gadget which Rico can traverse if and only if they are carrying something and even then at most once. We denote this combined gadget by , or .

(a) Proof-of-Holding gadget.
(b) One-Time-Traversal gadget.
(c) Combined start-of-room construction.
Figure 3: The Proof-of-Holding and One-Time-Traversal gadgets. These exclusively appear together and at the start of most rooms, so we will always use the combined version shown in (c) for compactness.

Prove-Verify Gadget

The primary driving gadget behind much of our construction is what we call a Prove-Verify (PV) gadget. The basic idea is that the gadget primarily consists of a single room which contains a green glowing block which can be in one of two states: set or unset. If Rico is able to visit a Prove chest, , they can put the gadget in the set state. If Rico visits a Verify chest, , they will be able to retrieve a key from if and only if the gadget is Set, and in doing so must return it to the Unset state. In this way, retrieving the key from verifies that was visited. Note that a Verify chest is always followed by a locked door, denoted by (k for key). Unless otherwise stated, PV gadgets are initially unset. We note that this is a minor variation on the “Self-closing Door” gadget [AAD+19] in the framework of [DGL+18].

A major use case for PV gadgets is to force Rico to prove that a room is being entered when and from where it is intended to be. To enforce this, for most rooms , the first element encountered will be a gadget corresponding to that particular room, which will be set only if Rico is coming into that room immediately after visiting a corresponding gadget in the previous room. Correspondingly, whenever we intend Rico to continue on to in the intended call stack, we will precede the chest containing with a gadget followed by a one-way.

The crux of the gadget is a stateful memory room shared by a Prove-Verify pair and , shown in Figure 4. If the green block is in the pit, the gadget is Unset, for Rico cannot retrieve the key (or indeed, leave the gadget at all once falling down the cliff next to the entry). If the block is not in the pit, Rico can jump on it to retrieve the other block up on the ledge, and put both of them in the pit which is enough to get up to the key and back around to the exit. Of course, after doing so the green block is in the pit and the gadget is unset again.

(a) Unset state.
(b) Set state.
Figure 4: The Mem component of the Prove-Verify gadget.

The Prove gadget simply gives Rico a block to take into the corresponding Verify chest with which they can retrieve the green block from the pit (by using both the extra block and the block up on the ledge), shown in Figure 4(a). At no point can anything but the block enter the Mem room, due to the 3 block high barrier which Rico cannot carry any object over. Similarly, no object but the key may exit the Mem gadget, and bringing the key out of the Mem chest while in the Prove chest is clearly not useful due to the same barrier preventing it going anywhere else.

(a) Prove gadget .
(b) Verify gadget .
Figure 5: The Prove and Verify gadgets.

The Verify gadget, shown in Figure 4(b), is intended to allow retrieval of a single key if the corresponding Mem room is set. It is a bit more complicated in order to prevent cheating. The intended usage is to jump into the Mem room and retrieve a key, then throw that key against the door on the left to allow access to the other key, which can then be brought out of the Verify chest.

It is important to maintain the invariant that no object (other than a block from the corresponding Prove gadget) can enter the Mem chest, because if Rico could bring in, say, another chest, they could then move the green glowing block from the Mem chest into some other room, and this could subsequently result in Bad Things. First, note that the Mem chest only appears in the Prove and Verify gadgets. For the Prove gadget, the 3 tile high barrier ensures that nothing can be brought from the entrance of the gadget to the Mem chest. For the Verify gadget, we again use a 3 tile high barrier which nothing can be carried over. However, in order to allow the Mem chest state to interact with the rest of the gadget, we require a gap which the key retrieved from the Mem room can be thrown through, opening the door on the left. The important observation is that no object can be usefully thrown through the gap except a key going from right to left hitting and opening the door. Any other object will hit a wall or the door and land inaccessibly in the pit under one of the ledges. Thus, again, no object can enter the Mem chest, and no object can leave the Mem chest except a key, and therefore no object can leave the Verify chest except the key behind the door. Finally, we need to ensure that the Mem chest itself cannot exit the Prove or Verify gadgets. Once again, the 3 tile high barriers and the ledges also prevent this.

Note that Rico could bring in a key from outside to open the door with, but all this would achieve is replacing the old key with a new key, so doing so cannot be eminently useful.


We will also use a variant of the Prove-Verify gadget semantics which we will call a Global-Lock (GL). The Global-Lock can be ‘set’ just once, and subsequently used to retrieve a key any number of times. The Global-Lock gadget will only be used to allow Rico to transition between the domino selection phase and the “popping” phase, and subsequently verify that the transition was made. The Global-Lock is just a room with a green glowing locked door with a key behind it (see Figure 6). As long as the door is locked, the key is irretrievable, but once Rico is given a key to take into even one chest containing the Global-Lock room, they can permanently unlock the door and allow all the other chests containing this room to dispense keys.

Figure 6: The Global-Lock gadget.

3.3 Component rooms

In this section, we describe the macro-level component rooms of the construction. Many of them are fairly simple to implement in a way that allows Rico to act in the intended way, but have many additional complications which prevent Rico from cheating, usually in the form of Prove-Verify gadgets separated by One-Ways.

For every following gadget, there is always a one-way path from any terminus back to the exit, since we will need to pop all the rooms off the call stack later.


The Domino-Choice gadget is constructed with a series of rooms, , which are structured in a binary tree. In each room, shown in Figure 7, Rico can choose which of two paths to take, and each leaf of the tree will contain two chests each corresponding to choosing a particular domino to place (and one additional chest for choosing to stop)7. The binary tree or a similar structure is necessary to ensure that the level specification contains only a bounded number of objects per room, which is a real requirement of levels in the game, preventing us from simply packing all domino choice chests into a single room. is the th possible room Rico can be in at depth in the tree.

Figure 7: The Domino-Choice rooms.

In order to prevent Rico from cheating later on when popping the call stack, each choice room also has an initial Verify chest , which for simplicity is the same for all chests at a particular depth , and which verifies that Rico came from an intended place (i.e. a chest at depth ). Correspondingly, each has a Prove chest, , followed by a One-Way preceding chest selection, proving that Rico really is allowed to go into one of the subsequent chests now.

The leaf nodes of the binary tree structure contain chests pointing to rooms for each Domino (see below). Similarly, the Prove chest in the leaf nodes will correspond to , which is a special Prove chest corresponding to all rooms simultaneously (see Section 3.3.2). If the top half string of Domino happens to be empty, then will be replaced with . These Prove-Verify pairs are important because when Rico later pops out of, say, when back-traversing the call stack, they cannot (usefully) go back into that chest because the first element will be an untraversable chest, and Rico cannot back-track to the corresponding chest because it is behind a one-way.

Whichever chest Rico chooses, when they eventually pop back out of it, we will require that they have switched to the checking phase in order to progress, and so we place one final Global-Lock gadget after a One-Way before allowing traversal back to the exit.


Consider the th symbol in the top half of the th domino. We uniquely identify that location by and the (nonunique) symbol by . Similarly, we label the bottom half locations corresponding to symbol . Each location has a corresponding room, also labeled , shown in Figure 8.

Figure 8: The rooms.

Pushing. During the pushing phase, Rico will do the following. Upon entering, Rico must interact with several elements, each separated from the next by a one-way:

  1. Traverse a Proof-of-Holding gadget

  2. Traverse a gadget

  3. Traverse a gadget

  4. Enter a chest leading to the next symbol room, .

Note that if , then will be replaced with independent of as described in Section 3.3.1. If is the last symbol in the top half string for this domino (i.e. Domino has exactly top half symbols), and will be replaced with and respectively (see Section 3.3.3). If the bottom string of Domino is empty, the replacements will instead be the first Domino-Choice room, , and , respectively. This is as far as Rico will go during the Domino Selection phase.

Popping. Of course, that is not the end of the room, for when Rico jumps back out of the chest they entered in step 4 above during the Popping phase, this is the point where they will need to pop a symbol from and prove that it is equal to . Note that Rico will not be able to usefully go back into the chest they just jumped out of, since there will immediately be an untraversable gadget.

During the checking phase, Rico must take the following steps, comprising a 2-way handshake to prove that and are equal to each other. Again, all elements are separated by One-Ways (besides entering and exiting held jars, of course).

  1. Traverse the Global-Lock gadget to prove the checking phase has been entered and a “handshake” chest , allowed in either order to save space. The gadget will prove that the handshake has been appropriately initiated (see below).

  2. Traverse a gadget corresponding to the “bottom half version” of .

  3. Delve into the jar they should be carrying, hopefully containing with .

  4. Inside the jar (see Section 3.3.3 for details), traverse a gadget, only possible if .

  5. Traverse a gadget corresponding to the “top half version” of .

  6. Traverse a chest.

  7. Exit the jar, thereby destroying the instance, effectively popping .

  8. Traverse the from step 2 again (see below for an explanation).

  9. Traverse a gadget, again only possible if .

  10. Traverse an instance of to re-unset it from step 8.

The - handshake pair is necessary to disallow popping multiple instances of off of . Without it, after step 8, Rico could enter the new top jar, and traverse it successfully, contingent on the symbol it corresponds to being equal to . However, the gadget prevents this, since it will become unset after having traversed the previous intended jar.

Steps 8 and 10 are necessary because there is no way to prevent Rico from traversing the an extra time after exiting the jar, which could allow future unintended traversals of a somewhere else. Thus, we must simply assume that Rico will traverse the chest again and then force them to unset the in step 10.


The rooms are a bit more complicated (yes, really), shown in Figure 9. Recall that Rico is always carrying around a jar containing the chain of jars representing , with a prize (block) at the bottom. We need to force Rico to add more rooms to the jar chain. For each symbol , we will have two corresponding rooms: one room which will go on our call stack which forces us to place the other, , in our jar chain.

(a) “call stack” rooms.
(b) “jar chain” rooms.
Figure 9: The rooms.

Pushing. During the pushing phase, the intended traversal is as follows (each element separated from the next by a one-way):

  1. Traverse a Proof-of-Holding gadget.

  2. Traverse .

  3. Traverse .

  4. Enter carrying the current top jar (or, initially, the block).

  5. Traverse a Proof-of-Holding gadget, to prove Rico brought the jar chain with.

  6. Traverse (this prevents Rico from trying to push onto more than once).

  7. Traverse (allowing Rico to prove that this symbol really was pushed, and not skipped).

  8. Put down the jar and exit via green flame, creating a new jar with the chain extended by one. The jar must be put down here to allow use of the green flame (recall Section 2.5).

  9. Traverse , which is possible only if Rico really did push the new symbol.

  10. Traverse .

  11. Continue on to .

As with the chests in Section 3.3.2, if corresponds to the last symbol of domino , and will be replaced with and respectively.

Popping. During the checking phase, the are very simple. Rico does not need to prove anything while popping out of , and Rico cannot jump back into the chest they came from since they will be met by an untraversable . Thus, Rico just traverses a Global-Lock gadget to prove that they really are in the popping phase, and then loops back up to the exit and pops up.

Figure 10: The rooms while they are in the jar chain. Note, relative to the room’s initial state: (1) the One-Time-Traversal gadget has been traversed, so the ring has been moved (e.g. by being thrown against the far right wall); (2) Rico has used the green flame, so it is gone (but Rico appears where it used to be); (3) Rico has dropped the jar containing the next room in the chain next to the re-entry point, for retrieval.

The rooms, on the other hand, contain the two-way handshake machinery described in section 3.3.2. Figure 10 depicts the (intended) intermediate state of the rooms at the point when Rico re-enters the corresponding jar. To reiterate, Rico is intended to go into the top level jar containing after traversing and in the corresponding room (where if the solution is correct), but before traversing . Given this, Rico can:

  1. Jump into the jar containing .

  2. Traverse a Global-Lock gadget to prove that they are in the popping phase.

  3. Traverse .

  4. Traverse .

  5. Traverse .

  6. Carry the jar containing the rest of the chain back to the exit, returning to the room with the new jar.

Top level (start room)

As described in Section 3.1, Rico initially spawns in a room with a block and an chest, a Global-Lock chest behind a One-Way, and the crystal 4 blocks up behind a locked door, shown in Figure 2.

The room has a chest (see Section 3.3.2) which is specially initialized to Set (unlike every other chest), since we enforce that domino must be chosen first (this way we prevent winning by placing no dominoes). Rico can take the block into , and in fact, must do so in order to pass the first Proof-of-Holding gadget. This very special block will be in place of the final jar at the very end of the chain. This block is so special because it is the only block in the entire level which is not contained in a Prove-Verify gadget. Furthermore, because it exists in the starting room, which is not contained in any chests, the block can never be duplicated by any means. Rico could use this block to cheat and falsely traverse a gadget of their choice, but this would permanently lose the block and Rico will never be able to get another block outside of gadgets and thus will never be able to reach the goal crystal. Rico probably should not do that. This property is also why Rico should never leave behind the chain of jars containing the block; if the jar chain is ever lost, the goal will be unreachable. The block cannot help Rico do anything else (except reach the goal of course!), thus, it is of no more use than a jar until the very end.

If Rico tries to traverse the One-Way before opening the Global-Lock and returning to this room as in an intended solution, they will necessarily get stuck either without the block (necessary to reach the crystal) or without the chest (necessary to have any way to open the Global-Lock chest) and be unable to complete a solution.

If Rico pops back up the call stack to the very first room (so back out of the first ) while carrying the block (having traversed precisely all of the jar chain, Rico can open the locked door using the Global-Lock chest, jump on the block and reach the crystal! If Rico reaches this point but is still carrying a jar and not the block, the gadgets in the jar will be untraversable and Rico will not be able to ever reach the block. If Rico reaches the block in the jar chain without popping the call stack all the way back to the starting room, the gadgets in the remaining rooms will be untraversable (at least not without losing the block) and Rico cannot get back to the goal.

3.4 Changing phases

When Rico wants to switch from the pushing phase to the popping phase, they must choose the stop chest in the Domino-Choice room. The stop chest is a comparatively simple room, shown in Figure 11. It first contains a Proof-of-Holding gadget, followed by a Verify chest (see Section 3.3.1) followed by a Global-Lock chest… along with a key! Rico can thus permanently unlock the Global-Lock chest and allow all its instances to produce keys.

Figure 11: The Stop room which allows Rico to switch from the Pushing phase to the Checking phase.

At this point, all Rico can do is leave the room and return to the Domino-Choice room. From now on, Rico should never again be able to visit any of the chests which correspond to chests at the start of each room, so Rico should never be able to generate and traverse a fresh instance of any of the DC, , or rooms. Popping mechanisms for each room type are described above.

3.5 Victory

If Rico has managed to pop all the way back up the call stack and clear out the chain of jars so that they are again directly carrying the block, they can traverse the open Global-Lock, obtaining a key to open the door, and using the block to jump and reach the crystal!

3.6 Reduction accounting

How many rooms are there? Suppose we have possible dominoes, and the sum of the length of the strings on the top half of dominoes is and the sum of the lengths of the strings on the bottom half of dominoes is . Suppose the number of distinct symbols is .

  1. rooms (since the rooms form a binary tree structure with leaf nodes)

  2. rooms corresponding to DC Prove-Verify gadgets (Prove, Verify, and Mem)

  3. rooms

  4. rooms for Prove-Verify gadgets corresponding to

  5. rooms for Prove-Verify gadgets corresponding to rooms, other than

  6. rooms (of and varieties)

  7. rooms for Prove-Verify gadgets corresponding to rooms

  8. 6 , , and corresponding Verify and Mem rooms

  9. rooms for Prove-Verify gadgets , , etc.

  10. 3 and and rooms

  11. 1 starting room

  12. 1 Stop room

  13. 1 Global-Lock room

The resulting grand total is , which is notably linear in the PCP instance size. This confirms that the Recursed level specification has size linear in the size of a Turing Machine simulated by a PCP instance.

Correspondingly, the length of the (shortest) solution path is where is the length (number of symbols) of the PCP solution string and, as above, is the number of possible dominoes. In particular, Rico must traverse exactly one and room for each symbol in the solution string. The rooms introduce the term, since Rico must traverse a length path through the binary tree of rooms in order to select a domino to place at each step. Each domino placed must contribute at least one symbol to at least one of the top half string or the bottom half string, so at most dominoes get placed. Each of the chests in the aforementioned room requires a constant amount of time spent traversing their component gadgets (mostly Prove-Verify rooms), resulting in a total of as claimed.

4 Open Problems

Although we achieve a tight result of RE-completeness, we could still ask about the complexity of Recursed with a subset of the puzzle mechanics. We propose two conjectures and two open problem relating to subsets of Recursed mechanics:

Conjecture 1 (Cauldrons but no Jars).

We conjecture that Recursed with Cauldrons, but no Jars, is still undecidable.

This conjecture seems very likely because Cauldrons (which are intended to intuitively represent multi-threading) allow Rico to jump between different “worlds” (up to , represented visually by background color) which each have their own chest history. Thus, it should not be difficult to build a reduction similar to ours which makes use of multiple stacks to simulate PCP or 2-stack Push Down Automata, both of which are undecidable.

Conjecture 2 (No Cauldrons or Jars).

Recursed without Cauldrons or Jars can be simulated by a Push-Down Automata, and is therefore undecidable.

The main difficulty with proving this conjecture is that during a solution, rooms can contain an unbounded number of objects (blocks, keys, or chests), and such state can not be trivially stored in either the automata head, or on the stack. However, we conjecture that after some bounded point, more objects of a given type cannot help towards a solution, and can therefore be forgotten. However, this seems difficult to prove.

Open Problem 1 (Jars or Cauldrons but no Green Glow).

What is the complexity of Recursed with Jars or Cauldrons or both, but without green glowing objects?

Green glowing objects are not required to build some form of two or more stateful stacks with either Jars or Cauldrons, but it seems very difficult to construct reductions without them. It’s possible that there simply is not enough interaction amongst the limited set of objects in Recursed for this problem class to be undecidable, but it seems quite difficult to rule out.

Open Problem 2.

What is the complexity of Recursed restricted to a polynomial-length “room stack” (analogous to call stack)?

This problem is naturally in NPSPACEPSPACE, but is it PSPACE-complete? This question likely needs a different approach, as our reduction is focused on time simulation and not on multiple uses of gadgets.


This work was initiated during the 33rd Bellairs Winter Workshop on Computational Geometry, co-organized by Erik Demaine and Godfried Toussaint in March 2018 in Holetown, Barbados. We thank the other participants — in particular, Robert Hearn — for related discussions and providing an inspiring atmosphere.


  1. All products, company names, brand names, trademarks, and sprites are properties of their respective owners. Sprites are used here under Fair Use for the educational purpose of illustrating mathematical theorems.
  2. A brief recap on terminology: RE (Recursively Enumerable) is the class of decision problems whose “yes” instances are accepted by a Turing machine in finite time, but whose “no” instances may be indicated by the machine running for infinite time, while R (Recursive or Decidable) is the class of decision problems whose “yes” and “no” instances are accepted and rejected, respectively, by a Turing machine in finite time. It is known that RER; for example, the Halting Problem is in the difference RER.
  3. Inexhaustively including water, acid, Ooblecks, cauldrons, paradoxes, glitches, and cloud walls.
  4. The entry point is a property of the room itself; Rico will appear at the same entry point regardless of which chest was used to enter the room.
  5. Rico can reach a jump height of 3 tiles and is 2 tiles tall, and so can reach a crystal 5 blocks high.
  6. One might be forgiven for referring to this as the “blockchain representation” of .
  7. The playable level provided at [DK20] provides a single room with choices for simplicity. The shortest solution path, after being forced to place first, chooses the middle chest corresponding to upon first visiting the room, and the final chest corresponding to Stop on the second and final visit.


  1. Z. Abel, J. Bosboom, E. D. Demaine, L. Hamilton, A. Hesterberg, J. Kopinsky, J. Lynch and M. Rudoy (2018-06) Who witnesses The Witness? Finding witnesses in The Witness is hard and sometimes impossible. In Proceedings of the 9th International Conference on Fun with Algorithms (FUN 2018), La Maddalena, Italy, pp. 3:1–3:21. Cited by: §1.
  2. J. Ani, S. Asif, E. D. Demaine, Y. Diomidov, D. Hendrickson, J. Lynch, S. Scheffler and A. Suhl (2019-09) PSPACE-completeness of pulling blocks to reach a goal. In Abstracts from the 22nd Japan Conference on Discrete and Computational Geometry, Graphs, and Games (JCDCGGG 2019), Tokyo, Japan, pp. 31–32. Cited by: §3.2.4.
  3. A. Churchill, S. Biderman and A. Herrick (2019) Magic: The Gathering is Turing complete. Note: arXiv:1904.09828\url Cited by: §1.
  4. A. Churchill (2012) Magic: the Gathering is Turing complete. Note: \url hologram/Turing/ Cited by: §1.
  5. (2017) Computational complexity theory Steam curator. Note: Steam curator page claiming hardness results for various games.\url Cited by: §1.
  6. M. J. Coulombe and J. Lynch (2018-06) Cooperating in video games? impossible! undecidability of team multiplayer games. In Proceedings of the 9th International Conference on Fun with Algorithms (FUN 2018), H. Ito, S. Leonardi, L. Pagli and G. Prencipe (Eds.), LIPIcs, Vol. 100, La Maddalena, Italy, pp. 14:1–14:16. External Links: Link, Document Cited by: §1.
  7. E. D. Demaine, I. Grosof, J. Lynch and M. Rudoy (2018-06) Computational complexity of motion planning of a robot through simple gadgets. In Proceedings of the 9th International Conference on Fun with Algorithms (FUN 2018), LIPIcs, Vol. 100, La Maddalena, Italy, pp. 18:1–18:21. Cited by: §3.2.4.
  8. E. D. Demaine and J. Kopinsky (2020) Recursed-xls2lua. Note: Tool to convert xls descriptions of Recursed levels to playable lua files, with examples.\url Cited by: §1, §3.1, footnote 7.
  9. edderiofer (2017) Edderiofer Steam review. Note: User review for Recursed which conjectures undecidability.\url Cited by: §1.
  10. L. Hamilton (2014) Braid is undecidable. arXiv:1412.0784. Note: \url Cited by: §1, §1.
  11. R. A. Hearn and E. D. Demaine (2009) Games, Puzzles, and Computation. A. K. Peters, Ltd., Natick, MA, USA. External Links: ISBN 1568813228 Cited by: §1.
  12. M. L. Minsky (1961-11) Recursive unsolvability of Post’s problem of “Tag” and other topics in theory of Turing machines. Annals of Mathematics 74 (3), pp. 437–455. Cited by: §1.
  13. Portponky (2016) Recursed. Note: \url External Links: Link Cited by: §1.
  14. E. L. Post (1946) A variant of a recursively unsolvable problem. Bulletin of the American Mathematical Society 52 (4), pp. 264–268. Cited by: §3.
  15. M. Sipser (2012) Introduction to the theory of computation. 3rd edition, Cengage Learning. Cited by: §1, §3.
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
Add comment
Loading ...
This is a comment super asjknd jkasnjk adsnkj
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test description