WO2018171110A1

WO2018171110A1 - Maximum likelihood decoding algorithm for tail-biting convolutional code

Info

Publication number: WO2018171110A1
Application number: PCT/CN2017/097667
Authority: WO
Inventors: 韩永祥; 吴庭伊; 陈伯宁; 瓦悉尼星巴
Original assignee: 东莞理工学院
Priority date: 2017-08-11
Filing date: 2017-08-16
Publication date: 2018-09-27
Also published as: CN107872232B; CN107872232A

Abstract

A maximum likelihood decoding algorithm for a tail-biting convolutional code, said algorithm comprising the following steps: (A) executing a Viterbi algorithm (VA) on a backward surrounding grid; obtaining information retained from a previous backward Viterbi algorithm (VA); (B) applying a priority search algorithm to a forward direction of all sub-grids. The advantageous effects are: an effective early stop standard is used, in order to reduce decoding complexity; a simulation of a (2,1,6) tail-biting convolutional code in an additive white Gaussian noise channel exhibits significant savings exceeding BEAST and CMLDA in terms of decoding complexity maximum value and variance.

Description

Maximum Likelihood Decoding Algorithm for New Type-End Convolutional Codes

[Technical Field]

The present invention relates to the field of data processing, and in particular to a novel maximum likelihood decoding algorithm MLWAVA for tailing convolutional codes.

【Background technique】

Since the invention of convolutional codes, they have been widely used to provide effective error prevention capabilities in digital communications. In the actual implementation of a convolutional encoder, a certain number of zeros are typically appended to the end of the sequence of information bits to clear the contents of the shift register so that the encoding process of the next sequence of information can be performed directly without initialization. These zero tail bits can enhance the error prevention capability of the convolutional code. For sufficiently long sequences of information, the rate loss due to these zero tail bits is almost negligible; however, when the information sequence is short, these zero tail bits introduce significant loss of code rate.

In the literature, several methods have been proposed to mitigate the loss of code rate of the above (short length) zero-tailed convolutional codes, such as direct truncation [1] and spurious [1] and appendix [2], [3], [4]. In particular, the trailer convolutional code overcomes the loss of code rate in a straightforward manner and causes a small performance degradation. This has been confirmed in the literature [1], which shows that the trailer convolutional code has better error prevention performance than the spurious and zero-tailed convolutional codes. Unlike a zero-tail convolutional encoder that always starts at the all-zero state, the trailer convolutional encoder only ensures that the initial state and the final state are the same (where a particular state is determined by the input data). Since any state may be the initial state of the trailer convolutional encoder, the decoding complexity increases dramatically.

Similar to the decoding of the zero-tail convolutional code, the decoding of the tail convolutional code is performed on the grid, and the codeword through the grid now corresponds to the path starting and ending in the same (not necessarily all-zero) state. For convenience, a path having the same initial state and final state on the trailer convolutional code grid is referred to as a trailing path. Since there is a one-to-one correspondence between "codewords" and "tailing paths", these two terms are used interchangeably herein.

Let the number of all possible initial states (equivalent to the final state) of the trailer convolutional code grid be N _s . Then, the mesh can be decomposed into N _s sub-grids with the same initial state and final state. According to the previous naming convention, these sub-grids are called the tail sub-grid, or if there is no ambiguity caused by the abbreviation, it can be called a simple sub-grid. For convenience, the convolutional code representing a xianwei grid and which represents a k-th sub-cell by T _k with T. It can be clearly seen that the decoding complexity of the trailer convolutional code will be multiplied by a similarly sized zero-tail convolutional code because all trailing paths in each sub-grid must be examined.

In order to reduce the decoding complexity, several sub-optimal decoding algorithms for the tailing convolutional codes have been proposed in the literature [2], [3], [5], [6], [7], and surround these algorithms. The decoding complexity of the Viterbi algorithm (WAVA) is minimal [2]. Conceptually, WAVA repeatedly applies the Viterbi algorithm (VA) to the grid of the trailer convolutional code in a round-robin fashion. During its execution, the WAVA not only checks the trailing path but also the trails starting and ending in different states; therefore, it may result in a path without a codeword. WAVA can be viewed equally as an application of VA on a "supergrid" with a pre-specified number in series Formed by a grid of connected to each other. By simulation, it is enough to wrap up to four grids to obtain approximate optimal performance [2].

In the case where optimal decoding performance is required, WAVA is no longer a suitable choice because it cannot guarantee that the Maximum Likelihood (ML) trailing path will always be found. By performing VA on all trailing sub-lattices, the ML end-of-the-path can be obtained directly; however, this powerful method is impractical due to its high computational complexity.

In 2005, Bocharova et al. proposed an ML decoding algorithm for tailing convolutional codes, which is called the bidirectional efficient algorithm (BEAST) of the search tree [8]. Conceptually, BEAST repeatedly and simultaneously explores specific nodes in both forward and backward directions, and these nodes have decoding metrics below a certain threshold on each subgrid. It increments the threshold continuously in each step until it finds an ML path. The simulation results provided in [8] show that BEAST has very low decoding complexity and is effective at high signal-to-noise ratio (SNR).

