Why it is one strand

Every tile carries the same drawing: fourteen ribbon pieces, with one crossing inside the tile. Copies of the tile, laid without flipping, cover the plane, but never in a repeating pattern, and where two tiles meet their ribbons join up. The two theorems say how the pieces join: in every spectre tiling whose supertiles fill the plane, no strand closes into a loop; and in the tiling drawn here, all the pieces form one strand.

The proof climbs the tiling’s family tree. Steps 2 to 7 show that every supertile, however big, looks the same from outside, which rules out loops. Steps 8 and 9 follow the ribbon up the nest until everything joins. Step 10 says exactly which tilings this covers.

The proof rests on three ideas.

Black boxes. Seen from outside, a supertile is just a list of which points on its outline its ribbons join. So a big supertile can be worked out from its pieces without looking inside them, and every supertile turns out to look the same: a hook round every corner but two (steps 3 and 4).

Only even or odd. Where two supertiles share a run of edges, all that matters is whether the run is even or odd. From one level to the next, every side grows by an even number of edges. So a single computation, on the smallest supertiles, settles every level, and with it the first theorem (steps 5 to 7).

Up the nest. The tiling drawn here grows outwards from one tile. Its blocks fill the plane (step 8), and a rule computed once says where each ribbon of a block goes in the next. Three or four levels up, all the ribbons of a block are on one strand (step 9).

The marks on each step say what it rests on: cited from the spectre paper, computed by a program, or argued in words; Lean where the Lean proof assistant checks it too.

The paper states the Daedalus Theorem as Theorem A (The Daedalus Theorem; argued Lean, in part) and the Ariadne Theorem as Theorem B (The Ariadne Theorem; argued Lean, in part), and proves them in the order of this page: its section n is step n here.

“Supertiles fill the plane” means that the supertiles around any one tile grow to cover everything. When they do not, the tiling splits into two or more infinite supertiles along a fault line, and neither theorem covers it (step 10). The tile is Tile(1,1), the straight-edged form of the spectre. Laid without flipping, its tilings correspond exactly to those of the curved spectre; these are the spectre tilings meant here.

The nest tiling is fixed by its starting tile: the block of 9 around it is the Δ supertile that has the tile as its child number 1, the block of 71 around that is the Δ that has the block of 9 as its child number 1, and so on (step 8). Every picture on this site is a piece of it.

Spectre tiles group into clusters called supertiles, those group into bigger supertiles, and so on without end, every level built by the same rule.

In any spectre tiling the tiles come in clusters of eight or nine. There are nine kinds of cluster, named by Greek letters (Γ, Δ, Θ, Λ, Ξ, Π, Σ, Φ, Ψ). The clusters themselves group into bigger clusters of eight (seven for Γ), of the same nine kinds, and so on up. Every tile belongs to a level-1 supertile, which belongs to a level-2 supertile, and so on for ever.

This family tree is why the tiling can never repeat, and it is the ladder the whole proof climbs. Going up one level multiplies the number of tiles by about 8, and the length of the outline (the rim) by about 4.2.

The block sizes of the Δ supertiles are 1, 9, 71, 559, 4,401, 34,649, … tiles, with rims of 14, 46, 182, 758, 3,198, 13,534 tile edges. The tiling drawn on this site is built from a nest: N1 ⊂ N2 ⊂ N3 ⊂ …, where each block is child number 1 of the next. Every picture on the site is a piece of it.

That every tile has such a hierarchy, and that it is unique, comes from the spectre paper’s Theorems 2.2, 3.1 and 4.1 (Theorem 4.1 groups the tiles into the first supertiles; the uniqueness is part of Theorem 2.2). That every level is built by the same combinatorial rule comes from its Theorems 3.1, 4.1 and 5.1. The Spectre Knot paper restates both as its Theorem 2.1 (The spectre hierarchy; cited).

