Decoding of Two-Deletion Correcting Codes

Chapter II: Binary 2-Deletion/Insertion Correcting Codes

2.5 Decoding of Two-Deletion Correcting Codes

In this section it is shown how to decode Construction2.1.1. Recall the encoding function

E (c) =(c, 𝑓(c), ℎ(c), 𝑟₃(𝑓(𝑓(c), ℎ(c))), 𝑟₃(ℎ(𝑓(c), ℎ(c)))), (2.39) with redundancy 𝑓(c), ℎ(c)of length 𝑁₁ ≜ 7 log𝑛+8 and 3-fold repetition redun- dancy𝑟₃(𝑓(𝑓(c), ℎ(c))), 𝑟₃(ℎ(𝑓(c), ℎ(c)))of length 𝑁₂ ≜ 21 log(7 log𝑛+8) +8.

To conveniently describe the decoding algorithm, two building blocks are needed.

The first is a 3-fold repetition decoding function

D₁:{0,1}^𝑁2−2→ {0,1}^𝑁2/3

that takes a subsequence d₁ ∈ {0,1}^𝑁2−2of a 3-fold repetition codeword 𝑟₃(s₁) ∈ {0,1}^𝑁2 for some s₁ ∈ {0,1}^𝑁2/3 as input, and outputs an estimate ˜s₁ of the se- quences₁. The second is a decoding function which is defined for every positive

integer𝑞as follows

D₂:{0,1}^𝑞−2× {0,1}^{7 log𝑞+2}→ {0,1}^𝑞.

The function D₂ takes a subsequence d₂ ∈ {0,1}^𝑞−2 of some s₂ ∈ {0,1}^𝑞, re- dundancy 𝑓(s₂), and redundancy ℎ(s₂) as input, and outputs an estimate ˜s₂ of the sequence s₂. In Algorithm 1, the function D₂ is used twice with two different values of 𝑞. As will be shown, the two calls of the function D₂ aim to recover the redundancy 𝑓(c)andℎ(c) and the sequencecrespectively.

The 3-fold repetition decoding D₁ can be implemented by adding two bits to d₁ such that the length of each run is a multiple of 3, which can obviously be done in linear time. According to Theorem2.1.2, there exists a decoding functionD₂that recovers the original sequence s₂ correctly given its 𝑓(s₂) and ℎ(s₂) redundancy.

The linear complexity ofD₂will be shown later in this section.

The functions D₁ and D₂ are used as subroutines to describe the decoding pro- cedure that is given in Algorithm1. First, we use the function D₁ to recover the redundancy 𝑓(𝑓(c), ℎ(c))andℎ(𝑓(c), ℎ(c))from the 3-fold repetition code. Then, by applyingD₂and using the redundancy 𝑓(𝑓(c), ℎ(c))andℎ(𝑓(c), ℎ(c)), the 𝑓(c) andℎ(c)can be recovered. Finally and similarly, redundancy 𝑓(c)andℎ(c) can be used to recover the original sequencec, again with the help ofD₂.

Algorithm 1: Decoding

Input: A subsequenced ∈ {0,1}^𝑁−2ofE (c)for somecin the code.

Output: The sequencec.

layer2_redundancy=D₁(d^{(𝑁−𝑁2+1, 𝑁−2)});

if two deletions are detected byD₁then returnd^(1,𝑛);

else

𝐿 ≜ The length of the longest suffix ofdthat is a subsequence of𝑟₃(layer2_redundancy);

layer1_redundancy=D₂(d^{(𝑁−𝑁1+1−𝐿 , 𝑁−2−𝐿)},layer2_redundancy);

c=D₂(d^(1,𝑛−2),layer1_redundancy); return c.

Theorem 2.5.1. If the functionsD₁andD₂provide the correct estimates in𝑂(𝑛) time, then given an 𝑁 −2 subsequence of E (c), Algorithm 1returns the original sequencecin𝑂(𝑛)time.

Proof. To prove the correctness of Algorithm1, it suffices to show the following

(1). d^{(𝑁−𝑁2+1, 𝑁−2)} is a length𝑁₂−2 subsequence of the repetition code 𝑟₃(𝑓(𝑓(c), ℎ(c))), 𝑟₃(ℎ(𝑓(c), ℎ(c)))).

(2). d^{(𝑁−𝑁1+1−𝐿 , 𝑁−2−𝐿)}is a length𝑁₁−2 subsequence of the 𝑓(c), ℎ(c)redundancy.

(3). d^(1,𝑛−2) is a length𝑛−2 subsequence of the sequencec.

Sincedis a length 𝑁−2 subsequence ofE (c), 𝑑_𝑛−2must be either the (𝑛−2)-th, the (𝑛− 1)-th or the 𝑛-th bits of E (c), and hence (3) must hold. Similarly, (1) holds by consideringdandE (c) in reversed order. By the definition of 𝐿, 𝑑_{𝑁−2−𝐿} is the 𝑖₁-th bit of E (c) for some 𝑖₁ ≤ 𝑛+ 𝑁₁. Since (1) holds, we have that 𝐿 is either 𝑁₂, 𝑁₂− 1, or 𝑁₂−2. Therefore, 𝑑_𝑁−𝑁

1+1−𝐿 is the𝑖₂-th bit of E (c) for some𝑖₂ ≥ 𝑁−𝑁₁+1−𝐿 > 𝑛. Since(𝑓(c), ℎ(c)) =E (c)^{(𝑛+1,𝑛+𝑁1)}, (2)must hold.

