The tile language

How a tile is written down, and how to construct each of the 28 Heesch–Kienzle isohedral types. Every figure on this page was measured from the engine, not asserted.

• 1. A tile is a walk
• 2. Bumps and nicks
• 3. Segments and repeats
• 4. Reversal, reflection, translation
• 5. Brackets
• 6. Worked examples
• 7. The 28 types
• 8. What you asked vs what you get

1. A tile is a walk

A tile is its boundary, written as a closed walk. Each letter is one move: a turn followed by a step. Because every turn is measured against the previous edge, the same string describes the tile in any orientation — turtle geometry, not coordinates.

[@:BUBLBLBUBLBLBU]

That is a literal word: [@:…] means these exact codes. Which letters exist depends on the lattice, because each is a (turn, length) pair drawn from that lattice's own alphabet:

The workbench writes this for you: draw edges and the word appears in the family program box. Draw an open run and the segment box gives its letters, ready to paste into a definition. Its first letter is a -, because a turn is measured against the edge before it and an open run has nothing before its first edge — where the segment starts is decided by whatever you attach it to.

2. Bumps and nicks

An edge may carry a marking, written after the word and separated by a slash, one glyph per code:

^

a bump — sticks out

v

a nick — cuts in

=

flat

.

wild — unconstrained

[@:BUBLBLBU/^^==vv==]

Marks are what break a tiling. A tile built to an isohedral type tiles the plane and so has no finite Heesch number at all. Mark it so that bumps and nicks are unequal in number and every bump must still meet a nick — they cannot all be satisfied, so the tiling stops. The type guarantees it tiles, the marking guarantees it stops, and the Heesch number is what is left in between.

3. Segments and repeats

A program is a list of definitions followed by the walk. The last bare token is the walk; everything before it names a segment.

A:-4 B:-4 ABab

A:-4 defines A as four free edges. - means free: the enumerator tries every legal code there. Constrain by turn instead when you want a particular kind of corner:

-n

n free edges — any turn

=n

n straight edges (turn 0)

>n

n obtuse turns, less than 90°

|n

n right-angle turns

<n

n acute turns, more than 90°

~n

n edges that turn at all — anything but straight

So A:-6 is six free edges and A:=2<1=2 is straight, straight, a sharp turn, straight, straight. A count may follow a segment letter too: B3 is three copies of B.

4. Reversal, reflection, translation

These are how one segment becomes the matching side elsewhere on the boundary, and they are the reason the language exists.

A

the segment

a

reversal — the same segment walked the other way. This is what a translation pair looks like from inside the walk: going round the boundary, the far side is traversed backwards.

A%

reflection — the mirrored segment. A glide pair is A … A%.

a%

reflected and reversed

A#

an explicit translate of the segment

Every letter after the first occurrence is a copy: the enumerator chooses A's edges once and every A, a, A% and a% in the walk follows. That is what makes a family — one program, many tiles, all sharing one structure.

5. Brackets

[@:CODES]

literal codes, exactly as given

[@:CODES/MARKS]

literal codes with their markings

[S:A]

centrosymmetric side: A, then a 180° turn, so the side is its own partner. This is the letter C in a type pattern.

[S120:A]

paired by a 120° rotation — the letter D

[S90:A]

paired by a 90° rotation — the letter E

[S60:A]

paired by a 60° rotation — the letter F

[=:A]

constrain every edge of A to straight; likewise [<:A], [>:A], [|:A], [~:A]

[M:A,B]

try the sub-segments in every order

6. Worked examples

Two sides and their translates

A:-3 B:-3 ABab

Heesch type 1. On kisrhombille this yields 16 shapes, 14 of which the engine classifies as type 1.

The pillar family

A:-[@:LB] B:Aa% B2A-5aB%2-5

Reading it: A is a free edge followed by the literal pair LB. B is A followed by A reflected-and-reversed — a glide. The walk uses B twice, then A, five free edges, a, B reflected twice, and five more free edges. Changing the repeat counts and run lengths walks the whole family; this is the shape of program that produced the 40- and 52-edge tiles.

A literal tile

[@:BUBLBUBBBIBIBXBIBIBEAOLBUBLBL]

David Smith's shape A at √3 scale: 29 edges, unmarked, H = 4.

7. The 28 Heesch–Kienzle types

A type is a pattern read round the boundary, one letter per side:

T … t

a translation pair. Partners are t u v for the first, second and third translation.

C

a centrosymmetric side — its own 180° partner

D E F

sides paired by a 120°, 90° or 60° rotation

G … g

a glide pair. Partners are g h.

The engine knows 76 boundary patterns, which reduce to these 28 types — TCtC and CTCt are one type read from a different starting side, and the greyed aliases show the other readings. The programs are built from free segments; replace -n with your own edges to make a particular tile.

The three right-hand columns give how many of 60 generated shapes the engine actually classified as that type, at segment lengths 2–4. A number means it works; "n shapes" means shapes were produced but none of that type; — means the boundary never closed.

8. What you asked vs what you get

Two things in that table are worth taking seriously, because both are easy to assume away.

A type is not guaranteed by its program

The program fixes how the sides pair. It does not stop the edges you choose from being more symmetric than that. Ask for CCC on kisrhombille and a good share of the shapes come back classified CD or DC — the free edges happened to land so that the tile has a rotation the program never asked for. The engine reports what the tile is, which is the useful answer.

A lattice may not admit a type at all

Types 8–16, the ones built on D, E and F rotations, produced no tile of their own type on any of the three lattices surveyed. Some produced nothing at all; others produced shapes that classified elsewhere. Note that kisrhombille does carry ±90° turns, so where EE fails there it is the boundary failing to close, not a missing letter. This is a measurement at segment lengths 2–4 over 60 sampled shapes, not a proof of impossibility — a longer segment or another lattice may well close where these did not.