Zigzag Array Codes in Distributed Storage

• Zigzag Array Codes are MDS array codes that leverage structured row permutations to rebuild lost data by accessing only a fraction of surviving nodes.
• They attain the information-theoretic optimum rebuilding ratio of e/r, reducing data access complexity compared to earlier methods like EVENODD and RDP.
• Extensions include variants for multiple erasures, enhanced error correction, and adaptations to small-field arithmetic, improving practical repair efficiency.

Searching arXiv for relevant papers on zigzag array codes and related developments. Zigzag Array Codes are a family of maximum-distance separable (MDS) array codes for distributed and RAID-style storage systems in which parity equations are organized through structured permutations of row indices, called zigzag sets, so that erased columns can be rebuilt by accessing only a prescribed fraction of the surviving array rather than reading all remaining data. In the original formulation, the central quantity is the rebuilding ratio $R(e)$, defined as the fraction of surviving information accessed to exactly rebuild $e$ erased columns. The defining result is that, for an $r$-erasure-correcting MDS array code, Zigzag Codes attain the information-theoretically optimal rebuilding ratio $R(e)=e/r$ for $1\le e\le r$, while retaining efficient encoding and decoding and, in the classical construction, the optimal update property (Tamo et al., 2011). Subsequent work generalized the lower-bound theory, extended optimal rebuilding from single to multiple erasures, constructed variants with optimal rebuilding for parity-node erasures, developed error-correction algorithms beyond minimum Hamming distance, and revisited the framework to obtain small-field and low-skip-cost repair schemes (Wang et al., 2016, Zhang et al., 27 Sep 2025).

1. Definition and core coding model

An MDS array code is a two-dimensional array of size $p\times n$ over a finite field $F$, with $k$ systematic columns containing raw data and $r=n-k$ parity columns. The code is MDS if any $r$ erased columns can be exactly reconstructed from the remaining $e$0 columns (Tamo et al., 2011). In later notation, the same structure is described as a systematic $e$1 MDS array code with sub-packetization $e$2, where a node erasure means loss of all $e$3 elements in a column (Wang et al., 2016).

The distinctive performance metric is the rebuilding ratio. For $e$4 erasures, it is the fraction of surviving data that must be accessed in order to rebuild the erased nodes exactly. In the original formulation,

$e$5

For a single erasure in an $e$6-erasure-correcting code, the surviving symbols are $e$7; for $e$8 erasures, they are $e$9 (Tamo et al., 2011). A later averaged formulation writes the rebuilding ratio over a set $r$0 of candidate erased nodes as

$r$1

where $r$2 is the minimum number of accessed elements required to rebuild the erased set $r$3 (Wang et al., 2016).

This framework is closely related to repair bandwidth. If $r$4 is the minimum number of elements transmitted from surviving nodes during rebuilding, then the normalized repair bandwidth is

$r$5

Because transmitted information cannot exceed accessed information, $r$6 is a lower bound on $r$7 (Wang et al., 2016). This relation is important because the optimality of Zigzag Codes can be derived both from direct combinatorial counting in the array and from the storage–repair trade-off associated with regenerating-code theory (Tamo et al., 2011, Wang et al., 2016).

A further structural notion is optimal update. An MDS array code with $r$8 parities is optimal update if each information element appears in exactly $r$9 parity elements (Wang et al., 2016). In the original Zigzag construction, every parity element is a linear combination of exactly one element from each systematic column, and every information symbol appears exactly once in each parity column; consequently, updating one information symbol affects the information element itself and one parity symbol in each parity column, for a total of $R(e)=e/r$0 updates, which is optimal (Tamo et al., 2011).

2. Optimal rebuilding ratio and lower bounds

The central theorem of the original construction is that an MDS array code with $R(e)=e/r$1 parity columns must satisfy the lower bound

$R(e)=e/r$2

for exact rebuilding of $R(e)=e/r$3 erasures, and Zigzag Codes attain this bound for all $R(e)=e/r$4 (Tamo et al., 2011). For the particularly important case of a single erasure in a two-parity code, previous work had only bounded the rebuilding ratio between $R(e)=e/r$5 and $R(e)=e/r$6; Zigzag Codes resolved the open problem by proving that the exact optimum is $R(e)=e/r$7 and by constructing codes that achieve it (Tamo et al., 2011).

