Papers for

distributed storage engineers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Reed-Solomon code subpacketization limits for optimal linear repair found

The Minimum Subpacketization of Reed-Solomon Codes with Linear Repair Achieving the Cut-Set Bound

Abstract: In this paper, we study the minimum subpacketization of $(n,k)$ Reed-Solomon (RS) codes over $\mathbb{F}_{q^\ell}$ admitting cut-set-optimal exact $\mathbb{F}_q$-linear repair of every coordinate from any $d$ helpers. For $3\le k<d\le n-1$, write $s=d+1-k$ and denote this minimum by $\ell_{min}(n,k,d;q)$. Using divisibility and relative-degree constraints on cross-ratio fields of evaluation sets, we establish $\ell_{min}(n,k,d;q)\ge sG_s(d+1)$, where $G_s(m)$ is the minimum product of $m$ pairwise coprime integers, each at least $s$. Let $Δ_s(n,d)$ be the minimum of $lcm(a_1,\ldots,a_n)$ over positive integers $a_1,\ldots,a_n$ satisfying $lcm(a_j:j\in J\cup\{i\})\ge s~lcm(a_j:j\in J)$ for every $d$-subset $J\subseteq[n]$ and every $i\in[n]\setminus J$. We construct RS codes with subpacketization $sΔ_s(n,d)$ and further prove that $\ell_{min}(n,k,d;q)=sΔ_s(n,d)=sG_s(n)$ whenever $d(d+2)\geq 4(n+1)$, for every prime power $q$. In particular, this determines the minimum subpacketization in the full-helper case $d=n-1$, resolving the corresponding exact linear-repair case of Open Problem 20 posed by Ramkumar et al. in their survey on codes for distributed storage. We further give a finite formula for $G_s(n)$ and determine the exact threshold for its closed-form expression in terms of the first $n$ primes. For fixed $k$ and $d$, we prove $\log\ell_{min}(n,k,d;q)= Θ_{k,d}(\log n\log\log n)$ as $n\to\infty$, using divisor-function estimates and cover-free families. An affine-plane construction shows that $Δ_s(n,d)<G_s(n)$ for some parameters, so $sG_s(n)$ is not a universal formula. We conjecture that $\ell_{min}(n,k,d;q)=sΔ_s(n,d)$ for every prime power $q$ and all $3\le k<d\le n-1$.

Tue 27 OctInformation Theory
The gist
Reed-Solomon codes are important for storing data reliably across many places, and fixing broken parts quickly without extra data is a challenge. This paper finds the smallest way to split data to fix any piece from some helpers, minimizing how complicated the repair process must be. The authors solved this fully when nearly all helpers are involved and gave formulas for other cases, showing how complexity grows with system size. They also give constructions that achieve their proven lower bounds and propose a general formula for all setups.
Open → 2610.37522v1

Recovery balance in linear codes tied to matroid properties

A Matroidal Framework for Random Access in Linear Codes

Abstract: We study random access in linear codes when codeword symbols are sampled independently and uniformly with replacement. A code is recovery balanced if the expected number of samples required to recover a codeword coordinate is the same for every coordinate. We express the recovery expectations in terms of the associated matroid and derive a coordinatewise identity relating these values for a code and its dual. This proves that a linear code is recovery balanced if and only if its dual is recovery balanced, establishing a conjecture of Gruica et al. We further define the recovery balance for arbitrary matroids and show that asymptotically almost every sparse paving matroid is not recovery balanced.

Tue 20 OctInformation Theory
The gist
The paper looks at how to recover lost parts of special codes called linear codes by randomly sampling their pieces. It introduces a way to tell if each part of the code is equally easy to recover, called recovery balance. The authors prove that if such a code is recovery balanced, then its related code (called the dual) also has this property. They also explore recovery balance in a broader concept called matroids and find that most sparse paving matroids don’t have this balance.
Open → 2610.28820v1

Exact tradeoffs found for repairing failed storage systems

Exact Storage-Repair-Bandwidth Tradeoffs for $(6,5,5)$ and $(7,6,6)$ Exact-Repair Regenerating Codes

Abstract: This note provides exact information-theoretic outer bounds that completely characterize the storage-repair-bandwidth tradeoff regions for the cases $(n,k,d)=(6,5,5)$ and $(7,6,6)$. The layered code proposed by Tian et al. achieves the tradeoff and is thus optimal. GPT-6 Astra assisted in the discovery of these bounds, based on a new conditioning argument and a structured search over the restricted subsets of entropy linear program constraints. The proofs are given as exact integer-valued certificates, which are difficult for direct human verification, and a Python verifier is included as part of the package, together with the certificates.

