Chapter 14 trellis based decoding of linear block codes
1 / 17

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

  • Uploaded on
  • Presentation posted in: General

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

Download Presentation

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

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

Branch complexity

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

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

Sectionalization: Example

Three trellis sections

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

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


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

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

Recursive MLD (continued)

  • 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

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

Optimum Sectionalization

  • Lafourcady-Vardy algorithm applied to RMLD

Complexity comparisons

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.

Suggested exercises

  • 14.1-14.5

  • Login