Tile Codes: A Unified Coding Framework

• Tile Codes are error-correcting codes constructed from tilings on discrete spaces, combining classical perfect codes with scalable quantum error correction.
• They leverage TS-metrics and concatenation methods to produce systematic constructions with tunable parameters and robust logical operator frameworks.
• Their unified framework encompasses combinatorial, algebraic, and topological viewpoints, enabling enhanced encoding rates and fault-tolerant operations.

A tile code is a family of error-correcting codes—classical and quantum—arising from the combinatorial structure of tilings on discrete spaces, such as the Hamming cube or the planar lattice. Tile codes unify several perspectives in coding theory, combining concepts from support-respecting metrics, lattice tilings, permutation codes, and topological quantum codes. In the quantum regime, tile codes are distinct from surface codes by allowing higher encoding rates and a broader range of stabilizer weights, all while preserving tunably local (typically 2D) geometry. In classical coding theory, “tile codes” correspond to tilings of $\mathbb{F}_2^n$ that become perfect codes under suitable translation-invariant support metrics.

1. TS-Metrics and Perfect Tile Codes in $\mathbb{F}_2^n$

Tile codes in the classical Hamming cube $\mathbb{F}_2^n$ are built from tilings $(D,C)$, where $C$ is a code (a set of coset representatives), and $D$ is a tile such that the translates $c+D$ for $c\in C$ partition the space. The induced coding-theoretic properties depend on the metric chosen. The central concept is that of a TS-metric: a translation-invariant weight function $$\omega:\mathbb{F}_2^n\rightarrow \mathbb{R}_{\ge 0}$$ that also respects supports, i.e.,

$\supp(u)\subseteq\supp(v)\implies \omega(u)\le\omega(v).$

Every TS-metric $d(x,y)=\omega(x-y)$ ensures the induced metric balls $B_d(0,r)$ are closed under taking subvectors. A tile $D$ is a TS-ball if and only if it is the ball of some TS-metric, and in this case, $C$ is a TS-perfect code.

Key subfamilies include:

• Poset metrics: Weights are determined by ideals of a poset on $[n]$. For a poset $P$, the poset weight is $\omega_P(x)=|\langle \supp(x)\rangle_P|$.
• Combinatorial metrics: Weights derive from the minimal size of a covering $\mathcal{F}$ required to cover $\supp(x)$.

Classification results show that exactly six equivalence classes of small tiles (with $|D|\leq 8$) admit TS-metrics that turn the tiling into a perfect code, corresponding to particular poset and combinatorial metrics. For high-rank tilings, a tile $D_n(x)=\{0, e_1,\dots,e_n, x\}$ (with Hamming weight $2$) is a TS-ball if and only if $x$ has Hamming weight $2$, and can be realized as a combinatorial metric ball (Miyamoto et al., 2019).

2. Construction and Concatenation of Tile Codes

The product structure of the Hamming cube allows for concatenation constructions: if $(D_1,C_1)$ and $(D_2,C_2)$ are TS-tilings in $\mathbb{F}_2^{n_1}$ and $\mathbb{F}_2^{n_2}$, then $(D_1|D_2,C_1|C_2)$ is a TS-tiling in $\mathbb{F}_2^{n_1+n_2}$. TS-metrics extend naturally via the max-metric:

$$d_{\max}(x_1|x_2, y_1|y_2) = \max\{d_1(x_1,y_1), d_2(x_2,y_2)\}.$$

If $D_1$ and $D_2$ are balls of radius $r$ in their spaces, their concatenation is the ball of radius $r$ in the max-metric on the product. For balls of different radii, conditional sum metrics $\omega_1\oplus_{s}^r\omega_2$ extend the structure to more parameter regimes.

This framework yields infinite families of TS-perfect codes built from smaller constituent tile codes, with rigorous correspondence between the metric, tile, and decoding performance (Miyamoto et al., 2019).

3. Tile Codes as Quantum Error-Correcting Codes

In quantum coding, tile codes generalize the surface code paradigm. On a planar square lattice, qubits are placed on edges, and X- and Z-type check operators (“tiles”) are defined via fixed-size masks ($B\times B$ boxes) acting on the local neighborhood of each vertex. Stabilizers may be nonplanar within the box but remain constant-size.

Parameter specifications:

• Box size $B$ determines tile size and locality; larger $B$ increases logical qubits encoded.
• For a rectangular patch of $L\times L$ bulk vertices, with appropriate boundary layers, the number of encoded qubits is $k=2(B-1)^2$, and the code length $n\approx 2(L+B-1)(L+B-2)$ after trimming unused qubits.
• Distance $d$ corresponds to the minimal nontrivial logical string connecting appropriate boundaries, computable via integer linear programming.