A year later, Shankar et al. [9] proposed another ML decoding algorithm for tailing convolutional codes, which is called the Creative Maximum Likelihood Decoding Algorithm (CMLDA) for convenience. CMLDA has two phases. The first stage applies VA to the mesh of the trailer convolutional code to obtain some grid information. Based on these grid information, the algorithm A* will execute in parallel on all sub-grids of the second stage to generate ML decisions. As demonstrated in [9], CMNDA reduces the decoding complexity from the number of N _s VA implementations required for the robust approximation method to approximately 1.3 times the number of VA executions without sacrificing performance optimality. In order to seek further improvements in CMLDA in terms of decoding complexity, the authors of [10] and [11] have redefined the heuristic functions given in [9]. The former algorithm [10] proposes to apply the backward VA in the first phase instead of applying the VA in the forward mode as described in [9] and [11]. This article provides an important extension of [10] and considers multiple iterations of backward VA in the first phase.

Recently, Wang et al. proposed another ML decoding algorithm that does not use a stack [12]. It compares the survivor path between two consecutive WAVA iterations, and whenever the critical surviving path described in [12] is "captured" on the non-ML path, it will start VA on the particular tail subgrid. . However, the decoding complexity result of [12] is much higher than [9].

[Summary of the Invention]

In order to solve the problems in the prior art, the present invention provides a novel maximum likelihood decoding algorithm for tailing convolutional codes, which solves the problem of high maximum decoding complexity in the prior art.

The invention is realized by the following technical solutions: a novel maximum likelihood decoding algorithm for designing and manufacturing a novel tailing convolutional code, comprising the following steps: (A) performing a Viterbi algorithm VA on a backward surrounding grid; The information retained by the VA round of the Viterbi algorithm before and after; (B) The priority-first search algorithm is applied to the forward direction of all sub-grids.

As a further improvement of the present invention, in the step (A), the backward surround Viterbi algorithm WAVA is applied to the trailing convolutional code grid T, and the trailing path is checked and the auxiliary super code is checked.

All paths in .

As a further improvement of the present invention: the auxiliary super code

By grid

All the paths on it, among them,

Representing a (n, 1, m) trailer convolutional code having L information bits, the target convolution map is limited from 1 information bit to n code bits, and m is the memory order.

As a further improvement of the present invention, the metric of the path in the grid T is set as follows: Let l be a fixed integer satisfying 0 ≤ l ≤ L, for a binary label

Path; it ends at level l in grid T, the path associated with it

The metric is defined as

among them

For the corresponding bit metric, the so-called cumulative metric for the path is the sum of the pre-specified initial metric and the associated path metrics associated therewith.

As a further improvement of the present invention, in the step (A), obtaining the maximum likelihood ML judgment is performed in the following manner: at the end of the first iteration, if the optimal backward survival path

Is a trailing path, then it is the ML decision, for the remaining iterations other than the first iteration, if

Suitable for each

among them

Is the best end-of-life path for the end-to-WAVA until the end of the end-of-life path encountered by the i-th iteration.

It is the ML decision.

As a further improvement of the present invention, in the step (B), two data structures are used for the priority-first search algorithm, the two data structures are an open stack and a closed table; the open stack is stored by the priority-first search algorithm so far. The accessed path, the closed table tracks those paths that were previously at the top of the open stack.

As a further improvement of the present invention, the plurality of sub-grids backward survival paths obtained from the step (A) are sorted according to the ascending order of their cumulative metrics, and the maximum likelihood ML judgment is obtained and the algorithm is stopped.

As a further improvement of the present invention: an effective early stop criterion is employed to reduce decoding complexity.

The beneficial effects of the present invention are: using an effective early stopping criterion to reduce decoding complexity; in the additive white Gaussian noise channel, the simulation involving the (2, 1, 6) trailer convolutional code has a maximum decoding complexity and Variances have shown significant savings beyond BEAST and CMLDA.

[Description of the Drawings]

Figure 1 is used for [24, 12, 8] extended Golog code and [96, 48, 10] block code WAVA (2) and ML decoder (such as MLWAVA, TDMLA, CMDDA or BEAST) word error rate (WER );

Figure 2 is a variance of the number of calculations per information bit branch metric for the [24, 12, 8] extended Golay code decoding algorithm shown in Table I;

Figure 3 is a variance of the number of calculations per information bit branch metric for the [96, 48, 10] block code decoding algorithm shown in Table I;

4 is an ML decoder word error rate (WERs) of [192, 96, 10] and [96, 48, 16] block codes;

Figure 5 is an average calculated number of information bit branch metrics for the [24, 12, 8] extended Golay code decoding algorithm shown in Table I;

Figure 6 is an average calculated number of information bit branch metrics for the [96, 48, 10] block code decoding algorithm shown in Table I;

Figure 7 is an average calculated number of information bit branch metrics for the [192, 96, 10] block code decoding algorithm shown in Table II;

Figure 8 is the average number of calculations per information bit branch metric for the [96, 48, 16] block code decoding algorithm shown in Table II.

【detailed description】

The invention will now be further described with reference to the drawings and specific embodiments.

A novel maximum likelihood decoding algorithm for tail-end convolutional codes includes the following steps: (A) performing a Viterbi algorithm VA on a backward-surrounded grid; acquiring information retained by a previous-to-after Viterbi algorithm VA round (B) Apply the priority-first search algorithm to the forward direction of all sub-grids.

In the step (A), the backward surround Viterbi algorithm WAVA is applied to the trailing convolutional code grid T, and the trailing path is checked and the auxiliary super code is checked.

All paths in .

The auxiliary super code

