arXiv subjects

Roni Con

Publications and source records attributed to Roni Con.

At least 19 recordsLinked to original sources

arXiv2026

Capacity of Additive-Noise Sticky Channels

Sticky channels, which never destroy nor create runs, are some of the simplest types of channels with synchronization errors (such as deletions, insertions, and replications). Despite their simplicity, we know little about the capacity of the sticky channels considered in the literature so far beyond what can be gleaned from purely numerical methods. Towards a broader and systematic exploration of these channels, we initiate the study of additive-noise sticky channels, a basic family of sticky channels that extend each input run by an amount independently sampled from a fixed noise distribution. The capacity of these channels corresponds to the capacity per unit cost of additive-noise memoryless channels over the non-negative integers, and they capture some aspects of the loss of synchronization caused by homopolymer length miscalls in DNA sequencing. We first focus on the setting of Bernoulli additive noise with parameter $p$, and uncover curious behavior of the capacity beyond what numerical methods can tell us. For example, the capacity is constant when $p\in [1/\varphi^2,1/2]$ with $\varphi\approx 1.618$ the golden ratio, achieved by zero-error runlength-constrained coding, and behaves differently when $p\approx 0$ vs. when $p\approx 1$. More generally, we determine the capacity exactly for all $p\leq 1/2$, and when $1/2<p<1$ we give analytical bounds that allow us to characterize the asymptotic behavior of the capacity as $p\to 1$. We also extend our analysis to the setting where input strings have bounded runlengths, motivated by DNA-based data storage. Then, we study additive-noise sticky channels beyond Bernoulli noise. We derive capacity lower bounds for all additive-noise sticky channels whose noise distributions have a given mean and support. These lower bounds allow us to characterize the regime where zero-error runlength-constrained coding is never optimal.

cs.IT↗

arXiv2026

The Insertion List-Decoding Capacity and an Improved Bound on the Deletion List-Decoding Capacity

Informally, the capacity of list-decoding in a given adversarial error model is the largest rate at which we can list-decode with list size polynomial in the block length. The capacity of list-decoding from insertions and deletions is a basic, yet poorly understood, aspect of coding against synchronization errors. For example, when dealing with a $\delta>1/2$ fraction of insertions, the best known lower bounds give little more than the fact that the capacity is positive. Beyond that regime we also only have loose bounds, with the lower bounds stemming from the analysis of uniformly random codes. We make progress in our understanding of the limits of list-decoding binary codes from insertions and deletions. We show that the capacity of list-decoding from a $\delta$-fraction of insertions is exactly \begin{equation*} (1+\delta)\left(1-h\left(\frac{\delta}{1+\delta}\right)\right) \end{equation*} for all $\delta\in[0,1]$, achieved with high probability by a code sampled according to a symmetric $2$-state Markov chain. Curiously, we complement this by showing that such an approach does not beat uniformly random coding in list-decoding from deletions. We also give an improved upper bound on the capacity of list-decoding from a $\delta$-fraction of deletions, showing in particular that it behaves like $1-h(\delta)$ when $\delta\to 0$. This matches the asymptotic behavior of the capacity of the binary deletion channel for vanishing deletion probability.

cs.IT↗

arXiv2026

Expected Recovery Time in DNA-based Distributed Storage Systems

We initiate the study of DNA-based distributed storage systems, where information is encoded across multiple DNA data storage containers to achieve robustness against container failures. In this setting, data are distributed over $M$ containers, and the objective is to guarantee that the contents of any failed container can be reliably reconstructed from the surviving ones. Unlike classical distributed storage systems, DNA data storage containers are fundamentally constrained by sequencing technology, since each read operation yields the content of a uniformly random sampled strand from the container. Within this framework, we consider several erasure-correcting codes and analyze the expected recovery time of the data stored in a failed container. Our results are obtained by analyzing generalized versions of the classical Coupon Collector's Problem, which may be of independent interest.

cs.IT↗

arXiv2025

Improved Constructions of Linear Codes for Insertions and Deletions