The lower bound has both an array-theoretic and a bandwidth-theoretic interpretation. In array terms, for arrays with $R(e)=e/r$8 rows, at least $R(e)=e/r$9 zigzag equations are required across the $1\le e\le r$0 parity columns; by the pigeonhole principle, one parity contributes at least $1\le e\le r$1 equations, which forces each surviving systematic column to supply at least an $1\le e\le r$2 fraction of its symbols (Tamo et al., 2011). In bandwidth terms, for exact-repair reconstructing codes with node storage $1\le e\le r$3, helper degree $1\le e\le r$4, and per-helper transmission $1\le e\le r$5, the file size $1\le e\le r$6 satisfies

$1\le e\le r$7

where $1\le e\le r$8, $1\le e\le r$9. For MDS codes, this yields

$p\times n$0

and with all remaining nodes available, $p\times n$1, the normalized repair-bandwidth lower bound becomes $p\times n$2, implying $p\times n$3 (Wang et al., 2016).

The practical significance of this optimum is clearest in comparison with earlier two-parity array codes. EVENODD and RDP require approximately $p\times n$4 of the surviving data to rebuild one erased systematic column, whereas Zigzag achieves the optimal $p\times n$5; with three parities, the generalized Zigzag construction attains $p\times n$6 (Tamo et al., 2011). This suggests that the contribution of Zigzag Codes is not merely an incremental improvement in access volume, but the exact attainment of the minimum permitted by the MDS and exact-repair constraints.

3. Classical construction for two parities

The canonical $p\times n$7 Zigzag construction is specified by a binary-vector permutation framework. Fix $p\times n$8. The array has $p\times n$9 rows, $F$0 systematic columns, and two parity columns: a row parity and a zigzag parity (Tamo et al., 2011). Choose a set $F$1 of $F$2 nonzero binary vectors $F$3. For each $F$4, define a permutation on row indices $F$5, viewed in binary, by

$F$6

where addition is bitwise XOR. Also define the orthogonality set

$F$7

where the inner product is over $F$8. Each $F$9 has size $k$0 (Tamo et al., 2011).

The row parity is defined by

$k$1

and the zigzag parity by

$k$2

In the optimal-update form, every parity element is a linear combination of exactly one element from each systematic column (Tamo et al., 2011).

For single-erasure rebuilding of systematic column $k$3, the rows are partitioned into

$k$4

Elements in rows $k$5 are rebuilt from row parity, and elements in rows $k$6 are rebuilt from zigzag parity (Tamo et al., 2011). Explicitly, for $k$7,

$k$8

and for $k$9,

$r=n-k$0

Only half the rows are used, so $r=n-k$1 (Tamo et al., 2011).

The exact access count is governed by the interaction between the row-based and zigzag-based accesses. For distinct $r=n-k$2, the number of elements accessed in surviving node $r=n-k$3 while rebuilding node $r=n-k$4 equals

$r=n-k$5

Moreover, when $r=n-k$6 and $r=n-k$7,

$r=n-k$8

where $r=n-k$9 counts positions with $r$0 and $r$1 (Tamo et al., 2011). This leads to the notion of orthogonal permutations: a family $r$2 with associated subsets $r$3 of size $r$4 is orthogonal if

$r$5

The fundamental $r$6 theorem chooses

$r$7

where $r$8 is the standard basis of $r$9 and $e$00 is the all-ones mask used to define

$e$01

With $e$02 and $e$03 defined as above, the resulting $e$04 array code has rebuilding ratio $e$05 for any single systematic erasure (Tamo et al., 2011).

4. MDS property, coefficients, and decoding

Achieving the rebuilding optimum does not by itself ensure the MDS property; the parity coefficients must be chosen so that any two erased columns can be recovered. For the $e$06 optimal Zigzag Code, a simple assignment over $e$07 suffices, and $e$08 is the smallest possible field (Tamo et al., 2011).

The coefficient assignment is: $e$09 and

$e$10

where

$e$11

Here the exponent $e$12 is computed in $e$13, and $e$14 is the primitive element (Tamo et al., 2011). With these coefficients, the $e$15 Zigzag Code is MDS. In particular, for any two erased systematic columns $e$16 and rows $e$17,

$e$18

so the resulting $e$19 linear system built from two row-parity and two zigzag-parity equations is nonsingular (Tamo et al., 2011).

The explicit encoding equations are correspondingly simple. If $e$20 is the systematic symbol at row $e$21, column $e$22, then

$e$23

and

$e$24

This form makes both encoding and rebuilding sparse: each parity symbol depends on one symbol per systematic column (Tamo et al., 2011).

For two systematic erasures with $e$25, two cases arise. If the corresponding permutations are equal, the unknowns in each row decouple into a $e$26 system,

$e$27