By grid

All the paths on it, among them,

The metric of the path in the grid T is set as follows: Let l be a fixed integer satisfying 0 ≤ l ≤ L, for a binary label

path of;

It ends at level l in grid T, and its associated path metric is defined as

among them

In the step (A), obtaining the maximum likelihood ML judgment is performed in the following manner: at the end of the first iteration, if the optimal backward survival path

Suitable for each

among them

It is the ML decision.

In the step (B), two data structures are used to perform a priority-first search algorithm, two data structures are an open stack and a closed table; the open stack stores a path that has been accessed so far by a priority-first search algorithm, and the closed table Track those paths that were previously at the top of the open stack.

The plurality of sub-grids backward survival paths obtained from the step (A) are sorted according to the ascending order of the cumulative metrics, and the maximum likelihood ML judgment is obtained and the algorithm is stopped.

Use effective early stop criteria to reduce decoding complexity.

The present invention proposes a novel maximum likelihood WAVA (MLWAVA) decoding algorithm for tailing convolutional codes. Unlike WAVA, MLWAVA's super mesh is conceptually formed by connecting meshes in a backward fashion. Specifically, MLWAVA first performs VA on the backward-surrounded grid, and then applies the priority-first search algorithm to the forward direction of all sub-grids based on the information retained from the previous to the VA round. Note that the priority-first search algorithm is a simplified version of algorithm A*. Similar to the ML decoding algorithm in [9], MLWAVA can also be regarded as a two-stage decoding algorithm, in which the backward execution of VA and the forward execution of the priority-first search algorithm are regarded as the first and second stages, respectively. Nevertheless, this paper designs a new ML decoding metric and a new evaluation function for the first and second phases respectively. In addition, it proposes an effective early stop criterion for each of the two phases to further reduce decoding complexity. The simulation results for the (2,1,6) trailer convolutional code with information length of 48 indicate that the average decoding complexity of MLWAVA is less than the average of ML decoding algorithm in [9] and [12] at SNR _b = 4 dB. The decoding complexity, where SNR _b represents the signal to noise ratio per information bit. Although the average decoding complexity of BEAST at high SNR is better than MLWAVA, the variance of decoding complexity of MLWAVA is 7234 times lower than that of BEAST at SNR _b = 4 dB. This makes MLWAVA a better choice between the two when the decoding delay time is the focus of attention. Compared to the near-optimal WAVA [2], the optimal MLWAVA is lower in both the average and maximum decoding complexity.

make

An (n, 1, m) trailer convolutional code having L information bits is represented, wherein for simplicity only the target convolution map is limited from 1 information bit to n code bits, and m is the memory order. Such a system may also be referred to as a [nL, L, d _min ] block code. ¹ based on this setting, the end convolutional code

The grid T has N _s = 2 ^m states at each level and has L+1 levels. Although only the restriction path that limits itself to the same initial state and final state corresponds to

Codeword, but introduced an auxiliary super code

Grid

All the paths on it are composed, and the grid can now start and end in different states.

May wish to use

To represent

Binary codeword, where N=nL. A hard decision sequence y=(y ₀ , y ₁ , . . . , y _N-1 ) corresponding to the reception vector r=(r ₀ , r ₁ , . . . , r _N− ₁ ) is defined as

among them

The y corrector is correspondingly

Given, where

Yes

Equivalent block code parity check matrix. Let E(s) be the set of all error patterns whose syndrome is s. Then the ML decoding output of the received vector r

equal

among them

Satisfy

and

Addition for modulo 2. The metric of the path in the grid T is thus defined as follows.

Definition 1: Let l be a fixed integer satisfying 0 ≤ l ≤ L. For a binary tag

Path; it ends at level l in grid T, defining the path metric associated with it as

¹ because a trailer code with a specific length is also a block code. So [nL, L, d _min ] is used throughout the text to represent the trailer convolutional code as a block code form, where d _min represents the minimum pairwise Hamming distance of the code.

among them

Is the corresponding bit metric. The so-called cumulative metric for this path is the sum of the pre-specified initial metrics and the above-mentioned path metrics associated with it. Note that the initial metric is zero for the first WAVA iteration and is set to a specific value based on the previous iteration of the iteration (except for the first iteration).

Since the backward VA is performed instead of the forward VA in the proposed decoding algorithm, the definition of the definition of the backward VA can be obtained in a straightforward manner. For example, with tags

The metric associated with the backward path is given by

Thus, the cumulative metric for the backward path is the sum of the initial metric specified for the starting state at level L and the associated metric given above. It should be emphasized that a binary tag can uniquely determine the path and its start and end states.

As mentioned in the introduction, the proposed algorithm can be divided into two phases. In the first phase, the backward WAVA is applied to the grid T, which not only checks the trailing path but also checks

All paths in . Then each N _s state at level l in the ith WAVA iteration has a VA backward survival path, and if the backward survival path (at level l) ends,

Then the associated cumulative metric can be

Said. Please note,

Will be set to the initial metric of the state at level L at the beginning of the (i+1)th WAVA iteration; therefore, the label is the backward of x _[ln] =(x _N-1 ,...,x _ln ) Survival path will have cumulative metrics

among them

And s are the initial state of the backward survival path at the level L and the end state at the level l, respectively. All metrics

