Partial Unit-Memory MDP Codes

• Partial Unit-Memory MDP codes are memory-1 convolutional codes defined by a generator matrix G(z)=G0+G1z with rk(G1)<k, achieving maximal column distances.
• They guarantee optimal sliding-window erasure recovery by ensuring every finite window meets the maximum correctable erasure bound determined by the MDP property.
• Their construction leverages sparse, superregular matrices, such as Cauchy and Vandermonde forms, to reduce encoding complexity while maintaining robust error correction.

Partial unit-memory maximum distance profile codes are memory-$1$ convolutional codes whose delayed generator part has rank strictly smaller than the input dimension and whose column distances attain the largest admissible values for as long as the degree permits. In the recent memory-$1$ formulation, a partial unit-memory code has generator matrix $G(z)=G_0+G_1z$ with $\operatorname{rk}(G_1)<k$; in the regime $k>n-k=\delta$, one has $L=1$, so MDP-ness is equivalent to $d_1^c(\mathcal C)=2(n-k)+1$ and, equivalently, to the nonvanishing of all nontrivial full-size minors of $G_1^c=\begin{bmatrix}G_0&G_1\0&G_0\end{bmatrix}$ (Dang et al., 14 Jul 2025). More generally, for a PUM code with memory $1$ and $\delta<k$, the MDP horizon simplifies to $1$0, so the subject is fundamentally about optimal finite-window distance growth, sliding-window erasure recovery, and the algebraic design of sparse or superregular memory-$1$1 polynomial matrices (Tomás et al., 2010, Dang et al., 23 Apr 2026).

1. Code model and the PUM specialization

In the standard generator description of a memory-$1$2 convolutional code, the encoded blocks satisfy

$1$3

A unit-memory code has $1$4, whereas a partial unit-memory code has $1$5; in the $1$6 notation, only a $1$7-dimensional part of the previous information block affects the current code block (Wachter-Zeh et al., 2012). The same distinction is used in the recent matrix-completion literature: a convolutional code with $1$8 is unit-memory if $1$9 and partial unit-memory if $G(z)=G_0+G_1z$0 (Dang et al., 23 Apr 2026).

A complementary block-code-based formulation writes

$G(z)=G_0+G_1z$1

with associated constituent block codes $G(z)=G_0+G_1z$2. In that framework, PUM decoding is organized around direct decoding in $G(z)=G_0+G_1z$3, one-sided propagation through $G(z)=G_0+G_1z$4 and $G(z)=G_0+G_1z$5, and two-sided reconstruction through $G(z)=G_0+G_1z$6 (Puchinger et al., 2017). This viewpoint does not define MDP, but it makes explicit the local, neighboring-block recovery mechanism that MDP theory later optimizes.

For the MDP specialization, the important parameter is the code degree $G(z)=G_0+G_1z$7. In the standard memory-$G(z)=G_0+G_1z$8 specialization, each column degree is $G(z)=G_0+G_1z$9 or $\operatorname{rk}(G_1)<k$0, so $\operatorname{rk}(G_1)<k$1 is the characteristic PUM regime; in the recent sparse constructions one further imposes $\operatorname{rk}(G_1)<k$2, which forces $\operatorname{rk}(G_1)<k$3 and makes the first nontrivial sliding matrix decisive (Tomás et al., 2010, Dang et al., 14 Jul 2025).

2. Column distances and the MDP property

For a codeword $\operatorname{rk}(G_1)<k$4, the $\operatorname{rk}(G_1)<k$5-th column distance is

$\operatorname{rk}(G_1)<k$6

and the free distance satisfies

$\operatorname{rk}(G_1)<k$7

For every $\operatorname{rk}(G_1)<k$8,

$\operatorname{rk}(G_1)<k$9

An $k>n-k=\delta$0 convolutional code is MDP if

$k>n-k=\delta$1

where

$k>n-k=\delta$2

Thus MDP means maximal column-distance growth for as long as the general bound allows (0903.3004, Tomás et al., 2010).

For PUM codes, the memory-$k>n-k=\delta$3 condition simplifies the horizon. Since typically $k>n-k=\delta$4,

