arXiv subjects

Stanislav Kruglik

Publications and source records attributed to Stanislav Kruglik.

16 recordsLinked to original sources

arXiv2026

Linear Code Conversion in the Merge Regime: General Bounds and Reed-Muller Constructions

Erasure codes are a core component of most existing large-scale distributed storage systems, ensuring reliability against node failures. Recent work has shown that adapting code parameters to changing node failure rates can lead to significant storage savings. The default approach is to re-encode the data under a new code, which consumes substantial system resources. Code conversion was introduced to reduce this cost. However, existing work has mainly focused on conversions within specific classes of codes. In this paper, we study scalar linear code conversion in the merge regime for arbitrary linear codes. We derive universal lower bounds on the write and read costs in terms of unchanged and read symbols. The bounds are refined using generalized Hamming weights, which capture support-growth properties of subcodes and can give sharper estimates than minimum-distance-only arguments. We show that the framework recovers known bounds for important special cases and can be strictly stronger when the final code has nontrivial jumps in its generalized Hamming weight hierarchy. We then apply the framework to Reed-Muller codes and construct explicit Reed-Muller convertible codes using the Plotkin decomposition. For a natural Reed-Muller parameter regime, the construction attains the derived write-cost lower bound. For the read cost, the generalized-Hamming-weight analysis is sharp for one initial block, while a gap remains for the other block.

cs.IT↗

arXiv2026

Robust Repair of Reed-Solomon Codes

We study the problem of robust repair of a single erasure in Reed--Solomon codes under low communication bandwidth. Focusing on the Guruswami--Wootters trace repair framework, we investigate whether a failed node can be correctly repaired in the presence of erroneous responses from helper nodes. Equivalently, we view the collection of downloaded traces as a code, which we call the repair-trace code. By characterizing the zero coefficients of the associated polynomial in terms of cyclotomic cosets, we derive upper bounds on the dimension $k$ that allow correction of a given number of erroneous traces $e$, as well as lower bounds on the minimum distance as a function of $k$. For the case $q=2$, we exploit explicit formulas for cyclotomic coset representatives to obtain the exact optimal dimension bound for single-error correction. We also propose two efficient robust repair schemes. Our first scheme achieves the error-correction capability guaranteed by the BCH bound. To approach a stronger bound based on character sums, we develop a second scheme that tolerates more errors at the cost of an additional factor $n$ in computational complexity.

cs.IT↗

arXiv2026

Convertible Codes for Data and Device Heterogeneity

Distributed storage systems must handle both data heterogeneity, arising from non-uniform access demands, and device heterogeneity, caused by time-varying node reliability. In this paper, we study convertible codes, which enable the transformation of one code into another with minimum cost in the merge regime, addressing the latter. We derive general lower bounds on the read and write costs of linear code conversion, applicable to arbitrary linear codes. We then focus on Reed-Muller codes, which efficiently handle data heterogeneity, addressing the former issue, and construct explicit conversion procedures that, for the first time, combine both forms of heterogeneity for distributed data storage.

cs.IT↗

arXiv2026

Trace Repair Never Loses to Classical Repair: Exact and Explicit Helper Nodes Selection

Repairing Reed-Solomon codes with low bandwidth is a central challenge in distributed storage. Following the trace-repair framework of Guruswami and Wootters (2017), recent works by Lin (2023) and Liu-Wan-Xing (2024) provided significant improvements in bandwidth using two distinct ideas. Lin constructed a trace-repair scheme that requires no contribution from a set of predetermined nodes $\mathscr{S}$, while Liu-Wan-Xing identified linear dependencies among the downloaded traces, relating the number of dependent traces to the dimension of a subspace $\mathscr{W}_k$. In this work, we fully utilize and unify these ideas. We compute the exact dimension of $\mathscr{W}_{k,\mathscr{S}}$ (a generalization of $\mathscr{W}_k$). We identify the trade-off between the set size $|\mathscr{S}|$ and the dimension $\dim(\mathscr{W}_{k,\mathscr{S}})$. We provide an algorithm to find the combination that results in the lowest bandwidth. Furthermore, we provide an explicit choice of the helper nodes for the repair. Finally, we prove that our optimized scheme never loses to the classical repair scheme, establishing a bandwidth guarantee of at most $k\log|\mathbb{F}|$ bits for all dimension $k$ and field $\mathbb{F}$, whenever the trace repair is applicable.

cs.IT↗

arXiv2024

Repairing Reed-Solomon Codes with Side Information

