Trellis.2: Graphical Decoding & Code Complexity

• Trellis.2 is a structured graphical representation of finite-state codes that captures constraints, state evolution, and feasible sequences for optimal decoding.
• It leverages algebraic methods like minimal span form and characteristic matrices to minimize state complexity and link to concepts in linear algebra and matroid theory.
• Advanced formulations extend to multiuser detection, quantization, and time-variant decoding, enabling efficient applications in trellis-coded modulation and non-orthogonal communications.

A trellis is a structured graphical representation of the constraints, state evolution, and feasible sequences in a finite-state code or system, central to maximum-likelihood decoding and inference. In coding theory, trellises underpin the practical realization, analysis, and minimization of convolutional, block, and tail-biting codes, form the basis of key decoding algorithms (Viterbi, BCJR), and interface profoundly with topics in linear algebra (span forms, characteristic matrices), matroid theory (pathwidth), and quantization. Variations such as tensor-product trellises, skew trellis codes, and time-variant trellis constructions extend the classical theory to address multi-user, nonlinear, or spectrally efficient communications scenarios.

1. Algebraic and Matrix-Theoretic Foundations of Trellises

The combinatorial structure of a trellis encodes the evolution of codeword support across time or symbol indices. At each stage, a set of states encodes partial information about feasible codewords; edges represent allowable transitions labeled by code symbols. The minimal trellis for a linear block code is built via the product construction applied to a generator matrix in minimal span form, as formalized by Kschischang and Sorokine.

A generator matrix $G$ in reduced minimal span form has the property that no two rows start or end in the same column, leading to a partition of "leading" (start) and "trailing" (end) pivots. The resulting trellis, via the product construction, represents the row space of $G$ with minimal vertex complexity: the number of states at each stage is minimized, corresponding to the intersections of partial row spans. The extension to tail-biting trellises uses characteristic matrices, which select $n$ generators with distinct cyclic (start, end) supports and minimal total spanlength. Every minimal tail-biting trellis arises from an appropriate subset of such a characteristic matrix (Duursma, 2015).

Characteristic matrices have canonical reduced forms, leading to duality properties between primal and dual code trellises. Orthogonality of the column spaces of the characteristic matrices for a code and its dual is equivalent to duality of their tail-biting trellis representations. The transpose of a characteristic matrix is again characteristic if and only if the matrix is reduced. This matrix-theoretic formalism unifies the trellis viewpoint with system-theoretic and convolutional code realizations, and underlies the BCJR and related constructions (Duursma, 2015).

2. Trellis Complexity: Matroid Pathwidth, Trellis-Width, and Algorithms

The trellis-width of a linear code---the logarithm (base $q$) of the largest state complexity in any minimal trellis for the code---is exactly the pathwidth of its associated representable matroid. For a matroid $M$ with rank function $r$, the connectivity function $\lambda_M(X) = r(X) + r(E\setminus X) - r(E)$ measures the intersection of spans on subsets $X \subseteq E$. Minimizing the maximum $\lambda_M$ over all orderings yields the pathwidth; for a code, this is the minimal trellis-width over all coordinate permutations (0705.1384, Jeong et al., 2015).

Computing the trellis-width (or matroid pathwidth) is NP-hard in general (0705.1384), yet for fixed width $k$, fixed-parameter tractable (FPT) algorithms exist. One such algorithm, operating in time $G$0, constructs an explicit minimal-width layout for an input collection of subspaces or a matroid representation. This is achieved via dynamic programming on a branch-decomposition, tracking "compact $G$1-trajectories" over intermediate boundaries (Jeong et al., 2015).

For fixed $G$2, the class of codes (or matroids) of trellis-width at most $G$3 is closed under minors, and by the Geelen–Whittle theorem, is characterized by finitely many excluded minors. For $G$4, this set is exactly the matroids $G$5, $G$6, $G$7, $G$8 and their code-theoretic representations; for $G$9, the list contains $n$0, $n$1, $n$2, $n$3, $n$4, $n$5, and certain cycle-matroids, though the list is not complete (0705.1384).

3. Trellis Computation and Generalized Inference

The BCJR algorithm and its generalizations perform forward-backward recursion on trellises to compute marginal probabilities, symbol probabilities, and expectations over codewords and path-constrained quantities. For separable edge-additive path functions, higher-order path moments (e.g., conditional means, variances) can be computed recursively via binomial expansions, with complexity matching that of the standard BCJR pass. Symbol-constrained moments (conditioning on the symbol traversed at a specific depth) are also computable with mixed $n$6/$n$7 recursions.

The entire machinery generalizes to arbitrary commutative semirings, where sum and product are replaced by abstract operations ($n$8, $n$9); in this setup, the classical Viterbi algorithm emerges as the zero-th moment (max-sum path metric), and flow computations connect to algebraic graph theory (0711.2873). Applications include discriminated belief propagation, calculation of conditional entropy along the trellis, and efficient moment-based approximations for turbo decoding.

4. Trellis-Coded Modulation and Multiuser Trellis Schemes