$k>n-k=\delta$5

Hence a PUM code is MDP exactly when its early column distances satisfy

$k>n-k=\delta$6

This is the central finite-window optimality statement for PUM MDP codes (Tomás et al., 2010).

In the particularly important sparse PUM regime

$k>n-k=\delta$7

one gets

$k>n-k=\delta$8

Then the MDP condition reduces to

$k>n-k=\delta$9

In that setting, the recent construction papers also note that the generalized Singleton bound equals $L=1$0, so

$L=1$1

This makes the memory-$L=1$2 PUM MDP problem a first-window design problem on $L=1$3 (Dang et al., 14 Jul 2025).

3. Sliding-window erasure decoding

The operational value of the MDP property is clearest on the erasure channel. There the receiver knows the erased positions, and decoding reduces to solving linear systems obtained from the parity-check equations in sliding windows. If

$L=1$4

then the truncated sliding parity-check matrix is

$L=1$5

The MDP criterion is that the admissible full-size minors of $L=1$6 be nonzero; equivalently, the relevant erasure-location submatrices have full rank (0903.3004).

The fundamental decoding theorem is window-local. If $L=1$7 is an $L=1$8 MDP convolutional code and in any sliding window of length $L=1$9 there are at most

$d_1^c(\mathcal C)=2(n-k)+1$0

erasures, then the whole sequence can be recovered. More generally, because

$d_1^c(\mathcal C)=2(n-k)+1$1

in any sliding window of size $d_1^c(\mathcal C)=2(n-k)+1$2 one can recover up to

$d_1^c(\mathcal C)=2(n-k)+1$3

erasures, provided the previous symbols are already known (Tomás et al., 2010, 0903.3004).

This theorem specializes directly to PUM MDP codes. If the code is memory $d_1^c(\mathcal C)=2(n-k)+1$4 and MDP, then the same formulas hold with

$d_1^c(\mathcal C)=2(n-k)+1$5

Thus the PUM MDP property is not merely a global free-distance statement; it is a deterministic guarantee of optimal local erasure correction in streaming windows (Tomás et al., 2010).

The comparison with MDS block codes is one of the classical motivations. In a window of length $d_1^c(\mathcal C)=2(n-k)+1$6, an MDP convolutional code corrects the same fraction

$d_1^c(\mathcal C)=2(n-k)+1$7

as an MDS block code of the same rate, but the convolutional decoder can slide the window and adapt to burst structure. The illustrative example in the erasure-decoding paper compares a $d_1^c(\mathcal C)=2(n-k)+1$8 MDP convolutional code with a $d_1^c(\mathcal C)=2(n-k)+1$9 MDS block code: both correct roughly $G_1^c=\begin{bmatrix}G_0&G_1\0&G_0\end{bmatrix}$0 erasures, but the convolutional code succeeds on two bursts of $G_1^c=\begin{bmatrix}G_0&G_1\0&G_0\end{bmatrix}$1 erasures separated by $G_1^c=\begin{bmatrix}G_0&G_1\0&G_0\end{bmatrix}$2 clean symbols because it can decode them in different windows, whereas the fixed $G_1^c=\begin{bmatrix}G_0&G_1\0&G_0\end{bmatrix}$3 block fails on $G_1^c=\begin{bmatrix}G_0&G_1\0&G_0\end{bmatrix}$4 erasures inside one block (0903.3004).

On complexity, the erasure-channel papers emphasize that decoding is computationally easy: one solves linear systems over the base field, and in the MDP case each erasure group requires inversion of a matrix of size at most $G_1^c=\begin{bmatrix}G_0&G_1\0&G_0\end{bmatrix}$5, with complexity

$G_1^c=\begin{bmatrix}G_0&G_1\0&G_0\end{bmatrix}$6

For PUM codes, $G_1^c=\begin{bmatrix}G_0&G_1\0&G_0\end{bmatrix}$7 is often small, so the sliding systems remain modest (Tomás et al., 2010).

4. Reverse-MDP, complete-MDP, and bounded-delay refinements

