Non-CSS Parametrization

• Non-CSS parametrization is a systematic framework for constructing quantum codes with stabilizers that mix X, Y, and Z operators, enabling richer error syndrome structures.
• It integrates algebraic methods like the Goursat-based framework with graph-state measurement techniques to derive explicit formulas for code distance and logical operators.
• This approach optimizes quantum error correction by tailoring code parameters, trade-offs, and topological features in both 2D color codes and 3D lattice models.

Non-CSS parametrization refers to the systematic description and construction of stabilizer codes and related quantum codes whose stabilizer groups are not restricted to products of purely X-type or Z-type Pauli operators. This is in contrast to CSS (Calderbank-Shor-Steane) codes, which admit a parameterization via pairs of classical linear codes and split stabilizer generators into commuting X- and Z-type parts. In non-CSS codes, stabilizers generically mix X, Y, and Z operators, resulting in richer code structures, error syndromes, and logical operator properties. Recent work has elucidated explicit frameworks for non-CSS parametrization, deepened the understanding of their operational and topological features, and demonstrated concrete non-CSS families with advantageous error-correcting or hardware-tailored properties.

1. Algebraic Parametrization of Non-CSS Stabilizer Codes

A foundational result in non-CSS parametrization arises from the Goursat-based framework for subsystem stabilizer codes, as detailed in (Liu et al., 2023). Consider a Pauli group on $n$ $p$-ary qudits, represented with symplectic vector space $V=G\times G$, $G=\mathbb{F}_p^n$. Any subgroup $H\leq V$ (the gauge group modulo phases) is characterized up to equivalence by the four classical codes

$$E_X = \{x\in G \mid \exists z:(x,z)\in H\}, \quad N_X = \{x \mid (x,0)\in H\},$$

$$E_Z = \{z\in G \mid \exists x:(x,z)\in H\}, \quad N_Z = \{z \mid (0,z)\in H\},$$

together with a canonical isomorphism

$\phi: E_X/N_X \rightarrow E_Z/N_Z,$

such that

$$H = \{(x,z)\in E_X\times E_Z \mid \phi(x+N_X)=z+N_Z\}.$$

This parametrization strictly generalizes the CSS case: for CSS codes, $H=H_X\times H_Z$, corresponding to $E_X=H_X$, $N_X=H_X\cap H_Z^\theta$, $E_Z=H_Z$, $N_Z=H_Z\cap H_X^\theta$, and $\phi$ is the trivial isomorphism.

An arbitrary non-CSS code is thus parametrized as a "twisted product" of two subspaces—encoding all stabilizer, logical, and gauge properties into the algebraic data $(E_X, N_X; E_Z, N_Z; \phi)$ (Liu et al., 2023). This approach provides direct formulas for the dimensions of code parameters, logicals, and gauge subsystems, as well as closed-form expressions for code distance and operator supports in terms of these subspaces and their intersections.

2. Non-CSS Code Construction via Graph and Cluster-State Measurements

Measurement-based quantum codes provide a highly flexible route to non-CSS code families through projective measurements on cluster or graph states. Begin with an $(n+1)$-qubit cluster state $\ket{C_{n+1}}$ defined by a graph $G = (V,E)$, whose stabilizers are $K_i = X_i\prod_{j:\Gamma_{ij}=1} Z_j$. A measurement on qubit $n+1$ in a rotated basis $M_{n+1}(\theta) = \cos\theta\, X + \sin\theta\, Y$ partitions $K_j$ into commuting and anticommuting sets with respect to the measurement. The post-measurement code has stabilizer generators constructed from the surviving $K_j$, together with products of anticommuting pairs, all projected onto the remaining $n$ qubits. This recipe yields a continuous family of $[[n,1]]$ non-CSS codes parameterized by both the graph $G$ and the measurement angle $\theta$, with explicit construction of both stabilizer group and logical operators (Shaw et al., 2022).

Graph-based measurement reduction produces families of rate-optimal non-CSS codes, such as the $[[6,1,3]]$ "bare" ancilla code and its generalizations to larger $n$. The free parameters for these families are determined by the (non-planar) adjacency of the parent graph and the measurement location, providing a parametric map from graph-theoretic data to non-CSS code families (Gupta et al., 21 Jan 2025).

3. Structural and Physical Properties of Non-CSS Code Families

Non-CSS codes exhibit diverse properties in terms of error syndromes, logical operator mixing, and energetics:

