Is there an L-system for aperiodic tilings of the plane with the "hat" monotile?

Question

Most aperiodic tilings of the plane, except possibly for spiral tilings like the Voderberg tiling, exhibit a fractal pattern of self-similarity. This is no exception for the recently discovered "hat" monotile.

Now, in Figure 2.12 of that paper, reproduced here for convenience,

the union of all tiles which belong to a so-called fylfot (the ones colored in gray, or black for that matter) appears to be simply connected and shows a striking similarity to the well known Gosper curve (see for instance the first example here upon scrolling down 2-3 screens), as constructed e.g. by an L-system.

(In a precise sense, we are of course not talking about the fractals themselves, rather about the iterations approximating them. But for both the iterative construction of the hat covering via metatiles and the iterations towards the very Gosper fractal, the steps correspond nicely.)

Look at the following coloring of the two regions separated by the Gosper curve and compare the appearance.

If we imagine the blue part a third wider and the black part a third narrower, the resemblance is even more striking. (Note that up to boundary effects, in the hat tiling on the right, the union of all the dark blue, light blue and white tiles also appears to be a simply connected region with the same "fractal quality" as the black/grey one, topologically equivalent so to say, just twice as "thick".)

All this is to introduce my main question, as I am sure from this that tilings by the hat monotile can also be represented (at least locally) by an L-system, which might in turn provide more information about the nature of the hat tilings.

How to come up with L-system rules to formalize/generate the structure of this pattern?

Note that the two rules for the Gosper curve,

$A=A-B--B+A++AA+B-$
$B=+A-BB--B-A++A+B$

are obtained from each other by reversing and switching everything, which I would of course expect to be similar for the hat tiling pattern.

Answer 1

(a second answer because this one is an answer)

So, I misled myself staring at the H8 in Smith et al. The way to solve this is to look at the F-supertile. That tile has 5 edges, and 4 of them are F-tiles that make up the fractal (at the next expansion level). So if we just ignore other parts of the F-supertile, it will expand to form at least part of the fractal.

The F-tiles surrounding the F-supertile each belong to a fylfot (3 F-tiles). By carefully including those F-tiles as well during the expansion, you get a curve which never draws the same edge twice.

• $A \to +A[+F]-BA[+F]-C+$
• $B \to -D+[--F]BA[-F]+B-$
• $C \to -D+[--F]BA$
• $D \to BA[+F]-C+$
• $F \to -D+[--F]BA[-F]+BA[-F]+F$

Where at level 0 symbols $C$ and $D$ are lines 1 unit long, $A$, $B$, and $F$ are lines $\dfrac{\phi}{\sqrt{2}}$ long, $-$ and $+$ are left and right turns by $\dfrac{\pi}{3}$, $[$ is stack push, and $]$ is stack pop.

Running code: https://trinket.io/python/df6f9fa4db

import turtle
import math

# use the simpler 'Golden Key' f-tile from
# Socolar, 'Quasicrystalline structure of the Smith monotile tilings'
# https://arxiv.org/pdf/2305.01174.pdf
phi = (1 + math.sqrt(5))/2
root2 = math.sqrt(2)

def expand(order, a, stack, s0, s1):
  for op in s0 if order <= 0 else s1:
    mono_op_map[op](order - 1, a, stack)    
    
def op_push(stack):
  stack.append([turtle.pos(), turtle.heading()])
  
def op_pop(stack):
  pos, hd = stack.pop()
  turtle.up()
  turtle.setpos(pos)
  turtle.setheading(hd)
  turtle.down()

# The F-supertile in Smith et al has 5 sides, 4 of which are F-tiles.
# to get an L-system for the F-tile fractal, we just expand those.
# Choosing rules carefully avoids repeating any edge.
mono_op_map = {
  "a": lambda o, a, s: turtle.forward(a*phi/root2),
  "b": lambda o, a, s: turtle.forward(a),
  "A": lambda o, a, s: expand(o, a, s, "a", "+A[+F]-BA[+F]-C+"),
  "B": lambda o, a, s: expand(o, a, s, "a", "-D+[--F]BA[-F]+B-"),
  "C": lambda o, a, s: expand(o, a, s, "b", "-D+[--F]BA"),
  "D": lambda o, a, s: expand(o, a, s, "b", "BA[+F]-C+"),
  # A free edge from a fylfot, allowed to branch everywhere.
  # Use 'B' instead of 'F' above to get a sponge.
  "F": lambda o, a, s: expand(o, a, s, "a", "-D+[--F]BA[-F]+BA[-F]+F"),
  "+": lambda o, a, s: turtle.right(60),
  "-": lambda o, a, s: turtle.left(60),
  "[": lambda o, a, s: op_push(s),
  "]": lambda o, a, s: op_pop(s),
}
stack = []
start = "A"
order = 6
size = 70/(order*order)
turtle.speed("fastest")
# this system is super slow, disable animation entirely
#turtle.hideturtle()
turtle.tracer(0, 0)
expand(order, size, stack, start, start)
turtle.update()

Answer 2

I don't know the answer to the second part of your question (yet), about the self-avoiding fylfot fractal, but here's an L-system generating outlines of patches of monotiles, implied by the H7/H8 recursion in the original paper.

Running code here: https://trinket.io/library/trinkets/274cc18bd5

The rules I came up with were:

• $U \to V++R++U++V++W++V++R--U++V++W++V++R++U--V$
• $V \to W++V++R++U++V++W++V++R--W$
• $W \to V++R++U++V++W++V++R--W++V++R++U++V++W--V$
• $R \to V++R++U++V++W++V++R--W$

with a starting pattern of $U++V++W++V++R$, where $+$ is rotate right 30 degrees, $-$ is rotate left 30 degrees, and the basic symbols $UWVR$ are defined in terms of the angle operators above and 2 straight lines of length $a$ and $b$ like so:

• $U \to a+++b--b+++a--a+++b$
• $V \to b---a$
• $W \to a+++b$
• $R \to aa$

In the production rules, there are various cycles of the starting position; those cycles are adding a monotile at the next level down in the pattern.

For the fractal: in every H8, 2 of the 7 (unflipped) tiles are part of a fylfot - and it's always the 2 at the top left of the H8 diagram... so it seems likely to me that further consideration of H8 will lead to the solution.

(Edited to remove the use of a stack; this was being used to return the turtle to the position a tile branches off the outline, but if I just complete the loop round the tile the turtle is there anyway. So now this draws a single continuous line. Also, refactored $R$ to remove an instance of $V$)