neural_tile: a self-assembling tile computer in the abstract tile assembly model. A tile binds at a site when the summed strength of its matching glues reaches tau, which is the Heaviside gate H(strength.match - tau), so growth is governed by threshold neurons. Verified: the binding decision equals the gate; a general 2-input rule-tile set grows value(x,y)=f(W,S) for f in XOR/AND/OR (529 tiles each, checked against the recurrence, XOR = Sierpinski/Rule 90); a binary counter grows one integer per row (8-bit, 255 rows, row y encodes y) with carry by cooperative binding; both directed (deterministic). Turing-universal at tau=2 (Winfree 1998). Ships variants/neural_tile.safetensors (glue tables + binding-gate weights); eval_all skips it; README section and counts updated (9 standalone machines, 28-file family).

README.md

@@ -41,9 +41,10 @@ variants/neural_reflect.safetensors                              interpreter who
 variants/neural_attractor.safetensors                            energy-based solver; a multiplier run backward factors
 variants/neural_reversible.safetensors                           reversible arithmetic core, a bijection with no erasure
 variants/neural_ca.safetensors                                   reversible cellular-automaton medium (no processor)
+variants/neural_tile.safetensors                                 self-assembling tile computer (computation as growth)
 ```
 
-Eight further machines are detailed in their own sections below, and together
+Nine further machines are detailed in their own sections below, and together
 they carry the family from the smallest possible processor to several results
 about what a threshold network can be. `neural_subleq8` is a Turing-complete
 one-instruction computer whose entire control flow is a single threshold
@@ -69,7 +70,10 @@ reconstruct its input, a processor with no Landauer erasure floor. And
 `neural_ca` has no processor at all: one fixed reversible rule applied to every
 2x2 block of a lattice (a Margolus cellular automaton), where a particle
 collision computes an AND gate and ballistic transport plus collisions are the
-billiard-ball universality primitives.
+billiard-ball universality primitives. And `neural_tile` computes by
+self-assembly: a tile set whose binding rule is a threshold gate grows a crystal
+that is the trace of a computation, a Sierpinski (Rule 90) pattern or a binary
+counter, Turing-universal at temperature 2 (Winfree 1998).
 
 ---
 
@@ -365,7 +369,7 @@ Every weight and bias tensor in the canonical model fits in `int8`. The eval pip
 
 The 8-bit arithmetic and ALU tests use strategic sampling rather than the full 65,536-case sweep because exhaustive coverage at 8-bit is feasible but not necessary given that the circuits are constructed gate-by-gate. The 16-bit and 32-bit arithmetic tests sample edge cases only; full exhaustive coverage at those widths is infeasible without specialized hardware.
 
-`src/eval_all.py` runs the unified suite. Exit code is the number of failing variants (0 means all pass). **Testing is evaluation, not rebuilding**: `python src/eval_all.py variants/` scores all 18 fitness variants against the shipped weights in about two minutes (~6 s each, the composed float netlists evaluated in `NetlistEvaluator`'s leveled mode) and cleanly skips the eight standalone machines. Rebuilding the models (`tools/build_all.py`, ~50 min for all 18) is a separate step, needed only when the circuit constructions in `src/build.py` change; routine verification never rebuilds. The batched evaluator is population-safe: every chained intermediate (carry, borrow, mux select) is computed per population slot, so `tools/prune_weights.py`'s parallel fitness screens are exact rather than slot-0 approximations.
+`src/eval_all.py` runs the unified suite. Exit code is the number of failing variants (0 means all pass). **Testing is evaluation, not rebuilding**: `python src/eval_all.py variants/` scores all 18 fitness variants against the shipped weights in about two minutes (~6 s each, the composed float netlists evaluated in `NetlistEvaluator`'s leveled mode) and cleanly skips the nine standalone machines. Rebuilding the models (`tools/build_all.py`, ~50 min for all 18) is a separate step, needed only when the circuit constructions in `src/build.py` change; routine verification never rebuilds. The batched evaluator is population-safe: every chained intermediate (carry, borrow, mux select) is computed per population slot, so `tools/prune_weights.py`'s parallel fitness screens are exact rather than slot-0 approximations.
 
 ---
 
@@ -529,7 +533,7 @@ then the byte-for-byte safetensors file of the host itself.
 
 The equality is machine-checked rather than observed on one run:
 
-- the recipe codec round-trips every file in the family (all 27 shipped
+- the recipe codec round-trips every file in the family (all 28 shipped
   `.safetensors`, 971 MB, byte-identical and sha-verified);
 - the constructor program is executed on three independently-verified
   backends — a pure-integer reference, the gate-graph `SubleqThresholdCPU`
@@ -706,6 +710,39 @@ python tools/build_ca.py     # ship the block rule as a ternary matrix tile (per
 
 ---
 
+## neural_tile — computation as self-assembly
+
+A tile computer in the abstract tile assembly model. The program is a finite set
+of square tiles with glue labels and integer strengths on their edges; a seed is
+placed and tiles accrete onto the assembly by one rule: a tile binds at an empty
+site when the summed strength of its glues that match the already-present
+neighbors reaches the temperature tau. That binding decision is the Heaviside
+gate `H(sum_d strength_d * match_d - tau)`, weights the glue strengths and bias
+`-tau`, so every attachment is a threshold neuron and the assembly grows site by
+site under the family's gate. At tau = 2 the model is Turing-universal
+(Winfree 1998).
+
+Two directed tile sets are verified. The rule-tile set computes
+`value(x,y) = f(value(x-1,y), value(x,y-1))` for any 2-input `f`: with `f` = XOR
+the assembly is the Sierpinski triangle (Rule 90), and AND and OR grow their own
+patterns, each of 529 tiles checked cell by cell against the recurrence. The
+binary counter grows one integer per row: at 8-bit width it fills 255 rows and
+row y encodes the integer y, with the increment carry propagating westward by
+cooperative binding. Both tile sets are directed, so a unique tile binds at each
+site and the assembly is deterministic.
+
+The shipped `variants/neural_tile.safetensors` stores the counter tile set as its
+glue tables together with the per-tile binding-gate weights (glue strengths) and
+bias (`-tau`); reloading it regrows the counter and reproduces the binding
+decision from the gate.
+
+```bash
+python src/tile.py           # binding gate, XOR/AND/OR rule tiles, binary counter
+python tools/build_tile.py   # ship + regrow variants/neural_tile.safetensors
+```
+
+---
+
 ## Threshold logic
 
 A threshold gate computes a Boolean function by taking a weighted sum of binary inputs and comparing the result to a threshold; the output is 1 when the sum meets or exceeds the threshold and 0 otherwise. Equivalently, it is a neuron with Heaviside step activation, integer weights, and an integer bias.
@@ -878,10 +915,11 @@ Loss components: BCE on output bits, BCE on extracted A and B bits (2× weight),
 
 ```
 neural_computer.safetensors         canonical model (32-bit, 64 KB, ~8.61M params)
