Constant Query Local Decoding Against Deletions Is Impossible

Locally decodable codes (LDC's) are error-correcting codes that allow recovery of individual message indices by accessing only a constant number of codeword indices. For substitution errors, it is evident that LDC's exist -- Hadamard codes are examples of $2$-query LDC's. Research on this front has focused on finding the optimal encoding length for LDC's, for which there is a nearly exponential gap between the best lower bounds and constructions. Ostrovsky and Paskin-Cherniavsky (ICITS 2015) introduced the notion of local decoding to the insertion and deletion setting. In this context, it is not clear whether constant query LDC's exist at all. Indeed, in contrast to the classical setting, Block et al. conjecture that they do not exist. Blocki et al. (FOCS 2021) make progress towards this conjecture, proving that any potential code must have at least exponential encoding length. Our work definitively resolves the conjecture and shows that constant query LDC's do not exist in the insertion/deletion (or even deletion-only) setting. Using a reduction shown by Blocki et al., this also implies that constant query locally correctable codes do not exist in this setting.


Introduction
The study of classical error-correcting codes dates back to Shannon and Hamming in the mid-1900's [Sha48,Ham50].While the initial focus was on substitution errors, the field expanded to address synchronization errors with the seminal work of [Lev66].Synchronization errors involve inserting or deleting symbols in a transmitted message rather than substituting symbols.Such errors are prevalent in applications such as text/speech processing [CS08], DNA storage technologies [GYM16,LSWZY19], and communication complexity [BGMO17].
Within the study of classical (substitution) error-correcting codes, the concept of locally decodable codes (LDC's) has garnered considerable attention.In a locally decodable encoding C of a message x ∈ Σ n for some alphabet Σ, a receiver can decode any individual symbol x[i] by making a constant number of queries1 to C(x), even in the presence of a small constant fraction of adversarial corruption.It is evident that such codes exist in the classical setting, for example Hadamard codes, and research has focused on finding the optimal encoding length.Despite considerable effort, there remains a nearly exponential gap between the best lower bounds and constructions [Yek12].
Recently, the work of Ostrovsky and Paskin-Cherniavsky [OPC15] introduced the notion of local decoding to insertion/deletion codes.Unlike in the setting of substitutions, here it is not clear whether constant query LDC's exist at all: For a constant-sized alphabet Σ, is there an encoding function C : Σ n → Σ M such that any one symbol x[i] of the original message can be recovered with high probability using only a constant number of queries to the corrupted transmission?Block et al. [BBG + 20] conjecture that in contrast to the substitution setting, constant query insertion/deletion LDC's do not exist.That is, even when the encoding can be arbitrarily long in terms of n, constant-query LDC's do not exist in the insertion/deletion setting.Subsequent research by Blocki et al. [BCG + 22] makes progress toward this conjecture, demonstrating that any candidate LDC must have at least exponential length relative to n, but it does not definitively rule out their existence.Blocki et al.'s negative result holds even when the adversary can only perform deletions (without insertions).
In this work, we fully resolve Block et al.'s conjecture, establishing that constant-query LDC's of any length do not exist in the insertion/deletion setting.Like [BCG + 22], our result holds when the adversary can only perform deletions.Moreover, due to a reduction shown by [BCG + 22], this implies that locally correctable codes (LCC's) do not exist in the deletion setting.

Our Results
Our main result is that constant query locally decodable codes of any length do not exist in the deletion setting.We refer the reader to Definition 3.1 for a formal definition of locally decodable codes for the deletion channel.
Theorem 1.1.For any ε > 0, k ∈ N, and alphabet Σ, there exists a constant C := C(ε, k, |Σ|) such that for all n > C, there is no k-query deletion LDC C : Σ n → Σ M for any M that is resilient to ε-fraction of deletions.
We conjecture a stronger version of Theorem 4.1, which we hope to see proven or disproven in future work.
Conjecture 1.2.For any ε > 0 and k ∈ N, and alphabet Σ, there exists a constant C := C(ε, |Σ|) such that for all n > Ck, there is no non-adaptive k-query deletion LDC C : Σ n → Σ M that is resilient to ε-fraction of adversarial deletions.
In other words, we conjecture that any LDC for deletions requires a number of queries directly proportional to the length of the original message to recover a single message symbol.We emphasize that this conjectured lower bound only applies when all queries to a candidate LDC must be specified non-adaptively.When the queries can be submitted adaptively, prior results [OPC15, BBG + 20] demonstrate that polylog(n) queries is achievable.
Theorem 4.1 also implies that locally correctable codes do not exist in the deletion setting.The implication follows from a result in [BCG + 22], which states that the existence of LCC's for insertions/deletions would imply LDC's for insertions/deletions.We remark that they present this reduction for adversarial codes allowing both insertions and deletions, but their proof also works in the deletion-only setting.
Corollary 1.3.For any ε > 0, k ∈ N, and alphabet Σ, there exists a constant C := C(ε, k, |Σ|) such that for all n > C, there is no k-query deletion LCC C : Σ n → Σ M for any M that is resilient to ε-fraction of adversarial deletions.

Related Works
Locally decodable codes for insertion/deletions.Locally decodable codes for insertions and deletions were introduced by Ostrovsky and Paskin-Cherniavsky in [OPC15].They present deletion LDC's of length Õ(n), resilient against a constant fraction of adversarial deletions with polylog(n) queries.Cheng, Li, and Zheng [CLZ20] introduce locally decodable codes with randomized encoding and demonstrate improved rate-query tradeoffs in this setting.[BBG + 20] replicate [OPC15]'s results using different techniques and conjecture the non-existence of deletion LDCs of any length in the constant query regime.
As previously mentioned, Blocki et al. [BCG + 22] make progress on this conjecture, proving that any candidate LDC must have exponential length relative to n.More specifically, they eliminate the possibility of 2-query linear deletion LDCs and establish an exponential lower bound for the size of any 2-query deletion LDC.In general, they prove a lower bound of exp(n 1/O(k) ) for a candidate k-query LDC.
[BBC + 22] introduces the relaxed local decoding model (RLDC's) to the insertion/deletion setting, which allows limited decoding failure answers ⊥.They show lower bounds for constant query "strong" RLDC's and constant query constructions for "weak" RLDC's.A few other models for insertion/deletion LDC's have been explored, including the secret key setting in [BB21, BCG + 22].
Insertion/deletion codes.The study of codes that correct insertions and deletions was initiated by [Lev66].Correcting for insertions and deletions is generally more challenging than substitutions, and our understanding of the field remains limited.Nevertheless, efficient constructions of constant rate codes that correct a constant fraction of insertion/deletion errors have been shown, initially in [SZ99].More recently, the work of [HS17] introduces synchronization strings, which transform substitution error-correcting codes into insertion/deletion error-correcting codes in an efficient blackbox manner.The optimal error resilience of constant rate insertion/deletion codes was studied by [GHL22].
Many other aspects of insertion/deletion codes have been explored.For more details, we refer to surveys on this topic, including [Mit09,HS21].
LDC's and LCC's for substitutions.Locally decodable codes and locally correctable codes were initially introduced in the classical setting of substitution errors.The ideas behind LDC's and LCC's arose as early as Reed-Muller codes [Ree54,Mul54] and were first formalized by Katz and Trevisan [KT00].They have applications in many areas, including in PCP's [BFLS91], private information retrieval [CKGS98], and average case complexity [Tre04].
The best constructions of LDC's and LCC's for constant queries are barely sub-exponential in the length of the message [Efr09], while lower bounds are polynomial for k > 3 queries [KT00, WDW05, Woo07, AGKM23], except in the case of 2-query LDC's and LCC's [GKST02,KDW03] and linear 3-query LCC's [KM23].The question of whether constant query LDC's with polynomial message length exist remains open.We refer the reader to [Yek12] for a survey of the work on LDC's.

Technical Overview
In this section, we'll overview our main result that constant query deletion LDC's do not exist.We'll restrict our attention to the case where the alphabet Σ = {0, 1} as the proof is the same for any constant-sized alphabet.
Before delving into the details, let's set up the problem.Given a sufficiently small ε > 0 and a constant number of queries k, our goal is to show the existence of a constant C(ε, k) such that for all n > C(ε, k), there is no function C : {0, 1} n → {0, 1} M for any value of M , which satisfies local decoding for deletions.That is, the adversary has a randomized corruption process C(x) → C(x) using at most ε-fraction corruption with the following guarantee.For any candidate local decoding algorithm that non-adaptively queries k indices of C(x) to guess x[i], there exists an index i and some x for which it fails with probability greater than 1 2 − ε.Throughout the overview, we use q to denote the index of a query in the corrupted codeword C(x), while q represents its corresponding index in the original uncorrupted codeword C(x).For convenience, we'll use τ to represent a generic constant much smaller than ε (around poly(ε)).

Reduction to Simulating All Queries with a Fixed Constant-Sized Set
Our main goal will be to show the following: the adversary can perform deletions in such a way that there is a constant-sized set Q of lists of queries ( q 1 . . .q k ) such that any pair of queries ( q 1 . . .q k ) can be simulated by a corresponding pair of queries ( q 1 . . .q k ) ∈ Q.That is, for most x, the distribution over {0, 1} k of the output of queries ( q 1 . . .q k ) is approximately the same (TV distance < τ ) as the output of ( q 1 . . .q k ) over the randomness of the corruption process.
Pictorially, we want to construct Q so that for any list of queries ( q 1 . . .q k ), the following two processes yield roughly the same distribution of outputs for most C(x).
(1) Perform the randomized deletion pattern, then query ( q 1 . . .q k ) so that the induced indices of the queries in the original codeword are (q 1 . . .q k ), and receive as output the values (2) Choose the representative query list ( q 1 . . .q k ) ∈ Q that approximates ( q 1 . . .q k ).Then, perform the randomized deletion pattern, query ( q 1 . . .q k ) so that the induced indices of the queries in the original codeword are (q 1 . . .q k ), and receive as output the values If we can successfully establish this statement, then any local decoding algorithm can be emulated by one that only queries lists in Q.Consequently, we can conclude that constant query deletion LDCs do not exist, as querying a fixed constant-sized list provides only a constant amount of information about x, while the number of choices for the index i is super-constant.A similar information-theoretic argument also shows that constant query deletion LCC's do not exist.
For the remainder of this overview, we will show how to design the adversary's corruption process and find this constant-sized Q.We will begin with the 2-query case which illustrates many of the ideas, and then we will describe how to modify the argument for the general k-query case.

The Corruption Process.
We'll begin by defining the corruption process used by the adversary.This is the same process used in the work [BCG + 22].The adversary performs two types of corruptions to C(x).2 • Type 1: Choose ε 1 ∈ [0, ε 2 ] uniformly at random and delete the first ε 1 M bits of C(x).• Type 2: Choose ε 2 ∈ [0, ε 2 ] uniformly at random and delete every 1 ε 2 'th remaining bit.

Constructing
for Each Layer ℓ.
We'll first attempt to construct Q so that it satisfies an even stronger guarantee than that the output in {0, 1} 2 of any pair ( q 1 , q 2 ) can be approximated by some pair ( q 1 , q 2 ) ∈ Q. We'll have Q contain, for every possible pair of queries ( q 1 , q 2 ), a corresponding pair ( q 1 , q 2 ) ∈ Q such that the distribution of (q 1 , q 2 ) is similar to (q 1 , q 2 ).This is essentially what [BCG + 22] do, and the argument we outline below is a reformulation of theirs.We will show that if Q contains q 1 ∈ q 1 ± τ M and q 2 ∈ q 2 ± τ ( q 2 − q 1 ) , then the statement holds true.With just Type 1 deletions, shifting a query pair ( q 1 , q 2 ) by (τ M, τ M ) maintains the distribution of the q 1 and q 2 .This is because the small difference in the indices queried is counteracted by the unpredictability of ε 1 .Similarly, Type 2 deletions counteract a small change in the distance between q 1 and q 2 , so they can be shifted by (0, ( q 2 − q 1 )τ ) without changing the output by much.
Notice that a "random" deletion process, where every index is deleted with probability ε/2, doesn't work here, because the unpredictability of the index q 1 is proportional only to √ q 1 and not to M .Even if the deletion fraction is chosen randomly instead of being ε/2, the unpredictability of q 2 conditioned on q 1 is only proportional to q 2 − q 1 and not to ( q 2 − q 1 ).Now, we want to construct Q so that it has a pair q 1 ∈ q 1 ± τ M and q 2 ∈ q 2 ± τ ( q 2 − q 1 ) for every ( q 1 , q 2 ).For a fixed "layer" ℓ of queries -that is queries satisfying ℓ := ⌊log( q 2 − q 1 )⌋, only a constant number of queries need to be added to Q to approximate all queries in this layer.This is because only one option for q 1 is needed in each τ M -length range, and only one option for q 2 − q 1 in each τ ℓ-length range.To be explicit, any such pair of queries can be approximated by one of the form (τ M i, τ M i + τ 2 a j) for i ∈ [τ −1 ], j ∈ [τ −1 ].We'll add all queries of this form into the set Q (ℓ) .
If there were only a constant number of layers, that is if log M were a constant, then we would be done, as all queries can be approximated by queries in ℓ∈[log M ] Q (ℓ) .Unfortunately, log M need not be a constant, and in fact will certainly depend on n.The main goal of the rest of our argument is to show that we only need to include Q (ℓ) for a constant number of layers ℓ, and these alone will approximate all queries.This constant-sized set of layers will be represented as L.
We remark that this argument suffices for the bound in [BCG + 22].It is actually enough that | Q| = o(n) to achieve the information-theoretic contradiction in the previous section, so they establish a contradiction whenever log(M ) = o(n), which yields their exponential lower bound.

If we let
, it is not only true that ( q 1 , q 2 ) shares the same distribution of outputs in {0, 1} 2 as their representative queries in Q, but they also correspond to a similar distribution on indices of the uncorrupted codeword C(x).As explained earlier, this is stronger than necessary.We'll identify layers ℓ that cen be excluded because they induce the same output distribution as other layers, even if not the same distribution on indices of the uncorrupted codeword C(x).
An illustrative example.Let's with an example.Look at the following string: In layers where q 2 − q 1 ≪ √ n, any two queries ( q 1 , q 2 ) have a very high probability of being identical.This is because the random shift from the Type 1 deletions mean that q 1 (the induced index of q 1 in the original codeword) is fairly uniform within the block it falls into, making it likely that q 2 is in the same block.Thus, slightly changing the gap between the queries does not significantly affect the output distribution, and hence, the set Q (1) accounts for all Q (ℓ) with 2 ℓ ≪ √ n.
A similar argument works for queries where q 2 − q 1 ≫ √ n.In this case, q 1 and q 2 will be in different blocks with many blocks between them.In particular, Type 2 errors make it approximately equally likely for there to be an odd or even number of blocks between q 1 and q 2 , and so their values are uncorrelated.Since this is true for all layers where 2 ℓ ≫ √ n, any single Q (ℓ) correctly models all the queries in these layers.
Hence, to model all queries, L would need only to include ℓ = 1, one value of ℓ much larger than log √ n, and a few values of ℓ near log √ n.A more detailed analysis shows that only constantly many layers of the third type are necessary.This results in a constant sized union Q.
Surprisingly, this phenomenon is not limited to the specific example shown; most strings exhibit a similar behavior.For a general string, consider the fraction of 0's and 1's in each block of size 2 α and 2 β for some β ≫ α.The main claim is as follows.Assume that most blocks of size 2 α within the same 2 β chunk i have approximately the same fraction of 0's (i.e.p (α) 2 β i+j is similar for all j ∈ [2 β−α ], which also implies all p (α) 2 β i+j are approximately equal to the mean p needs to be included in L (within this layer, it holds that 2 α ≪ q 2 − q 1 ≪ 2 β ).
To illustrate this, consider a pair of queries ( q 1 , q 2 ).Conditioned on q 1 falling within a specific size 2 β chunk i (and q 2 will likely fall in the same chunk since q 2 − q 1 ≪ 2 β ), we'll show that the distribution of the output of queries ( q 1 , q 2 ) is Bern(p the Type 2 errors cause enough unpredictability in q 2 − q 1 that both q 1 and q 2 can be considered essentially independent and uniformly distributed within the size 2 α chunk that each falls into (even though which size 2 a each query falls into can be correlated).We've assumed that each 2 α block has distribution Bern(p (β) i ) for a query made randomly to it, so the joint distribution on ( q 1 , q 2 ) is [Bern(p Consequently, the output is essentially the same for all ℓ ∈ [α + τ −1 , β − τ −1 ] within the 2 β -sized block of the original codeword that the queries fall into.In particular, any query ( q 1 , q 1 +D) exhibits almost an identical same output distribution as long as α + τ −1 < log D < β − τ −1 .Therefore, it suffices to represent all of the queries in a single one of the layers ℓ rather than all of them, which is adequately done by one Q (ℓ) .
A structure lemma.It may seem like a strong assumption that most blocks of size 2 α within the same 2 β chunk have approximately the same fraction of 0's, but it is indeed the case that any string has only constantly many layers at which this fraction changes.Specifically, we'll identify a list α 1 < . . .< α τ −1 such that most blocks of size 2 α i within the same 2 α i+1 chunk have approximately the same fraction of 0's.Then, only one layer between α i + 1 and α i+1 needs to be included in L since they all then Q (ℓ) induce the same distribution of outputs. 4onsider the variance of p (α) within a size 2 β chunk (for simplicity of notation let's focus on the first size 2 β chunk). Var We want to characterize the ranges in which this variance is large.For any θ ∈ [log M ], define the weight . Then, averaging the above variance (of 2 α sized blocks) over all the sized 2 β chunks gives In simpler terms, we have found a weight function on layers W θ such that the variance of the fraction of 0's in a sized 2 α block in a 2 β chunk is W α − W β .Moreover, this weight W θ decreases as θ increases and always falls between 0 and 1.Therefore, the string can be partitioned into a constant length list α 1 . . .α τ −1 such that for all i, W α i+1 − W α i +1 ≪ ε and so only a single layer in each interval needs to be included.
Reconciling with C. Recall that Q needs to be a function of the code C, not each individual string the sender could send.To deal with this, one can instead use W θ (C) := E z∈C W θ (z) , and find the relevant α 1 . . .α τ −1 according to this weighting.Then, on most strings z ∈ Im(C), layers between adjacent elements of the sequence will induce the same output distribution, which is enough for the argument to work.

The k -Query Case
Next, we'll extend this argument to the k-query case.

Naive Attempt to Extend 2-Query Argument.
Ideally, the same corruption pattern and a similar analysis would still apply.We had identified a sequence of critical transition layers α 1 . . .α τ −1 using the weight function defined above, and based on this, pinpointed a constant-sized list of layers L that adequately approximated all pairs of queries.We can attempt to extend this by defining To carry through the 2-query analysis, we would need to show the following two claims: (1) Any ( q 1 , . . ., q k ) satisfying q i+1 − q i ≈ 2 ℓ i induces the same distribution on (q 1 , . . ., q k ) as some list in Q (ℓ 1 ...ℓ k−1 ) .
(2) Any successive difference between queries ( q i+1 − q i ) that does not correspond to a layer in L is suitably approximated by a layer in L.
Unfortunately, neither of these claims is true as stated.

Addressing the First Issue.
To see this issue with (1), consider the following triples of queries for some fixed q, d where d ≈ 2 ℓ for some layer ℓ ∈ L: ( q 1 := q, q 2 := q + d, q 3 := q + 2d) and ( q ′ 1 := q, q ′ 2 := q + d, q ′ 3 := q + 2d + 10).We want the distributions of (q 1 , q 2 , q 3 ) and (q ′ 1 , q ′ 2 , q ′ 3 ) to be similar.However, since q 3 − q 2 = q 2 − q 1 , any induced indices (q 1 , q 2 , q 3 ) always take on the form (Q, Q + D, Q + 2D) for some Q, D since Type 2 deletions delete the same fraction of each equal-length interval.By similar logic (q ′ 1 , q ′ 2 , q ′ 3 ) takes on the form (Q, Q + D, > Q + 2D + 5).Consequently, not only are the induced distributions of (q 1 , q 2 , q 3 ) and (q ′ 1 , q ′ 2 , q ′ 3 ) different, but they have no overlap, as the triples take on different forms.The key issue here is that every interval of length D in a codeword has the same number of bits deleted, while the desired behavior is to have a random, uncorrelated number of bits deleted.To achieve this, we'll modify the deletion process as follows: for every layer ℓ ∈ L, in the i'th chunk of length 2 ℓ , choose a random fraction ε (ℓ) i and delete every 1 ε (ℓ) i 'th bit.Since there are only a constant number of layers in L, this still results in a constant fraction of corruption overall.Now, each interval of length ≈ 2 ℓ not only has a random fraction of bits deleted, but these fractions are uncorrelated.Consequently, the example from the previous paragraph would induce the same distribution on (q 1 , q 2 , q 3 ) and (q ′ 1 , q ′ 2 , q ′ 3 ) as originally intended.

Addressing the Second Issue.
The issue with (2) is that L doesn't actually encompass all the important layers.We will show that there are important transition layers that are not accounted for by the weight function W defined previously.In the final argument, the number of transition layers will still be constant, but we need a new weight function to identify additional important layers.
An illustrative example.Let's begin with an example that demonstrates why W is inadequate.
. For all θ > α, this quantity is 1/4, so if W were sufficient, differences between queries that are ≫ 2 α would need to behave essentially the same.However, it is evident that the structure of the string chanes around the scale 2 β .Two queries weren't sufficient to detect this change, but it turns out that four queries are.
To be concrete, choose D 1 and D 2 satisfying 2 α ≪ D 1 ≪ 2 β and D 2 ≫ 2 β .Make the following two sets of queries: (0, 1, D 1 , D 1 +1) and (0, 1, D 2 , D 2 +1).The aim is for the distribution on outputs to be the same since D 1 and D 2 correspond to supposedly indistinguishable layers.However, when a pair of queries differing by 1 falls in a type A block, the outputs are typically the same, and when such a pair falls in a type B block, the outputs are typically different.In the query (0, 1, D 1 , D 1 +1), the first pair is likely in the same length 2 β block as the second pair (so whether the first pair are the same is correlated to whether the second pair are the same).However, in (0, 1, D 2 , D 2 + 1), the first and second pair are likely in different, uncorrelated blocks.Therefore, the distribution of outputs in {0, 1} 4 for the queries (0, 1, D 1 , D 1 + 1) and (0, 1, D 2 , D 2 + 1) are different.
Defining more weight functions.In this way, layer β is a transition point where smaller layers look substantially different than larger ones, and it's not accounted for by W. Our new weighting needs to say something about what happens when you make two queries to this region rather than just considering the fraction of 0's and 1's.Given any pair of queries ( q 1 , q 2 ), define the weight: Pr ( q 1 + c, q 2 + c) outputs 00 2 .
We similarly define W (01) , W (10) , and W (11) , and if the alphabet Σ were larger than binary, we would define W (σ 1 σ 2 ) for all σ 1 , σ 2 ∈ Σ, but we'll focus the discussion on W (00) .In our earlier example, observe that layers smaller than β have significantly higher weight than layers larger than β for q 1 = 0 and q 2 = 1, so this successfully addresses the issue.Furthermore, for a fixed ( q 1 , q 2 ), this weight is also (approximately) decreasing with respect to θ, so it has a constant number of transition points.Consequently, we can use the constant-sized set of transition points for W (00) θ ( q 1 , q 2 ) and correspondingly add a constant number more layers into L for each ( q 1 , q 2 ).As it turns out, this new L successfully accounts for all the relevant layers, at least when k = 3.
One issue remains: there are super-constantly many pairs ( q 1 , q 2 ), but we can only add a constant number of layers to L. This is easily addressed by utilizing only a representative set of ( q 1 , q 2 ) whose elements approximate all possible queries that could be made.This is exactly what the set Q calculated for the 2-query case represents (so we only need to use W (00) θ ( q 1 , q 2 ) for pairs of queries in the original Q).
In general, for each of the k queries, we define an additional recursive layer of weightings.In this manner, we construct the set L of relevant layers based on those relevant to any weighting, and include every corresponding Q (ℓ 1 ...ℓ k−1 ) .We refer the reader to Section 4 for a comprehensive analysis.It is worth noting that the formal analysis in Section 4 does not define Q in in the same way, but the ideas remain the same.

Model Definitions
We'll start with the definition of locally decodable codes (LDC's) that are resilient to ε-fraction of adversarial deletions.Definition 3.1 (Deletion LDC).For a fixed value of n and alphabet Σ, a candidate deletion LDC is an encoding C : Σ n → Σ M .We say that C is resilient to ε-fraction of adversarial deletions as a q-query deletion LDC (for shorthand, just k-query ε-resilient LDC) if the following holds.
For all i ∈ [n], there exists an algorithm that makes k queries5 to a codeword C(x) adversarially6 corrupted by an adversary using less than εM deletions and with probability at least 1 2 + ε correctly guesses x[i] for all values of x ∈ Σ n .
Next, we'll define locally decodable codes (LCC's) that are resilient to ε-fraction of adversarial deletions.
Definition 3.2 (Deletion LCC).For a fixed value of n and alphabet Σ, a candidate deletion LCC is an encoding C : Σ n → Σ M .We say that C is resilient to ε-fraction of adversarial deletions as a q-query deletion LCC (for shorthand, just k-query ε-resilient LCC) if the following holds.
For all i ∈ [M ], there exists an algorithm that makes k queries to a codeword C(x) adversarially corrupted by an adversary using less than εM deletions and with probability at least 1 2 + ε correctly guesses C(x)[i] for all values of x ∈ Σ n .

Notation and Definitions
Notation.
• Logarithms are in base 2 unless otherwise specified.
• In general, messages will be denoted by x, encoded messages by C(x), and corrupted encoded messages by C(x).
• By default, if an algorithm makes queries q 1 . . .q r , the queries will be non-adaptive and in increasing order (so q r > • • • > q 1 ).The induced indices of q 1 . . .q r in the uncorrupted codeword are q 1 . . .q r .
First, we define a (randomized) deletion pattern that the adversary can perform on a string with indices 1 . . .n.

Definition 3.3 (Deletion Pattern)
. A deletion pattern del on the indices 1 . . .ν is a probability distribution over subsets of 1 . . .n. Usually, in a string of length ν, the bits at the indices corresponding to the subset will be deleted.
For the context of our next definition, consider the situation after Bob has received a corrupted codeword and queries the indices q 1 . . .q k .Definition 3.4 (D(S)).For a measurable space S, the family of probability distributions over S is denoted by D(S).Definition 3.5 (D( q 1 , . . ., q k ; del)).For a deletion pattern del on strings of length n, given that Bob has queried q 1 , . . ., q k , let the distribution of q 1 , . . .q k (indices of the original string) be denoted D := D( q 1 , . . ., q k ; del).
For a distribution D and string z of length n, the distribution z[D] denotes the distribution of Σ * obtained by indexing the tuple D into the string z.If a queried index in D are out of bounds for z (i.e.not in the range 1 . . .n), then instead return err (so the distribution also supports some error rather than only valid outputs in Σ r . Next, we'll define an easy way to view a string z as a concatenation of chunks.Definition 3.6 (C i,ν (z)).Consider a string z whose length is a multiple of ν (specifically, length αν).For i ∈ [α], we define C i,ν (z) to be the i'th length ν chunk of length of the string z.

Impossibility of k -Query Deletion LDC's
In this section, we establish the main theorem, that constant query locally decodable codes for deletion errors do not exist.
Theorem 4.1.For any ε > 0, k ∈ N, and alphabet Σ, there exists a constant C := C(ε, k, |Σ|) such that for all n > C, there is no k-query deletion LDC C : Σ n → Σ M for any M that is resilient to ε-fraction of deletions.
Moreover, we establish that constant query LCC's do not exist.
Corollary 4.2.For any ε > 0, k ∈ N, and alphabet Σ, there exists a constant C := C(ε, k, |Σ|) such that for all n > C, there is no k-query deletion LCC C : Σ n → Σ M for any M that is resilient to ε-fraction of adversarial deletions.
We'll show these theorems by considering any candidate locally decodable code C and describing a corruption pattern for which some index i cannot be recovered with only k queries.Throughout this section, ε, k and n are fixed, and we'll let κ be the smallest power of 2 greater than ε −k•|Σ| .Let C denote the candidate LDC (encoding strings of length n to length M = κ m ), x denotes a message being sent, and z typically is an arbitrary string of length M .
We remark that the assumption that M is a power of κ is almost without loss of generality.This is because any encoding is effectively padded with infinitely many 0's since out-of-bounds queries return 0. To make the code's length a power of κ, simply increase the length of the code until the next power of 2 larger than M which at most doubles the total length.Then, any adversarial attack on the new padded encoding also works on the original (since deleting indices larger than M doesn't change the string) and requires (at most) the same number of deletions, but since M increased in length by a factor of up to κ, we will require error resilience εκ −1 instead of ε.

Definitions and Useful Lemmas
We begin with a few useful definitions and simple facts.Throughout, the length of an arbitrary string ν will be assumed to be a power of κ (so that it divides M ).

Frequencies
When discussing lists of queries, we'll usually be interested in the list of differences between successive queries rather than the queries themselves.In particular, for any list of queries q 1 . . .q r , we'll define the list of differences d 1 . . .d r−1 as d i := q i+1 − q i .We'll often state lemmas about the lists of query differences rather than the queries themselves.
Our first definition describes the probability of the output being a specific pattern b when queries with differences d 1 . . .d r−1 are made to a string s on which some probabilistic deletion pattern is performed.The queries will be randomly shifted in the string subject to the successive differences being d 1 . . .d r−1 .For a shift i ∈ 1 . . .ν, let Next, we define the error probability of querying a list with differences d 1 . . .d r−1 in a string s.Specifically, there's some chance of outputting err because some of the indices in the queries are out of bounds when the shift is realized.Definition 4.4 (err(s; d 1 . . .d r−1 ; del)).The error probability err(s; d 1 . . .d r−1 ; del) when querying i, i + d 1 . . .i + d 1 + . . .+ d r−1 for a uniformly random shift i ∈ [ν] on a string s with deletion pattern del is the probability that at least one index is out of bounds (and so the query returns err).

Approximation Equivalence of Queries
Next, we'll define what it means for a list of query differences d 1 . . .d r−1 to approximate another list of differences d 1 . . .d r−1 for a deletion pattern del.Definition 4.5 (δ-Approximate Queries).For a deletion pattern del on a string s of length ν, a list of query differences d 1 . . .d r−1 δ-approximates another list of query differences If s is length αν and del is a deletion pattern on strings of length ν, then we say that d In other words, on the average chunk of length ν, d 1 . . .d r−1 δ-approximates d 1 . . .d r−1 .

Layered Deletion Patterns and Significant Layers
Next, we'll define a specific type of deletion pattern that we call a layered deletion pattern.To perform the (randomized) deletions, for each layer α ∈ [a], the string is divided into chunks of length κ α .Then, for each chunk, a uniformly random integer I between 0 and ⌊ε α κ α ⌋ is chosen, and the first I bits of the chunk are marked to be deleted.At the end, traverse the string left to write.Keep a counter that starts at 0, and at every index, if an index is marked as deleted t times, add t to the counter.Moreover, if the counter is greater than 0, delete the index and decrement the counter by 1.
The layered deletion pattern del a is the pattern del restricted to layers 1 . . .a.It is on strings of length κ a instead of κ M .The layered deletion pattern del a|A is the pattern del a extended to strings of length κ A but still only incorporating the deletions in layers 1 . . .a.
Next, we'll define significant layers in a code C. Loosely speaking, these are the values of a such that performing some fixed list of queries with differences d 1 . . .d r−1 with a random shift of about κ a generates different outputs from performing the queries with a random shift somewhat smaller than κ a .These are the scales at which we'll need to insert random deletions.Definition 4.7 (Significant Layers for Threshold ρ).We define as follows a set L to be the significant layers for some threshold ρ given the code C, a pattern b ∈ Σ r , query differences d 1 . . .d r−1 and deletion pattern del.
The possible layers are 1 . . .m, corresponding to partitions of a codeword into exponentiallysized intervals.The first 10κ κ significant layers will be the one corresponding to layer τ = ⌊( d 1 + . . .+ d r−1 )⌋, . . ., ⌊( d 1 + . . .+ d r−1 )⌋ + 10κ κ − 1.Every future layer ℓ i+1 will be constructed from ℓ i as follows.It is the smallest possible is the length κ ℓ i chunk that contains C j,κ ℓ i+1 (z).Loosely speaking, ℓ i+1 is the smallest layer significantly larger than ℓ i such that queries performed at the scale ℓ i+1 look significantly different to those performed at the scale ℓ i .

Useful Lemmas
Lemma 4.8.Given a string s ∈ Σ * and a deletion pattern del on strings of length ν|s, if a list of query differences d Proof.This follows from the triangle inequality.Note that the condition is met that and also that Therefore, by the triangle inequality and the fact that the err function is always nonnegative, Lemma 4.9.Consider a layered deletion pattern del on the code C whose total corruption is at most 2 −κ .For a list of query differences d 1 + . . .+ d r−1 and a threshold ρ > 2 −κ , there are at most κ κ + ρ −3 significant layers in C.
Moreover, we define the cumulative weight of the code C as follows: Assume for the sake of contradiction that there are more than c = ρ −5 remaining significant layers aside from the first κ κ , denoted ℓ 1 . . .ℓ c .Recall that a significant layer satisfies: by the QM-AM inequality.Expanding, we get the the left side is equal to Finally, note that within a block of length κ ℓ i+1 , the values of freq (b) (C j ′ ,κ ℓ i (z); d 1 . . .d r−1 ; del τ |ℓ i ), which just represent the probability of getting the output b on a randomly shifted query with the specified differences, average to freq (b) (C j ′ ,κ ℓ i+1 (z); d 1 . . .d r−1 ; del τ |ℓ i+1 ) minus an error term corresponding to the chance that the output was err in the case of size κ ℓ i blocks due to out of bounds but is b when the block size is expanded, which we'll denote e (b) (C j ′ ,κ ℓ i+1 (z); d 1 . . .d r−1 ; del τ |ℓ i+1 ).This term is nonnegative and at most the probability of an out of bounds error, which is at most κ −κ κ since there are −κ κ layers before ℓ i .Thus, the above equation is equal to If there are more than ρ −3 terms in the sequence ℓ i , it would hold that W (b) but all values of the weight function fall between 0 and 1, which is a contradiction.

Lemmas for Proof of Lemma 4.15
The next three lemmas are the core of the proof of Lemma 4.15 in Section 4.3.They describe modifications that can be made to a list of queries d 1 . . .d r−1 to make a new list of queries d 1 . . .d r−1 that approximates the old one.
The first lemma essentially says that shifting a query difference by a small amount nearby a layer a where f del (a) > 0 does not affect the distribution of outputs.
Lemma 4.10.Consider a string z ∈ Σ M , a layered deletion pattern del on strings of length κ a for some a < m with total corruption fraction at most 2 −κ , and query differences d 1 . . .d r−1 satisfying r be the distribution of q 1 . . .q r in the original string when the queries d 1 . . .d r−1 with a random shift are performed to the string z a with random deletions according to del.Similarly, define q( d 1 . . .d r−1 ).It suffices to show that the TV distance of these distributions is at most (2 −κ/2 ) (where getting out of bounds errors counts against the TV distribution on both ends).
Consider a randomly generated set of deletions from del.This assigns for each ℓ ≤ a, a list of κ a−ℓ values E ℓ,i for how many indices to delete in each layer using which the layered deletion algorithm is performed.Moreover, condition on the randomness of the queries' shift.Denote the induced indices in the original codeword when the queries d 1 . . .d r−1 with the fixed random shift are performed by q 1 . . .q r .The way we found these was by considering the string z, marking all the deleted symbols, and counting q 1 non-deleted symbols from the left, then d 1 more symbols, and so on.
Let I be the index of the first chunk of length κ a ′ that begins after q j .Increment the value of E a ′ ,I by τ .The probability that this becomes invalid (note that all valid options are equally likely since del is uniform) option for del is at most The above defines a mapping from an element of del to another element of del, except for a very small fraction of the time.In this new element of del, the queries q 1 . . .q r yield q 1 . . .q r , because the transformation just causes an extra τ indices to get marked between q j and q j+1 which exactly compensates for subtracting τ .To show that the new likelihood of getting q 1 . . .q r is at least as large as before, we need to show this mapping is an injection.In particular, no instantiation of del is mapped to twice.We will show the mapping is injective.If two instances of del and the query shift map to the same thing, they can only differ on the layer a ′ because only that changes in the mapping.If the index I is the same, then the map of adding τ is injective.If the index τ is different, then something before reaching I must have been different, to induce a different choice of I (which depends only on the choices of E before I), but then that index of E will be different in the image as well.
The two failure cases are where the mapping fails, because E ℓ,i + τ is too large, or the initial choice of del and the query shift resulted in err rather than a valid output.The latter occurs with probability at most d 1 +...+ d r−1 κ a < κ −κ 2 .This failure probability amounts to less than κ −κ in total.Therefore, the TV distribution of the queries differs by at most 2κ −κ , since the one-sided TV distance differs by at most κ −κ .
The second lemma essentially says that replacing a group of query differences with one that approximates it, when the surrounding query differences are much larger in comparison, does not affect the distribution of outputs.
Lemma 4.11.Consider a string z ∈ Σ M , a layered deletion pattern del on strings of length κ a for some a < m with total corruption fraction at most 2 −κ , and query differences d 1 . . .d r−1 .Moreover, every layer has corruption at most κ −κ 2 and d 1 + . . .
Proof.We use a similar proof strategy as Lemma 4.10.Our goal will be to find an injective mapping from the queries d 1 . . .d r−1 to d 1 . . .d r−1 resulting in the same distribution of outputs that only fails with small probability over the randomness of choosing a query shift and an instance of del.
First, we remark that there is an injective map that except with failure probability ((2k) j ′ −j+1 2 −κ/100 ) over uniformly randomly chosen options does the following.It maps a size κ a ′ chunk (of the κ a−a ′ options), query shift for that chunk, and del a ′ pattern to another such that the output of d j . . .d j ′ is the same as d j . . .d j ′ .
Secondly, we consider the distribution of a random instance of del a and query shift.We look at where q j falls, and our main goal will be to show that the chunk of size κ a ′ it is in, as well as the deletion pattern within that chunk, is essentially uniform (small TV distance from uniform).We'll start by conditioning on the deletions for chunks of size larger than κ a ′ .The corruptions on chunks larger than κ a ′ +2κ , when implemented, only affect up to κ −κ -fraction of the chunks at all, and so ruling those out is only a negligible fraction of total chunks.The ones between κ a ′ and κ a ′ +2κ only cause at most κ a ′ +2κ−κ 2 < κ a ′ −κ deletions total, and so only affect a negligible κ −κ fraction of the chunk they fall into.Now, generate the small chunks' deletions randomly.The query shift dominates in which chunk q j will fall into of the ones that weren't ruled out by the large deletions or by being in the first d 1 + . . .+ d j eligible bits.In particular, the size remaining post-deletion of a chunk determines the chance of falling into it given the query shift, which differs by a factor of at most 1 − 2 −κ − κ −κ between chunks.Thus, the distribution is TV distance at most 2 −κ/2 from uniform.
Combining these two facts, we can apply the injective map to adjust the deletion pattern in the chunk that d j falls into so that queries d j . . .d j ′ become d j . . .d j ′ except with probability ((2k) j ′ −j+1 2 −κ/100 ) + 2 −κ/2 .In order to account for the query shift in the chunk of length κ a ′ , one has to also adjust the amount of corruption in the length κ a ′ +κ κ/1000 length chunks directly before and after the chunk where d j fell.This adjustment fails with probability at most Because this map is reversible, it is injective.In all, the failure probability is at most ((2k) j ′ −j+1 2 −κ/100 ) + 2 −κ/10 , and so the TV distance of distribution of outputs for the two sets of queries is at most two times that, which in total results in a ((2k) j ′ −j+1 2 −κ/100 ) + 2 −κ/10 < (2k) r−1 approximation.
Lemma 4.12.Consider a layered deletion pattern del on strings of length κ a for some a < m with total corruption fraction at most 2 −κ , and query differences d 1 . . .d r−1 .Choose a ′ such that every d i is either larger than κ a ′ • κ κ κ/100 or smaller than κ a ′ • κ −κ κ/100 .Let us further assume that for all lists of query differences of length s at most r − 2 (corresponding to r − 1 queries) where the total width is at most κ a ′ κ −κ 2 , there exists a list of query differences that (2k) s (2 −κ/2 )-approximates it on at least (1 − (2k) s 2 κ/2 ) fraction of strings z ∈ Im(C) for the deletion pattern del a ′ .Finally, assume that for at most where j ′ = i κ d 1 +...+ d r−1 +κ 2 −a ′ −κ 2 .has no significant layers between a ′ − κ 2 and d 1 + . . .+ d r−1 + κ 2 .Finally, f del (a ′ ) > κ κ κ/1000 .Then, there is a list of queries d 1 . . .d r−1 that (2k) r−1 (2 −κ/100 )-approximates d 1 . . .d r−1 on del, which satisfies that all d i ≤ κ a ′ +κ κ/1000 .Proof.We can partition the queries d 1 . . .d r−1 into groups d j . . .d j ′ that comprise of the small query differences (and exclude the large differences).Firstly, we can apply Lemma 4.11 to successively replace the query differences d j . . .d j ′ with a list d j . . .d j ′ from the list of approximating queries that has no significant layers in the desired range, such that (2k) j ′ −j+1 2 −κ/100 -approximates it.We can do this by choosing a ′ in the lemma to be a ′ +κ κ/1000 , because the adjacent query differences are all larger by at least a factor of κ κ κ/100 , and the layer a ′ has sufficient corruption.Each iteration of this is a (2k) j ′ −j+1 2 −κ/100 -approximation, so by Lemma 4.8, after performing all the replacements, we are left with a (2k) r−1 2 −κ/100 -approximation at worst.Now, the queries in the groups d j . . .d j ′ has essentially the same distribution of outputs in the layers a ′ − κ 2 and d 1 + . . .+ d r−1 + κ 2 , and in fact in all layers between.At a high level, we want to show that replacing the remaining differences (large differences) with κ a ′ +κ does not change the distribution of outputs by much because there are no significant layers for any of the lists of short queries between layers a ′ − κ 2 and d 1 + . . .+ d r−1 + κ 2 , and so all query differences at approximately that scale function similarly.
Let the groups of short queries be d j 1 . . .d j ′ 1 , d j 2 . . .d j ′ 2 , . .., such that between each pair, there is a single d p 1 that is large.(If there are multiple large differences in a row, the short query group between them is the empty list.) We will show that we can replace any d p i with κ a ′ +κ κ/1000 and adjust d p i+1 by d p i − κ a ′ +κ κ/1000 without changing the output distribution.In the case where d p i is the rightmost difference, no further value d p i+1 need be adjusted We remark that this does not result in the same distribution of output queries induced in the original codeword, just of outputs in Σ r .Repeating this process for each d p i from left to right recovers the lemma statement.
By the same argument as in the proof of Lemma 4.11, the distribution of which κ a ′ block that d j i . . .d j ′ i falls into and the corruption pattern within the block and the shift is at most 2 −κ/2 TV distance from uniform.Then, when we reduce the value of d p i , there is a change in which block this query falls in.However, the distribution of where the list of queries falls now is still approximately uniform, since the argument would've also held using κ a ′ +κ κ/1000 for d p i .Then, the distributions of outputs for the queries induced by the differences d j i . . .d j ′ i is the same in both cases.Moreover, there is a bijection between the shift and instantiation of del a ′ in the block that the list of queries falls into in each case, because there are no significant layers.Since there are no significant layers, the output distribution in each length κ a ′ block is the same, except with small probability at most 2 κ/2 .By increasing the value of d p i+1 by exactly how much d p i was decreased, the distribution of the other outputs does not change.However, the conditional distribution may change, based on the shift induced by d j ′ i , but because the outputs could be approximately bijected without adjusting the shift of d j ′ i by more than κ a ′ , this can be compensated for by adjusting the deletion in the preceding and following κ a ′ +κ κ/2000 -sized block.Formally, like in the previous arguments, the map where these adjustments are made forms an injection that succeeds with high probability.
In all, this final list of queries, formed by replacing all the large differences by the value κ a ′ +κ κ/1000 results in a (2k) r−1 (2 −κ/100 )-approximation.

Deletion Pattern and a Representative Set of Queries
In this section, we'll define the layered deletion pattern del used by the adversary in terms of the choice of code C.
The key idea of the proof of the main theorem (that a constant number of queries don't suffice for recovering every index) is that, given the deletion pattern del, there is a constant-sized representative set of lists of queries F such that any arbitrary query list can be simulated by an element of F. That is, the output of the arbitrary list of queries and the chosen list from F have approximately the same distribution for most codewords in the code upto a random shift of the queries.More granularly, we'll let F r be the subset of F consisting of successive differences for size r query lists.
In the following definition, we'll build up del and F simultaneously layer by layer.
The Deletion Pattern del and Representative Family of Query Differences F We define del by assigning for all a ∈ [m] a value to f del (a).Simultaneously, we'll build F .
Preliminary values for layers a ≤ 2κ κ 2 : For a ≤ κ 3 let f del (a) = 0 and for κ 3 < a < 2κ κ , let f del (a) := κ −κ 2 .Correspondingly, add the following elements to F r .Define the set S of important differences as follows.Add every integer from 0 . . .κ 3 .Next, for κ 3 < a < 2κ κ and 0 < i ≤ κ 2κ 2 , add κ a • 1 + i κ 2κ 2 .To each F r , add every (r − 1)-sized list where each d i is an element of S. Also, include the empty list in F 1 .
Assigning layers a ∈ [2κ κ 2 , m − κ κ ] (roughly) in sequence: We'll proceed one layer at a time starting from a = κ 2 to add more corruption to del.Which layers are corrupted next will depend on the current F and del.For each value of a ranging from κ 2 to m, do the following: 1.For each list of queries in q 1 . . .q r ∈ F with d 1 + . . .+ d r−1 < κ a−κ κ /2 and each b ∈ Σ r , decide whether a is a significant layer for any b ∈ Σ r for the deletion process del (only looking at what it is so far) for the threshold 2 −κ .
2. If not, then move on to the next a.Otherwise, let r be the smallest for which there is a query list higher than the threshold.Assign f del (a ′ ) := κ −κ 3 r r for all a − κ κ ≤ a ′ < a + κ κ (unless the already-assigned value was higher, in which case leave it).
3. For all r ′ > r (note the strict inequality), add the following query difference lists to F r .Define the set S a of important differences as follows: for a − κ κ ≤ a ′ < a + κ κ and 0 < i ≤ κ 2κ 2 r r , add in κ a • 1 + i κ 2κ 2 r r .Then, choose an arbitrary difference list d 1 . . .d t ∈ F with t < r − 1 (for example, the singleton query list q 1 = 1) and set d 1 . . .d t to those values.Then, set d t+1 to an element in S a , and set q t+2 . . .q t ′ as an arbitrary element of F as before shifted such that the first query is q t+1 ).Then set the next value d t ′ +1 to an element in S a and repeat.
Assigning layers a > m − 2κ κ : Assign f del (a) := κ −κ 3 .(This part will be completed after the previous one, even though there is a slight overlap in layer.)Assign f del (m) := κ −5 .Now, we'll prove a couple facts about del and F .Lemma 4.13.For each r, the size of F r is at most κ 4κ 2 r r .
Proof.We'll show the claim by induction on r.For r = 1, the only query we have added is q 1 = 1 so there is only one element.Now we'll show the claim for r if it's true for all r ′ < r.
The first elements added to F r were determined by a set S defined as every integer from 0 . . .κ 3 and for κ 3 < a < 2κ κ and 0 < i ≤ κ 2κ 2 , adding an element.The size of this set is less than κ 3κ 2 .Then, each of the r − 1 differences between adjacent queries may be chosen from this set, for a total of κ 3κ 2 r possible lists of queries.Note for clarity that this part did not involve the inductive hypothesis.
In the second way of adding elements to F r , we first find a value of a such that the layer is significant for one of the queries in F r ′ with r ′ < r.By Lemma 4.9, for each query list, there are at most κ 2κ values of a.In each, when we add new queries of length r, we first partition r into the sum of r 1 . . .r i where the sum is r and each 1 ≤ r ι < r.Letting N r ′ denote the size of F r ′ , this quantity is at most The number of options for r 1 . . .r i and the number of significant layers κ 2κ increases this by at most a factor of κ κ 2 .When describing the corruption process for a as a significant layer, we constructed the set S a of differences.The set was constructed so that for every integer between κ a−κ κ and κ a+κ κ , there is s ∈ S a that is at most a factor of κ −2κ 2 r r smaller.This requires that κ a−κ κ > κ κ 2 r r due to approximation issues.This holds as long as a > κ κ + κ 2 r r , which is true since c > 2κ κ 2 .
Partition the list d 1 . . .d r−1 into groups of consecutive elements as follows: starting from the first d i , let a group be all the following consecutive elements satisfying d i < κ a ′ .If there are none, just let it be the next element that is larger.As such, groups of elements are either a single large element or a consecutive list of small elements.
From left to right, if the next group of query differences is a single element larger than κ a ′ , then by Lemma 4.10, for every z ∈ Im(C), there exists a way to replace it with an element of S a such that the new query approximates the old one on all strings of length κ m .
If the next group of query differences (length r ′ ) is a group of elements all smaller than κ a ′ −κ κ/20 , then the conditions of Lemma 4.11 are satisfied, so we can replace the group of query differences with one that approximates it in F r ′ by the inductive hypothesis.On all z ∈ Im(C) where the approximation held, which was (1 − (2k) r−1 2 κ/2 ) fraction at least, the approximation holds for the new list of queries as well by Lemma 4.11.
In all, this new list of query differences has been constructed using elements of F r ′ and with differences in S a .As such, this list of differences is in F r by construction.
Since each successive change to the query provided a 2 −κ/100 k-approximation of the previous step, this means that d 1 . . .d r−1 2 −κ/100 k-approximates the query d of the values of z ∈ Im(C) by Lemma 4.8 and a union bound on the deletion pattern .
Case 3: For all q ′ 1 . . .q ′ r ′ ∈ F r ′ for some r ′ < r, it holds that a is not a significant layer for the threshold 2 −κ for any c − κ κ 10 < a < c + κ κ 10 .
Define the layer a to be the largest significant layer for some q ′ 1 . . .q ′ r ′ ∈ F r ′ for some r ′ < r that is smaller than c.
Similar to the previous case, select a threshold layer a + κ κ 50 < a ′ < a + κ κ 20 such that no value of log κ d i falls between a ′ − κ κ/80 and a ′ .Then, for at least 2 −κ/2 fraction of values of z ∈ Im(C), the following holds by Markov's inequality and the definition of a significant layer.
. Now, we can apply Lemma 4.12, and we can replace all the d i that are large with precisely the value κ a ′ .This new query 1 − (2k) r /2 • 2 κ/2 approximates the old one on 1 − (2k) r /2 • 2 κ/2 values of z ∈ Im(C), and additionally now falls into Case 2. Therefore, there is a query that approximates this query, and ultimately 1 − (2k) r • 2 κ/2 approximates the original query on 1 − (2k) r • 2 κ/2 values of z ∈ Im(C) on the deletion pattern del a .Definition 4.16 ( G and Q).Let G ⊂ [M ] be the differences that appear in some list in F. This set G is constant-sized.Moreover, add every multiple of κ m−1.75κ κ that is at most M to the set G.
Let Q be constructed as follows.For every tuple g 1 , . . .g k ∈ G, let q 1 := g 1 , q 2 := g 1 + g 2 . .., and add this list of queries to Q.This set Q is constant-sized.
The following lemma says that querying q 1 . . .q k will produce essentially the same output as some q 1 . . .q k ∈ Q.
Lemma 4.17.For any (ordered) query list q 1 . . .q k ∈ [M ] k and for at least 1 − κ −4 fraction of z ∈ Im(C), there exists a list of queries q 1 . . .q k ∈ Q such that q 1 . . .q k approximates q 1 . . .q k for the deletion pattern del, meaning the following.For any b Proof.Given a list of queries q 1 . . .q k ∈ [M ] k , separate the differences d 1 . . .d k−1 as follows.Find a layer a ∈ [m − 1.7κ κ , m − 1.6κ κ ] such that no value of log κ d i falls between a − κ κ/20 and a + κ κ/20 .
Using this layer, we can designate the small and large differences.At a high level, we'll show that replacing sequences of small differences with ones that approximate them on some layer c < a ′ does not change the output distribution by much, and adjusting large differences by κ m−1.75κ κ .The main difference between this situation and Case 2 of Lemma 4.15 is that we won't desire to shift the entire query by uniformly random amount in [κ m ]; only by an amount in [0, κ m−5 , since that is the corruption of layer m.
By Lemma 4.15, for at least 1 − κ −100 fraction of the z ∈ Im(C), a given short sequence of differences can be 2 −κ/2000 -approximated by one in G.In particular, this means that for at least 1 − κ −90 of the z ∈ Im(C), a 2 κ/5000 -approximation holds on all of the κ m−10 -sized chunks.
The shift of the queries dictated by the deletion at layer m is κ m−5 .Therefore, when a random shift (deletion at layer m is chosen), except for probability of failure at most κ −5 , this deletion amount can be shifted by κ m−10 .In other words, except with probability at most κ −5 , the shift will be uniform within this chunk.This allows us to apply Lemma 4.11 on the layer a to replace sequences of short queries with a sequence in G, and since the output given a uniform shift is a 2 −κ/1000 -approximation, it is in this situation as well, since except with probability 1 − κ −5 the query could be simulated with a uniform shift.Next, we can apply Lemma 4.10 to adjust the large queries slightly such that differences of successive queries are multiples of κ m−1.75κ κ .In total, the probability of this new query output not appropriately simulating the original q 1 . . .q k is at most κ −4 , proving the lemma.

Concluding Theorem 4.1 and Corollary 4.2.
We begin with a lemma that shows that z ∈ Im(C) can be compressed down to a constant K(ε, |Σ|, k) length string such that outputs of any list of k queries can be predicted by this compressed string.
Lemma 4.18.There exists a constant K := K(ε, |Σ|, k) and a compression function f : Im(C) → Σ K such that the following holds.For any k queries q 1 . . .q k , there is a randomized function query : Σ K → Σ k such that for at least 1 − κ −1 fraction of z ∈ Im(C), the distribution of query(f (z)) has TV distance at most 1 − κ −1 from the outputs of the queries q 1 . . .q k after applying the deletion pattern del.
Proof.This is essentially a restatement of Lemma 4.17.In particular, define f as follows.Apply the deletion pattern del, and for every query q in any list in Q, let the output of q be included in the compression.Then, query can be performed by taking the queries q 1 . . .q k ∈ Q that approximate q 1 . . .q k , and looking at f (z) to figure those out.The output of this has TV distance at most 1−κ −1 for at least 1 − κ −1 fraction of values of z.
Lemma 4.19.If the output of all lists of queries can be deduced up to TV distance 1 − κ −1 on κ −1 -fraction of strings from some randomized compression function f : Im(C) → Σ K , there exists a constant K so that for n > K, there exists i ∈ [n] such that for uniformly random x, the index x[i] cannot be guessed correctly from any query list with probability more than 1 2 + ε 2 .
Proof.Assume for the sake of contradiction that the queries are capable of recovering every index i with probability 1 2 + ε 2 .Then, on 1 − κ −1 -fraction of inputs, the compressed version of it f (C(x)) is capable of recovering i with probability 1 2 + ε + κ −1 .Perform the following process, which we'll call Y : take a random string x ∈ Σ n , take the compressed string f (C(x)) and use it to recover each of x[1] . . .x[n].We know that H(Y ) ≤ K.Each index i has a 1 2 + ε 2 − 2κ −1 > 1 2 + ε 3 chance (but not independent) of yielding the correct value of x[i].In total, this means the entropy of each bit of the string x conditional on the guesses provided by the string is at most 1 − ε 6 .By the subadditivity of entropy, the entropy of this is at most (1 − ε 6 )n, so H(Y ) ≤ (1 − ε 6 )n.Also, the entropy of the string x, which we'll call H(X), is n.
We know that which is a contradiction for sufficiently large n.
Combining Lemma 4.18 and Lemma 4.19 concludes the proof of Theorem 4.1.Theorem 4.2 follows by Theorem 4 in [BCG + 22], which states that the existence of LCC's in the adversarial insertion/deletion setting would imply LDC's in the adversarial insertion/deletion setting, which don't exist by Theorem 4.1.
Our result requires that deletion resilient LCC's would imply deletion resilient LDC's.Their proof carries over identically to this setting, and we briefly sketch why.
Proof Sketch.The main property of the corruption pattern they used was that no two codewords z, z ′ in the codespace of an LCC could have Hamming distance less than ε ′ n, where ε ′ is the allotted corruption for the adversary.This also holds in the deletion-only setting, because if two codewords z and z ′ were within Hamming distance ε ′ n, the adversary could delete all the indices on which they differ.The resulting messages would be the same, and any bit that differed between the two encodings cannot be recovered.
Then, the codespace has VC dimension d = O ε,|Σ| (n), by Lemma 6 in [BCG + 22].Restrict the code to a subset C ′ of size Σ d with the same shattering set, and define the corresponding code Σ d → C ′ , as the extension of the values on the shattering set into C ′ .This new code is an LCC that follows a systematic encoding, which would also make it an LDC on messages of length d = O ε,|Σ| (n).This cannot exist by Theorem 4.1.

Acknowledgements
Meghal Gupta is supported by an NSF Graduate Research Fellowship.The author would like to thank her advisor Dr. Venkatesan Guruswami for invaluable guidance, helpful discussions, and feedback on the manuscript.The author would also like to thank Omar Alrabiah and Yang Liu for helpful discussions and comments on the paper.
frac 0's 0101010101 . . .Type B block A B A B . . .In this example, the string consists of M/2 β alternating Type A and Type B blocks.At each scale θ ∈ [log M ], let's examine the weight W b) (s; d 1 . . .d r−1 ; del)).We define the shift-invariant frequency freq (b) (s; d 1 . . .d r−1 ; del) of a pattern b ∈ Σ r in a string s ∈ Σ ν on the query differences d 1 . . .d r−1 with deletion pattern del on strings of length ν as follows.

Definition 4. 6 (
Layered Deletion Pattern).For a length ν = κ a , we define a layered deletion pattern on the indices [ν].Each layer α ∈ [a] is assigned a maximum deletion fraction described by a function f del : N → R.