Low-complexity codes with instantaneous encoding

Chapter IV: Causal joint source-channel coding with feedback

4.7 Low-complexity codes with instantaneous encoding

(i)Type update: At each timet, the algorithm first updates the types. Att= 1, the algorithm is initialized with one typeS₁ ≜ [q]^N(1). Att=t_n,n = 2, . . . , k, the al- gorithm updates all the existing types by appending every sequence in[q]^{N(t)−N(t−1)} to every sequence in the type. After the update, the length of the source sequences in each type is equal toN(t); the cardinality of each type is multiplied byq^{N(t)−N(t−1)}; the total number of types remains unchanged. At t ̸= t_n, n = 1,2, . . . , k, the algorithm does not update the types.

(ii)Prior update: Once the types are updated, the algorithm proceeds to update the prior of the source sequences in each existing type. The priorθS_j(y^t−1),j = 1,2, . . . of the source sequences in typeS_j is fully determined by (4.22) with θ_i(y^t−1) ← θSj(y^t−1),P_S^N(t)_|S^N(t−1)(·|·) ←

1 q

N(t)−N(t−1)

, andρ_i^N(t−1)(y^t−1) ←ρSj(y^t−1). If the types are not updated, the priors are equal to the posteriors, i.e., θ_Sj(y^t−1) ← ρ_Sj(y^t−1),j = 1,2, . . .

(iii)Group partitioning: Using all the existing types and their priors, the algorithm determines a partition{G_x(y^t−1)}x∈X that satisfies the partitioning rule (4.24) via a type-based greedy heuristic algorithm. It operates as follows. It initializes all the groups{Gx(y^t−1)}x∈X by empty sets and initializes the group priors{πx(y^t−1)}x∈X

by zeros. It forms a queue by sorting all the existing types according to priors θ_Sj(y^t−1), j = 1,2, . . . in a descending order. It moves the types in the queue one by one to one of the groups{G_x(y^t−1)}x∈X. Before each move, it first deter- mines a group G_x^∗(y^t−1) whose current prior π_x^∗(y^t−1)has the largest gap to the corresponding capacity-achieving probabilityP_X^∗(x^∗),

x^∗ ≜arg max

x∈X P_X^∗(x)−π_x(y^t−1). (4.64) Suppose the first type in the sorted queue, i.e., the type whose sequences have the largest prior, isS_j. It then proceeds to determine the number of sequences that are moved from typeS_j to groupG_x^∗(y^t−1)by calculating

n ≜

P_X^∗(x^∗)−π_x^∗(y^t−1) θSj(y^t−1)

. (4.65)

If n ≥ |S_j|, then it moves the whole type S_j to group G_x^∗(y^t−1); otherwise, it splits S_j into two types by keeping the smallest or the largest n consecutive1 (in lexicographic order) sequences inSj and transferring the rest into a new type, and

1This step ensures that all sequences in a type are consecutive. Thus, as we will discuss in the last paragraph in Section4.7, it is sufficient to store two sequences, one with the smallest and one with the largest lexicographic orders, in a type to fully specify that type.

it moves typeS_j to groupG_x^∗(y^t−1)and moves the new type to the beginning of the queue. It updates the priorπ_x^∗(y^t−1)after each move.

(iv)Randomization: The type-based instantaneous encoding algorithm implements the randomization in (4.25)–(4.30) with respect to a partition{G_x(y^t−1)}x∈X. (v) Posterior update: Upon receiving the channel output Y_t = y_t, the algorithm updates the posterior of the source sequences in each existing type. The posterior ρSj(y^t), j = 1,2, . . . of the source sequences in type S_j is fully determined by (4.32) withρ_i(y^t)←ρ_Sj(y^t),θ_i(y^t−1)←θ_Sj(y^t−1).

Using (4.65) and AppendixC.1, we conclude that the type-based greedy heuristic algorithm ensures (4.24).

