Tile: A Generic Locality Primitive

• Tile is a generic locality primitive characterized by well-defined interfaces that determine global configurations through localized interactions.
• Tiles play a pivotal role across diverse domains, including geometric tessellations, computational tiling, self-assembly models, GPU simulation, calorimetry, and quantum error correction.
• The study of tiles reveals how local matching rules and constraints can lead to optimized structures, impacting both theoretical models and practical engineering applications.

Tile denotes a localized unit that participates in a larger global structure. In the cited literature, the term ranges from a compact connected subset in a tessellation of a surface (Faraco, 2023), to a rigid 2D shape or candidate placement in computational tiling (Xu et al., 2020), to a unit square or polygonal region carrying glues in self-assembly models (Doty et al., 2011), to a contiguous sub-region of a tensor operated on by one warp in GPU kernels (Ding et al., 13 Jul 2026), to alternating sensor planes in compensated calorimetry (Winn et al., 2022), and to a subset of edges of a $B\times B$ square grid in planar quantum-code design (Steffan et al., 12 Apr 2025). This recurrence suggests that the tile functions as a generic locality primitive: a small object with well-specified interfaces whose admissible interactions determine a global configuration.

1. Geometric tilings, tessellations, and aperiodicity

A tessellation or tiling of a surface $S$ is a collection of compact connected subsets $\{t_1,t_2,\dots\}$ such that $\bigcup_i t_i = S$, the interiors are pairwise disjoint, and each tile is bounded by finitely many geodesic edges meeting at vertices (Faraco, 2023). When every pair of tiles meets edge-to-edge, one obtains the standard edge-to-edge notion; when a group of isometries acts transitively on the tiles, the tessellation is symmetric; when the prototile is a regular polygon, it is regular. For a closed orientable surface $\Sigma_g$, any edge-to-edge tessellation satisfies

$\chi(\Sigma_g)=V-E+F=2-2g,$

and in the regular $\{p,q\}$ case one additionally has $pF=2E$ and $qV=2E$, yielding the curvature constraints $1/p+1/q>1/2$ on $S$0, $S$1 on the torus, and $S$2 for $S$3 (Faraco, 2023).

Within Euclidean and non-Euclidean tiling theory, a central theme is aperiodicity. One line of work analyzes the “hat” or Einstein tile. According to the cited account, David Smith et al. exhibited a 13-sided polygon in March 2023, and the alternative proof in “Proof of Aperiodicity of hat tile using the Golden Ratio” treats the hat as a tile that can be placed only in two reflections and proves aperiodicity by showing that a relevant density ratio converges to $S$4, which is irrational (Sharma, 2023). The argument uses a combinatorial ring count $S$5, a recurrence $S$6, and the asymptotic ratio

$S$7

Under the paper’s assumptions, any periodic tiling would force the limiting ratio to be rational, yielding a contradiction (Sharma, 2023).

A second line studies a single connected hexagonal monotile with explicit edge-to-edge matching rules. “An aperiodic tile with edge-to-edge orientational matching rules” defines a regular hexagon with R1 black-line decorations and an R2 orientational “charge” rule on edges. The rule system forces a hierarchy of triangles, proves that valid tilings are non-periodic, and establishes structural results about the tiling hull: unique ergodicity, a minimal substitution-generated core for almost all tilings, and pure point dynamical spectrum after quotienting by charge-flip (Walton et al., 2019). In this setting, the tile is not merely a geometric shape; it is a shape together with local matching data whose admissibility conditions encode global order.

2. Tiling as an optimization and learning problem

In computational geometry and design, tiling is posed as a constrained placement problem. “TilinGNN: Learning to Tile with Self-Supervised Graph Neural Network” considers a finite tile set $S$8 of rigid 2D shapes and a target region $S$9, possibly nonconvex and with holes. The objective is to select and place instances of tiles so as to maximally cover the interior of $\{t_1,t_2,\dots\}$0, avoid overlaps, and avoid holes between adjacent tiles (Xu et al., 2020).

The paper reformulates the task as a graph problem. A large periodic superset $\{t_1,t_2,\dots\}$1 of candidate placements is pre-computed and clipped to $\{t_1,t_2,\dots\}$2 at test time. Nodes correspond one-to-one to candidate placements. Two edge sets encode constraints: overlap edges connect placements whose interiors would overlap, and neighbor edges connect placements sharing a common boundary segment (Xu et al., 2020). The resulting graph supports a two-branch graph convolutional architecture of depth $\{t_1,t_2,\dots\}$3 and feature dimension $\{t_1,t_2,\dots\}$4, typically $\{t_1,t_2,\dots\}$5 and $\{t_1,t_2,\dots\}$6, alternating neighbor-aggregation and overlap-aggregation layers. Neighbor aggregation is edge-conditioned convolution; overlap aggregation is a simplified GIN-style convolution. Residual connections are used within each module, all intermediate features are concatenated, and a final MLP with sigmoid produces per-node selection probabilities $\{t_1,t_2,\dots\}$7 (Xu et al., 2020).