Since finding 𝐿 has𝑂(𝑁₂) complexity, the complexity of Algorithm1 is𝑂(𝑁) = 𝑂(𝑛), given that the complexities of the functionsD₁andD₂are linear. □ It can be verified that Algorithm 1 outputs the original sequence c in the case of a single deletion. One can also use a VT decoder (see [64]), which has a simpler implementation and 𝑂(𝑛) time complexity. We are left to implement D₂ with linear complexity. In particular, we need to recover the sequence c ∈ {0,1}^𝑛 from its length 𝑛−2 subsequence d in time 𝑂(𝑛), given the redundancies 𝑓(c) and ℎ(c). Note that there are𝑂(𝑛²) supersequences of dof length𝑛, and 𝑓 and ℎ can be computed on each of them in𝑂(𝑛). Hence, the brute force approach would require𝑂(𝑛³).

To achieve linear time complexity, we first recover1₁₀(c)from an(𝑛−3)-subsequence 1₁₀(d) of 1₁₀(c) ∈ {0,1}^𝑛−1, and then use it to recover c. In particular, we first find the positions and values of the deleted bits in1₁₀(c) by an iterative updating algorithm, rather than by exhaustive search, and hence linear complexity is ob- tained. Furthermore, the uniqueness of the resulting sequence is guaranteed by Lemma2.2.2. After recovering1₁₀(c), We can find all length 𝑛supersequencesc^′ ofd such that1₁₀(c^′) =1₁₀(c). It is shown that there are at most 4 such possible supersequences, and since Theorem2.1.2guarantees uniqueness, the rightcis found by computing and comparing ℎ(c). Therefore, the decoding can be done in linear time in total.

Recovering1₁₀(c). For 1 ≤𝑖 ≤ 2𝑛−2, let

𝑝_𝑖 ≜











𝑛−𝑖 if 1 ≤𝑖 ≤ 𝑛−1 𝑖−𝑛+1 if𝑛 ≤𝑖 ≤ 2𝑛−2

, and (2.40)

𝑏_𝑖 ≜











0 if 1 ≤𝑖 ≤ 𝑛−1 1 if𝑛 ≤𝑖 ≤ 2𝑛−2

. (2.41)

For example, when𝑛 =5, we have

(𝑝₁, 𝑝₂, 𝑝₃, 𝑝₄, 𝑝₅, 𝑝₆, 𝑝₇, 𝑝₈) =(4,3,2,1,1,2,3,4) and (𝑏₁, 𝑏₂, 𝑏₃, 𝑏₄, 𝑏₅, 𝑏₆, 𝑏₇, 𝑏₈) =(0,0,0,0,1,1,1,1).

Given a subsequence d ∈ {0,1}^𝑛−2 of c, let 1₁₀(d) = (𝑟₁, . . . , 𝑟_𝑛−3), and let 𝑤 : {0,1}^𝑛−2× [2𝑛−2] × [2𝑛−2] → {0,1}^𝑛−1∪ {★}be defined as

𝑤(d, 𝑖, 𝑗) =



































(𝑟₁, 𝑟₂, . . . , 𝑟_𝑝

𝑖−1, 𝑏_𝑖, 𝑟_𝑝

𝑖

, . . . , 𝑟_𝑝

𝑗−2, 𝑏_𝑗, 𝑟_𝑝

𝑗−1, . . . , 𝑟_𝑛−3) if 𝑝_𝑖 < 𝑝_𝑗,

(𝑟₁, 𝑟₂, . . . , 𝑟_𝑝

𝑗−1, 𝑏_𝑗, 𝑟_𝑝

𝑗, . . . , 𝑟_𝑝

𝑖−2, 𝑏_𝑖, 𝑟_𝑝

𝑖−1, . . . , 𝑟_𝑛−3) if 𝑝_𝑖 > 𝑝_𝑗,

★

if 𝑝_𝑖 = 𝑝_𝑗,

that is, 𝑤(d, 𝑖, 𝑗) results from 1₁₀(d) inserting 𝑏_𝑖 at position 𝑝_𝑖 and 𝑏_𝑗 in posi- tion 𝑝_𝑗 of 1₁₀(d), if 𝑝_𝑖 ≠ 𝑝_𝑗. Notice that 𝑤(d, 𝑖, 𝑗) is one possible candidate for1₁₀(c). To illustrate𝑤(d, 𝑖, 𝑗), let us consider again the example where 𝑛 = 5.

Let d ∈ {0,1}^𝑛−2 = (1,0,1), which implies that 1₁₀(d) = (1,0). Then, we have that 𝑤(d,2,7) = ★ since 𝑝₂ = 𝑝₇ = 3, and that 𝑤(d,2,6) = (1,1,0,0) since 𝑝₂ =3, 𝑏₂=0, 𝑝₆ =2, 𝑏₆=1.

For𝑒 ∈ {0,1,2}define (2𝑛−2) × (2𝑛−2) integer matrices{𝐴^(𝑒)}²

𝑒=0as follows.

𝐴^(𝑒)

𝑖, 𝑗 =











𝑤(d, 𝑖, 𝑗) ·m^(𝑒) −Í𝑛−3 𝑘=1m^(𝑒)

𝑘 1₁₀(d)𝑘 if𝑤(d, 𝑖, 𝑗) ≠★.

★ if𝑤(d, 𝑖, 𝑗) =★.

Notice that𝐴^(𝑒)

𝑖, 𝑗 is the difference in the weighted sums of𝑤(d, 𝑖, 𝑗)and1₁₀(d), with weightsm^(𝑒). We now show that the entry of 𝐴^(𝑒) that we are looking for is equal modulo𝑛_𝑒 to the difference in entry𝑒 of the 𝑓 redundancies ofcand ofd. That is, 𝐴⁽

𝑒)