We show that the complexity of the type-based instantaneous encoding phase is log- linearO(tlogt) at times t = 1,2, . . . , tk. We first show that the number of types grows linearly, i.e.,O(t). Since the type update in step (i) does not add new types, the number of types increases only due to the split of types during group partitioning in step (iii). At most|X |types are split at each time. This is because the ceiling in (4.65) ensures that the group that receives thensequences from a split type will have a group prior no smaller than the corresponding capacity-achieving probability, thus the group will no longer be the solution to the maximization problem (4.64) and will not cause the split of other types. We proceed to analyze the complexity of each step of the algorithm. Step (i) (type update) has a linear complexity in the number of types, i.e.,O(t). This is because the methods of updating and splitting a type in steps (i) and (iii) ensure that the sequences in any type are consecutive, thus it is sufficient to store the starting and the ending sequences in each type to fully specify all the sequences in that type. As a result, updating a type is equivalent to updating the starting and the ending sequences of that type. Step (ii) (prior update) and step (v) (posterior update) have a linear complexity in the number of types, i.e., O(t). Step (iii) (group partitioning) has a log-linear complexity in the number of types due to type sorting, i.e., O(tlogt). This is because the average complexity of sorting a sequence of numbers is log-linear in the size of the sequence [103]. Step (iv) (randomization) has complexityO(1)due to determining{px→x}_x∈X(yt−1),x∈X(y^t−1)

in (4.27)–(4.28).

Type-based instantaneous SED codes for deterministic arrivals

We present type-based codes for the anytime instantaneous SED code in Section4.5 and for the instantaneous SED code restricted to transmitksymbols in Section4.5,

respectively.

The type-based anytime instantaneous SED code for a symmetric binary-input DMC operates at timest= 1,2, . . .:

(i^′) Type update: At each time t, the algorithm updates types as in step (i) with k =∞.

(ii^′)Prior update: The algorithm updates the prior of the source sequences in each existing type as in step (ii) withk =∞.

(iii^′)Group partitioning: Using all the existing types and their priors, the algorithm determines a partition{G_x(y^t−1)}x∈{0,1}using anapproximatinginstantaneous SED rule that mimics the exact rule in (4.43)–(4.44) as follows. It forms a queue by sorting all the existing types according to priors θSj(y^t−1), j = 1,2, . . . in a descending order. It moves the types in the queue one by one to G0(y^t−1) until π0(y^t−1) ≥ P_X^∗(0) = 0.5for the first time. Suppose the last type moved to G0(y^t−1)isSj. To make the group priors more even, it then calculates the number of sequencesn to be moved away fromS_j as

n ≜arg min

n∈{n,¯n}

π₀(y^t−1)−nθS_j(y^t−1)

− π₁(y^t−1) +nθS_j(y^t−1)

, (4.66a) n ≜

π0(y^t−1)−0.5 θS_j(y^t−1)

, (4.66b)

¯ n ≜

π₀(y^t−1)−0.5 θS_j(y^t−1)

. (4.66c)

It splitsS_j into two types by transferring the first or the lastn(4.66a) lexicograph- ically ordered sequences in S_j to a new type. It moves the new type and all the remaining types in the queue toG1(y^t−1).

(iv^′) The randomization step in (iv) is dropped.

(v^′)Posterior update: The algorithm updates the posteriors of the source sequences in each existing type. The posteriorρS_j(y^t), j = 1,2, . . ., is fully determined by (4.45) withρ_i(y^t)←ρS_j(y^t),θ_i(y^t−1)←θS_j(y^t−1).

(vi^′) Decoding at timet: To decode the first k symbols at timet, wherek can be any integer that satisfies t_k ≤ t, the algorithm first finds the type whose source sequences have the largest posterior. Then, it searches for the most probable length- k prefix in that type by relying on the fact that sequences in the same type share the same posterior; thus, the prefix shared by the maximum number of sequences

is the most probable one. Namely, the algorithm extracts the length-k prefixes of the starting and the ending sequences, denoted by i^k_start and i^k_end, respectively. If i^k_start =i^k_end (Fig.4.8-a), then the decoder outputs Sˆ_t^k = i^k_start. Ifi^k_start andi^k_end are not lexicographically consecutive (Fig.4.8-b), then the decoder outputs a length-k prefix in between the two prefixes. Ifi^k_startandi^k_endare lexicographically consecutive (Fig.4.8-c), then the algorithm computes the number of sequences in the type that have prefixi^k_startand the number of sequences in the type that have prefixi^k_endusing the last N(t)−k symbols of the starting and the ending sequences; the decoder outputs the prefix that is shared by more source sequences.

000 000 ...

000

0010000 0010001

...

0110000

000 000 001

1111110 1111111 0000000

... ...

001 1111111 010 0000000

010 010 011

1111110 1111111 0000000 011 0000001 011 0000010

(a) (b) (c)

