1

(Chapter 14): Trellis based decoding of linear block codes

• Previous discussion on trellis based decoding of convolutional codesapplies directly to any code with a (moderately complex) trellis

• Viterbi

• SOVA

• BCJR

• MAP

• Log-MAP

• Max-log-MAP etc.

• Irregular trellises: May be more difficult to design HW decoder

2

Branch complexity• Let Ii=2 if there is an information symbol corresponding to

output bit i, Ii =1 otherwise.• Then the branch complexity is the number of one-symbol branches

= the number of additions in the Viterbi algorithm= Na = i=0...n-1 Ii 2i

• Let Ji=0 if there is only one branch entering each state at time i, Ji= 1 otherwise

• Then the number of comparisons in the Viterbi algorithm= Nc = i=0...n-1 Ji 2i+1 Example: (8,4) RM

Na = 44Nc = 11

3

Trellis sectionalization• Sectionalization combines adjacent bits and provides a trellis with

fewer time instances, in order to simplify the decoders.

• Let ={t0, t1,…,t}, for n. Delete all state spaces (and their adjacent branches) at time instances not in , and connect every pair of states, one in tj and one in tj+1, iff there were a path between these states in the original trellis, label the new branches by the old path labels.

• A set of parallel paths forms a composite branch

4

Sectionalization: Example

Three trellis sections

5

Decoding of Sectionalized trellis

• For each composite branch,

• find the best single path among those that form the composite branch. Make a note of who is the winner.

• The branch metric of the composite branch is by definition equal to the branch metric of this winning branch.

• The metrics of the composite branch is added to the path metrics of the state it starts in.

• The rest proceeds as the ordinary Viterbi algorithm

6

Complexity of sectionalized trellis decoding

• Depends on choice of section boundaries

• Optimal sectionalization: Minimum number of additions+comparisons (Lafourcade & Vardy)

(x,y)= number of computations to calculate section from time x to time y

min(x,y)= minimum number of computations to calculate section from time x to time y

min(0,y)=min{ (0,y) , min0<x<y{min(0,x) + (x,y)} }

• Algorithm:

• Calculate (x,y) for 0x<yn

• Use these values to calculate min(0,y) for successive values of y

7

Example

8

Recursive ML decoding• Sectionalized trellis

• Recursive combining of the path metrics

• Start with minimal trellis for an (n,k) block code

• Consider state sx at time x and state sy at time y

• L(sx,sy) is the set of parallel branches from sx to sy (forming one composite branch)

• L(sx =zero state ,sy =zero state ) is a linear block code Cx,y

• Each L(sx,sy) is a coset of Cx,y , that is a coset in px,y(C) /Cx,y

• The number of distinct such sets is

= 2k(px,y(C))-k(Cx,y)

• So each coset appears (Chapter 9)

= 2k - k(C0,x) - k(Cy,n) - k(px,y(C)) times as a composite path

9

Composite Path Metric Table• For each distinct L(sx,sy), store in CPMTx,y

• Label: Best path within composite branch, l(L(sx,sy))

• Metric: The metric of the best path, m(L(sx,sy))

• Eventually, CPMT0,n will contain just one path

• Construct CPMTx,y by

1. For small y-x: Compute metrics for each path in composite path.

This requires 2k(Cx,y)(y-x-1) additions 2k(Cx,y)

-1 comparisons

= 2k(Cx,y)(y-x) – 1 operations.

2. For larger y-x : Recursively, i. e. from CPMTx,z and CPMTz,y

10

Recursive MLD (continued)

• L(sx,sy) = sz L(sx,sz) L(sz,sy)

• m(L(sx,sy)) = maxsz { m( L(sx,sz)) + m( L(sz,sy)) }

• l(L(sx,sy)) = l( L(sx,s*z)) l( L(s*z,sy))

• This computation requires z additions and z -1 comparisons,

• where z = the number of states at time z, = 2k(Cx,y) - k(Cx,z) - k(Cz,y)

• Forming the CPMTx,y requires 2k(px,y(C))-k(Cx,y) (2z -1) operations

11

Comparison

• Per L(sx,sy) :

• Direct: 2k(Cx,y)(y-x) – 1

• Recursively: (2z -1) = 2(2k(Cx,y) - k(Cx,z) - k(Cz,y)-1) – 1)

• Recursive computation significantly faster if k(Cx,z) and k(Cz,y) are large.

12

Computation• Instead of forming the trellis section Tx,y from the complete trellis:

• Construct the special trellis T({x,z,y,nx,y}):

Each state at time x

13

An RMLD-IV algorithm• Divide code into very short sections

• Apply MakeCPMT procedure to these.

• MakeCPMT-I: ”brute-force”

• Apply CombCPMT to the smaller sections

• CombCPMT-V: Use Viterbi for the comparisons

14

Optimum Sectionalization

• Lafourcady-Vardy algorithm applied to RMLD

15

Complexity comparisons

16

Humble remark

• First such algorithm devised in [14,15]

• But...

• Similar algorithm for convolutional codes in

– Marianne Fjelltveit and Øyvind Ytrehus. On Viterbi decoding of high rate convolutional codes. In Abstracts of Papers of the 1994 IEEE International Symposium on Information Theory, Trondheim, 1994.

– Marianne Fjelltveit and Øyvind Ytrehus. Two-step trellis decoding of partial unit memory convolutional codes. IEEE Transactions on Information Theory, IT-43:324–330, January 1997.

17

Suggested exercises

• 14.1-14.5