-variants/                           18 fitness variants + 8 standalone machines
+variants/                           18 fitness variants + 9 standalone machines
                                     (neural_subleq8, neural_rv32, neural_matrix8,
                                      neural_subleq8io, neural_reflect,
-                                     neural_attractor, neural_reversible, neural_ca)
+                                     neural_attractor, neural_reversible, neural_ca,
+                                     neural_tile)
 src/                                the library (run scripts as `python src/<name>.py`)
   ├── build.py                      generator (one safetensors per invocation; also `subleq`, `rv32`)
   ├── quantize.py                   min integer dtypes + ternary verification/repair
@@ -901,15 +939,17 @@ src/                                the library (run scripts as `python src/<nam
   │                                 Bennett construction
   ├── reversible_cpu.py             reversible register machine: bijective step, backward execution
   ├── reversible_prog.py            structured reversible programs (multiply, Fibonacci, Janus IF)
-  └── ca.py                         neural_ca: reversible Margolus cellular automaton, threshold
-                                    block rule, lattice reversibility and billiard-ball dynamics
+  ├── ca.py                         neural_ca: reversible Margolus cellular automaton, threshold
+  │                                 block rule, lattice reversibility and billiard-ball dynamics
+  └── tile.py                       neural_tile: abstract tile assembly, threshold binding rule,
+                                    XOR/Sierpinski and binary-counter tile sets
 tools/                              build_all.py (build + quantize + verify every profile),
                                     cpu_programs.py (assembler + CPU program suite), test_cpu.py
                                     (program suite vs a variant), play.py (interactive demo),
                                     prune_weights.py (GPU-batched weight reduction),
                                     build_attractor.py / test_attractor.py (neural_attractor),
                                     build_reversible.py / reversible_matrix.py (neural_reversible),
-                                    build_ca.py (neural_ca matrix tile)
+                                    build_ca.py (neural_ca matrix tile), build_tile.py (neural_tile)
 llm_integration/                    SmolLM2 extractor + circuit wrapper + training code
   ├── circuits.py                   FrozenThresholdCircuits (loads safetensors, exposes
   │                                 add_8bit / sub_8bit / mul_8bit / compare_*)

src/eval_all.py

@@ -673,6 +673,7 @@ MACHINE_VERIFIER = {
     "attractor": "tools/test_attractor.py",
     "reversible": "src/reversible.py",
     "ca": "src/ca.py",
+    "tile": "src/tile.py",
 }
 
 

src/tile.py

@@ -0,0 +1,222 @@
+"""Self-assembling tile computer (abstract tile assembly model).
+
+Computation is the growth of a crystal. The program is a finite set of square
+tiles; each edge carries a glue label with an integer strength. A seed is placed
+and tiles accrete onto the assembly by one rule: a tile binds at an empty site
+if the summed strength of the glues that match its already-present neighbors is
+at least the temperature tau. That binding rule is a threshold gate,
+
+    bind = H( sum_d strength_d * match_d  -  tau ),
+
+a weighted sum of matching-glue indicators against tau, so every attachment is
+decided by the same Heaviside neuron the rest of the repository is built from.
+At tau = 2 the model is Turing-universal (Winfree 1998): a directed tile set
+grows a unique structure, and that structure is the trace of a computation.
+
+Sides are N,E,S,W; a tile's N glue abuts its north neighbor's S glue, and so on.
+A glue label "" is the null glue (strength 0, matches nothing). Glue strengths
+are a property of the label (matching glues have equal strength), held in a map.
+"""
+from __future__ import annotations
+from typing import Dict, List, Optional, Tuple
+
+# side -> (dx, dy, my_side, neighbor_side)
+_SIDES = [(0, 1, "N", "S"), (1, 0, "E", "W"), (0, -1, "S", "N"), (-1, 0, "W", "E")]
+
+
+class Tile:
+    __slots__ = ("N", "E", "S", "W", "name")
+
+    def __init__(self, N="", E="", S="", W="", name=""):
+        self.N, self.E, self.S, self.W, self.name = N, E, S, W, name
+
+    def glue(self, side):
+        return getattr(self, side)
+
+
+def bind_strength(A: Dict[Tuple[int, int], Tile], x: int, y: int, t: Tile,
+                  strength: Dict[str, int]) -> int:
+    """Summed strength of t's glues that match the abutting neighbor glues."""
+    s = 0
+    for dx, dy, side, opp in _SIDES:
+        nb = A.get((x + dx, y + dy))
+        if nb is None:
+            continue
+        g = t.glue(side)
+        if g and g == nb.glue(opp):
+            s += strength.get(g, 1)
+    return s
+
+
+def binds(A, x, y, t, tau, strength) -> bool:
+    """The threshold-gate binding decision: H(sum strength*match - tau)."""
+    return bind_strength(A, x, y, t, strength) >= tau
+
+
+def grow(tileset: List[Tile], seed: Dict[Tuple[int, int], Tile], tau: int,
+         strength: Dict[str, int], bounds: Tuple[int, int, int, int],
+         max_tiles: int = 100000) -> Tuple[Dict[Tuple[int, int], Tile], bool]:
+    """Directed growth from a seed. Returns (assembly, deterministic): at every
+    site at most one tile binds when the set is directed, so the assembly is
+    unique. deterministic=False flags a site where two tiles could bind."""
+    x0, y0, x1, y1 = bounds
+    A = dict(seed)
+    deterministic = True
+    changed = True
+    while changed and len(A) < max_tiles:
+        changed = False
+        frontier = set()
+        for (x, y) in list(A):
+            for dx, dy, _, _ in _SIDES:
+                p = (x + dx, y + dy)
+                if p not in A and x0 <= p[0] <= x1 and y0 <= p[1] <= y1:
+                    frontier.add(p)
+        for (x, y) in frontier:
+            binders = [t for t in tileset if binds(A, x, y, t, tau, strength)]
+            if len(binders) == 1:
+                A[(x, y)] = binders[0]
+                changed = True
+            elif len(binders) > 1:
+                deterministic = False
+    return A, deterministic
+
+
+# ---------------------------------------------------------------------------
+# XOR / Sierpinski tile set: value(x,y) = value(x-1,y) XOR value(x,y-1)
+# ---------------------------------------------------------------------------
+def rule2_tileset(fn) -> List[Tile]:
+    """Rule tiles for value(x,y) = fn(W-input, S-input): four tiles, each binds
+    cooperatively (S and W, strength 1 each = tau) and emits fn on N and E."""
+    ts = []
+    for s in (0, 1):
+        for w in (0, 1):
+            v = fn(w, s)
+            ts.append(Tile(N=f"v{v}", E=f"v{v}", S=f"v{s}", W=f"v{w}",
+                           name=f"R w{w} s{s} -> {v}"))
+    return ts
+
+
+def sierpinski_tileset() -> List[Tile]:
+    return rule2_tileset(lambda w, s: w ^ s)
+
+
+def _row_col_seed(bottom: List[int], left: List[int]):
+    """Seed the bottom row (y=0) and left column (x=0) with fixed value tiles,
+    presenting value glues north and east for the rule tiles above/right."""
+    seed = {}
+    for x, b in enumerate(bottom):
+        seed[(x, 0)] = Tile(N=f"v{b}", E="", S="", W="", name=f"seedB{x}={b}")
+    for y, l in enumerate(left):
+        if y == 0:
+            continue
+        seed[(0, y)] = Tile(N="", E=f"v{l}", S="", W="", name=f"seedL{y}={l}")
+    return seed
+
+
+def _test_binding_gate():
+    """The binding decision is exactly the Heaviside threshold gate."""
+    strength = {"v0": 1, "v1": 1}
+    ts = sierpinski_tileset()
+    A = {(1, 0): Tile(N="v1"), (0, 1): Tile(E="v0")}
+    bad = 0
+    for t in ts:
+        for x, y in [(1, 1)]:
+            w = sum(strength.get(t.glue(side), 1)
+                    for dx, dy, side, opp in _SIDES
+                    if A.get((x + dx, y + dy)) and t.glue(side)
+                    and t.glue(side) == A[(x + dx, y + dy)].glue(opp))
+            gate = 1 if (w - 2) >= 0 else 0                # H(sum*match - tau)
+            if gate != int(binds(A, x, y, t, 2, strength)):
+                bad += 1
+    print(f"  binding decision == Heaviside gate H(sum-tau): {'OK' if bad == 0 else 'FAIL'}")
+    return bad == 0
+
+
+def _test_rule2(fn, name, n=24):
+    strength = {"v0": 1, "v1": 1}
+    bottom = [1 if x == 0 else 0 for x in range(n)]
+    left = [1 if y == 0 else 0 for y in range(n)]
+    seed = _row_col_seed(bottom, left)
+    A, det = grow(rule2_tileset(fn), seed, 2, strength, (0, 0, n - 1, n - 1))
+
+    def val(x, y):
+        t = A.get((x, y))
+        return None if t is None else (1 if t.N == "v1" else 0)
+
+    ref = {(x, 0): bottom[x] for x in range(n)}
+    ref.update({(0, y): left[y] for y in range(n)})
+    for y in range(1, n):
+        for x in range(1, n):
+            ref[(x, y)] = fn(ref[(x - 1, y)], ref[(x, y - 1)])
+
+    filled = bad = 0
+    for y in range(1, n):
+        for x in range(1, n):
+            v = val(x, y)
+            if v is not None:
+                filled += 1
+                bad += v != ref[(x, y)]
+    tag = "OK" if (det and bad == 0 and filled > 0) else "FAIL"
+    print(f"  rule-tile CA fn={name:3s}: directed={det}  placed={filled}  "
+          f"every tile = fn(W,S) {tag}")
+    return det and bad == 0 and filled > 0
+
+
+# ---------------------------------------------------------------------------
+# Binary counter: each row is the row below plus one. LSB is the right column;
+# carry propagates west by cooperative binding (S = bit below, E = carry in).
+# ---------------------------------------------------------------------------
+def counter_tileset() -> List[Tile]:
+    ts = []
+    for b in (0, 1):
+        for c in (0, 1):
+            ts.append(Tile(N=f"b{b ^ c}", E=f"c{c}", S=f"b{b}", W=f"c{b & c}",
+                           name=f"C b{b} c{c} -> b{b ^ c} carry{b & c}"))
+    ts.append(Tile(N="edge", E="", S="edge", W="c1", name="edge(+1 injector)"))
+    return ts
+
+
+def counter_seed(n: int):
+    """Bottom row (y=0) all zero, plus the right-edge +1 injector column base."""
+    seed = {}
+    for x in range(n):
+        seed[(x, 0)] = Tile(N="b0", name=f"seed b0 col{x}")
+    seed[(n, 0)] = Tile(N="edge", W="c1", name="seed edge")
+    return seed
+
+
+def _test_counter(n=6, rows=None):
+    rows = rows or (1 << n) - 1
+    strength = {"edge": 2}                       # value/carry glues default 1
+    A, det = grow(counter_tileset(), counter_seed(n), 2, strength,
+                  (0, 0, n, rows))
+
+    def rowval(y):
+        bits = []
+        for x in range(n):
+            t = A.get((x, y))
+            if t is None:
+                return None
+            bits.append(1 if t.N == "b1" else 0)
+        return sum(bit << (n - 1 - x) for x, bit in enumerate(bits))
+
+    bad = filled = 0
+    for y in range(1, rows + 1):
+        v = rowval(y)
+        if v is not None:
+            filled += 1
+            if v != (y & ((1 << n) - 1)):
+                bad += 1
+    print(f"  binary counter {n}-bit: directed={det}  rows grown={filled}  "
+          f"row y encodes the integer y {'OK' if bad == 0 else f'FAIL({bad})'}")
+    return det and bad == 0 and filled == rows
+
+
+if __name__ == "__main__":
+    print("Self-assembling tile computer")
+    a = _test_binding_gate()
+    b = all(_test_rule2(fn, nm) for fn, nm in
+            [(lambda w, s: w ^ s, "XOR"), (lambda w, s: w & s, "AND"),
+             (lambda w, s: w | s, "OR")])
+    c = _test_counter()
+    print("PASS" if (a and b and c) else "FAIL")

tools/build_tile.py

@@ -0,0 +1,89 @@
+"""Ship the self-assembling tile computer as variants/neural_tile.safetensors: a
+tile set (the binary counter) stored as its glue tables, together with the
+binding gate that governs growth. A tile binds at a site when the summed
+strength of its matching glues meets tau, which is the Heaviside gate
+H(strength . match - tau) with per-tile weights = glue strengths and bias = -tau.
+Round-trips the file, regrows the counter, and confirms row y encodes y."""
+from __future__ import annotations
+import json
+import os
+import sys
+
+import torch
+from safetensors.torch import save_file, load_file
+from safetensors import safe_open
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, os.path.join(ROOT, "src"))
+import tile as T
+
+OUT = os.path.join(ROOT, "variants", "neural_tile.safetensors")
+NBITS = 8
+TAU = 2
+
+
+def main() -> int:
+    ts = T.counter_tileset()
+    strength = {"edge": 2}
+    glues = sorted({g for t in ts for g in (t.N, t.E, t.S, t.W) if g})
+    gid = {g: i for i, g in enumerate(glues)}
+    tile_glues = torch.tensor([[gid.get(t.N, -1), gid.get(t.E, -1),
+                                gid.get(t.S, -1), gid.get(t.W, -1)] for t in ts],
+                              dtype=torch.long)
+    glue_strength = torch.tensor([strength.get(g, 1) for g in glues], dtype=torch.long)
+    # per-tile binding-gate weights = strengths of the tile's four glues (0 = null)
+    bind_w = torch.tensor([[strength.get(g, 1) if g else 0 for g in (t.N, t.E, t.S, t.W)]
+                           for t in ts], dtype=torch.long)
+    tensors = {"tile_glues": tile_glues, "glue_strength": glue_strength,
+               "binding_weight": bind_w, "binding_bias": torch.tensor(-TAU)}
+    meta = {"machine": "tile", "tau": str(TAU), "glues": json.dumps(glues),
+            "tile_names": json.dumps([t.name for t in ts]), "program": "binary counter"}
+    save_file(tensors, OUT, metadata=meta)
+    print(f"Built {os.path.relpath(OUT, ROOT)}: binary-counter tile set")
+    print(f"  tiles={len(ts)}  glues={len(glues)}  tau={TAU}  size={os.path.getsize(OUT)} bytes")
+
+    # round-trip: reconstruct the tiles from the file and regrow the counter
+    t = load_file(OUT)
+    with safe_open(OUT, framework="pt") as f:
+        m = f.metadata()
+    gl = json.loads(m["glues"])
+    strg = {gl[i]: int(s) for i, s in enumerate(t["glue_strength"].tolist())}
+    tiles = []
+    for row, name in zip(t["tile_glues"].tolist(), json.loads(m["tile_names"])):
+        sides = [gl[i] if i >= 0 else "" for i in row]
+        tiles.append(T.Tile(N=sides[0], E=sides[1], S=sides[2], W=sides[3], name=name))
+
+    rows = (1 << NBITS) - 1
+    A, det = T.grow(tiles, T.counter_seed(NBITS), int(m["tau"]), strg,
+                    (0, 0, NBITS, rows))
+    bad = filled = 0
+    for y in range(1, rows + 1):
+        cells = [A.get((x, y)) for x in range(NBITS)]
+        if any(c is None for c in cells):
+            continue
+        filled += 1
+        v = sum((1 if c.N == "b1" else 0) << (NBITS - 1 - x) for x, c in enumerate(cells))
+        if v != (y & ((1 << NBITS) - 1)):
+            bad += 1
+    print(f"  round-trip regrow {NBITS}-bit counter: directed={det}  rows={filled}  "
+          f"row y == y {'OK' if bad == 0 else f'FAIL({bad})'}")
+
+    # the stored binding gate reproduces the model's binding decision
+    gate_ok = True
+    Atest = {(1, 0): T.Tile(N="b0"), (2, 0): T.Tile(N="b0")}
+    for ti, tt in enumerate(tiles):
+        for site in [(1, 1), (2, 1)]:
+            w = t["binding_weight"][ti].tolist()
+            match = [1 if tt.glue(side) and Atest.get((site[0] + dx, site[1] + dy))
+                     and tt.glue(side) == Atest[(site[0] + dx, site[1] + dy)].glue(opp) else 0
+                     for dx, dy, side, opp in T._SIDES]
+            gate = 1 if sum(wi * mi for wi, mi in zip(w, match)) + int(t["binding_bias"]) >= 0 else 0
+            if gate != int(T.binds(Atest, site[0], site[1], tt, TAU, strg)):
+                gate_ok = False
+    print(f"  stored binding gate H(weight.match - tau) matches growth rule: "
+          f"{'OK' if gate_ok else 'FAIL'}")
+    return 0 if (bad == 0 and det and gate_ok) else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

variants/neural_tile.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba6e721eef8359d84ec58c46c1436c1298ac8191539adf9cc2c03ff9123583a8
+size 920