Why every level is assembled the same way. Theorems 3.1 and 4.1 of the spectre paper turn a spectre tiling into a tiling by nine marked hexagons; its Theorem 5.1 says those group into supertiles that are, combinatorially, reflected versions of the same nine hexagons. So every level is assembled by the same pattern, and each side of a bigger supertile is a row of whole sides of its children: the Spectre Knot paper’s Proposition 2.4 (The pattern holds at every level; argued), checked against the computed hierarchy at every level from 1 to 8.

Two supertiles of the same kind are copies of each other, turned and slid, down to the number of every tile inside: the paper’s Lemma 2.6 (Rigidity; argued).

Every tile carries the same drawing, and where two tiles meet, the ribbon runs straight on across the edge into the next tile. Follow it from piece to piece and one of two things happens: it comes back to where it started, a closed loop, or it runs on for ever in both directions.

Where two tiles meet along an edge, the ribbon crosses the edge at one point and crosses it on a slant: it arrives near one end of the edge and leaves near the other. So on each side of an edge there are two places a ribbon can be, one near each end. Call them ports. A tile has 14 edges, so 28 ports, and its drawing joins them in pairs.

So every port is joined to exactly two others: one by the piece inside its tile, one straight across its edge. Following a ribbon never branches and never stops, and a strand, a whole joined-up run, is either a closed loop or an endless line. The two theorems say which: in every spectre tiling whose supertiles fill the plane, never a loop (the Daedalus Theorem); in the nest tiling, just one line (the Ariadne Theorem).

This is also why the tile has to be one whose tilings never repeat: in a repeating pattern the pieces can never all lie on one strand (why).

In the paper, the drawing on the tile is Definition 3.1 (The decoration; definition), the rule for carrying a ribbon across an edge Definition 3.2 (Straight-through rule; definition), and the strands are the connected pieces of the strand graph, Definition 3.3 (Strand graph; definition). Every strand is either a ring or runs on for ever both ways: Lemma 3.4 (Strands are cycles or lines; argued Lean).

All the outside world can tell about a supertile is which points on its outline its ribbons join. So we can work out a big supertile from its pieces without looking inside them. And seen from outside, every supertile, of every kind and size, looks the same: the ribbon hooks round every corner of its outline except two, where two ribbons cross. There is no closed loop inside.

What is true of a tile is true of a supertile: each ribbon inside runs from one rim port to another (or closes into a ring, if rings exist). That pairing is everything the outside sees. So a supertile’s pairing can be found from its children’s pairings alone: put the children side by side, start at a rim port, follow the ribbon from port to port through the children until it comes out on the rim again.

At every corner of the rim except two, the ribbon that arrives on one edge turns straight round and leaves on the next edge: a hook. At the two remaining corners, the two ends of one edge, the ribbons swap partners and cross: the crossover. The single tile already looks like this: 12 hooks and one crossover. So does every supertile found by the computer.

The same holds for the 71-tile block: 182 edges, 180 corner U-turns, one crossover.

The work grows with the length of the rim, not with the number of tiles. That is why a computer can do it for every supertile of all nine kinds up to level 9, where a supertile has about 133 million tiles (in floating point, as a check; the proof itself needs only level 1, done in exact arithmetic). The program never looks inside a child: it follows ports. A ring would show up as ports left over that never reach the rim.

The pairing computed this way was checked against the drawn ribbons for every supertile of levels 1 to 3, all nine kinds: they agree port for port. The pictures on this site are drawn by the separate drawing program.

That a patch of tiles acts as a black box, a pairing of its rim ports plus any rings inside, is the paper’s Lemma 4.1 (The box of a patch; argued Lean, in part), and that the box of a glued patch comes from the boxes of its parts and their shared edges alone is Lemma 4.2 (Gluing; argued Lean, in part).

The signature is the paper’s Definition 4.3 (Signature; definition). A single tile has it: Lemma 4.4 (Signature of the tile; argued Lean). The computer found it for every supertile of every kind at every level from 1 to 9. The crossover always sits at the same place: the corner of the supertile’s Γ child, and it is one particular tile’s own crossover, handed up from Γ child to Γ child. No ring appears inside at any level.