Tue 20 OctInformation Theory
The gist
Storing data safely across many computers means you need to fix lost pieces quickly and without using too much space or communication. This paper finds the exact best balance between how much data each computer stores and how much information needs to be shared to repair a failure in certain setups with six or seven storage nodes. The authors also confirm that an existing layered coding method perfectly matches this balance. They used advanced mathematical tools, assisted by AI, to prove these limits exactly.
Open → 2610.28199v1

Capacity limits found for noisy unordered fragment channels

The Capacity of the Noisy Torn Paper Channel and the Noisy Shuffling Channel

Abstract: The torn paper channel breaks a codeword into fragments and returns all fragments without their original order. The noisy torn paper channel additionally introduces bit substitution errors to each fragment. Recovering the message therefore requires accounting for both bit errors and uncertainty about the fragment order. We establish a capacity upper bound for the noisy torn paper channel that matches the achievable rate of Ravi, Vahid, and Shomorony and resolves their conjecture. Our results also determine the capacity of the noisy shuffling channel of Shomorony and Heckel, in which all fragments have the same length, and resolve their open question.

Tue 13 OctInformation Theory
The gist
Sending a message broken into scrambled pieces is tricky when each piece may also have errors. The authors studied models where message parts are both shuffled and have bit errors. They found exact limits on how much information can be reliably sent in such noisy, unordered fragment channels. This settles previous open questions about how well communication over these channels works.
Open → 2610.19300v1

Reed solomon decoding methods correct more insertion and deletion errors

Insdel Reed-Solomon Decoding Algorithms up to the Half-Singleton Bound

Abstract: In this paper, we focus on decoding optimal Reed-Solomon codes of dimension two for insdel errors up to the half-Singleton bound. We present a decoding algorithm for the general insertion-and-deletion scenario with a time complexity smaller than brute-force decoding. Our algorithm corrects insdel errors up to the half-Singleton bound, which exceeds the scope of existing methods. Additionally, for the special cases of insertion-only and deletion-only insdel error patterns, we present two different algorithms with a time complexity smaller than our general algorithm.

Sun 11 OctInformation Theory
The gist
Communication and storage systems sometimes lose or add extra pieces in transmitted messages, causing errors. Decoding these messages correctly is important to recover the original information. The authors focus on a special type of error called insertion and deletion errors for certain Reed-Solomon codes. They designed new algorithms that can correct more of these errors efficiently than previous methods. Their work offers faster ways to fix messages even when errors involve insertions only or deletions only.
Open → 2610.15413v1

Plotkin-type codes reveal new recovery sets for better data service rates

Recovery Set Structures and Service Rates of Codes Obtained by the Plotkin-type Construction

Abstract: In distributed storage systems, redundancy enables a single data object to be reconstructed using several disjoint groups of servers. The resulting service rate region (SRR) captures all combinations of object request rates that the system can support simultaneously without overloading any individual server. We analyze the SRR of binary codes obtained via the Plotkin-type construction. We demonstrate that each recovery set for an information object of the Plotkin-type code $\mathcal{C}_p$ induces a corresponding recovery set for the same data object characterized by the underlying code $\mathcal{C}$. Furthermore, by characterizing the recovery sets structure of $\mathcal{C}_p$ in terms of the recovery set structure of $\mathcal{C}$, we identify the additional recovery sets introduced by this construction. Using the associated recovery hypergraphs, we establish bounds on the SRRs of $\mathcal{C}_p$ and iterated code $\mathcal{C}_{p^m}$ in terms of the SRR of $\mathcal{C}$. We consider the family of first-order binary Reed-Muller codes and show how the recovery structure, and consequently, the service rates of R$(1,m)$ for arbitrary $m$ can be recursively derived from a generator matrix of R$(1,2)$ through our results for successive Plotkin-type constructions.

Thu 1 OctInformation Theory
The gist
In systems that store data across many servers, it's important to recover data quickly without overloading any single server. The authors study a special way to build error-correcting codes called Plotkin-type construction and how it creates new ways to recover data. They show that recovery groups for these codes relate closely to those from the original code, revealing extra recovery options. This helps understand and improve the combinations of requests the system can handle at the same time. Their method extends to a famous family of codes, Reed-Muller codes, to find recovery sets recursively.
Open → 2610.01900v1

Storage codes from binary BCH codes approach perfect efficiency

Asymptotically unit-rate storage codes from binary BCH codes