(where s ∈ S, 0 ≤ l ≤ L and 1 ≤ i ≤ I) are reserved for future use in the second phase. Here, I is the maximum number of WAVA iterations performed. At the end of the first phase, a N _s backward survival path at level 0 (instead of level L) will be generated. Again, these backward survival paths are only guaranteed to exist in

Medium but may not be

The code word in .

Some of the symbols that are subsequently used in the description of the algorithm to the WAVA are described below. The label of the best backward survival path is the smallest cumulative path metric in all backward survival paths at the end of the i-th WAVA iteration,

Said. Optimal backward survival path

Associated cumulative metric

Said. Similarly, if the best end-of-life path corresponding to the end of the ith WAVA iteration exists, use

To express it and use

To represent its associated cumulative path metric. make

with

Separately

with

The labels with the smallest cumulative metrics, and their cumulative path metrics are represented as

with

. The following theorem is a modified version of the theorem in [2], which provides an early stop criterion to WAVA after iteration.

Theorem 1 ([2]): at the end of the first iteration, if the best backward survival path

Is a trailing path, then it is the ML decision. For the remaining iterations other than the first iteration, if

Suitable for each

among them

Is the set of all end states of the trailing survival path (at level 0) that is followed by the WAVA until the i-th iteration, then the best end-of-life path

It is the ML decision.

From Theorem 1, the ML decision may be found before the backward WAVA reaches the maximum number of iterations; therefore, the decoding complexity can be reduced. Considering the integrity, the following algorithm steps are proposed to the WAVA, which is basically the same as the WAVA. The different aspects are: it performs in a backward manner and needs to record the path metric.

Where s∈S, 0≤l≤L and 1≤i≤I.

Step 1: Initialize for each state s ^s∈S

Step 2: Apply the VA backwards mode to the grid T, ie from level L back to level 0. From l=L-1 down to l=0, record for each state s at level l

. Find

And if

Exist, also find together.

Step 3: If

Then

The output is an ML decision and the algorithm is stopped.

Step 4: If I=1, stop the algorithm.

Step 5: Let i=2.

Step 6: Initialize for each state s∈S

Step 7: Apply the VA backwards mode to the grid T, ie from level L back to level 0. From l=L-1 down to l=0, record for each state s at level l

. Find

And if

Exist, also find together.

Step 8: If

Meet the stopping criteria in (3), then

The output is an ML decision and the algorithm is stopped.

Step 9: If i < I, execute i = i + 1 and go to step 6; otherwise, stop the algorithm.

Before continuing to introduce the decoding algorithm of the second stage, an important fact should be mentioned. Obviously, if the ML decision is not output to the WAVA after 1 iteration, then

An upper bound above the metric determined by ML. This fact will be used to accelerate the second phase. Again, unlike the first-stage mode operation in the grid T, the second-stage forward approach applies priority-first search decoding to all N _s tail sub-grids. This ensures that the output of the second phase is always

The code word in .

For a path on the subgrid T _k with a label x _k,(ln-1) =(x _k,0 ,x _k,1 ,...,x _k,ln-1 ), a new associated with it The evaluation function is given as follows:

f(x _k,(ln-1) )=g(x _k,(ln-1) )+h(x _k,(ln-1) ), (4)

According to definition 1,

Has an initial value g(x _k,(-1) )=0, and

In (6), s is the forward path x _k, the state at which _(ln-1) ends (at level l), and s _k is the single initial (and final) state of the grid T _k . It can be seen that f(x _k,(N-1) )=g(x _k,(N-1) ), because

Therefore, the trailing path with the smallest f-function value is the trailing path with the smallest ML metric in (2).

The priority-first search algorithm requires two data structures. The first is called an open stack, which stores the paths that have been accessed so far by a priority-first search algorithm. The other is called a closed table, which tracks those paths that were previously at the top of the open stack at some point in time. The reason they are so named is that the path in the open stack may be further extended and thus kept open in the future, while the paths in the closed table can no longer be expanded and therefore closed for future expansion. Next, the priority-first search algorithm for the N _s sub-grid is summarized below.

Step 1: Sort the N _s backward survival paths obtained from the first stage according to the ascending order of their cumulative metrics. If the backward survival path with the smallest cumulative metric is also a trailing path (starting at the same state), it is output as the final ML decision and the algorithm is stopped.

Step 2: If it exists, initialize

with

Otherwise, set c _UB = ∞ and x _UB to = null. Delete all backward survival paths whose cumulative metric is not less than c _UB .

Step 3: Load the initial zero length forward path of the subgrid into the open stack, which is consistent with the initial state of level 0 and any end state of the remaining backward survival paths. Arrange them in ascending order of the f-function values of these zero-length paths in the open stack.

Step 4: If the open stack is empty, output x _UB as the final ML decision and stop the algorithm. ²

Step 5: If the current top path in the open stack reaches level L in its corresponding subgrid, the path is output as the final ML decision and the algorithm is stopped.

Step 6: If the current top path in the open stack has been recorded in the closed list, discard it from the open table and go to step 4 otherwise; record information about the top path in the closed list. ³

Step 7: Calculate the f function value of the trailing path of the top path in the open stack. Then, remove the top path from the open stack. Delete those subsequent paths where the f function value ≥ c _UB .

Step 8: If a successor x _{k, (Ln-1)} reaches a level L with f(x _k,(Ln-1) )<c _UB , then update x _UB =x _k,(Ln-1) and c _UB =f(x _k,(Ln-1) ). Repeat the previous update until all subsequent elements that reach the level L are checked. Delete all subsequent elements that reach the level L.