𝑖, 𝑗 ≡ (𝑓(c)𝑒− 𝑓(d)𝑒)mod𝑛_𝑒. On the one hand, since1₁₀(c)is obtained after two insertions in1₁₀(d), it follows that there exists (𝑖, 𝑗) such that 𝑤(d, 𝑖, 𝑗) = 1₁₀(c) and that 𝐴^(𝑒)

𝑖, 𝑗 ≡ (𝑓(c)𝑒 − 𝑓(d)𝑒) mod𝑛_𝑒 for every 𝑒 ∈ {0,1,2}. On the other hand, by Lemma 2.2.2, it follows that this (𝑖, 𝑗) pair is unique, given that the sequence𝑤(d, 𝑖, 𝑗)does not contain consecutive 1’s. Hence, since𝑤(d, 𝑖, 𝑗)which contain consecutive 1’s are skipped in our algorithm (see Algorithm2in the sequel), it follows that𝑤(d, 𝑖, , 𝑗) =1₁₀(c).

We prove the following properties of 𝐴^(𝑒). In the first property, we give an explicit expression for an entry 𝐴^(𝑒)

𝑖, 𝑗 in terms of1₁₀(d), 𝑝_𝑖, 𝑝_𝑗, 𝑏_𝑖, and 𝑏_𝑗. This expression will be used for calculating 𝐴⁽

𝑒)

𝑖, 𝑗 in constant time from its neighboring entries during D₂. In the following we use 𝛿(𝑥) to denote the Boolean indicator of an event𝑥, where𝛿(𝑥) =1 if and only if𝑥is true.

Proposition 2.5.1. If𝐴^(𝑒)

𝑖, 𝑗 ≠★then 𝐴^(𝑒)

𝑖, 𝑗 =𝑏_𝑖m^(𝑒)𝑝𝑖 +𝑏_𝑗m^(𝑒)𝑝𝑗+

𝑛−3

∑︁

𝑘=1

1₁₀(d)𝑘[(𝑘+1)^𝑒𝛿(min{𝑝_𝑖, 𝑝_𝑗} < 𝑘+1)+

(𝑘+2)^𝑒𝛿(max{𝑝_𝑖, 𝑝_𝑗} < 𝑘 +2)]. (2.42) Proof. The difference between Í𝑛−3

𝑘=1m⁽_𝑘^𝑒)1₁₀(d)𝑘 and 𝑤(d, 𝑖, 𝑗) ·m^(𝑒) consists of two parts. The first part follows from the two inserted bits, and can be written as

𝑏_𝑖m^(𝑒)𝑝_𝑖 +𝑏_𝑗m^(𝑒)𝑝_𝑗 . (2.43) The second part follows from the shift of bits in 1₁₀(d)𝑘 that is caused by the insertions of two bits𝑏_𝑖and𝑏_𝑗. Each bit1₁₀(d)𝑘shifts from position𝑘to position𝑘+ 1 if one insertion occurs before1₁₀(d)𝑘, i.e., min{𝑝_𝑖, 𝑝_𝑗} < 𝑘+1 and max{𝑝_𝑖, 𝑝_𝑗} ≥ 𝑘+2. The resulting difference is given by

𝑛−3

∑︁

𝑘=1

1₁₀(d)𝑘𝛿(min{𝑝_𝑖, 𝑝_𝑗} < 𝑘 +1)·

𝛿(max{𝑝_𝑖, 𝑝_𝑗} ≥ 𝑘+2) (m⁽_𝑘^𝑒)₊₁−m^(𝑒)_𝑘 )

=

𝑛−3

∑︁

𝑘=1

1₁₀(d)𝑘𝛿(min{𝑝_𝑖, 𝑝_𝑗} < 𝑘 +1)·

𝛿(max{𝑝_𝑖, 𝑝_𝑗} ≥ 𝑘+2) (𝑘+1)^𝑒. (2.44) The bit1₁₀(d)𝑘shifts from position𝑘to𝑘+2 if two insertions occur before1₁₀(d)𝑘, i.e., max{𝑝_𝑖, 𝑝_𝑗} < 𝑘 +2. The corresponding difference is given by

𝑛−3

∑︁

𝑘=1

1₁₀(d)𝑘𝛿(min{𝑝_𝑖, 𝑝_𝑗} < 𝑘 +1)·

𝛿(max{𝑝_𝑖, 𝑝_𝑗} < 𝑘 +2)1₁₀(d)𝑘(m⁽_𝑘+2^𝑒) −m^(𝑒)

𝑘 )

=

𝑛−3

∑︁

𝑘=1

1₁₀(d)𝑘𝛿(max{𝑝_𝑖, 𝑝_𝑗} < 𝑘 +2) [(𝑘 +1)^𝑒+ (𝑘 +2)^𝑒]. (2.45) Combining (2.44) and (2.45), we have that the difference that results from the second part is given by

𝑛−3

∑︁

𝑘=1

1₁₀(d)𝑘[(𝑘+1)^𝑒𝛿(min{𝑝_𝑖, 𝑝_𝑗} < 𝑘 +1)+

(𝑘+2)^𝑒𝛿(max{𝑝_𝑖, 𝑝_𝑗} < 𝑘 +2)],

that together with (2.43), implies (2.42). □

The following shows that the entries of each 𝐴^(𝑒) are non-decreasing in rows and columns, and that the respective sequences𝑤(d, 𝑖, 𝑗)that lie in the same column or the same row, are unique given each entry value. This property guarantees a simple algorithm for finding a sequence𝑤(d, 𝑖, 𝑗) with a given value 𝐴⁽

𝑒)

𝑖, 𝑗 by decreasing𝑖 or increasing 𝑗 by 1 in each step.