We generalize the problem of recovering a lost/erased symbol in a Reed-Solomon code to the scenario in which some side information about the lost symbol is known. The side information is represented as a set $S$ of linearly independent combinations of the sub-symbols of the lost symbol. When $S = \varnothing$, this reduces to the standard problem of repairing a single codeword symbol. When $S$ is a set of sub-symbols of the erased one, this becomes the repair problem with partially lost/erased symbol. We first establish that the minimum repair bandwidth depends on $|S|$ and not the content of $S$ and construct a lower bound on the repair bandwidth of a linear repair scheme with side information $S$. We then consider the well-known subspace-polynomial repair schemes and show that their repair bandwidths can be optimized by choosing the right subspaces. Finally, we demonstrate several parameter regimes where the optimal bandwidths can be achieved for full-length Reed-Solomon codes.

cs.IT↗

arXiv2024

Private Repair of a Single Erasure in Reed-Solomon Codes

We investigate the problem of privately recovering a single erasure for Reed-Solomon codes with low communication bandwidths. For an $[n,k]_{q^\ell}$ code with $n-k\geq q^{m}+t-1$, we construct a repair scheme that allows a client to recover an arbitrary codeword symbol without leaking its index to any set of $t$ colluding helper nodes at a repair bandwidth of $(n-1)(\ell-m)$ sub-symbols in $\mathbb{F}_q$. When $t=1$, this reduces to the bandwidth of existing repair schemes based on subspace polynomials. We prove the optimality of the proposed scheme when $n=q^\ell$ under a reasonable assumption about the schemes being used. Our private repair scheme can also be transformed into a private retrieval scheme for data encoded by Reed-Solomon codes.

cs.IT↗

arXiv2023

Committed Private Information Retrieval

A private information retrieval (PIR) scheme allows a client to retrieve a data item $x_i$ among $n$ items $x_1,x_2,\ldots,x_n$ from $k$ servers, without revealing what $i$ is even when $t < k$ servers collude and try to learn $i$. Such a PIR scheme is said to be $t$-private. A PIR scheme is $v$-verifiable if the client can verify the correctness of the retrieved $x_i$ even when $v \leq k$ servers collude and try to fool the client by sending manipulated data. Most of the previous works in the literature on PIR assumed that $v < k$, leaving the case of all-colluding servers open. We propose a generic construction that combines a linear map commitment (LMC) and an arbitrary linear PIR scheme to produce a $k$-verifiable PIR scheme, termed a committed PIR scheme. Such a scheme guarantees that even in the worst scenario, when all servers are under the control of an attacker, although the privacy is unavoidably lost, the client won't be fooled into accepting an incorrect $x_i$. We demonstrate the practicality of our proposal by implementing the committed PIR schemes based on the Lai-Malavolta LMC and three well-known PIR schemes using the GMP library and blst, the current fastest C library for elliptic curve pairings.

cs.CR↗

arXiv2023

Verifiable Coded Computation of Multiple Functions

We consider the problem of evaluating distinct multivariate polynomials over several massive datasets in a distributed computing system with a single master node and multiple worker nodes. We focus on the general case when each multivariate polynomial is evaluated over its corresponding dataset and propose a generalization of the Lagrange Coded Computing framework (Yu et al. 2019) to perform all computations simultaneously while providing robustness against stragglers who do not respond in time, adversarial workers who respond with wrong computation and information-theoretic security of dataset against colluding workers. Our scheme introduces a small computation overhead which results in a reduction in download cost and also offers comparable resistance to stragglers over existing solutions. On top of it, we also propose two verification schemes to detect the presence of adversaries, which leads to incorrect results, without involving additional nodes.

cs.IT↗

arXiv2023

Two-Server Private Information Retrieval with Optimized Download Rate and Result Verification

Private Information Retrieval (PIR) schemes allow a client to retrieve any file of interest, while hiding the file identity from the database servers. In contrast to most existing PIR schemes that assume honest-but-curious servers, we study the case of dishonest servers. The latter provide incorrect answers and try to persuade the client to output the wrong result. We introduce several PIR schemes with information-theoretic privacy and result verification for the case of two servers. Security guarantees can be information-theoretical or computational, and the verification keys can be public or private. In this work, our main performance metric is the download rate.

cs.IT↗

arXiv2023

Explicit Low-Bandwidth Evaluation Schemes for Weighted Sums of Reed-Solomon-Coded Symbols