Step 9: Insert the remaining subsequent paths into the open stack and reorder the open stack based on the ascending f function values. Go to step 4.

² Note that x _UB cannot be empty when the open stack is empty. This is because only when

When it does not exist, x _UB can be initially cleared in step 2, at which time c _UB = ∞. In this case, step 8 replaces x _UB with the first successor x _{k, (Ln-1)} , which reaches level L and the open stack must not be empty before the replacement. Therefore, when the open stack is forcibly cleared by deleting the path of the f function value ≥ c _UB , x _UB will never be empty.

³ Please note that in order to uniquely identify the path, only the start and end states and the end level need to be recorded in the closed table.

As can be seen from the above algorithm, the open stack is similar to the way the stack operates in the conventional sequential decoding algorithm. However, the introduction of closed tables is to eliminate the top path that ends in a state that was accessed at some previous time. It will be shown later in (8) that these top paths have worse f function values than the top paths that were previously accessed and ended in the same state; therefore, they can be eliminated directly to speed up the decoding process.

It is to be noted that the proposed MLWAVA can be applied to a generic (n, k, m) (where 1 < k ≤ n) trailer convolutional codes by employing its corresponding super-mesh and sub-mesh. In addition, one can also use the forward WAVA in the first phase and the priority in the second phase. Priority search. Considering that the decoder typically tends to list the output code bits in a forward manner, it is chosen to perform a priority-first search algorithm in a forward manner in the second phase.

Third, the early stop criteria of the priority search algorithm

In this section, the characteristics of the evaluation function f will be derived and subsequently used to speed up the priority-first search decoding algorithm. Starting with a lemma, this lemma is crucial for proving the main theorem 3 in this section.

Lemma 2: l to end in a horizontal path to the state s x _k T _k to the _{grid, (ln-1),}

If

The cumulative path metric to the surviving path after the start state at level L is s _{k is} recorded. ⁴

Proof: obviously, give

After the survival path after a valid grid T _k to the path, because it starts at the level of the state s _k L. Let x _{k, (N-1)} be the end of the combination of x _{k, (ln-1)} and this survival path. Suppose there is i ₂

For some i ₂ ≠i ₁ . Since the f function value is non-decreasing along all paths in the sub-grid T _k ,

f(x _k,(ln-1) )≤f(x _k,(N-1) )=g(x _k,(N-1) )+h(x _k,(N-1) ). (9 )

Can also be exported

⁴ Please note that passing the symbol

The parameter specified in this, the backward survival path must be obtained during the i1th WAVA iteration and must end at state s on level l.

Equations (9) and (10) are combined to show

This contradicts the definition of the function h, which ensures that h(x _k,(N-1) )=0.

Theorem 3: Let x _k,(ln-1) =(x _k,0 ,x _k,1 ,...,x _k,ln-1 ) open the current top path in the stack and use s to indicate its level The end state on l. Hypothesis

A backward survival path with a start state of s _k at level L and an end state of s at level l is recorded.

The cumulative path metric, which is obtained during the iteration i ₁ times WAVA. Then forward path x _{k, (ln-1)} and backward path

Merge to get the desired ML end trail, ie

Proof: make the path

For the path x _{k, (ln-1)} along the backward survival path

Immediately after the yuan, and

To indicate its end state. According to the backward WAVA, get

Then, the f function value of the path x _{k, ((l+1)n-1)} can be calculated as follows:

Among them, (12) has Lemma 2 implies, and (13) follows (11). Through a similar argument, it can be continuously proved that the value of the f function of each next posterior element along the backward path

constant. Because the top path x _k,(ln-1). has the smallest f function value among all the paths coexisting in the open stack, and the f function value is non-decreasing along all paths, the forward path x _{k is} combined _{, (ln-1)} and backward path

The ML tailing path is given, which has the smallest f-function value in all trailing paths of length N.

Theorem 3 then provides an early stop criterion for the second stage of the program step so that the priority-first search process does not necessarily have to reach level L to determine the final ML decision. Therefore, step 5 of the second phase can be modified accordingly by adding "if the value of the h function of the top path is determined by a backward survival path of the initial state of the top path (on the horizontal L) and the initial state of the top path, Then the combined path is output as an ML decision and the algorithm is stopped" to speed up the decoding algorithm.

It can be seen from the proof of Theorem 3 that the equivalence of f(x _k,((l+1)n-1) ) and f(x _k,ln-1) ) depends mainly on the validity of (12). Maximize

The number of WAVA iterations i ₁ should be identified. When the number of iterations I is equal to 1, i ₁ must be 1. In this case, the f-function value of the immediately following element along the backward survival path obtained from the first stage is always unchanged. Summarize this fact in the next inference.

Corollary 1: Fix the maximum number of WAVA iterations to I=1. Let path x _{k, (ln-1)} denote the current top path in the open stack, and denote its end state on level l with s. Assumed path

To end the backward survival path with state s on level l. then,

f(x _k,((l+1)n-1) )=f(x _k,(ln-1) ),

among them