Proposition 2.5.2. For every𝑖, 𝑗and𝑖₁ < 𝑖₂, 𝑗₁ < 𝑗₂, if neither ofd(𝑖₁, 𝑗),d(𝑖₂, 𝑗), d(𝑖, 𝑗₁), and d(𝑖, 𝑗₂) equals ★, then 𝐴⁽

𝑒)

𝑖₁, 𝑗 ≤ 𝐴⁽

𝑒)

𝑖₂, 𝑗 and 𝐴⁽

𝑒) 𝑖, 𝑗₁ ≤ 𝐴⁽

𝑒)

𝑖, 𝑗₂. Moreover, if𝐴^(𝑒)

𝑖₁, 𝑗 = 𝐴^(𝑒)

𝑖₂, 𝑗 (resp.𝐴^(𝑒)

𝑖, 𝑗₁ = 𝐴^(𝑒)

𝑖, 𝑗₂), thend(𝑖₁, 𝑗) =d(𝑖₂, 𝑗)(resp.d(𝑖, 𝑗₁)=d(𝑖, 𝑗₂)).

Proof. By symmetry we only need to prove that the matrix 𝐴^(𝑒) is non-decreasing in each column, for which it suffices to prove that:

(1). 𝐴^(𝑒)

𝑖₁, 𝑗 ≤ 𝐴^(𝑒)

𝑖₂, 𝑗 for 1≤ 𝑖₁ < 𝑖₂ ≤ 𝑛−1.

(2). 𝐴^(𝑒)

𝑛−1, 𝑗 ≤ 𝐴^(𝑒)

𝑛, 𝑗. (3). 𝐴⁽

𝑒) 𝑖₁, 𝑗 ≤ 𝐴⁽

𝑒)

𝑖₂, 𝑗 for𝑛 ≤𝑖₁< 𝑖₂ ≤ 2𝑛−2.

For(2), the only difference betweend(𝑛−1, 𝑗)andd(𝑛, 𝑗)is that their first bits are 0 and 1 respectively, and hence 𝐴⁽

𝑒)

𝑛−1, 𝑗 +1= 𝐴⁽

𝑒)

𝑛, 𝑗. We are left to show(1) and(3). (1): For 1 ≤ 𝑖₁ < 𝑖₂ ≤ 𝑛−1, we have 𝑏_𝑖

1 = 𝑏_𝑖

2 =0 and 𝑝_𝑖

1 > 𝑝_𝑖

2. Letd^′(𝑖₁, 𝑗) ∈ {0,1}^𝑛−2andd^′(𝑖₂, 𝑗) ∈ {0,1}^𝑛−2be two subsequences ofd(𝑖₁, 𝑗) andd(𝑖₂, 𝑗), re- spectively, after deleting the𝑝_𝑗-th bit from bothd(𝑖₁, 𝑗) andd(𝑖₂, 𝑗), and similarly, let m^{(𝑒), 𝑝𝑗} = (m₁^(𝑒),m₂^(𝑒), . . . ,m⁽_𝑝^𝑒)

𝑗−1,m⁽_𝑝^𝑒)

𝑗+1, . . . ,m_𝑛−1^(𝑒) ) be a subsequence of m^(𝑒) after deleting the 𝑝_𝑗-th entry. Since d^′(𝑖₁, 𝑗) ∈ 𝐵₁(d^′(𝑖₂, 𝑗)), the remaining argu- ments follow those in the proof of Proposition2.1.1. According to (2.6) and (2.7), we have that

𝐴⁽

𝑒) 𝑖₂, 𝑗 − 𝐴⁽

𝑒)

𝑖₁, 𝑗 =d(𝑖₂, 𝑗) ·m^(𝑒) −d(𝑖₁, 𝑗) ·m^(𝑒)

=d^′(𝑖₂, 𝑗) ·m^{(𝑒), 𝑝𝑗} −d^′(𝑖₁, 𝑗) ·m^{(𝑒), 𝑝𝑗}

=𝑔(𝑘₁,d^′(𝑖₂, 𝑗)^{(𝑘1, 𝑘2)},d^′(𝑖₁, 𝑗)𝑘₂)

≥ 0, (2.46)

where𝑘₁ =𝑝_𝑖

2−𝛿(𝑝_𝑖

2 > 𝑝_𝑗)and𝑘₂= 𝑝_𝑖

1−𝛿(𝑝_𝑖

1 > 𝑝_𝑗)are the indices whose dele- tion fromd^′(𝑖₂, 𝑗) andd^′(𝑖₁, 𝑗), respectively, results in1₁₀(d). Similarly, as in the proof in Proposition2.1.2, the last inequality follows from the fact thatd^′(𝑖₁, 𝑗)𝑘₂ = 𝑏_𝑖

1 =0. Furthermore, equality holds when d^′(𝑖₂, 𝑗)^{(𝑘1, 𝑘2)} = 0 and d^′(𝑖₁, 𝑗)𝑘₂ = 0, which implies thatd^′(𝑖₁, 𝑗) =d^′(𝑖₂, 𝑗), and henced(𝑖₁, 𝑗) =d(𝑖₂, 𝑗).

(3): For 𝑛 ≤ 𝑖₁ < 𝑖₂ ≤ 2𝑛−2, we have 𝑏_𝑖

1 = 𝑏_𝑖

2 = 1 and 𝑝_𝑖

1 < 𝑝_𝑖

2. Similar to (2.46), we have that

𝐴^(𝑒)

𝑖₁, 𝑗 −𝐴^(𝑒)

𝑖₂, 𝑗 =𝑔(𝑘₁,d^′(𝑖₁, 𝑗)^{(𝑘1, 𝑘2)},d^′(𝑖₂, 𝑗)𝑘₂) ≤0, where 𝑘₁ = 𝑝_𝑖