In this work, we study linear error-correcting codes against adversarial insertion-deletion (indel) errors. While most constructions for the indel model are nonlinear, linear codes offer compact representations, efficient encoding, and decoding algorithms, making them highly desirable. A key challenge in this area is achieving rates close to the half-Singleton bound for efficient linear codes over finite fields. We improve upon previous results by constructing explicit codes over $\mathbb{F}_{q^2}$, linear over $\mathbb{F}_q$, with rate $1/2 - \delta - \varepsilon$ that can efficiently correct a $\delta$-fraction of indel errors, where $q = O(\varepsilon^{-4})$. Additionally, we construct fully linear codes over $\mathbb{F}_q$ with rate $1/2 - 2\sqrt{\delta} - \varepsilon$ that can also efficiently correct $\delta$-fraction of indels. These results significantly advance the study of linear codes for the indel model, bringing them closer to the theoretical half-Singleton bound. We also generalize the half-Singleton bound, for every code $C \subseteq \mathbb{F}^n$ linear over $\mathbb{E} \subset \mathbb{F}$ a subfield of $\mathbb{F}$, such that $C$ has the ability to correct $\delta$-fraction of indels, the rate is bounded by $(1-\delta)/2$.

cs.IT↗

arXiv2025

Oblivious Deletion Codes

We construct deletion error-correcting codes in the oblivious model, where errors are adversarial but oblivious to the encoder's randomness. Oblivious errors bridge the gap between the adversarial and random error models, and are motivated by applications like DNA storage, where the noise is caused by hard-to-model physical phenomena, but not by an adversary. (1) (Explicit oblivious) We construct $t$ oblivious deletion codes, with redundancy $\sim 2t\log n$, matching the existential bound for adversarial deletions. (2) (List decoding implies explicit oblivious) We show that explicit list-decodable codes yield explicit oblivious deletion codes with essentially the same parameters. By a work of Guruswami and H\r{a}stad (IEEE TIT, 2021), this gives 2 oblivious deletion codes with redundancy $\sim 3\log n$, beating the existential redundancy for 2 adversarial deletions. (3) (Randomized oblivious) We give a randomized construction of oblivious codes that, with probability at least $1-2^{-n}$, produces a code correcting $t$ oblivious deletions with redundancy $\sim(t+1)\log n$, beating the existential adversarial redundancy of $\sim 2t\log n$. (4) (Randomized adversarial) Studying the oblivious model can inform better constructions of adversarial codes. The same technique produces, with probability at least $1-2^{-n}$, a code correcting $t$ adversarial deletions with redundancy $\sim (2t+1)\log n$, nearly matching the existential redundancy of $\sim 2t\log n$. The common idea behind these results is to reduce the hash size by modding by a prime chosen (randomly) from a small subset, and including a small encoding of the prime in the hash.

cs.IT↗

arXiv2025

Decoding Insertions/Deletions via List Recovery

In this work, we consider the problem of efficient decoding of codes from insertions and deletions. Most of the known efficient codes are codes with synchronization strings which allow one to reduce the problem of decoding insertions and deletions to that of decoding substitution and erasures. Our new approach, presented in this paper, reduces the problem of decoding insertions and deletions to that of list recovery. Specifically, any $(\rho, 2\rho n + 1, L)$-list-recoverable code is a $(\rho, L)$-list decodable insdel code. As an example, we apply this technique to Reed-Solomon (RS) codes, which are known to have efficient list-recovery algorithms up to the Johnson bound. In the adversarial insdel model, this provides efficient (list) decoding from $t$ insdel errors, assuming that $t\cdot k = O(n)$. This is the first efficient insdel decoder for $[n, k]$ RS codes for $k>2$. Additionally, we explore random insdel models, such as the Davey-MacKay channel, and show that for certain choices of $\rho$, a $(\rho, n^{1/2+0.001}, L)$-list-recoverable code of length $n$ can, with high probability, efficiently list decode the channel output, ensuring that the transmitted codeword is in the output list. In the context of RS codes, this leads to a better rate-error tradeoff for these channels compared to the adversarial case. We also adapt the Koetter-Vardy algorithm, a famous soft-decision list decoding technique for RS codes, to correct insertions and deletions induced by the Davey-MacKay channel.

cs.IT↗

arXiv2025

Channels with Input-Correlated Synchronization Errors