• In 2D color codes, parametrization via local bulk patterns $[abc]$—the number of stabilizers violated by single-qubit $X,Y,Z$ errors—yields a taxonomy: $[336]$ (CSS), $[345]$ (non-CSS, deconfined/confined), and $[444]$ (fully non-CSS, maximally mixed). Each pattern encodes different local error energetics and logical operator composition while preserving the global code space and topological order (Padmanabhan et al., 2021).
• In 3D, the parameterization is fundamentally topological: logical qubits are counted by the second Betti number $k=b_2(M)$ of the 3-manifold, and stabilizer supports are specified by the tessellation geometry. Unlike CSS codes, each non-CSS stabilizer generator mixes a single Pauli type, conferring symmetry between bit- and phase-flip errors (Kim, 2010).

Non-CSS codes can be engineered to optimize rate (e.g., minimizing $n$ in $[[n,1,3]]$ constructions), support transversal Clifford gates, and protect against biased noise channels due to the mixed nature of their stabilizers and logical operators (Gupta et al., 21 Jan 2025, Padmanabhan et al., 2021).

4. Dualities, Topological Order, and Mapping to Physical Models

Many non-CSS codes admit geometric and topological parametrization in relation to physical models:

• 3D non-CSS codes constructed on a 4-valent tessellation realize ground states with $2^k$ degeneracy, corresponding to the second Betti number, and support both string-like and surface-like logical operatiors. The partition function maps onto an Ising gauge theory, and under Wegner duality, to a 3D Ising model on the dual lattice. The parameterization by topological invariants directly controls phase transitions and finite-temperature stability (Kim, 2010).
• In 2D non-CSS color codes, local unitary mappings demonstrate LU-equivalence of code spaces between CSS and non-CSS variants, implying invariance of long-range physical properties such as ground-state degeneracy and anyon content, despite parametric differences in local excitation energetics (Padmanabhan et al., 2021).

5. Algorithmic and Non-Intrusive Parametrization in Parametric Problems

Parametrization in the context of numerical solution of parametric and stochastic PDEs distinguishes between intrusive and non-intrusive methods. A non-intrusive Galerkin parametrization allows for the efficient construction of parametric solution maps $p\mapsto u^*(p)$ without requiring direct manipulation of the operator $A(p)$. Instead, the parametric solution $u_N(p) = \sum_{i=1}^M u_i \psi_i(p)$ is evaluated using quadrature, basis function evaluations, and repeated calls to a "black-box" single-parameter solver at quadrature points. This non-intrusive methodology enables the use of existing solvers for coupled parametric problems, with convergence guarantees and error bounds inherited from the underlying solver properties (Giraldi et al., 2013).

6. Scaling, Trade-offs, and Performance Implications

Non-CSS parametrization enables explicit characterization of code parameters:

Family/Geometry	Parametric Scaling (n, k, d)	Notable Parametric Feature
3D non-CSS (bitruncated cubic honeycomb)	$n\sim L^3$, $k=b_2\sim O(1)$, $d\sim L$	$k$ given by 2nd Betti number of manifold
2D color code (pattern $[abc]$)	$k=4g$, $n=|V|$, $d$ depends on lattice	Code family tuned by vertex pattern $[abc]$
"Bare" non-CSS ancilla code	$[[n,1,3]]$, $n\geq6$	$n$ optimized via graph adjacency for rate/distance

Minimizing $n$ subject to constraints on distance and syndrome uniqueness leads to rate-optimal constructions (e.g., $[[6,1,3]]$ as the smallest bare ancilla code with $d=3$) (Gupta et al., 21 Jan 2025). In general, increasing $n$ in non-CSS code families can create redundancy but not increase distance. The parametrization framework also accounts for performance under different physical noise models and syndrome measurement procedures.

7. Summary and Context

Non-CSS parametrization generalizes the classical CSS framework, accommodating the full diversity of stabilizer codes, including those whose generators and logical operators mix multiple Pauli types. Recent progress has provided both algebraic and constructive recipes: Goursat's Lemma formalizes the parameter map from classical code data and isomorphisms to general (possibly non-CSS) stabilizer codes (Liu et al., 2023); measurement-based schemes define entire parametric families from graph-theoretic and measurement data (Shaw et al., 2022, Gupta et al., 21 Jan 2025). Physical implementations benefit from the non-CSS structure with respect to logical operator mixing, optimal rates, and topological protection, while non-intrusive computational parametrizations in other domains facilitate the solution of high-dimensional coupled systems with minimal solver modification (Giraldi et al., 2013). Non-CSS parametrization thereby underpins both the mathematical structure and practical construction of quantum codes and parametric models across quantum information and computational mathematics.