A distinctive feature is self-supervision. No ground-truth tilings are required. Instead, the loss is constructed from three differentiable criteria on the network outputs: coverage, overlap penalty, and hole penalty. The overall loss is

$\{t_1,t_2,\dots\}$8

with hyper-weights $\{t_1,t_2,\dots\}$9. The product formulation is reported to ensure stable training and to make overlap avoidance the top priority; replacing the multiplicative combination with a sum prevents convergence (Xu et al., 2020). Training uses 12,000 random 2D shapes generated by sampling 3–20 vertices and rejecting self-intersecting cases, with a 10,000/2,000 train/validation split, Adam at learning rate $\bigcup_i t_i = S$0, and one random cropped graph per iteration (Xu et al., 2020).

At inference, the method is approximately linear in the number of candidate tile locations: forward GCN computation is $\bigcup_i t_i = S$1, followed by greedy-like selection passes, for overall $\bigcup_i t_i = S$2. Empirically, wall-clock time grows linearly over 2,000–10,000 candidate locations, a typical tiling takes 20–30 s on a Titan Xp, and the method is reported as 10×–100× faster than IP solvers such as Gurobi and COIN-CBC while achieving comparable or superior coverage and hole counts (Xu et al., 2020). Ablation studies further indicate that removing the overlap branch, edge labels, residual or skip connections, or reducing depth to $\bigcup_i t_i = S$3 degrades coverage by 3–10% (Xu et al., 2020).

3. Tile assembly models and programming abstractions

In the abstract Tile Assembly Model (aTAM), a tile type is a unit square with glues on its four sides, and a tile assembly system is $\bigcup_i t_i = S$4, where $\bigcup_i t_i = S$5 is a finite tile set, $\bigcup_i t_i = S$6 is a finite $\bigcup_i t_i = S$7-stable seed assembly, and $\bigcup_i t_i = S$8 is the temperature (Doty et al., 2011). Assemblies are partial functions $\bigcup_i t_i = S$9 whose domains are connected in the grid graph. Tiles attach one at a time whenever the total binding strength of matching contacts is at least $\Sigma_g$0, producible assemblies are those reachable from the seed, terminal assemblies are those to which no further tile can attach, and a system is directed if it has exactly one terminal assembly (Doty et al., 2011).

Programming such systems at scale motivates domain-specific abstractions. Doty and Patitz introduce an internal Python DSL in which the central object is the TileTemplate, representing a family of tile types that share input sides, output sides, the signals they receive or emit, and the same mapping from inputs to outputs. A TileSetTemplate contains Tile and TileTemplate objects and enforces global constraints: every template must have either two strength-1 inputs or one strength-2 input, no side may be both an input and an output, every output signal must have an associated transition, and ambiguous template competition must be resolved by a chooser (0903.0889).

The primitive operations of the DSL are semantically narrow but expressive. A join connects the output side of one tile template to the input side of another and specifies the admissible ranges of signal values carried across that interface. An addTransition maps one or more input signals to one or more output signals by a function, table, or expression. A setChooser resolves intentional nondeterminism. Calling createTiles() enumerates the Cartesian products of input signals, invokes the user-specified transitions and choosers, materializes concrete tile types, and annotates glue labels so that only explicitly joined templates can bind (0903.0889). In the cited binary-counter example, the construction uses two hard-coded seed tiles, five TileTemplate declarations, twelve join calls, three addTransition calls, one setChooser, five setLabelFunction calls, and one createTiles() that produces approximately 20 concrete tile types (0903.0889).

The broader significance of these abstractions is organizational rather than geometric. A tile in aTAM is defined by binding interfaces and assembly dynamics, while a tile template is a compact specification of many such tiles. This shifts the design problem from manual enumeration of tile types to composition of interfaces, transitions, and constraints.

4. Universality, minimal tile sets, and pattern complexity

The aTAM is intrinsically universal. Doty, Lutz, Patitz, Schweller, Summers, and Woods prove that there exists a single tile set $\Sigma_g$1 such that, for every TAS $\Sigma_g$2, one can encode $\Sigma_g$3 into a seed assembly and obtain a simulation at some scale $\Sigma_g$4 by $\Sigma_g$5 supertiles (Doty et al., 2011). The simulation preserves both equivalent production and equivalent dynamics. Technically, each supertile carries the entire “genome” of the simulated system, and asynchronous coordination is achieved by a 4-layer frame, probes, and crawlers with states $\Sigma_g$6 (Doty et al., 2011).