"Independent and identically distributed" errors do not accurately capture the noisy behavior of real-world data storage and information transmission technologies. Motivated by this, we study channels with input-correlated synchronization errors, meaning that the distribution of synchronization errors (such as deletions and insertions) applied to the $i$-th input $x_i$ may depend on the whole input string $x$. We begin by identifying conditions on the input-correlated synchronization channel under which the channel's information capacity is achieved by a stationary ergodic input source and is equal to its coding capacity. These conditions capture a wide class of channels, including channels with correlated errors observed in DNA-based data storage systems and their multi-trace versions, and generalize prior work. To showcase the usefulness of the general capacity theorem above, we combine it with techniques of Pernice-Li-Wootters (ISIT 2022) and Brakensiek-Li-Spang (FOCS 2020) to obtain explicit capacity-achieving codes for multi-trace channels with runlength-dependent deletions, motivated by error patterns observed in DNA-based data storage systems.

cs.IT↗

arXiv2025

Reed-Solomon Codes Against Insertions and Deletions: Full-Length and Rate-$1/2$ Codes

The performance of Reed--Solomon codes (RS codes, for short) in the presence of insertion and deletion errors has attracted growing attention in recent literature. In this work, we further study this intriguing mathematical problem, focusing on two regimes. First, we study the question of how well full-length RS codes perform against insertions and deletions. For 2-dimensional RS codes, we provide a complete characterization of codes that cannot correct even a single insertion or deletion. Furthermore, we prove that for sufficiently large field size~$q$, nearly all full-length $2$-dimensional RS codes can correct up to $(1 - \delta)q$ insertion and deletion errors for any $0 < \delta < 1$. Extending beyond the 2-dimensional case, we show that for any $k \ge 2$, there exists a full-length $k$-dimensional RS code capable of correcting $q / (10k)$ insertion and deletion errors, provided $q$ is large enough. Second, we focus on rate $1/2$ RS codes that can correct a single insertion or deletion error. We present a polynomial-time algorithm that constructs such codes over fields of size $q = \Theta(k^4)$. This result matches the existential bound given in \cite{con2023reed}.

cs.IT↗

arXiv2024

Anonymous Shamir's Secret Sharing via Reed-Solomon Codes Against Permutations, Insertions, and Deletions

In this work, we study the performance of Reed-Solomon codes against an adversary that first permutes the symbols of the codeword and then performs insertions and deletions. This adversarial model is motivated by the recent interest in fully anonymous secret-sharing schemes [EBG+24],[BGI+24]. A fully anonymous secret-sharing scheme has two key properties: (1) the identities of the participants are not revealed before the secret is reconstructed, and (2) the shares of any unauthorized set of participants are uniform and independent. In particular, the shares of any unauthorized subset reveal no information about the identity of the participants who hold them. In this work, we first make the following observation: Reed-Solomon codes that are robust against an adversary that permutes the codeword and then deletes symbols from the permuted codeword can be used to construct ramp threshold secret-sharing schemes that are fully anonymous. Then, we show that over large enough fields of size, there are $[n,k]$ Reed-Solomon codes that are robust against an adversary that arbitrary permutes the codeword and then performs $n-2k+1$ insertions and deletions to the permuted codeword. This implies the existence of a $(k-1, 2k-1, n)$ ramp secret sharing scheme that is fully anonymous. That is, any $k-1$ shares reveal nothing about the secret, and, moreover, this set of shares reveals no information about the identities of the players who hold them. On the other hand, any $2k-1$ shares can reconstruct the secret without revealing their identities. We also provide explicit constructions of such schemes based on previous works on Reed-Solomon codes correcting insertions and deletions. The constructions in this paper give the first gap threshold secret-sharing schemes that satisfy the strongest notion of anonymity together with perfect reconstruction.

cs.IT↗

arXiv2024

Random Reed-Solomon Codes Achieve the Half-Singleton Bound for Insertions and Deletions over Linear-Sized Alphabets

In this paper, we prove that with high probability, random Reed-Solomon codes approach the half-Singleton bound - the optimal rate versus error tradeoff for linear insdel codes - with linear-sized alphabets. More precisely, we prove that, for any $\epsilon>0$ and positive integers $n$ and $k$, with high probability, random Reed--Solomon codes of length $n$ and dimension $k$ can correct $(1-\varepsilon)n-2k+1$ adversarial insdel errors over alphabets of size $n+2^{\mathsf{poly}(1/\varepsilon)}k$. This significantly improves upon the alphabet size demonstrated in the work of Con, Shpilka, and Tamo (IEEE TIT, 2023), who showed the existence of Reed--Solomon codes with exponential alphabet size $\widetilde O\left(\binom{n}{2k-1}^2\right)$ precisely achieving the half-Singleton bound. Our methods are inspired by recent works on list-decoding Reed-Solomon codes. Brakensiek-Gopi-Makam (STOC 2023) showed that random Reed-Solomon codes are list-decodable up to capacity with exponential-sized alphabets, and Guo-Zhang (FOCS 2023) and Alrabiah-Guruswami-Li (STOC 2024) improved the alphabet-size to linear. We achieve a similar alphabet-size reduction by similarly establishing strong bounds on the probability that certain random rectangular matrices are full rank. To accomplish this in our insdel context, our proof combines the random matrix techniques from list-decoding with structural properties of Longest Common Subsequences.

