_{A strand from the infinite line in FASS_THEOREM.md (hexagons, rule 128), coloured by distance along it.}

Playing with the spectre tiling. You mark some of the edges, a line goes through each marked edge, and each tile joins up the lines coming into it. Then you see what happens: closed circuits, lines that go on forever, or both.

Mostly vibe coded and plagiarised from https://cs.uwaterloo.ca/~csk/spectre/app.html. I've included the original version of this under web_orig.

Explorer, level 3 supertile, rule 2578	Explorer in infinite mode
One strand traced on the infinite map	Infinite map, zoomed in
A Delta supertile split into its eight children	The Tails Problem
Classifications	Strand machine

Each screenshot links to the same view on the site.

The Spectre proof sorts tiles into nine types: Gamma, Delta, Theta, Lambda, Xi, Pi, Sigma, Phi and Psi. Gamma is a pair of Spectres (the "Mystic"), so it's split into Gamma1 and Gamma2, giving ten tile types.

Each tile's 14 edges are grouped into seams (about six per tile). A seam is where two tiles meet, and it has a class from 0 to 8. A 3 seam always meets a -3 seam. Class 7 only shows up inside the Mystic, so the site labels it 7(M).

1. Pick a set of classes, e.g. {2, 5, 7, 8}.
2. Every seam of a picked class gets one crossing point, where a line passes from one tile to the next. Both tiles have to agree where on the seam it is.
3. Inside each tile, join the crossings up in pairs. Every crossing joins exactly one other one, so no junctions. A tile with 4 crossings has 3 ways to do this, and each tile type picks one. That choice is the combination string, e.g. 2578-0100101100.
4. Follow the lines. Each one either closes into a circuit or keeps going.

If a tile type ends up with an odd number of crossings, one line has nothing to pair with and you get a tail. Only odd/even matters, so this is a mod 2 problem. Of the 512 possible sets, 8 work:

∅   {1,5}   {0,1,3,6}   {0,3,5,6}   {1,2,7,8}   {2,5,7,8}   {0,2,3,6,7,8}   {0,1,2,3,5,6,7,8}

Class 4 is never in any of them. The full explanation is on the Tails Problem page and in docs/EXPLAINER_COPY.md.

The open question: you can have [a fixed number | an infinite number] of infinite lines and [a fixed number | an infinite number] of circuits of unique lengths. Work out which combinations of lines between edges give each of these and which aren't possible.

• Explorer (/) - the main thing. Build supertiles, pick which edges join up, and watch the circuits light up. Tick Region colours to fill every region between the strands with its own colour, on the rooted patch and in infinite mode alike (in infinite mode a region keeps its colour as you pan). Tick Dual graph to see the dual of the strands on a rooted patch: one node per region, one edge wherever a strand separates two regions, with each node coloured by how many strands deep it sits (the dual is a tree whenever there are no junctions or dead ends). Switch it to infinite mode and tap a strand to follow it. It colours the line in a rainbow as far as the tiles on screen go, and keeps going as you pan.
• Infinite Map (/map.html) - one endless tiling per seed, expanded around the camera. Same tap-to-colour trick, plus seed and instance-budget controls. Works for all four tile families (Tile(1,1), Hexagons, Turtles in Hats, Hats in Turtles) via the family selector or f= in the URL. Region colours fills the regions between the strands, same as the Explorer. Auto-follow rides the traced strand with a smoothed camera, the Damping slider sets how floaty it is, and Record video saves the canvas to a WebM/MP4 file.
• The Tails Problem (/tails.html) - an explainer for the edge-matching stuff and why some tiles end up with tails.
• Classifications (/classifications.html) - every combination of every rule (over 600,000) as one dot, sorted into triangle fractals, infinite lines, chaotic thin circuits, space-filling hybrids and bounded loops. Pick the axes from the measurements, hover a dot to draw that combination, click to pin it. Method and scripts in web/circuit-classes/.
• Rules & isomorphism (/rules.html) - how the rules of Tile(1,1), the hexagons and the hexagon-matching Spectre labels line up, with combination counts per rule and where the combinations are the same patterns.
• Supertiles (/supertiles.html) - pull a supertile apart into the pieces it's made of.
• Strand machine (/machine.html) - walk a strand one tile at a time and see which joins the labels allow vs which the tiling actually uses.
• Legacy app (/legacy.html) - the original p5 version. It lets you draw on each of the 10 flavours of tile, has better navigation, and you can change the colours.

Edge selection 15 has a fixed, finite set of circuits and no infinite line at all. Every circuit is a loop of 3, 6 or 9 segments, and up to congruence there are only five distinct circuits across all four of its combinations. Two steps are finite checks rather than theorems and are flagged as such, so read it as a strong conditional result rather than a closed one. Write-up in docs/CIRCUITS_15.md, exact-arithmetic scripts in web/sel15-proof/, and a Lean 4 check of the combinatorial core in lean/.

The infinite line is now proved. Selection 128 on hexagons with combination 010100000, and selection 1278 on Tile(1,1) with 0101000000, make the Psi supertile's strands a single self-avoiding arc through every tile at every level, and along a chain of nested Psi supertiles that exhausts the plane those arcs grow at both ends into one bi-infinite curve. Every supertile is a combinatorial hexagon whose six edges compose from its children's edges by a fixed table, so the strand routing is a fixed operator; non-overlap of the pieces at every level comes from a covering-space argument rather than a per-level check. Write-up in docs/FASS_THEOREM.md, scripts in web/fass-theorem/, and the combinatorial core machine-checked in Lean 4 in lean/FASS/. The earlier proof plan and evidence are in docs/FASS_PROOF.md and docs/FASS_1278.md.

The original intuition, kept for the record: I'm pretty sure I can make either an infinite line but haven't got a solid proof yet. I think I'd need to rework the generator to do a kind of substitution thing instead of the standard spectre algorithm and then I could show that you make a long line/circuit, and when you substitue all the tiles for the next superset you maintain all the paths (like a standard infinite line proof, like the hilbert curve).

I plan on integrating some cool edge stuff from my blog.

cd web
npm install
npm run dev     # http://localhost:8081/Spectre/
npm test

npm run build && npm run preview serves the built version. It needs the /Spectre/ base path, so a plain static server at the root won't find the assets.

• 'Thumbs' - the editable tiles at the top of the page. Short for 'Thumbnails'.

• Do everything in shaders so it's nippy af.
• Click on a tile to bring up a large drawable window instead of having all of them at the top all the time.
• Put labels on the thumbnail boxes.
• Remove the duplicate Gamma colour boxes.
• Clean up the ui .. a lot.
• make quads, ids, and edge dots off by default.
• Make 'Show all edge numbers' only turn on/off the edge labels, not the joiner edges
• Add another checkbox for all joiner edges and put it with the joiner edges text
• Fix hexagons and 0-edges they don't need the same treatment as the other shapes.
• Colour choice for lines.
• Download a template, edit as svg and re-upload.
• analysis time in bottom
• graph showing the lines between thumbs