The MDP property is only the first level of the erasure-decoding hierarchy. A code is reverse MDP if the code and its reverse are both MDP, so the same maximal window guarantees hold in both time directions (Tomás et al., 2010). Complete MDP strengthens this further: its defining object is the partial parity-check matrix

$G_1^c=\begin{bmatrix}G_0&G_1\0&G_0\end{bmatrix}$8

and the code is complete MDP when every full-size minor of $G_1^c=\begin{bmatrix}G_0&G_1\0&G_0\end{bmatrix}$9 that is not trivially zero is nonzero (Lieb, 2017).

The hierarchy and its operational meaning are summarized below.

Property	Defining feature	Operational consequence
MDP	Maximal $1$0 for $1$1	Optimal forward sliding-window recovery
Reverse-MDP	Code and reverse code are both MDP	Forward and backward decoding
Complete-MDP	Nontrivial full-size minors of $1$2 are nonzero	Reduced waiting time after bad bursts
Complete $1$3-MDP	Truncated complete-MDP condition to depth $1$4	Optimal sequential decoding with delay $1$5

Every complete MDP code is reverse MDP, and complete MDP codes exist over sufficiently large fields iff

$1$6

The complete-MDP existence theorem is generic: for all parameters satisfying that divisibility condition, complete MDP codes form a generic subset of the variety of non-catastrophic convolutional codes (Lieb, 2017).

The bounded-delay refinement is the complete $1$7-MDP notion. For

$1$8

a code is complete $1$9-MDP if the truncated matrix used in the bounded-delay decoding equations has all nontrivial full-size minors nonzero. When $\delta<k$0, this recovers complete MDP. The key optimality statement is that complete $\delta<k$1-MDP convolutional codes are optimal for sequential erasure decoding with maximal delay $\delta<k$2 using the paper’s algorithm; if an erasure pattern cannot be corrected within delay $\delta<k$3 by a complete $\delta<k$4-MDP code, then no other convolutional code with the same parameters can correct it within delay $\delta<k$5 (Almeida et al., 2019).

For memory-$\delta<k$6 codes, the complete $\delta<k$7-MDP machinery specializes cleanly. If one takes

$\delta<k$8

then the complete $\delta<k$9-MDP matrix becomes a banded block matrix with only two nonzero block diagonals. The paper does not develop a separate PUM theory, but it states that the complete $1$00-MDP definitions, bounded-delay decoding theorem, and parity-check minor criteria are immediately relevant to memory-$1$01 studies (Almeida et al., 2019).

Field-size issues for MDP and complete MDP were analyzed systematically later. Upper bounds on the necessary field size and lower bounds on the probability that a random code is MDP or complete MDP were derived, and these bounds improve earlier ones in many parameter regimes (Lieb, 2018).

5. Algebraic characterizations and constructions for PUM MDP codes

The classical structural criterion is given by admissible minors of sliding Toeplitz matrices. On the parity-check side, MDP is characterized by nonvanishing admissible full-size minors of $1$02; on the generator side, by nonvanishing admissible full-size minors of

$1$03

For PUM codes this criterion is unchanged; only the memory-$1$04 structure makes the sliding matrices smaller (Tomás et al., 2010).

A general older construction route uses superregular lower block triangular Toeplitz matrices. When

$1$05

superregularity of the relevant Toeplitz matrix yields an MDP code, and the paper “A new class of superregular matrices and MDP convolutional codes” provides such matrices over sufficiently large finite fields of arbitrary characteristic (Almeida et al., 2013). In the memory-$1$06 subclass one has

$1$07

so this construction directly covers that degree regime. This suggests a parity-check-side route to memory-$1$08 MDP and reverse-MDP designs whenever the degree matches the redundancy.

The most direct PUM-MDP constructions are recent and explicitly phrased as matrix completion. The paper “A Matrix Completion Approach for the Construction of MDP Convolutional Codes” studies the specific PUM regime

$1$09

and imposes

$1$10

with $1$11 chosen as a structured superregular matrix, typically Cauchy, and $1$12 chosen to complete the sliding generator matrix

$1$13

The explicit sparse choice is

$1$14