Abstract: A storage code on a graph assigns a symbol to each vertex so that the symbol can be recovered from its neighbors. We prove that the binary full-parity storage codes on triangle-free coset graphs of primitive BCH codes have rate tending to one for every fixed error-correction capability of at least two. The conclusion also holds for an increasing error budget under an explicit growth condition. The proof bounds the binary rank of convolution matrices associated with polynomial maps. Low coordinate degree forces cancellation in the polynomial representing the image, and a polynomial rank bound converts this cancellation into a quantitative estimate for the storage rate. For the double-error-correcting family over $\mathbb{F}_{2^m}$, we prove that the storage deficiency is $Θ(((1+\sqrt{5})/4)^m)$. This refinement follows from an exact Fibonacci formula for a polynomial coefficient rank and a matching exponential lower bound after finite-field evaluation.

Thu 1 OctInformation Theory
The gist
The paper studies special codes that let you store data on a network, where each stored piece can be recovered from its neighbors’ data. It proves that certain binary BCH codes used in these networks get very close to perfect efficiency, meaning almost all the space is used for useful data as the network grows. The authors use mathematical tools involving polynomials to show how this works and even give precise formulas for some cases. This means better designs for storage that can recover errors while using very little extra space.
Open → 2610.01733v1

Replica counts needed to recover data with symmetric erasure codes

Replica Thresholds for Stripeless Erasure Coding Based on Symmetric Block Designs

Abstract: This paper investigates a fundamental question in stripeless erasure coding based on symmetric balanced incomplete block designs (SBIBDs): how many replicas per object are precisely required to guarantee recovery from any set of at most $p$ node failures? We refine the known sufficient recovery guarantee for the generalized SBIBD $(v,k,λ)$ construction. One replica is necessary and sufficient for $p=1$, and $q=λ(p-1)+2$ replicas ($q\le k$) guarantee recovery for $p\ge2$. Recovery takes one round for $p=2$ and at most two rounds in general. To study the tightness of this count, we define the universal replica threshold $q^\ast(A,p)$ for a fixed zero-diagonal SBIBD representative~$A$. We determine $q^\ast(A,p)$ for $p=1$ and $p=2$. For $p\ge3$, we identify pairwise separated sets and private target permutations as the structures determining whether the sufficient count is tight or can be further reduced. These conditions give exact thresholds for all but the case where $λ>1$ and $A$ contains no pairwise separated set of size~$p$. We improve the bounds for this remaining case and leave its exact threshold open. Finally, we give sufficient conditions for pairwise separated sets and show how affinity relabeling can realize private target permutations.

Thu 24 SeptInformation Theory
The gist
The paper studies how many copies of a data piece are needed to recover it if some storage nodes fail. The authors focus on special codes built from symmetric designs, which arrange data in balanced blocks. They find exact replica numbers required for up to two failures and identify structural reasons affecting higher failure cases. Their work refines previous limits and clarifies when fewer copies suffice for full recovery.
Open → 2609.29149v1

Linear and nonlinear codes provide infinite families of 3-designs

Infinite families of 3-designs from linear and nonlinear codes

Abstract: The connection between coding theory and combinatorial $t$-designs is an important research topic at the intersection of coding theory and combinatorics. Let $q=p^m$, where $p$ is an odd prime and $m\geq 2$. In this paper, we investigate a class of linear codes $\mathcal{C}$ over $\mathbb{F}_{q^2}$ and their connection with combinatorial $3$-designs. By analyzing the relevant structural properties of $\mathcal{C}$ and $\mathcal{C}^{\perp}$, we show that the supports of the codewords of every nonzero weight in $\mathcal{C}$ and {the supports of the codewords of weight $4$ in $\mathcal{C}^{\perp}$} form $3$-designs. We further investigate a class of nonlinear codes $\mathcal{C}_2$ associated with $\mathcal{C}$, and prove that the supports of the codewords of every nonzero Hamming weight in $\mathcal{C}_2$ also form $3$-designs. These results identify further classes of linear and nonlinear codes whose codewords support combinatorial $3$-designs. In particular, the nonlinear case provides additional examples of codes supporting $3$-designs, a topic for which relatively few results are currently available. As applications, we construct from $\mathcal{C}^{\perp}$ an entanglement-assisted quantum error-correcting code with parameters $[[q+1,q-3,4;4]]_q$. We also prove that $\mathcal{C}$ is an all-symbol locally repairable code with locality $3$. Furthermore, we show that the code $\mathcal{C}$ {meets the Singleton-type bound for locally repairable codes} and hence is optimal in some cases.

Mon 14 SeptInformation Theory
The gist
Certain types of codes used for error correction can be connected to special combinatorial structures called 3-designs, which help organize data in balanced ways. The authors study both linear and nonlinear codes defined over specific mathematical fields and show that the patterns formed by their codewords correspond to these 3-designs. This work expands the known examples of such codes, particularly for nonlinear ones where examples are rare. They also find practical uses of these codes in quantum error correction and efficient data repair techniques.
Open → 2609.15525v1