1 −𝛿(𝑝_𝑖

1 > 𝑝_𝑗) and 𝑘₂ = 𝑝_𝑖

2 −𝛿(𝑝_𝑖

2 > 𝑝_𝑗) are the indices whose deletion from d^′(𝑖₁, 𝑗) and d^′(𝑖₂, 𝑗), respectively, results in 1₁₀(d). The last in- equality follows from the fact that d^′(𝑖₂, 𝑗)𝑘₂ = 𝑏_𝑖

2 = 1, and equality holds

whend(𝑖₁, 𝑗) =d(𝑖₂, 𝑗). □

Remark 2.5.1. From Proposition2.5.2, we have that 0= 𝐴^(𝑒)

1,2 ≤ 𝐴^(𝑒)

𝑖, 𝑗 ≤ 𝐴^(𝑒)

2𝑛−2,2𝑛−3 ≤m_𝑛^(𝑒)₋₁+m_𝑛^(𝑒)₋₂ ≤ 𝑛_𝑒 for1≤ 𝑖, 𝑗 ≤ 2𝑛−2, 𝐴^(𝑒)

𝑖, 𝑗 ≠★, where𝑛₀=2𝑛, 𝑛₁ =𝑛², 𝑛₂ =𝑛³. Recall that our goal is to find a sequence𝑤(d, 𝑖, 𝑗) ≠★for which

𝐴⁽

𝑒)

𝑖, 𝑗 ≡ 𝑓(c)𝑒−

𝑛−3

∑︁

𝑖=𝑘

m⁽_𝑘^𝑒)1₁₀(d)𝑘 mod𝑛_𝑒 (2.47)

*

*

*

*

*

*

*

*

*

*

10 10

10

10 10

* 10

10

10

11 11 11 12 11 12 13 13 11 12 12 13 14 11

9 9 9

9 8 8 8

9 9 7 7 8

8 9

0

1 9

9

2𝑛−2 2𝑛−3 2𝑛−4 2𝑛−5 2𝑛−6 2𝑛−7

2 𝑖 =1

𝑗 =1 2 3 4 5 6 7 2𝑛−2

...

...

Figure 2.5: The path of Algorithm2on the matrix 𝐴⁽⁰⁾.

for every 𝑒 ∈ {0,1,2}. In addition, the sequence 𝑤(d, 𝑖, 𝑗) cannot contain adja- cent 1’s, i.e.,

𝑤(d, 𝑖, 𝑗)𝑝𝑖−1·𝑤(d, 𝑖, 𝑗)𝑝𝑖 =𝑤(d, 𝑖, 𝑗)𝑝𝑖 ·𝑤(d, 𝑖, 𝑗)𝑝𝑖+1 =0

𝑤(d, 𝑖, 𝑗)𝑝_𝑗−1·𝑤(d, 𝑖, 𝑗)𝑝_𝑗 =𝑤(d, 𝑖, 𝑗)𝑝_𝑗 ·𝑤(d, 𝑖, 𝑗)𝑝_𝑗+1=0, (2.48) and from Lemma2.2.2, such𝑤(d, 𝑖, 𝑗)equals1₁₀(c). Moreover, since Remark2.5.1 implies that 0 ≤ 𝐴^(𝑒)

𝑖, 𝑗 ≤ 𝑛_𝑒, it follows that the modular equality in (2.47) is unnec- essary, i.e., it suffices to find a sequence𝑤(d, 𝑖, 𝑗) ≠★that satisfies (2.48) and

𝐴^(𝑒)

𝑖, 𝑗 =𝑎_𝑒 ≜ 𝑓_𝑒(c) −

𝑛−3

∑︁

𝑘=1

m^(𝑒)_𝑘 1₁₀(d)𝑘 mod𝑛_𝑒, (2.49) where 𝑎_𝑒 is the target value to be found in matrix 𝐴^(𝑒). Eq. (2.49) implies that𝑤(d, 𝑖, 𝑗)satisfies the 𝑓 redundancy.

The procedure to find such 𝑤(d, 𝑖, 𝑗) is given in Algorithm 2. We search for all sequences 𝑤(d, 𝑖, 𝑗) ≠ ★ with no adjacent 1’s (2.48) such that 𝐴⁽⁰⁾

𝑖, 𝑗 = 𝑎₀. This clearly amounts to a binary search in a sorted matrix3. We start from the bottom left

3The two★entries in each row or column can simply be skipped.

corner of the matrix, proceed to the right in each step until reaching the rightmost entry such that𝐴⁽⁰⁾

𝑖, 𝑗 ≤ 𝑎₀, and then go one step up. Figure2.5illustrates an example of how Algorithm2runs on matrix 𝐴⁽⁰⁾.

To avoid the computation of the entire matrix, that would require𝑂(𝑛²)time, each entry is computed from previously seen onesonlyupon its discovery. To this end we prove the following lemma, that alongside Proposition2.5.1, provides a way of computing a newly discovered entry.

Proposition 2.5.3. Whenever the (𝑖, 𝑗)-th and (𝑖+1, 𝑗)-th (resp. (𝑖, 𝑗+1)) entries of 𝐴^(𝑒) are not★, we have that

𝐴⁽

𝑒) 𝑖, 𝑗 − 𝐴⁽

𝑒) 𝑖+1, 𝑗

=𝑏_𝑖m^(𝑒)𝑝𝑖 −𝑏_𝑖+1m^(𝑒)𝑝𝑖+1+

min{𝑝₁, 𝑝_𝑖+1}

∑︁

𝑘=min{𝑝_𝑖, 𝑝_𝑖+1}−1