The pictures above are a separate check of levels 0, 1 and 2: they are computed on this page’s build from the drawn ribbons, not from the port program, and the build stops if the count ever differs from “hooks at every corner but two”.

On its own, “true up to level 9” says nothing about level 10. Steps 5 to 7 turn a check at level 1 into every level.

Where two such supertiles meet along a run of edges, a ribbon zigzags along the run and comes out at the far end, on the same side if the run is even, on the other side if it is odd. Nothing else about the run matters.

Put two supertiles side by side so that they share a run of edges, with hooks at every corner along it. Follow a ribbon into the run: it hooks round the first corner in one supertile, crosses the next edge on a slant into the other, hooks round the next corner there, crosses back, and so on. It moves forward one edge at every step and changes side at every step. So after the last edge it is on the side it came in on if the run has an even number of edges, and on the other side if odd.

This is the step that makes the problem finite. A rim has thousands of corners, but along a shared run all that detail boils down to one bit: even or odd. In particular, a run two edges longer behaves exactly like the shorter one.

This is the paper’s Lemma 5.1 (Zigzag Lemma; argued Lean). Two ribbons use the run: one entering at each end, between them taking every hook on the run, alternately. The zigzag needs every corner inside the run to be a hook on both sides, that is, not a crossover corner of either supertile. It also needs the slanted crossing at every edge, which is the one rule used on every edge of every tile. Because the zigzag always moves forward, and the two ribbons between them use every port along the run, no ring can hide inside a run.

Step 7 uses it where a side is made two edges longer: one edge is cut into three, and a run of three edges joins its ends exactly as the single edge did.

A side of a bigger supertile is a row of whole sides of its children, always the same row. So the sides grow at every level, about 4.2 times longer each time, but a side with an even number of edges stays even, and an odd one stays odd.

At a higher level the children are bigger, so every side is longer. But it is longer by an even number of edges, at every level: the side lengths grow, but even stays even and odd stays odd. That is what the next step needs: a bigger supertile is assembled like a level-1 one, with every side longer by an even number of edges.

Each side’s length depends only on its letter, Proposition 6.1 (Lengths by letter; argued Lean), and every side length is a Fibonacci number, twice one, or one plus or minus two, Proposition 6.2 (Fibonacci side lengths; argued Lean), so the lengths only grow and their evenness never changes, Corollary 6.3 (Parities are constant; argued Lean). One side needs care: in the Σ child the crossover sits in the middle of a side, Lemma 6.4 (Position of A; argued Lean), so extra edges are never added right next to it, and edges added before it move it along by two; every side is at least five edges long, Lemma 6.5 (Lower bounds; argued Lean).

Make a shared run two edges longer and the ribbons come out exactly where they did before: they just zigzag round two more corners. A big supertile is built like a small one, only with every side longer by an even number of edges. So checking the smallest supertiles once settles every size: the signature passes up like falling dominoes. And as no supertile has a loop inside, no strand ever closes into a loop, in any spectre tiling whose supertiles fill the plane: the Daedalus Theorem.

Why every side keeps its odd-or-even, level after level, in pictures: Understand: why every level behaves the same.

To build a supertile from its children (step 4), put the children side by side and follow ribbons from port to port. With the children’s sides as long as at level 1, the computer did this for all nine kinds, each with the crossover pointing either way: 18 assemblies. Every one comes out with the signature, and no ring.

At a higher level every side is longer, but by an even number of edges (step 6). And making a side two edges longer is harmless. Where two children share that side, the ribbons zigzag across the two extra corners and come out where they did before (step 5). Where the side is on the outline, the two extra corners are just two more hooks. So the assembly at any level can be reached from the level-1 one, two edges at a time, without changing anything that matters.