Concrete parameter examples include $[[288,8,12]]$ (weight-6 stabilizer, $B=3$), $[[288,8,14]]$ (weight-8, $B=3$), and $[[512,18,19]]$ (weight-8, $B=4$), with the stabilizer weights $|T_X|=|T_Z|=w$. These codes can surpass the efficiency of rotated surface codes by up to a factor of $12$ in the expression $kd^2/n$ (Steffan et al., 12 Apr 2025).

4. Logical Operators and Algebraic Structure

Tile codes possess a highly structured logical operator space. Under total topological order assumptions, logical operators $\{\bar X_i, \bar Z_i\}$ (indexed by a $D\times D$ block) admit a canonical symplectic basis. Each logical operator is supported along a narrow strip on the lattice boundary, generable by a local cellular automaton: each $X$- or $Z$-logical is grown outward from a seed via update rules determined by the tile structure. The number of update rules scales with the non-locality parameter $D$.

Algebraically, the code is described as a Koszul complex over the ring $R=\mathbb{F}_2[x^{\pm 1}, y^{\pm 1}]$:

$$K^\bullet(R;f,g):\quad R \xrightarrow{\binom{-g}{f}} R^2 \xrightarrow{(f\;\;g)} R,$$

where error operators correspond to elements in $R^2$, and checks are encoded by $(f,g)$. The cohomology $H^{-1}(K^\bullet_{\text{tile}})\cong R/(f,g)$ yields the $2D^2$ logical qubits. This framework has an algebro-geometric interpretation as computing higher global sections of a twisted Koszul complex on $X=\mathbb{P}^1\times\mathbb{P}^1$ (Breuckmann et al., 18 Nov 2025).

5. Derived Automorphisms and Logical Gates

Tile codes support the notion of derived automorphisms: code equivalences implemented by patch extension and retraction. Explicitly, extending the lattice by one row or column and subsequently removing the opposite boundary induces a map on the logical space:

$T_x : H^{-1} \rightarrow H^{-1},\quad \text{corresponds to multiplication by $x$in$R/(f,g)$}.$

This implements a product of logical CNOT gates (and SWAPs) in the symplectic basis. The physical protocol involves adding ancillary qubits, performing appropriate check measurements, and applying a Pauli-frame update. Such automorphisms generalize lattice surgery and provide a low-overhead, fault-tolerant means to realize multi-qubit Clifford group operations directly at the code level (Breuckmann et al., 18 Nov 2025).

6. Flexibility and Comparison to Other Codes

Tile codes allow systematic variation in patch shape, boundary type, and tile structure:

• Arbitrary (simply-connected) bulk region shapes are supported.
• Boundary conditions are adjusted via additional layers of “red” (X-type boundary) and “blue” (Z-type boundary) vertices.
• Stabilizer weight and distance can be tuned by changing tile support in the local box (e.g., increasing $B$ for higher rate and distance at the expense of check weight).
• Rotated layouts and mixed boundaries interpolate between tile codes and surface code variants.

Compared with the standard (e.g., rotated) surface code, tile codes can encode multiple logical qubits in a single patch, with only a constant factor increase in check support per tile. This suggests a significant potential reduction in the space-time overhead for fault-tolerant quantum computation in 2D architectures (Steffan et al., 12 Apr 2025, Breuckmann et al., 18 Nov 2025).

7. Tile Codes and Square-Tiled Surface Codes

Permutation codes for square-tiled surfaces (origami) provide a classical manifestation of the “tile code” philosophy. Given $n$ squares, permutations $(\sigma_h,\sigma_v)\in S_n \times S_n$ determine gluings in the horizontal and vertical directions, classifying the translation surface and recording saddle-connection cylinder decompositions. Encoding the cylinder decomposition in a given rational direction as a permutation “left-code” enables combinatorial enumeration of the $SL_2(\mathbb{Z})$ orbit and explicit determination of the Veech group by group-theoretic conditions on these permutations (Tan, 2012).

This approach underlines the deep combinatorial and group-theoretic ties between tile code constructions in discrete spaces and geometric codings arising in translation surface theory.

---

Tile codes thus form a unifying conceptual framework at the intersection of classic and quantum coding: they encompass perfect codes in specialized metrics, combinatorial constructions in permutation group settings, and scalable, high-rate quantum codes with explicit logical structure and algebraic clarity.