Figure 4.8: Tables(a),(b),(c)represent three types at timet. Each row represents a source sequence in the type. The first row and the last row in each type represent the starting sequence and the ending sequence in that type, respectively. The first column represents the length-kprefix of sequences in the type. The source sequences in a type are lexicographically consecutive due to the methods of updating and splitting a type in steps (i^′) and (iii^′). In (a), since i^k_start = i^k_end = 000, the most probable sequence is000. In(b), sincei^k_start = 000andi^k_end = 010are not lexicographically consecutive, the most probable prefix is001. In(c), sincei^k_start = 010andi^k_end= 011 are lexicographically consecutive, the number of sequences with prefixi^k_startcan be computed by subtracting1111110, the lastN(t)−ksymbols of the starting sequence, from 1111111 and adding 1; the number of sequences with prefixi^k_end is equal to the lastN(t)−k symbols of the ending sequence plus1. Since(c)contains more sequences with prefix011, this is the most probable prefix.

We proceed to show that the complexity of the type-based anytime instantaneous SED code isO(tlogt). Similar to the type-based instantaneous encoding phase in Section 4.7, the number of types grows linearly with time t since the number of types increases only if a type is split in step (iii^′), and at most1type is split at each timet. The complexities of steps (i^′), (ii^′), (v^′) are all linear in the number of types O(t)due to the discussion at the end of Section 4.7. The complexity of step (iii^′) is log-linear in the number of types O(tlogt)due to sorting the types. Since the

sequences in a type are lexicographically consecutive due to the updating and the splitting methods in steps (i^′) and (iii^′), it suffices to use the starting and the ending sequences in a type to determine the most probable prefix in that type. Thus, the complexity of step (vi^′) is linear in the number of types due to searching for the type whose sequences have the largest posterior.

Restricting the type-based anytime instantaneous SED code described above to transmit only the firstk symbols of a DSS is equivalent to implementing steps (i), (ii), (iii^′), (v) one by one, and performing decoding as follows.

(vi^′′)Decoding and stopping: If there exists a typeS_j that satisfiesρ_Sj(y^t)≥1−ϵ and contains a source sequence of length k, then the decoder stops and outputs a sequence in that type as the estimateSˆ_η^k

k.

The complexity of the type-based instantaneous SED code for transmittingksymbols remains log-linear, O(tlogt), since the complexity of step (vi^′′) is O(t) due to searching for the type that satisfies the requirements.

While the type-based instantaneous encoding phase in Section 4.7 is the exact algorithm of the instantaneous encoding phase in Section4.3, the type-based anytime instantaneous SED code and the type-based instantaneous SED code for transmitting ksymbols areapproximationsof the original algorithms in Sections4.5and4.5due to two reasons below:

First, in step (iii^′) (group partitioning), we use the approximating instantaneous SED rule to mimic the exact rule in (4.43)–(4.44). The minimum of the objective function in (4.66a) is equal to the difference|π₀(y^t−1)−π₁(y^t−1)|between the group priors of the partition{G_x(y^t−1)}x∈{0,1} obtained by the approximating rule in step (iii^′).

The difference is upper bounded as (AppendixC.14)

|π₀(y^t−1)−π₁(y^t−1)| ≤θ_Sj(y^t−1), (4.67) whereS_j is the last type moved toG₀(y^t−1)so that its group prior exceeds0.5for the first time. Ifπ₀(y^t−1) ≥π₁(y^t−1), (4.67) recovers (4.44) sinceθS_j(y^t−1)is the smallest prior inG₀(y^t−1), thus the approximating instantaneous SED rule recovers the exact rule. Ifπ0(y^t−1) < π1(y^t−1), θSj(y^t−1)on the right side of (4.67) is the largest prior inG1(y^t−1), violating the right side of (4.44).

We use the approximating algorithm of the instantaneous SED rule (4.43)–(4.44) since it is unclear how to implement the exact instantaneous SED rule with polyno- mial complexity. In the worst case, the complexity of the latter is as high as double

exponential O 2^qN(t)

due to solving a minimization problem via an exhaustive search [45, Algorithm 1]. An exact algorithm for the SED rule with exponential complexity in the source length is given by [45, Algorithm 2].