That is the domino argument: if every level-n supertile has the signature, so does every level-(n+1) supertile, because its assembly is the level-1 assembly with longer sides. Level 1 was computed outright, so every domino falls.

That settles the first theorem. A closed loop is finite, so in a tiling whose supertiles fill the plane it would lie inside a single supertile, and no supertile has one. So every strand runs on for ever in both directions (step 3). This holds for every spectre tiling whose supertiles fill the plane, not only the one drawn here; it has also been checked in Lean, for any chain of supertiles that leaves no edge unglued.

Each of the 18 level-1 assemblies has 8 children (7 for Γ), 732 ports (640) and an outline of 182 edges (160). They were computed twice: by a program that builds them from the assembly tables and the level-1 side lengths alone, and again by the Lean proof assistant, a program that checks proofs step by step. All 18 have the signature, Computation 7.3 (The compositions at the level-1 lengths; computed Lean), and so do the nine level-1 supertiles themselves, the base case, Computation 7.5 (Base case; computed Lean, in part).

With the side lengths of step 6, the lengths of any level are reached from level 1 two edges at a time, Lemma 7.2 (Reachability; argued Lean), and two extra edges change nothing, Lemma 7.1 (Lengthening; argued Lean). So the assemblies have the signature at every level, Proposition 7.4 (Compositions at every level; argued Lean), and with the base case every supertile of every level has it: Theorem 7.6 (Signature Theorem; argued Lean).

Second checks. The same assemblies were also computed directly at the side lengths of levels 2 to 4, and with every single two-edge lengthening of the level-1 ones (1,792 of them, each with the crossover either way): all have the signature. An earlier, longer route (comparing reduced ‘skeletons’ of the assemblies level by level) gives the same result; it is kept only as a check.

The Daedalus Theorem is the paper’s Theorem A (The Daedalus Theorem; argued Lean, in part): in every spectre tiling whose supertiles fill the plane, a closed strand would lie inside a single supertile, and none has one.

Start from one tile. Take the block of 9 around it, the block of 71 around that, and so on, each block sitting in the same place (child number 1) inside the next: the nest. Each block lies well inside the block two levels up, so the blocks grow to cover the whole plane. The tiling they make is the nest tiling, the one drawn on this site.

Two things make the nest a tiling of the whole plane. The blocks are well defined: whichever level you start building from, you get the same blocks, each one child number 1 of the next. And no block touches the outline of its grandparent, the block two levels up. So every tile next to a block lies inside the block two levels up, and step by step the blocks swallow every tile.

The nest itself is the paper’s Construction 8.1 (The nest; argued), and its blocks are well defined, Proposition 8.2 (The blocks are well defined; argued). Each block shares no corner with the rim of its grandparent: in the fixed assembly pattern, the only side of the small block on its parent’s rim lies inside a side of the parent that faces a sibling one level up. So every tile next to block N_b is inside N_b+2, and the blocks swallow every tile eventually: Lemma 8.3 (Grandparent Lemma; argued Lean, in part) and Proposition 8.4 (The nest tiles the plane; argued).

Take a block, the block around it, the block around that, and so on. Each time, the pieces of the small block lie on fewer strands, until they lie on one. The blocks grow to cover the whole plane (step 8), so any two tiles end up on the same strand.

The signature says how a supertile looks from outside. It does not yet say that the pieces inside belong to one ribbon. For that, look one level up at a time. When a block sits inside the next block of the nest, each of its ribbons, followed outwards, ends on one of just five hooks of the bigger block, at the corners where the bigger block’s outline passes from one child to the next; and which of the five depends, for almost all of the small block’s outline, only on which side the ribbon leaves from (a short table covers the corners and the two crossover ribbons). (Ribbons on the one side of the small block that lies on the bigger block’s outline stay where they are, as hooks of the bigger block.)

This rule was computed once, at the level-1 sizes, and the argument of step 7 carries it to every level: two extra edges change nothing. Then follow it up. The five hooks lie well inside the sides of the bigger block, so one level further up the rule applies to them again, side by side. Three levels up (for an even-numbered block) or four (odd), every ribbon of the small block has arrived on the same hook.