A stronger geometric universality result is obtained in “One Tile to Rule Them All.” Demaine et al. show that any aTAM system can be simulated by a single polygonal tile type in the polygonal free-body Tile Assembly Model, provided rotation and translation are allowed (Demaine et al., 2012). The construction uses a large regular $\Sigma_g$7-gon with bump-and-dent geometry, with $\Sigma_g$8 in the intermediate simulation, and yields a single universal tile type of constant-size shape when combined with intrinsic universality. The same work also shows a sharp limitation: for a single nonrotatable tile of arbitrary shape, assemblies either grow infinitely or cannot grow at all, implying drastically limited computational power (Demaine et al., 2012).

Minimal tile sets also arise in the Maze-Walking Tile Assembly Model, where an input maze supplies routing and the tile set supplies computation. Cook, Stérin, and Woods exhibit two tiny universal tile sets. The first has four tiles and directly implements NAND, NXOR, and NOT gates. The second has six tiles, is called the Collatz tile set, and produces patterns associated with binary and ternary representations of iterations of the Collatz function. Using computer search, the authors show that Boolean circuits can be encoded using blocks of these patterns (Cook et al., 2021). In both cases, tiles attach cooperatively at temperature $\Sigma_g$9, and the computational maze structure separates routing from logic (Cook et al., 2021).

Pattern complexity quantifies how many tile types are needed to assemble colored outputs. “Self-Assembly of Patterns in the abstract Tile Assembly Model” gives $\chi(\Sigma_g)=V-E+F=2-2g,$0-tile constructions for a single black pixel in an $\chi(\Sigma_g)=V-E+F=2-2g,$1 white square, $\chi(\Sigma_g)=V-E+F=2-2g,$2 for a sparse multipixel pattern, and $\chi(\Sigma_g)=V-E+F=2-2g,$3 for stripe patterns (Drake et al., 2024). For arbitrary 2-colored $\chi(\Sigma_g)=V-E+F=2-2g,$4 patterns, the paper proves that almost all patterns require

$\chi(\Sigma_g)=V-E+F=2-2g,$5

tile types in the singly-seeded aTAM (Drake et al., 2024). It also exhibits an exponential separation between strictly 2D and “barely” 3D systems: for every $\chi(\Sigma_g)=V-E+F=2-2g,$6, there exists a 7-color pattern $\chi(\Sigma_g)=V-E+F=2-2g,$7 such that no singly-seeded 2D aTAM system with $\chi(\Sigma_g)=V-E+F=2-2g,$8 tile types can weakly self-assemble $\chi(\Sigma_g)=V-E+F=2-2g,$9, whereas a two-plane system using only $\{p,q\}$0 can do so with $\{p,q\}$1 tile types at temperature 2 (Drake et al., 2024).

5. Tiles as engineering units in calorimetry and GPU simulation

In detector instrumentation, tiles are physical layers with specific sensor modalities. “Tile Multiple-Readout Compensated Calorimetry” proposes replacing the parallel-fiber Cerenkov plus scintillator matrix with alternating tiles of absorber and sensors. Each tile plane may contain scintillator tiles, Cerenkov radiator tiles, and optional additional sensor tiles; stacking in the beam direction yields true longitudinal segmentation, turnkey projective wedges, easy access for replacement, and the possibility of an integral electromagnetic front end (Winn et al., 2022). The proposed front compartment interleaves thin W or Pb absorber tiles with dense scintillators such as LYSO or PbWO$\{p,q\}$2 and low-$\{p,q\}$3 Cerenkov tiles such as MgF$\{p,q\}$4, silica aerogel, or Teflon AF, with event-by-event compensated photon/electron response at the start of the shower (Winn et al., 2022).

The GEANT4 toy model described in the paper uses a $\{p,q\}$5 transverse geometry, total depth $\{p,q\}$6 ($\{p,q\}$7), and repeating units of 5 mm Cu absorber, 5 mm quartz, and 5 mm plastic scintillator. It simulates 1,000 $\{p,q\}$8 and 1,000 $\{p,q\}$9 at 50 GeV and 100 GeV normal incidence, with photons in the 325–650 nm band and 0.5% collection efficiency to photo-electrons (Winn et al., 2022). Dual-readout reconstruction defines $pF=2E$0 and $pF=2E$1 as scintillation and Cerenkov energies and uses

$pF=2E$2

where $pF=2E$3 is obtained from a fit line in the $pF=2E$4 plane (Winn et al., 2022). The reported toy-model resolution for 100 GeV pions is $pF=2E$5, corresponding to $pF=2E$6, slightly better than the cited baseline fiber dual-readout performance of $pF=2E$7–$pF=2E$8. The paper further gives a back-of-the-envelope target of $pF=2E$9 with $qV=2E$0–1% for finer sampling, and a projected $qV=2E$1 for triple-readout with scintillator, Cerenkov, and SE or neutron-sensitive tiles (Winn et al., 2022).