so $1$15 has exactly $1$16 nonzero entries and

$1$17

With extension degree

$1$18

the resulting code is MDP. The same paper proves that any generator matrix with optimal first column distance must satisfy

$1$19

so the sparse construction attains the minimum possible rank of the delayed term compatible with $1$20 MDP behavior (Dang et al., 14 Jul 2025).

The follow-up paper “Design of MDP Convolutional Codes and Maximally Recoverable Codes Through the Lens of Matrix Completion” restricts its convolutional-code section entirely to the memory-$1$21 or $1$22 regime and gives several concrete PUM-MDP constructions. Besides the general superregular-$1$23 plus diagonal-$1$24 template, it gives Vandermonde-based families for

$1$25

and

$1$26

with

$1$27

and $1$28 a small lower-triangular Toeplitz block placed in the last rows. These constructions replace full superregularity by a Vandermonde base matrix $1$29, while keeping the extension-field support confined to a small sparse block (Dang et al., 23 Apr 2026).

Encoding complexity is a stated design objective in the recent PUM-MDP work. With $1$30 chosen as a Cauchy matrix and $1$31 extremely sparse, the 2025 paper gives per-time-step encoding complexity

$1$32

and argues that this reduces encoding complexity compared to previous structured MDP constructions (Dang et al., 14 Jul 2025).

Several adjacent construction literatures are relevant but not explicitly PUM. Unit-memory MDS and strongly-MDS convolutional codes with maximum distance profile were constructed by parity-check splitting of block MDS codes; this suggests a nearby algebraic template for memory-$1$33 PUM adaptations, but the paper itself treats UM rather than PUM (Chan et al., 2015). Over finite chain rings, MDP and reverse-MDP codes admit analogous generator-matrix characterizations, lifting theorems from the residue field, and generalized superregular constructions; this suggests chain-ring analogues of memory-$1$34 PUM MDP codes when the usual extra rank restrictions are imposed (Alfarano et al., 2021).

6. Related notions, terminology, and common distinctions

A common misconception is to identify “PUM” with “MDP.” The PUM condition only fixes a memory-$1$35 rank profile; the MDP condition is an additional statement about column distances or, equivalently, admissible minors of sliding matrices. The PUM decoding papers based on constituent block codes and reduced trellises do not use MDP terminology, even though they analyze local window behavior and extended column or row distances (Wachter-Zeh et al., 2012, Puchinger et al., 2017).

This distinction is explicit in the probabilistic PUM literature. For memoryless channels, the success probability of decoding a PUM block can be written in terms of the probabilities

$1$36

for direct decoding, one-sided propagation, two-sided recovery, and failure, respectively, and the resulting formulas quantify how neighboring blocks improve recovery. This is complementary to MDP theory: it analyzes stochastic block recovery rather than deterministic maximal column distances (Puchinger et al., 2017).

A second adjacent direction is rank-metric or sum-rank PUM coding. Gabidulin-based PUM constructions optimize free rank distance and slope in the sum-rank metric and provide explicit parity-check constructions with dual memory $1$37, but they do not establish Hamming-metric MDP behavior or maximize finite-window column distances in the classical MDP sense (Wachter et al., 2011).

A third source of terminological confusion is the phrase “partial MDP.” In locally repairable convolutional codes, “partial $1$38-MDS” and “partial MDP” mean that after puncturing away $1$39 symbols per local group, the restricted code is $1$40-MDS or MDP up to the largest admissible $1$41. That is the convolutional analogue of partial-MDS or maximally recoverable locality, and it is conceptually distinct from “partial unit-memory MDP codes,” even though the unit-memory specialization is possible by taking memory $1$42 (Martínez-Peñas et al., 2019).

Taken together, the literature identifies partial unit-memory MDP codes as a narrow but technically rich intersection: the memory-$1$43 algebraic structure of PUM codes, the finite-window optimality of MDP column distances, the erasure-decoding hierarchy MDP $1$44 reverse-MDP $1$45 complete-MDP, and the recent matrix-completion program that makes sparse, structured, low-complexity PUM MDP constructions explicit (Dang et al., 23 Apr 2026).