where $e$28 are assembled from row and zigzag parities. Otherwise, rows are paired by $e$29, giving a coupled $e$30 system that remains nonsingular over $e$31 under the above coefficient assignment (Tamo et al., 2011).

The later general formalism rewrites Zigzag Codes by parity encoding matrices. For prime $e$32, with $e$33, vectors $e$34, and parity index $e$35, the parity node $e$36 is governed by permutations

$e$37

and can be represented through generalized permutation matrices $e$38. The full generator matrix has the block form

$e$39

and sufficiently large fields allow coefficient assignments that make every $e$40 block submatrix corresponding to $e$41 erased nodes invertible (Wang et al., 2016).

5. Generalization to $e$42 parities and multiple erasures

The original paper generalized the binary construction to $e$43-ary permutations, taking $e$44 rows and vectors $e$45 satisfying $e$46 for each $e$47 (Tamo et al., 2011). For parity index $e$48,

$e$49

and

$e$50

Parity node $e$51 uses zigzag sets $e$52 containing symbols $e$53 satisfying $e$54 (Tamo et al., 2011).

The optimal single-erasure result over $e$55 parities is obtained by choosing the orthogonal family generated by $e$56. The resulting $e$57 Zigzag Code has rebuilding ratio $e$58 for any single systematic erasure (Tamo et al., 2011). For $e$59, a field of size at most $e$60 suffices in the optimal construction via commuting block-permutation matrices augmented by powers of a primitive element (Tamo et al., 2011).

The later multiple-erasure theory established precise necessary and sufficient conditions for optimal rebuilding in general Zigzag Codes. For erasures $e$61, define, for each parity $e$62, the group $e$63 generated by $e$64. Optimal rebuilding ratio $e$65 holds if there exists a set $e$66 of size $e$67 such that:

1. for each parity $e$68, every $e$69 stabilizes $e$70;
2. for each erased systematic node $e$71,

$e$72

1. the selected $e$73 zigzag equations are linearly independent (Wang et al., 2016).

In the vector-indexed special case, writing rows as $e$74, define

$e$75

Then optimal rebuilding is achieved if there exists $e$76 of size $e$77 that is a union of cosets of $e$78 and satisfies

$e$79

for each erased $e$80, together with linear independence of the selected equations (Wang et al., 2016). This condition reduces further to

$e$81

which is both necessary and sufficient for the existence of such an $e$82 (Wang et al., 2016).

An explicit rebuilding algorithm follows this structure. For given erasures $e$83:

1. compute $e$84 with $e$85 a maximal admissible subset of survivors;
2. find $e$86 such that $e$87 for all erased $e$88, set $e$89, and let $e$90 be any union of $e$91 cosets of $e$92;
3. from each parity $e$93, access rows $e$94 and the corresponding surviving systematic elements, then solve the resulting $e$95 equations (Wang et al., 2016).

The same work proved that the optimal Zigzag Code with $e$96, $e$97, and $e$98 is MDS and achieves the optimal rebuilding ratio $e$99 for any set of $r$00 erasures, $r$01 (Wang et al., 2016). For $r$02, the required fields remain $r$03 and $r$04, respectively (Wang et al., 2016).

6. Variants, error correction, and practical trade-offs

A major limitation of the original optimal-update Zigzag Codes is asymmetry between systematic and parity erasures: for $r$05, they achieve optimal rebuilding ratio $r$06 for a systematic-node erasure, but rebuilding a parity-node erasure requires accessing all remaining information (Wang et al., 2016). To address this, a later construction introduced a systematic MDS array code with $r$07 systematic nodes, $r$08 parities, and $r$09 rows, achieving rebuilding ratio $r$10 for any single erasure, whether systematic or parity (Wang et al., 2016). The trade-off is update cost: this construction is not optimal update, since each information element appears in $r$11 parity symbols (Wang et al., 2016).

Zigzag Codes also admit syndrome-based error-correction procedures. For $r$12 two-parity codes, if one systematic column is erased and at most one element error occurs in another systematic column, syndromes

$r$13

identify the error location and support correction (Tamo et al., 2011). The expanded formulation gives an algorithm that corrects one node erasure plus one element error—beyond the minimum distance 3 for two parities—by using the MDS condition

$r$14

to disambiguate candidate error positions (Wang et al., 2016). For general $r$15, a single node error can be corrected by syndromes

$r$16

using the test $r$17 to identify the erroneous systematic column (Wang et al., 2016).