The big numbers one level up are pieces lying along the side of the block that is also part of the outline of the next block: they are gathered at the level after.

Number the stretches of the bigger block’s outline (each a side of one of its children) 0 to 21. The five hooks are at the corners where stretches 9, 12, 16, 17 and 21 start; call them junctions. Junctions 16 and 17 are the two ends of the small block’s side 2, the side on the outline. For an even-numbered small block, ribbons leaving its sides 0 and 1 go to junction 17, side 3 to 16, side 4 to 12, side 5 to 9; for an odd-numbered one, side 0 to 21, side 1 to 17, sides 3, 4 and 5 to 16. Junction 9 lies on side 2 of the bigger block, 12 on side 3, 16 and 17 on side 4, 21 on side 5. In the paper this rule is Computation 9.2 (The junction map at the level-1 lengths; computed Lean) at level 1 and Lemma 9.3 (The junction map; argued Lean) at every level; where the junctions lie is Lemma 9.4 (Where the junctions lie; argued Lean).

So for an even-numbered block every ribbon is, one level up, on a hook inside side 2, 3 or 4; two levels up, inside side 4; three levels up, on junction 12. For an odd-numbered block: inside side 4 or 5; then 3 or 2; then 4; then junction 12, four levels up. This gives exactly the counts in the last columns of the table, for every block N1, N2, N3, …: Theorem 9.1 (Merging; argued Lean). The rule was computed twice at level 1, by a program and by the Lean proof assistant, and checked directly at the sizes of levels 2 to 4.

It was also checked the long way: following every ribbon one by one, for the first six blocks of the nest, up to 133 million tiles; and by an earlier, longer method that carries labels up the nest and checks 2,106 comparisons of side lengths for every block from the second on (1,980 hold because every side is at least 5 edges long; the other 126 were certified exactly, twice; the first block was computed directly). Both agree.

The finish. Take any two tiles. Both lie inside some block N_b of the nest (step 8). Every ribbon piece in them is part of an arc of N_b (a stretch of strand inside the block), because nothing closes up inside, and all arcs of N_b lie on one arc of N_b+4. So the two tiles are on the same strand. And there is no ring: a ring is finite, so the smallest supertile containing it would contain a ring, and no supertile does (step 7). Every strand is either a ring or runs on for ever both ways (step 3), so this one runs on for ever: Theorem B (The Ariadne Theorem; argued Lean, in part).

The one-strand argument is for the tiling drawn on this site, the one grown from a nest, and for no other. Other spectre tilings whose supertiles fill the plane have no closed loops either (every strand runs on for ever in both directions), but one strand is not guaranteed: computer checks suggest that some have three. Tilings with ‘fault lines’ are not covered.

A spectre tiling is determined by its chain of ancestors. The tiling here grows by always taking child number 1 (the nest). Other tilings grow from a different chain of ancestors. For all of them whose supertiles fill the plane, the “no closed loops” part of the argument applies unchanged, so every strand runs on for ever in both directions; this part has also been checked in Lean, for any chain of supertiles. The “one strand” part depends on the chain, and it appears not to hold for every chain: along one chain, with Θ and Γ supertiles alternating (child 2, then child 7), the computer finds three strands that do not join, followed exactly to level 8 and by the label method to level 20. That is evidence, not a proof, and the site claims nothing about it. A few special tilings contain two or more infinite supertiles meeting along lines of tile edges (fault tilings); those are not covered at all.

The design is the same on every tile in the strict sense: the nest tiling uses only one handedness of the spectre, so it is one drawing, turned and slid, never flipped. Over and under is a separate question: any drawing of this kind can be given a weave that alternates along every ribbon. The single-strand result is about which pieces join.

The no-loop half is the Daedalus Theorem (step 7). The three strands along another chain are described in the last section of the paper, as evidence, not a claim.