1₁₀(d)𝑘[(𝑘+1)^𝑒(𝛿(min{𝑝_𝑖, 𝑝_𝑗} < 𝑘 +1)

−𝛿(min{𝑝_𝑖+1, 𝑝_𝑗} < 𝑘 +1))+

(𝑘+2)^𝑒(𝛿(max{𝑝_𝑖, 𝑝_𝑗} < 𝑘 +2)−

𝛿(max{𝑝_𝑖+1, 𝑝_𝑗} < 𝑘 +2))], and (2.50) 𝐴^(𝑒)

𝑖, 𝑗 − 𝐴^(𝑒)

𝑖, 𝑗+1

=𝑏_𝑗m^(𝑒)𝑝𝑗 −𝑏_𝑗+1m^(𝑒)𝑝_𝑗+1+

min{𝑝𝑗, 𝑝𝑗+1}

∑︁

𝑘=min{𝑝𝑗, 𝑝_𝑗+1}−1

1₁₀(d)𝑘[(𝑘+1)^𝑒(𝛿(min{𝑝_𝑖, 𝑝_𝑗} < 𝑘 +1)

−𝛿(min{𝑝_𝑖, 𝑝_𝑗+1} < 𝑘 +1))+

(𝑘+2)^𝑒(𝛿(max{𝑝_𝑖, 𝑝_𝑗} < 𝑘 +2)−

𝛿(max{𝑝_𝑖, 𝑝_𝑗+1} < 𝑘 +2))]. (2.51)

Proof. Note that if𝑖 increases by 1 or if 𝑗 decreases by 1, then 𝑝_𝑖 or𝑝_𝑗 changes by at most 1 (See (2.40)). Hence,

𝛿(min{𝑝_𝑖, 𝑝_𝑗} < 𝑘 +1) =𝛿(min{𝑝_𝑖+1, 𝑝_𝑗} < 𝑘+1), 𝛿(max{𝑝_𝑖, 𝑝_𝑗} < 𝑘 +2) =𝛿(max{𝑝_𝑖+1, 𝑝_𝑗} < 𝑘+2)

for𝑘 ≤ min{𝑝_𝑗, 𝑝_𝑖+1} −2 and𝑘 ≥ min{𝑝_𝑖, 𝑝_𝑖+1} +1. According to (2.42), we have that (2.50) holds, and similarly, (2.51) holds as well. □

Algorithm 2: Finding1₁₀(c).

Input: Subsequenced∈ {0,1}^𝑛−2ofc, and 𝑓(c) Output: 𝑖and 𝑗 such that𝑤(d, 𝑖, 𝑗) =1₁₀(c) Initialization: 𝑖=2𝑛−2, 𝑗 =1;

𝑥_𝑒 = 𝐴⁽

𝑒)

1,2𝑛−2for𝑒 ∈ {0,1,2};

𝑎_𝑒 = 𝑓_𝑒(c) −Í𝑛−3

𝑘=1m_𝑘^(𝑒)1₁₀(d)𝑘 mod𝑛_𝑒for𝑒 ∈ {0,1,2}; while 𝑖 ≥ 0do

if𝑥_𝑒 =𝑎_𝑒for every𝑒 ∈ {0,1,2}and𝑤(d, 𝑖, 𝑗) ≠★and𝑤(d, 𝑖, 𝑗) has no adjacent1’s (𝑤(d, 𝑖, 𝑗) satisfies(2.48))then

return𝑖, 𝑗; else

Find the maximum 𝑗 for which 𝐴⁽⁰⁾

𝑖, 𝑗 ≤ 𝑎₀. if 𝑝_𝑖 = 𝑝_𝑗 or (𝑥₀ > 𝑎₀)then

𝑡 𝑒𝑚 𝑝_𝑥_𝑒 =𝑥_𝑒+ 𝐴^(𝑒)

𝑖, 𝑗−1−𝐴^(𝑒)

𝑖, 𝑗 (using (2.51)), for𝑒 ∈ {0,1,2};

𝑡 𝑒𝑚 𝑝_𝑗 = 𝑗 −1;

while 𝑝_{𝑡 𝑒𝑚 𝑝_𝑗} =𝑝_𝑖do 𝑡 𝑒𝑚 𝑝_𝑥_𝑒 =𝑥_𝑒+ 𝐴^(𝑒)

𝑖,𝑡 𝑒𝑚 𝑝_𝑗−1− 𝐴^(𝑒)

𝑖,𝑡 𝑒𝑚 𝑝_𝑗 (using (2.51)) for𝑒 ∈ {0,1,2};

𝑡 𝑒𝑚 𝑝_𝑗 =𝑡 𝑒𝑚 𝑝_𝑗 −1;

if𝑡 𝑒𝑚 𝑝_𝑗 ≥ 1then 𝑗 =𝑡 𝑒𝑚 𝑝_𝑗;

𝑥_𝑒 =𝑡 𝑒𝑚 𝑝_𝑥_𝑒 for𝑒 ∈ {0,1,2,}; else

𝑡 𝑒𝑚 𝑝_𝑥_𝑒 =𝑥_𝑒+ 𝐴^(𝑒)

𝑖, 𝑗+1−𝐴^(𝑒)

𝑖, 𝑗 (using (2.51)), for𝑒 ∈ {0,1,2};

𝑡 𝑒𝑚 𝑝_𝑗 = 𝑗 +1;

while 𝑝_{𝑡 𝑒𝑚 𝑝_𝑗} =𝑝_𝑖do 𝑡 𝑒𝑚 𝑝_𝑥_𝑒 =𝑥_𝑒+ 𝐴⁽

𝑒)

𝑖,𝑡 𝑒𝑚 𝑝_𝑗+1− 𝐴⁽

𝑒)

𝑖,𝑡 𝑒𝑚 𝑝_𝑗 (using (2.51)) for𝑒 ∈ {0,1,2};