Trellis-coded modulation (TCM), notably Ungerboeck's construction, integrates convolutional coding with expanded signal constellations to maximize distance properties. For multiuser and non-orthogonal multiple-access (NOMA) channels, tensor-product trellis constructions enable joint maximum-likelihood sequence detection across users. In two-user TCM-NOMA, independent bit streams are convolutionally encoded (e.g., rate-2/3, 8-PSK), modulated, and superimposed with user-specific power allocation. The superimposed symbols correspond to edges of the tensor-product trellis, enabling ML detection via a single Viterbi pass on the joint state space (Zou et al., 2019).

The minimum Euclidean distance (free distance) of the joint code determines error performance. Power allocation between users is analytically optimized by maximizing the tensor trellis's free-distance metric, capturing both parallel-branch and diverge-and-merge events. TCM-NOMA outperforms uncoded NOMA and separate TCM-MAC designs, especially when user powers are comparable and error-propagation affects separate decoding or SIC.

In Gaussian MAC settings, TCM code pairs with optimally rotated PSK constellations and Ungerboeck partitioning achieve maximum constrained capacity and minimum pairwise error probability. The sum alphabet structure forms concentric rings, and Ungerboeck labeling on each trellis is proven optimal in maximizing the worst-case distance in the receiver sum-trellis. This architecture enables arbitrary rate pairs within the constrained MAC capacity region (0908.1163).

5. Skew Trellis Codes and Nonlinear Trellis Structures

Skew trellis codes generalize ordinary convolutional codes by defining codes as submodules over skew polynomial rings $q$0, where $q$1 is a field automorphism (e.g., Frobenius). Right submodules of $q$2 (with $q$3 the skew field of fractions) yield codes that are generally nonlinear over $q$4 but admit trellis representations with complexity and decoding (Viterbi, BCJR) analogous to conventional codes. The trellis structure captures the periodic, time-varying behavior induced by the noncommutative polynomial ring, and enables constructions achieving free-distance or slope bounds beyond those of commutative codes (Sidorenko et al., 2021).

With $q$5, skew trellis codes can match or surpass performance benchmarked by code parameters (e.g., unit-memory [2,1] code over $q$6 achieving $q$7 versus $q$8 for the best commutative code). Trellis construction proceeds via explicit state and edge labeling, incorporating the automorphism into the convolutional update equations.

6. Trellis-Based Quantization and Differentiable Relaxations

Trellis-coded quantization extends classic trellis ideas to quantizing high-dimensional vectors, such as neural network weights. QTIP encodes length-$q$9 blocks as paths through a trellis with codepoints optimized for minimal distortion via a Viterbi argmax. This non-differentiability blocks quantization-aware training (QAT). BCJR-QAT proposes a relaxation, replacing argmax with a finite-temperature Boltzmann distribution over paths, yielding a soft codeword equal to the Boltzmann expectation---exactly differentiable, and converging to the QTIP code as $M$0.

The forward-backward (BCJR) recursion computes these expectations efficiently, interpreted as transfer-matrix computations for a one-dimensional Ising-model spin chain. With an optimized Triton kernel, the method is tractable for large $M$1 on GPUs, and drift-budget theory quantifies the necessary conditions for escaping the Voronoi basin defined by the initial PTQ codeword. Empirically, BCJR-QAT applied to Llama-3.2-1B demonstrates that with a suitable temperature schedule, the method can achieve lower perplexity at 2 bits per weight than post-training QTIP, and super-additive gains under multi-layer application (Iyengar, 11 May 2026).

7. Time-Variant Trellis Constructions and Complexity-Reduced Decoders

Rate-adjustable TCM via convolutional code puncturing produces non-integer rates and time-variant trellis structures due to the periodic erasures of code bits. The mapping from convolutional outputs to constellation bits varies over time, modeled by generator-offsets that parameterize the finite set of trellis segments. Decoding over ISI channels requires forming a super-trellis incorporating channel memory, convolutional code state, and the puncturing buffer.

Reduced-State Sequence Estimation (RSSE) methods, such as DFSE and their extensions, merge groups of trellis states (hyperstates) based on least-reliable channel memory bits, enabling tractable decoding at a modest performance trade-off. Efficient partitioning and complexity-performance tradeoffs are analyzed, with simulation results validating the utility of segment-dependent state merging (Schuh et al., 2013).

---

References

• "Matrix Theory for Minimal Trellises" (Duursma, 2015)
• "Matroid Pathwidth and Code Trellis Complexity" (0705.1384)
• "The 'art of trellis decoding' is fixed-parameter tractable" (Jeong et al., 2015)
• "Trellis Computations" (0711.2873)
• "Trellis-Coded Non-Orthogonal Multiple Access" (Zou et al., 2019)
• "Trellis Coded Modulation for Two-User Unequal-Rate Gaussian MAC" (0908.1163)
• "On Skew Convolutional and Trellis Codes" (Sidorenko et al., 2021)
• "BCJR-QAT: A Differentiable Relaxation of Trellis-Coded Weight Quantization" (Iyengar, 11 May 2026)
• "Low Complexity Decoding for Punctured Trellis-Coded Modulation Over Intersymbol Interference Channels" (Schuh et al., 2013)