Scribd
Upload
52 views17 pages

Trellis Based Decoding of Linear Block Codes

This document discusses trellis-based decoding of linear block codes. It introduces recursive maximum-likelihood decoding (RMLD) as a way to simplify the decoding of trellises through sectionalization and recursive combination of path metrics. The complexity of RMLD depends on the choice of section boundaries, with optimal sectionalization minimizing computations. The document provides examples of applying RMLD to decompose a trellis into shorter sections and combining path metrics recursively.

Uploaded by

Aleksandar Minja
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
52 views17 pages

Trellis Based Decoding of Linear Block Codes

This document discusses trellis-based decoding of linear block codes. It introduces recursive maximum-likelihood decoding (RMLD) as a way to simplify the decoding of trellises through sectionalization and recursive combination of path metrics. The complexity of RMLD depends on the choice of section boundaries, with optimal sectionalization minimizing computations. The document provides examples of applying RMLD to decompose a trellis into shorter sections and combining path metrics recursively.

Uploaded by

Aleksandar Minja
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 17

(Chapter 14):

Trellis based decoding of linear block codes


• Previous discussion on trellis based decoding of convolutional codes
applies 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

1
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 2i
• 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 2i+1
Example: (8,4) RM

Na = 44
Nc = 11

2
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

3
Sectionalization: Example

Three trellis sections 4


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

5
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 0x<yn
• Use these values to calculate min(0,y) for successive values of y

6
Example

7
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
8
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

9
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) (2z -1) operations 10
Comparison

• Per L(sx,sy) :
• Direct: 2k(Cx,y)(y-x) – 1
• Recursively: (2z -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.

11
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 12


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

13
Optimum Sectionalization
• Lafourcady-Vardy algorithm applied to RMLD

14
Complexity comparisons

15
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.

16
Suggested exercises

• 14.1-14.5

17

You might also like