1 / 17

# (Chapter 14): Trellis based decoding of linear block codes - PowerPoint PPT Presentation

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

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about '(Chapter 14): Trellis based decoding of linear block codes' - rosina

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
(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

Example: (8,4) RM

Na = 44

Nc = 11

• 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-1Ii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-1Ji2i+1

• 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

Three trellis sections

• 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

• 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

• 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

• 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,nwill contain just one path

• Construct CPMTx,y by

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

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

• L(sx,sy) = szL(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

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

• 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

• 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

• Lafourcady-Vardy algorithm applied to RMLD

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

• 14.1-14.5