cs.IT↗

arXiv2024

Robust Gray Codes Approaching the Optimal Rate

Robust Gray codes were introduced by (Lolck and Pagh, SODA 2024). Informally, a robust Gray code is a (binary) Gray code $\mathcal{G}$ so that, given a noisy version of the encoding $\mathcal{G}(j)$ of an integer $j$, one can recover $\hat{j}$ that is close to $j$ (with high probability over the noise). Such codes have found applications in differential privacy. In this work, we present near-optimal constructions of robust Gray codes. In more detail, we construct a Gray code $\mathcal{G}$ of rate $1 - H_2(p) - \varepsilon$ that is efficiently encodable, and that is robust in the following sense. Supposed that $\mathcal{G}(j)$ is passed through the binary symmetric channel $\text{BSC}_p$ with cross-over probability $p$, to obtain $x$. We present an efficient decoding algorithm that, given $x$, returns an estimate $\hat{j}$ so that $|j - \hat{j}|$ is small with high probability.

cs.IT↗

arXiv2024

One Code Fits All: Strong stuck-at codes for versatile memory encoding

In this work we consider a generalization of the well-studied problem of coding for ``stuck-at'' errors, which we refer to as ``strong stuck-at'' codes. In the traditional framework of stuck-at codes, the task involves encoding a message into a one-dimensional binary vector. However, a certain number of the bits in this vector are 'frozen', meaning they are fixed at a predetermined value and cannot be altered by the encoder. The decoder, aware of the proportion of frozen bits but not their specific positions, is responsible for deciphering the intended message. We consider a more challenging version of this problem where the decoder does not know also the fraction of frozen bits. We construct explicit and efficient encoding and decoding algorithms that get arbitrarily close to capacity in this scenario. Furthermore, to the best of our knowledge, our construction is the first, fully explicit construction of stuck-at codes that approach capacity.

cs.IT↗

arXiv2024

An Optimal Sequence Reconstruction Algorithm for Reed-Solomon Codes

The sequence reconstruction problem, introduced by Levenshtein in 2001, considers a scenario where the sender transmits a codeword from some codebook, and the receiver obtains $N$ noisy outputs of the codeword. We study the problem of efficient reconstruction using $N$ outputs that are each corrupted by at most $t$ substitutions. Specifically, for the ubiquitous Reed-Solomon codes, we adapt the Koetter-Vardy soft-decoding algorithm, presenting a reconstruction algorithm capable of correcting beyond Johnson radius. Furthermore, the algorithm uses $\mathcal{O}(nN)$ field operations, where $n$ is the codeword length.

cs.IT↗

arXiv2024

Repairing Reed-Solomon Codes over Prime Fields via Exponential Sums

This paper presents two repair schemes for low-rate Reed-Solomon (RS) codes over prime fields that can repair any node by downloading a constant number of bits from each surviving node. The total bandwidth resulting from these schemes is greater than that incurred during trivial repair; however, this is particularly relevant in the context of leakage-resilient secret sharing. In that framework, our results provide attacks showing that $k$-out-of-$n$ Shamir's Secret Sharing over prime fields for small $k$ is not leakage-resilient, even when the parties leak only a constant number of bits. To the best of our knowledge, these are the first such attacks. Our results are derived from a novel connection between exponential sums and the repair of RS codes. Specifically, we establish that non-trivial bounds on certain exponential sums imply the existence of explicit nonlinear repair schemes for RS codes over prime fields.

cs.IT↗

arXiv2023

Optimal Two-Dimensional Reed--Solomon Codes Correcting Insertions and Deletions