Motivated by applications in distributed storage, distributed computing, and homomorphic secret sharing, we study communication-efficient schemes for computing linear combinations of coded symbols. Specifically, we design low-bandwidth schemes that evaluate the weighted sum of $\ell$ coded symbols in a codeword $\pmb{c}\in\mathbb{F}^n$, when we are given access to $d$ of the remaining components in $\pmb{c}$. Formally, suppose that $\mathbb{F}$ is a field extension of $\mathbb{B}$ of degree $t$. Let $\pmb{c}$ be a codeword in a Reed-Solomon code of dimension $k$ and our task is to compute the weighted sum of $\ell$ coded symbols. In this paper, for some $s<t$, we provide an explicit scheme that performs this task by downloading $d(t-s)$ sub-symbols in $\mathbb{B}$ from $d$ available nodes, whenever $d\geq \ell|\mathbb{B}|^s-\ell+k$. In many cases, our scheme outperforms previous schemes in the literature. Furthermore, we provide a characterization of evaluation schemes for general linear codes. Then in the special case of Reed-Solomon codes, we use this characterization to derive a lower bound for the evaluation bandwidth.

cs.IT↗

arXiv2023

$k$-server Byzantine-Resistant PIR Scheme with Optimal Download Rate and Optimal File Size

We consider the problem of designing a Private Information Retrieval (PIR) scheme on $m$ files replicated on $k$ servers that can collude or, even worse, can return incorrect answers. Our goal is to correctly retrieve a specific message while keeping its identity private from the database servers. We consider the asymptotic information-theoretic capacity of this problem defined as the maximum ratio of the number of correctly retrieved symbols to the downloaded one for a large enough number of stored files. We propose an achievable scheme with a small file size and prove that such a file size is minimal for the fixed number of retrieved symbols, solving the problem pointed out by Banawan and Ulukus.

cs.IT↗

arXiv2023

Repair of Reed-Solomon Codes in the Presence of Erroneous Nodes

We consider the repair scheme of Guruswami-Wootters for the Reed-Solomon code and ask: can we correctly repair a failed node in the presence of erroneous nodes? Equivalently, we consider the collection of downloaded traces as a code and investigate its code-distance properties. We propose three lower bounds on its minimum distance and study methods to efficiently correct errors close to these bounds.

cs.IT↗

arXiv2020

Secrecy and Accessibility in Distributed Storage

A distributed storage system (DSS) needs to be efficiently accessible and repairable. Recently, considerable effort has been made towards the latter, while the former is usually not considered, since a trivial solution exists in the form of systematic encoding. However, this is not a viable option when considering storage that has to be secure against eavesdroppers. This work investigates the problem of efficient access to data stored on an DSS under such security constraints. Further, we establish methods to balance the access load, i.e., ensure that each node is accessed equally often. We establish the capacity for the alphabet independent case and give an explicit code construction. For the alphabet-dependent case we give existence results based on a random coding argument.

cs.IT↗

arXiv2017

A method for constructing parity-check matrices of non-binary quasi-cyclic LDPC codes

An algorithm for constructing parity-check matrices of non-binary quasi-cyclic low-density parity-check (NB QC-LDPC) codes is proposed. The algorithm finds short cycles in the base matrix and tries to eliminate them by selecting the circulants and the elements of GF(q). Firstly the algorithm tries to eliminate the cycles with the smallest number edges going outside the cycle. The efficiency of the algorithm is demonstrated by means of simulations. In particular, it was shown that NB QC-LDPC codes constructed with use of our algorithm loose less that 0.1 dB in comparison to the best NB LDPC codes.

cs.IT↗

arXiv2017

On One Generalization of LRC Codes with Availability

We investigate one possible generalization of locally recoverable codes (LRC) with all-symbol locality and availability when recovering sets can intersect in a small number of coordinates. This feature allows us to increase the achievable code rate and still meet load balancing requirements. In this paper we derive an upper bound for the rate of such codes and give explicit constructions of codes with such a property. These constructions utilize LRC codes developed by Wang et al.

cs.IT↗

arXiv2017

Bounds and Constructions of Codes with All-Symbol Locality and Availability

We investigate the distance properties of linear locally recoverable codes (LRC codes) with all-symbol locality and availability. New upper and lower bounds on the minimum distance of such codes are derived. The upper bound is based on the shortening method and improves existing shortening bounds. To reduce the gap in between upper and lower bounds we do not restrict the alphabet size and propose explicit constructions of codes with locality and availability via rank-metric codes. The first construction relies on expander graphs and is better in low rate region, the second construction utilizes LRC codes developed by Wang et al. as inner codes and better in high rate region.

cs.IT↗