𝑡 𝑒𝑚 𝑝_𝑗 =𝑡 𝑒𝑚 𝑝_𝑗 +1;

if𝑡 𝑒𝑚 𝑝_𝑥₀ ≤ 𝑎₀then 𝑗 =𝑡 𝑒𝑚 𝑝_𝑗;

𝑥_𝑒 =𝑡 𝑒𝑚 𝑝_𝑥_𝑒 for𝑒 ∈ {0,1,2,};

else

𝑥_𝑒 =𝑥_𝑒+𝐴^(𝑒)

𝑖−1, 𝑗 − 𝐴^(𝑒)

𝑖, 𝑗 (using (2.50));

𝑖 =𝑖−1;

return (0,0);

We first show that Algorithm2outputs the (𝑖, 𝑗)pair such that𝑤(d, 𝑖, 𝑗) =1₁₀(c). Note that by Lemma 2.2.2 there exists a unique sequence 𝑤(d, 𝑖, 𝑗) = 1₁₀(c) for which𝑤(d, 𝑖, 𝑗) satisfies Eq. (2.48) and for which (𝑖, 𝑗) satisfies Eq. (2.49). Since the algorithm terminates either when such a sequence 𝑤(d, 𝑖, 𝑗) =1₁₀(c) is found or no such sequence is found and𝑖reaches 0, it suffices to show that the latter case does not occur. We prove this by contradiction. Assuming that the latter case occurs, we show that𝑤(d, 𝑖, 𝑗) ≠ 1₁₀(c) for all (𝑖, 𝑗) pairs, which is a contradiction. For each 𝑖 ∈ {1,2, . . . ,2𝑛− 2}, let 𝑗_𝑖 be the maximum 𝑗 = 𝑗_𝑖 for which 𝐴⁽⁰⁾

𝑖, 𝑗_𝑖 ≤ 𝑎₀. If𝐴⁽⁰⁾

𝑖, 𝑗 > 𝑎₀for some𝑖and for all 𝑗, then 𝑗_𝑖 =1. Note that each pair(𝑖, 𝑗_𝑖)is visited in Algorithm2and by assumption we have thatd(𝑖, 𝑗_𝑖) ≠ 1₁₀(c). We consider the following two cases

(1). 𝑗 > 𝑗_𝑖, (2). 𝑗 < 𝑗_𝑖

and conclude that no (𝑖, 𝑗) pair in these cases result in 𝑤(d, 𝑖, 𝑗) = 1₁₀(c). For 𝑗 > 𝑗_𝑖, by Proposition 2.5.2 we have that 𝐴⁽⁰⁾

𝑖, 𝑗 ≥ 𝐴⁽⁰⁾

𝑖, 𝑗_𝑖 or that 𝑤(d, 𝑖, 𝑗) = ★. Hence by definition of 𝑗_𝑖 we have that 𝐴⁽⁰⁾

𝑖, 𝑗 > 𝑎₀ or that 𝑤(d, 𝑖, 𝑗) = ★, and hence𝑤(d, 𝑖, 𝑗) ≠1₁₀(c). For 𝑗 < 𝑗_𝑖, by Proposition2.5.2we have that𝐴⁽⁰⁾

𝑖, 𝑗 ≤ 𝐴⁽⁰⁾

𝑖, 𝑗_𝑖

or that𝑤(d, 𝑖, 𝑗) =★. If 𝐴⁽⁰⁾

𝑖, 𝑗 < 𝐴⁽⁰⁾

𝑖, 𝑗𝑖, then𝐴⁽⁰⁾

𝑖, 𝑗 ≠𝑎₀. If𝐴⁽⁰⁾

𝑖, 𝑗 = 𝐴⁽⁰⁾

𝑖, 𝑗𝑖, then according to Proposition2.5.2, we have that𝑤(d, 𝑖, 𝑗) =d(𝑖, 𝑗_𝑖)≠ 1₁₀(c).

We now show that Algorithm2 terminates in𝑂(𝑛) time. From (2.50) and (2.51) the (𝑖, 𝑗)-th entry of 𝐴^(𝑒), 𝑒 ∈ {0,1,2}, can be computed by using the update rule 𝑥_𝑒+𝐴⁽

𝑒) 𝑖−1, 𝑗 −𝐴⁽

𝑒)

𝑖, 𝑗 and𝑥_𝑒+𝐴⁽

𝑒) 𝑖, 𝑗±1− 𝐴⁽

𝑒)

𝑖, 𝑗 (see Algorithm2), that can be computed in constant time. In addition, one can verify in constant time that (2.48) holds.

Note that in each round, either 𝑖 decreases by 1 or 𝑗 increases by 1, with the exception that 𝑗 decreases by 1 every time when 𝐴⁽⁰⁾

𝑖, 𝑗 =★or 𝐴⁽⁰⁾

𝑖, 𝑗 > 𝑎₀. We prove by contradiction that the latter case, in which 𝐴⁽⁰⁾

𝑖, 𝑗 > 𝑎₀ and 𝑗 > 1 is impossible.

Notice that for each current pair(𝑖, 𝑗), the value of next pair (𝑖^∗, 𝑗^∗)falls into either one of the following three case:

(1). (𝑖^∗, 𝑗^∗) = (𝑖, 𝑗^′)for some 𝑗^′> 𝑗 with𝐴⁽⁰⁾

𝑖^∗, 𝑗^∗ ≤ 𝑎₀, (2). (𝑖^∗, 𝑗^∗) = (𝑖−1, 𝑗),

(3). (𝑖^∗, 𝑗^∗) = (𝑖−1, 𝑗^′) for some 𝑗^′< 𝑗 when 𝐴⁽⁰⁾

𝑖−1, 𝑗 =★.