Second, in step (vi^′) (decoding at timet) of the type-based anytime instantaneous SED code, we only find the most likely length-k prefix in the type that achieves max_jρ_Sj(y^t), yet it is possible that this prefix is not the one that has the globally largest posterior (4.46). To search for the most probable length-kprefix, one needs to compute the posteriors for allq^kprefixes of lengthkusingO(t)types, resulting in an exponential complexityO(q^kt)in the length of the prefixk, whereas the complexity of step (vi^′) is onlyO(t)independent ofk.

Although the type-based instantaneous SED code is an approximation, as we are about to see in Fig.4.10Section4.8, it is almost as good as the exact code.

Type-based instantaneous SED code for random arrivals

We generalize the type-based instantaneous SED code for deterministic arrivals in Section4.7to random arrivals. We assume that a DSS with random arrivals emits a sequence of equiprobable bitsS_n ∈ {0,1}, n = 1,2, . . . following a Bernoulli-δ process2, i.e.,∀b ∈ {0,1},s∈ Q_t,

P_S1(0) =P_S1(1) = 0.5, (4.68a) P_S^N(t+1)_|S^N(t)(s⊞b|s) = δ

2, t≥1. (4.68b)

We call a binary sequence s1 theparent of a binary sequence s2 if s1 = s2⊟, and call a typeS_itheparentof a typeS_j if all the parents of the strings inS_j are inS_i. We denote byp(j)the index of the parent ofS_j, e.g.,p(j) = i.

The type-based code for random arrivals differs from the type-based codes for deterministic arrivals in that it creates new types at each time while keeping the parent types. The type-based codes for deterministic arrivals in Section 4.7 need not introduce the concept of parent types since the deterministic symbol arriving times imply that the lengths of all the source sequences at timetare the same.

The type-based instantaneous SED code for random arrivals operates at timet = 1,2, . . . as follows.

2The symbol arriving probability distribution must satisfy that P_SN(t+1)|S^N(t)(s⊞0|s) = P_SN(t+1)|S^N(t)(s⊞1|s), otherwise, the binary sequences in a type will not share the same prior probability. The type-based instantaneous SED code continues to apply ifδin (4.68) is time-varying and/or has memory.

(i^′′′)Update types: Att= 1, the encoder and the decoder create two typesS₁ ≜{0}, S₂ ≜{1}. Att ≥2, each type created at timet−1generates a new type by appending a 0and a 1to every binary sequence in that type, and the types that have already been created by time t−1 are kept. If the goal is to transmit the first k symbols only, then the algorithm stops creating new types at timest ≥k+ 1; otherwise, the algorithm keeps creating new types at each timet.

(ii^′′′) Prior update: Once the types are updated, the algorithm proceeds to update the prior of the binary sequences in each existing type. The priorθSi(y^t−1)(4.55), i = 1,2, . . . is fully determined by ρ_Si(y^t−1), ρ_Sp(i)(y^t−1)and the symbol arrival probability distribution (4.68).

(iii^′′′) Group partitioning: The algorithm implements the approximating instanta- neous SED rule in step (iii^′). Note that the types whose parent type is split may have two parents. To ensure that each type has one valid parent, we recursively search for the types whose binary sequences have parents from more than one type and split them accordingly. This guarantees that the posterior ρ_p(k)(t), k = 1,2, . . ., t= 1,2, . . . is deterministic.

(iv^′′′)Updating posteriors: The posteriorρS_i(y^t)(4.45),i= 1,2, . . . is fully deter- mined byθS_i(y^t−1), the channel transition probability,Y_t =y_t, and the group priors {π_x(y^t−1)}x∈{0,1}.

(v^′′′) The randomization step is dropped.

(vi^′′′) Decoding: The algorithm implements step (vi^′) as an anytime code, or it implements step (vi^′′) for transmittingksymbols.

For a BSC, a heuristic analysis in AppendixC.15 shows that the number of types at time t is O(t²). Since steps (i^′′′)(ii^′′′)(iv^′′′)(vi^′′′) have a linear complexity in the number of types, i.e.,O(t²), and step (iii^′′′) has a log-linear complexity in the number of types, i.e.,O(t²logt), the complexity of the type-based instantaneous SED code for random arrivals isO(t²logt).

Similar to the type-based instantaneous SED code for deterministic arrivals, the type-based instantaneous SED code for random arrivals is an approximation of the original code in Section4.6 due to the use of the approximating instantaneous SED rule in step (iii^′′′). Yet, Fig. 4.11 below shows that the rate gap between the instantaneous SED code for random arrivals and its corresponding type-based code is negligible.