There is also a binary-field branch of the Zigzag literature. A two-parity GF$r$18 construction achieved optimal repair of a failed information node using XOR operations only by sacrificing optimal update (Gad et al., 2013). In that design, the sub-packetization is

$r$19

the row parity is

$r$20

and the zigzag permutation for column $r$21 is

$r$22

To preserve the MDS property over GF$r$23, the zigzag parity augments the classical one-symbol-per-column pattern with extra terms determined by “dark” positions and right-neighbor sets. The construction still repairs a single systematic failure by reading exactly $r$24 symbols from each helper, but the expected number of parity updates per information update becomes $r$25, and the worst-case number becomes $r$26 (Gad et al., 2013). This suggests a broader pattern in the Zigzag family: smaller fields and simpler arithmetic may be obtained by relinquishing the optimal-update property.

7. Scaling, modern revisions, and relation to MSR formulations

The core optimal-update construction has a stringent size constraint: for $r$27, any orthogonal-permutation code over $r$28 rows has at most $r$29 systematic columns, which is tight for the standard-basis construction (Tamo et al., 2011). Thus the number of rows is exponential in the number of columns for exact optimal ratio together with optimal update (Tamo et al., 2011). Duplication can enlarge $r$30: duplicating each permutation $r$31 times yields $r$32 codes with rebuilding ratio

$r$33

For the optimal $r$34 code, this gives $r$35 as $r$36 (Tamo et al., 2011). The same source notes that alternative constructions using weight-3 vector sets achieve $r$37 columns with ratio approximately $r$38 on small constant fields such as GF$r$39 or GF$r$40 (Tamo et al., 2011).

A later revision revisited Zigzag Codes from the perspective of small fields and I/O locality. For row-indexing group $r$41, with field characteristic two, explicit Cauchy-type coefficients

$r$42

over any field with $r$43 guarantee the MDS property, thereby decoupling $r$44, $r$45, and $r$46 in a way that differs from classical $r$47 Zigzag parameterizations (Zhang et al., 27 Sep 2025). The same work introduced an ordering-and-subgroup framework yielding repair-by-transfer schemes with bounded skip cost and low repair-fragmentation ratio while preserving optimal access and optimal rebuilding ratio for single-node repair. Its explicit families include zero skip-cost constructions with rates approaching $r$48, and bounded skip-cost families with rates approaching $r$49 and $r$50 (Zhang et al., 27 Sep 2025). This indicates that the Zigzag paradigm can be adapted to storage settings where read contiguity and helper-side simplicity are as important as access volume.

Zigzag ideas also appear in minimum-storage regenerating (MSR) formulations. In Zigzag MSR codes, parity-check structure is expressed through block Vandermonde matrices and permutation-shift matrices $r$51, and single-node repair attains the MSR point with optimal bandwidth (Liu et al., 27 Feb 2025). A cooperative repair scheme for Zigzag MSR codes was later proposed for any number $r$52 of simultaneous failures, using $r$53 space-shared instances of the original Zigzag MSR code and achieving the cooperative cut-set bound with

$r$54

while reducing the field-size requirement to $r$55 (Liu et al., 27 Feb 2025). Although these MSR constructions belong to a regenerating-code rather than a classical array-code formulation, they preserve the central Zigzag feature: highly structured permutation-based interference alignment.

Several limitations remain intrinsic across the literature. Exact optimal ratio in the classical constructions requires $r$56, hence large sub-packetization; orthogonality of permutations is essential for the exact $r$57 single-erasure ratio; and some Zigzag codes exhibit a threshold $r$58 such that optimal rebuilding holds only for $r$59 (Tamo et al., 2011, Wang et al., 2016). The 2016 work proves a monotonicity property: if optimal rebuilding holds for $r$60, it also holds for all $r$61 (Wang et al., 2016). A plausible implication is that the geometry of the vector set $r$62 determines not only repair efficiency but also a phase transition in which erasure patterns admit the coset-stability conditions required for exact $r$63 rebuilding.

Taken together, these results establish Zigzag Array Codes as a structurally rich class of MDS array codes in which rebuild efficiency is controlled through algebraic permutations on row indices. Their foundational contribution is the exact attainment of the rebuilding lower bound $r$64 under exact repair, first for one erasure with two parities and then for all $r$65 in broader families (Tamo et al., 2011, Wang et al., 2016). Later developments show that the same framework can be modified to optimize parity repair, support error correction beyond minimum distance, operate over GF$r$66, reduce field size, improve I/O locality, and support cooperative repair in MSR settings (Gad et al., 2013, Zhang et al., 27 Sep 2025, Liu et al., 27 Feb 2025).