Constructing Reed--Solomon (RS) codes that can correct insertions and deletions (insdel errors) has been considered in numerous recent works. For the special case of two-dimensional RS-codes, it is known [CST23] that an $[n,2]_q$ RS-code that can correct from $n-3$ insdel errors satisfies that $q=\Omega(n^3)$. On the other hand, there are several known constructions of $[n,2]_q$ RS-codes that can correct from $n-3$ insdel errors, where the smallest field size is $q=O(n^4)$. In this short paper, we construct $[n,2]_q$ Reed--Solomon codes that can correct $n-3$ insdel errors with $q=O(n^3)$, thereby resolving the minimum field size needed for such codes.

cs.IT↗

arXiv2023

Improved Upper and Lower Bounds on the Capacity of the Binary Deletion Channel

The {\em binary deletion channel} with deletion probability $d$ ($\text{BDC}_d$) is a random channel that deletes each bit of the input message i.i.d with probability $d$. It has been studied extensively as a canonical example of a channel with synchronization errors. Perhaps the most important question regarding the BDC is determining its capacity. Mitzenmacher and Drinea (ITIT 2006) and Kirsch and Drinea (ITIT 2009) show a method by which distributions on run lengths can be converted to codes for the BDC, yielding a lower bound of $\mathcal{C}(\text{BDC}_d) > 0.1185 \cdot (1-d)$. Fertonani and Duman (ITIT 2010), Dalai (ISIT 2011) and Rahmati and Duman (ITIT 2014) use computer aided analyses based on the Blahut-Arimoto algorithm to prove an upper bound of $\mathcal{C}(\text{BDC}_d) < 0.4143\cdot(1-d)$ in the high deletion probability regime ($d > 0.65$). In this paper, we show that the Blahut-Arimoto algorithm can be implemented with a lower space complexity, allowing us to extend the upper bound analyses, and prove an upper bound of $\mathcal{C}(\text{BDC}_d) < 0.3745 \cdot(1-d)$ for all $d \geq 0.68$. Furthermore, we show that an extension of the Blahut-Arimoto algorithm can also be used to select better run length distributions for Mitzenmacher and Drinea's construction, yielding a lower bound of $\mathcal{C}(\text{BDC}_d) > 0.1221 \cdot (1 - d)$.

cs.IT↗

arXiv2022

Explicit and Efficient Constructions of linear Codes Against Adversarial Insertions and Deletions

In this work, we study linear error-correcting codes against adversarial insertion-deletion (insdel) errors, a topic that has recently gained a lot of attention. We construct linear codes over $\mathbb{F}_q$, for $q=\text{poly}(1/\varepsilon)$, that can efficiently decode from a $\delta$ fraction of insdel errors and have rate $(1-4\delta)/8-\varepsilon$. We also show that by allowing codes over $\mathbb{F}_{q^2}$ that are linear over $\mathbb{F}_q$, we can improve the rate to $(1-\delta)/4-\varepsilon$ while not sacrificing efficiency. Using this latter result, we construct fully linear codes over $\mathbb{F}_2$ that can efficiently correct up to $\delta < 1/54$ fraction of deletions and have rate $R = (1-54\cdot \delta)/1216$. Cheng, Guruswami, Haeupler, and Li [CGHL21] constructed codes with (extremely small) rates bounded away from zero that can correct up to a $\delta < 1/400$ fraction of insdel errors. They also posed the problem of constructing linear codes that get close to the half-Singleton bound (proved in [CGHL21]) over small fields. Thus, our results significantly improve their construction and get much closer to the bound.

cs.IT↗

arXiv2021

Reed Solomon Codes Against Adversarial Insertions and Deletions

In this work, we study the performance of Reed--Solomon codes against adversarial insertion-deletion (insdel) errors. We prove that over fields of size $n^{O(k)}$ there are $[n,k]$ Reed-Solomon codes that can decode from $n-2k+1$ insdel errors and hence attain the half-Singleton bound. We also give a deterministic construction of such codes over much larger fields (of size $n^{k^{O(k)}}$). Nevertheless, for $k=O(\log n /\log\log n)$ our construction runs in polynomial time. For the special case $k=2$, which received a lot of attention in the literature, we construct an $[n,2]$ Reed-Solomon code over a field of size $O(n^4)$ that can decode from $n-3$ insdel errors. Earlier constructions required an exponential field size. Lastly, we prove that any such construction requires a field of size $\Omega(n^3)$.

cs.IT↗