The significance of Inference 1 is that when I=1, it can greatly speed up the priority-first search process of the second stage. Specifically, it can be confirmed that each sub-grid has all Ns states S ₀ , from horizontal m to horizontal Lm except horizontal 0 to (m-1) and horizontal (L-m+1) to L,... , S _Ns-1 , where m is the storage order of the (n, 1, m) trailer convolutional codes. Therefore, by the above inference, when the priority-first search algorithm will end at a horizontal current top path x _k between m and Lm _{, when (ln-1) is} expanded, one of its immediately following elements should have the top path The same f function value. The immediately following element of x _k with the same f-function value _{, (ln-1)} can then be quickly obtained from the backward survival path obtained from the first phase and should be the next top path. The calculation of the value of the post-e f function thus becomes unnecessary and can be saved.

Nonetheless, a top path ending at a level between 0 and m-1 does not necessarily have a immediately following element along the first stage backward survival path that satisfies the top path. This is because not all N _s states are available at levels 0 through m-1 in the subgrid. Therefore, for a top path ending at a level less than m, the original priority first search step should still be performed. On the other hand, when a path reaches the horizontal Lm, it has a unique trajectory along its corresponding sub-grid to level L; therefore, it can be extended directly to the horizontal L to form a length N-tailed path and pass Compare the f function value with the f function value in the open stack to test if the resulting end trail is the final ML decision.

It can be seen from Inference 1 that the second-stage process can be simplified to a depth-first algorithm, and the decoding complexity is greatly reduced. The seventh step of the second stage algorithm can be modified accordingly by the following additional conditions: if all remaining back elements end at a level less than m, then go to the next step (ie step 8); otherwise, do the following:

● Directly (after reaching the level m) the post-element sequentially extends to the horizontal Lm along the first-stage backward survival path, and sets the f-function value of the extended-length element of length (Lm)n to be just mn with the length. The values calculated by the original non-expanded elements are the same.

• Further extending the posterior element of length (L-m)n to the horizontal L along a unique trajectory located on its respective sub-grid, and calculating the f-function value of the generated N-length trailing path.

Recall that, as mentioned at the end of the second part, the proposed two-stage decoding algorithm can alternatively be implemented as a forward iterative WAVA followed by a priority-first search algorithm. While this alternative implementation is also optimal in performance, it may result in different decoding complexity for a given receive vector; on average, the decoding complexity of both algorithms should still be the same.

Given the reduced complexity, one can actually launch the proposed two-stage decoding algorithm at any pre-selected level of the grid, since the end-of-flight convolutional code grid is essentially "loop-like". An equivalent, but perhaps more straightforward, process is to renumber the selected starting level on the grid to level 0 by cyclically rotating the

horizontal series

0, 1, ..., L. The simulation in [13] shows that a certain degree of complexity reduction can be achieved if the starting level can be correctly selected based on the "reliability" of the received vector. For example, the starting level l*[13] can be selected as

For some λ that are properly chosen. It is worth noting that the selection of the starting level and its subsequent alignment should be performed before the start of the first phase algorithm, and its complexity is almost negligible compared to the decoding complexity of the two-stage decoding.

Fourth, through the simulation experiment of AWGN channel

In this part, the computational workload and word error rate of the proposed ML decoding algorithm are explored by means of analog, through an additive white Gaussian noise (AWGN) channel. It is assumed that the transmitted binary codeword u = (u ₀ , u ₁ , ..., u _N-1 ) is binary phase shift keying (BPSK) modulated. Therefore, the reception vector r = (r ₀ , r ₁ , ..., r _N-1 ) is given by

Where ε is the signal power per channel bit, and

It is an independent noise sample for a white Gaussian process with a single-sided noise power of N ₀ per Hertz. Therefore, the signal-to-noise ratio (SNR) consists of

Given. In order to address code redundancy at different code rates, the SNR per information bit is used in the following discussion, ie

Note that for an AWGN channel, the metric associated with path x _(ln-1) in Definition 1 can be equivalently simplified to

Two (2, 1, 6) trailer convolutional codes with generators 103, 166 (octal) and 133, 171 (octal), respectively, were used in the simulation to obtain the results shown in Table I. The information length of the former is 12 and 48, which is [24, 12, 8] extended Golog code [14], and the latter is equivalent to [96, 48, 10] block code.

Before introducing the simulation results, it is pointed out that the computational complexity of a sequential search algorithm (such as the one performed by the second phase of MLWAVA) includes not only the evaluation of the decoding metric, but also the amount of work involved in searching and reordering the stack elements. By adopting a priority queue data structure [15], The latter's workload can be comparable to the former. One can further adopt a hardware-based stack structure [16] and achieve constant complexity for each stack insertion operation. These annotations prove the usual adoption of the number of metric calculations per information bit as an algorithmic complexity metric based on a sequential search algorithm.

It is now ready to provide simulation results of decoding complexity and the corresponding word error rate (WER) of the four decoding algorithms of MLWAVA compared to MLWAVA. In order to facilitate the specification of the parameters used in these algorithms within the various charts, the MLWAVA with the largest number of iterations I and the parameter λ (which determines the starting position l* by (14)) is represented by MLWAVA _λ (I) and has A The maximum iteration number I WAVA [2], the trap detection based ML decoding algorithm [12], the innovative ML decoding algorithm [9] and the bidirectional threshold based sequential decoding algorithm [8] are expressed as WAVA (I), TDMLDA, respectively. , CMDDA and BEAST. Note that MLWAVA _λ (I), TDMLDA, CMDDA, and BEAST are ML decoders. For all simulations, ensure that at least 100 word errors occur so that there is no bias in the simulation results.