In GPU architecture, the tile is instead a computational unit. GPU-Tile-Sim defines a tile as a contiguous sub-region of a tensor that a single warp or warp group operates on as a unit, for example a $qV=2E$2 tile of $qV=2E$3, a $qV=2E$4 tile of $qV=2E$5, and the corresponding $qV=2E$6 tile of $qV=2E$7 in GEMM (Ding et al., 13 Jul 2026). The simulator represents a kernel as a directed acyclic graph $qV=2E$8 whose nodes are tile-level operations such as TMA loads, WGMMA, elementwise ops, and stores, and whose edges are either data edges or order edges encoding synchronization and buffer-reuse constraints (Ding et al., 13 Jul 2026).

The frontend operates on TileLang IR after software-pipelining and warp-specialization passes, instantiating nodes and inferring dependencies using SSA-like tile versions. The backend schedules CTAs onto SMs, maintains ready queues, issues nodes when dependencies are released and target resources are free, and models compute, memory, and NoC/DSMEM resources by latency, width, throughput, bandwidth, and queueing. Node timing is summarized by

$qV=2E$9

Across GEMM, attention, and end-to-end Llama-3-8B inference on A100 and H100, the reported Mean Absolute Percentage Error ranges from 1.22% to 8.71%, outperforming prior analytical models such as TileFlow and LLMCompass, whose errors often exceed 25–100% (Ding et al., 13 Jul 2026). The same framework is extended to Blackwell with preliminary validation, and changes needed for FA3 versus FA4 on Blackwell are described as affecting less than 12% of the simulator core (Ding et al., 13 Jul 2026).

The two engineering uses are distinct in ontology: calorimeter tiles are replaceable physical modules, whereas GPU tiles are execution-level tensor partitions. A plausible implication is that “tile-centric” design in both cases serves to expose locality, segmentation, and controlled interaction, but the governing constraints are detector response and resource scheduling, respectively.

6. Tile codes in planar quantum error correction

In “Tile Codes: High-Efficiency Quantum Codes on a Lattice with Boundary,” a tile of size $1/p+1/q>1/2$0 is a subset of the edges of a $1/p+1/q>1/2$1 square grid whose support does not include the topmost horizontal edges or the rightmost vertical edges (Steffan et al., 12 Apr 2025). Physical qubits live on edges. One chooses an $1/p+1/q>1/2$2-tile $1/p+1/q>1/2$3 and a $1/p+1/q>1/2$4-tile $1/p+1/q>1/2$5 satisfying containment and an even-overlap condition: when placed at arbitrary relative positions on the infinite square grid, they overlap on an even number of edges. Equivalently, if $1/p+1/q>1/2$6 contains an edge at $1/p+1/q>1/2$7, then $1/p+1/q>1/2$8 contains an edge at $1/p+1/q>1/2$9, which guarantees commutation of $S$00- and $S$01-checks (Steffan et al., 12 Apr 2025).

A planar layout consists of a finite square-lattice region with black, red, and blue anchor vertices. Black vertices carry both $S$02- and $S$03-tiles, red vertices carry only $S$04-tiles, and blue vertices carry only $S$05-tiles. Boundary generators are truncated when their full support is not contained in the region. For a black vertex $S$06,

$S$07

The paper gives explicit $S$08 examples: a weight-6 tile pair producing a $S$09 code, and a weight-8 tile pair producing a $S$10 code (Steffan et al., 12 Apr 2025). Allowing slightly higher non-locality yields a $S$11 code using weight-8 stabilizers (Steffan et al., 12 Apr 2025).

For the unrotated rectangular layout with an $S$12 bulk of black vertices and $S$13 red or blue boundary layers, the paper derives

$S$14

Thus for $S$15, $S$16 independent of $S$17. Distances for the concrete examples are confirmed by integer-programming solvers (Steffan et al., 12 Apr 2025). The comparison metric $S$18 yields 4.0 for $S$19, approximately 5.4 for $S$20, and approximately 12.7 for $S$21, compared with approximately $S$22 for the rotated surface code (Steffan et al., 12 Apr 2025). Asymptotically, for fixed $S$23 and $S$24, one has $S$25, $S$26, and $S$27 (Steffan et al., 12 Apr 2025).

Tile codes therefore generalize the surface-code idea by replacing plaquette-like checks with configurable local tiles while preserving planar locality and open boundaries. In this usage, a tile is neither a geometric region to be packed nor a self-assembling object; it is the support template of a stabilizer generator, and its admissibility is controlled by commutation and boundary truncation rather than by overlap or matching rules.