Assume by contradiction that 𝐴⁽⁰⁾

𝑖^∗, 𝑗^∗ > 𝑎₀and 𝑗^∗ > 1, and (𝑖^∗, 𝑗^∗) is the first visited pair for which this statement is true. In Case (1), we have that 𝐴⁽⁰⁾

𝑖^∗, 𝑗^∗ ≤ 𝑎₀, in contradiction to 𝐴⁽⁰⁾

𝑖^∗, 𝑗^∗ > 𝑎₀. In Case (2) or Case (3), Proposition 2.5.2 implies that𝑎₀ < 𝐴⁽⁰⁾

𝑖^∗, 𝑗^∗ ≤ 𝐴⁽⁰⁾

𝑖, 𝑗 , contradicting the assumption that (𝑖^∗, 𝑗^∗) is the first visited pair which satisfies 𝐴⁽⁰⁾

𝑖^∗, 𝑗^∗ > 𝑎₀. Having proved that 𝐴⁽⁰⁾

𝑖, 𝑗 ≤ 𝑎₀whenever 𝑗 > 1, we have the Algorithm2proceeds to the left only when it encounters a ★-entry. We now show that the algorithm terminates in 𝑂(𝑛) time. Notice that unless Algorithm 2encounters a ★-entry, it proceeds either up or to the right, for which case, it is clear that only𝑂(𝑛)many steps occur. In cases where Algorithm2encounters a★-entry, it proceeds to theleftuntil a non★-entry is found. Then, this★-entry will not be visited again, because in the next step, it either goes up from the non★-entry or goes to the right of the★-entry.

Since the number of★-entries is 4𝑛−4, the number of left strides of the algorithm is at most this quantity, and therefore the algorithm terminates in at most𝑂(𝑛)time.

In the following, we provide a running example of Algorithm2.

Example 2.5.1. Consider a sequencec = (1,1,0,0,1,0,1,0), where the first and the 6-th bits are deleted, resulting in d = (1,0,0,1,1,0). Then 𝑛 = 8, 1₁₀(c) = (0,1,0,0,1,0,1), 𝑓(c) = (14,46,200), and 1₁₀(d) = (1,0,0,0,1). Hence 𝑎₀ = 8, 𝑎₁ =30, 𝑎₂=144.

Then, Algorithm2proceeds in the following manner. The underlined bits denote the inserted bits to1₁₀(d).

𝑖=1, 𝑗 =14, 𝑝_𝑖 = 𝑝_𝑗, 𝑥₀ =7, 𝑥₁=28, 𝑥₂=140

→𝑖=2, 𝑗 =14, 𝑤(d, 𝑖, 𝑗) =(1,0,0,0,1,0,1), 𝑥₀=7, 𝑥₁=28, 𝑥₂=140

→𝑖=3, 𝑗 =14, 𝑤(d, 𝑖, 𝑗) =(1,0,0,0,0,1,1), 𝑥₀=8, 𝑥₁=34, 𝑥₂=176,

→𝑖=4, 𝑗 =14, 𝑤(d, 𝑖, 𝑗) =(1,0,0,0,0,1,1), 𝑥₀=8, 𝑥₁=34, 𝑥₂=176,

→𝑖=5, 𝑗 =14, 𝑤(d, 𝑖, 𝑗) =(1,0,0,0,0,1,1), 𝑥₀=8, 𝑥₁=34, 𝑥₂=176,

→𝑖=6, 𝑗 =14, 𝑤(d, 𝑖, 𝑗) =(1,0,0,0,0,1,1), 𝑥₀=8, 𝑥₁=34, 𝑥₂=176,

→𝑖=7, 𝑗 =14, 𝑤(d, 𝑖, 𝑗) =(0,1,0,0,0,1,1), 𝑥₀=9, 𝑥₁=36, 𝑥₂=180

→𝑖=7, 𝑗 =13, 𝑤(d, 𝑖, 𝑗) =(0,1,0,0,0,1,1), 𝑥₀=9, 𝑥₁=36, 𝑥₂=180

→𝑖=7, 𝑗 =12, 𝑤(d, 𝑖, 𝑗) =(0,1,0,0,1,0,1), 𝑥₀=8, 𝑥₁=30, 𝑥₂=144

Recover the original sequence c

Let (𝑖, 𝑗) be the output of Algorithm2, for which we have that𝑤(d, 𝑖, 𝑗) =1₁₀(c).

Letc^′be a length𝑛supersequence after two insertions todsuch that1₁₀(c^′) =1₁₀(c).

If 𝑏_𝑖 = 1, then inserting 𝑏_𝑖 to 1₁₀(d) corresponds to either inserting a 0 to d as the𝑝_𝑖+1-th bit inc^′or inserting a 1 todas the𝑝_𝑖-th bit inc^′(see Table2.1). If𝑏_𝑖 =0, then inserting𝑏_𝑖 to1₁₀(d) corresponds to inserting a 0 or 1 in the first 0 run or 1 run respectively after the𝑘^′-th bit inc^′, where 𝑘^′ =max𝑘{𝑤(d, 𝑖, 𝑗)𝑘 = 1, 𝑘 < 𝑝_𝑖} is the index of the last 10-pattern that occurs before the 𝑝_𝑖-th bit in c^′. The same arguments hold for the insertion of𝑏_𝑗.

Therefore, given the (𝑖, 𝑗) pair that Algorithm 2 returns, there are at most four possible c^′ supersequences of d such that 1₁₀(c^′) = 1₁₀(c). One can check if thec^′sequences satisfy ℎ(c). According to Theorem2.1.2, there is a unique such sequence, the original sequencecthat satisfies both 𝑓(c)andℎ(c)simultaneously.