For reference, the WER performance of WAVA (2) and ML decoders (such as MLWAVA, TDMLDA, CMDDA or BEAST) is first shown in Figure 1 according to the comparison. Figure 1 shows that at WER = 10 ^-3 , WAVA (2) has a coding loss of about 0.5 dB compared to the ML performance when [Gore code is extended using [24, 12, 8], but at [96, 48, 10 The block code is instead used to approximate optimal performance. This result indicates that WAVA can use only a small number (here twice) of iterations to achieve approximate optimal performance when using a longer trailer convolutional code.

The average and maximum number of branch metric calculations for WAVA (2), MLWAVA ₆ (1), TDMLDA, CMDDA, and BEAST are listed in Table I. Four observations were obtained. First, because in the worst case the SNRb value only traverses the entire grid twice, the maximum number of branch metric calculations is a constant for WAVA(2) regardless of the value. In fact, the amount of computation for the double iteration of each information bit of the WAVA can be directly given by 2 ^m × n × I = 2 ⁶ × 2 × 2 = 256. Second, MLWAVA ₆ (1) is superior to other decoding algorithms in terms of average decoding complexity for all SNR _bs other than BEAST. Third, for the short-tailed convolutional codes used, BEAST has the smallest average decoding complexity among the five decoding algorithms, and also has the smallest average decoding for long-tailed convolutional codes with SNR _b ≥ 3 dB. the complexity. However, as SNR _b decreases, its average decoding complexity increases significantly, and for long tail-end convolutional codes, it exceeds the average decoding of WAVA(2), MLWAVA ₆ (1), and CMLDA at SNR _b =1 dB. the complexity. Fourth, for each SNR value simulated, the maximum number of information bit branch metric calculations required by MLWAVA ₆ (1) is the lowest of all ML decoding algorithms, and its reduction is compared to other ML decoding algorithms. It is remarkable. For example, at SNR _b = 4 dB, for [96, 48, 10] block codes, the maximum decoding complexity of MLWAVA ₆ (1) is 4 times, 4 times and 8 times smaller than the maximum decoding complexity of TDMLDA, CMDDA and BEAST, respectively. Times. This improvement is of practical importance because the decoding delay is primarily determined by the worst-case complexity.

Table I

The average (AVE) and maximum (MAX) numbers calculated for each information bit branch of WAVA (2), MLWAVA 6 (1), TDMLDA, CMDDA, and BEAST. The stopping criteria in Theorem 1 have been implemented in WAVA (2) and MLWAVA ₆ (1). In order to easily find the best value, the smallest number in each column has been shown in bold.

In addition, the variance of the decoding complexity of the five decoding algorithms is shown in Table I, and the results obtained are summarized in Figures 2 and 3. Both figures show that MLWAVA has significantly smaller variance than the other four decoders listed in Table I. Especially for the [96, 48, 10] block code, the variance of the MLWAVA decoding complexity and the decoding complexity of the other four decoding algorithms are at least two orders of magnitude worse. When only BEAST and MLWAVA are tested, Table I and the results shown in Figures 2 and 3 together show that even though BEAST is superior in average decoding complexity for many values of SNR, its variance is much higher than MLWAVA. . For example, at SNR _b = 4 dB, the MLWAVA's decoding complexity variance is 7,234 times lower than BEAST for the [96, 48, 10] block code. This again shows that MLWAVA is a better choice between the two when decoding delay practices are of particular interest in practical applications.

In the observations previously derived from Table I, it is noted that for long tail-end convolutional codes, in addition to the low SNR region, Beast defeats the other four decoding algorithms in terms of average decoding complexity. In addition, BEAST and MLWAVA are advantageous for MLWAVA in terms of decoding complexity variance, especially for trailing convolutional codes of length 96. Along this main line, the effect of the codeword length on the decoding complexity of BEAST and MLWAVA is examined next. By doubling the length of the [96, 48, 10] block code in Table I, it is suitable The [192, 96, 10] block code of this experiment. Table II then shows that when comparing the average decoding complexity per bit of information for the [96, 48, 10] block code in Table I, the average decoding per bit of information for MLWAVA is complex for the new double length tailing convolutional code. The degree remains the same or decreases slightly; nevertheless, when the length of the information is doubled, the average and maximum decoding complexity of BEAST is greatly increased. This indicates that the decoding complexity of MLWAVA is highly stable for varying codeword lengths, and the decoding complexity of BEAST may increase significantly as the codeword length increases.

Another factor that may affect decoding complexity is the code constraint length. This effect of this factor on MLWAVA and BEAST has been tested and is also summarized in Table II. The code used in this experiment is a (2, 1, 12) trailer convolutional code [17] with generators 5135, 14477 (octal). Its message length is 48, which is equivalent to the [96, 48, 16] block code.

Table II

The average (AVE) and maximum (MAX) numbers calculated for each information bit branch metric of MLWAVAλ(I) and BEAST. The stopping criterion in Theorem 1 has been implemented for MLWAVA _λ (I). In order to easily find the best value, the smaller number in each column has been shown in bold.

As expected, Table II shows that the decoding complexity of MLWAVA and BEAST increases significantly as the constraint length increases; however, their average decoding complexity ratio increases from 298/131=2.275 at SNR _b =1dB. To199100/8299=2.399. This means that at low SNR, the decoding complexity of BEAST is moderately faster than the MLWAVA decoding complexity as the constraint length increases. I would like to add here that there is a hidden decoding cost in BEAST, which is to check the complexity of matching nodes between the forward sub-grid and the backward sub-grid. Similar to the computational specification for a sequence-based search algorithm, where the workload for searching and reordering stack elements can be significantly mitigated by employing a priority queue data structure [15] or even a hardware-based stack structure [16]. The cost of the BEAST node check process can be mitigated by storing the state of all extended nodes in an array of appropriate structures, where the matching nodes can be located in one step of the storage singularity.

However, for [96, 48, 16] block codes, this cost will have

The order, which may not be feasible for actual implementation. In the case of a single-step memory access implementation without node matching, experiments have shown that for [96, 48, 16] block codes, at SNR _b = 3: 5 dB, BEAST completes a branch metric calculation longer than MLWAVA ₁₂ (1) It should be 859 times more.

The inconspicuous result that may be observed in Table II is that MLWAVA _λ (2) sometimes runs faster than MLWAVA _λ (1), especially at low SNR. Specifically, at SNR _b =1 dB, MLWAVA ₆ (2) has a smaller maximum complexity than MLWAVA ₆ (1) for the [192, 96, 10] block code. This suggests that the better predictions obtained from the first stage of retention information, along with the proposed early stop criteria, do help to reduce the complexity of priority-first search in the second phase.

For completeness, the ML decoder word error rate performance for the [192, 96, 10] and [96, 48, 16] block codes is depicted in Figure 4, and Table I in Figures 5 and 6. The relationship between the average decoding complexity and the decoding algorithm is plotted. The decoding complexity curves corresponding to Table II are shown in Figures 7 and 8.

It is pointed out that both MLWAVA and CMLDA need to record information from their respective first-stage algorithms; nevertheless, this storage requirement from MLWAVA and CMLDA is in most of the order of ILN _s and LN _s , respectively.

The above is a further detailed description of the present invention in connection with the specific preferred embodiments, and the specific embodiments of the present invention are not limited to the description. It will be apparent to those skilled in the art that the present invention may be made without departing from the spirit and scope of the invention.

Claims

A novel maximum likelihood decoding algorithm for tail-end convolutional codes, comprising: (A) performing a Viterbi algorithm VA on a backward-surrounded grid; acquiring a previous-to-backward Viterbi algorithm VA round The information retained; (B) applies the priority-first search algorithm to the forward direction of all sub-grids.
The novel maximum likelihood decoding algorithm for a tail-end convolutional code according to claim 1, wherein the combined forward path and backward path give an ML trailing path, and all trailing paths of length N are used. The calculation formula with the smallest f function value and the minimum f function value is obtained as follows:
For the path xk, (ln-1) along the backward survival path
Immediately after the yuan, and
To indicate the end state, the f function value of the path x k, ((l+1)n-1)

Where x k,(ln-1) =(x k,0 ,x k,1 ,...,x k,ln-1 ) open the current top path in the stack and use s to represent its level l End state,
A backward survival path with a start state of s k at level L and an end state of s at level l is recorded.
The cumulative path metric, which is obtained during the iteration i 1 times WAVA.
The maximum likelihood decoding algorithm for a novel tailing convolutional code according to claim 1, wherein in the step (A), the backward surround Viterbi algorithm WAVA is applied to the end-of-tail convolutional code grid T And check the trailing path and check the auxiliary super code
All paths in .
A maximum likelihood decoding algorithm for a novel tailing convolutional code according to claim 2, wherein said auxiliary super code
By grid
All the paths on it, among them,
Representing a (n, 1, m) trailer convolutional code having L information bits, the target convolution map is limited from 1 information bit to n code bits, and m is the memory order.
The maximum likelihood decoding algorithm for a novel tailing convolutional code according to claim 2, wherein the metric of the path in the grid T is set as follows: Let l be a fixed integer satisfying 0 ≤ l ≤ L For a binary tag
Path; it ends at level l in grid T, and its associated path metric is defined as
among them
For the corresponding bit metric, the so-called cumulative metric for the path is the sum of the pre-specified initial metric and the associated path metrics associated therewith.
The maximum likelihood decoding algorithm for a novel tailing convolutional code according to claim 1, characterized in that in the step (A), obtaining the maximum likelihood ML judgment is performed in the following manner: at the end of the first iteration If the best backward survival path
Is a trailing path, then it is the ML decision, for the remaining iterations other than the first iteration, if

Suitable for each
among them
Is the best end-of-life path for the end-to-WAVA until the end of the end-of-life path encountered by the i-th iteration.
It is the ML decision.
The maximum likelihood decoding algorithm for a novel tailing convolutional code according to claim 1, wherein in the step (B), two data structures are used to perform a priority-first search algorithm, and the two data structures are open. Stack and closed tables; the open stack stores paths that have been accessed so far by a priority-first search algorithm that keeps track of those paths that were previously at the top of the open stack.
The maximum likelihood decoding algorithm for a novel tailing convolutional code according to claim 6, wherein the plurality of subgrids obtained from the step (A) are sorted to the survival path according to the ascending order of the cumulative metrics. And the algorithm is stopped after obtaining the maximum likelihood ML judgment.
A novel maximum likelihood decoding algorithm for a trailer-type convolutional code according to claim 1 wherein an effective early stop criterion is employed to reduce decoding complexity.