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

Download Presentation

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

Loading in 2 Seconds...

- 134 Views
- Uploaded on
- Presentation posted in: General

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

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

- 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-1Ii2i
- 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-1Ji2i+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 0x<yn
- 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) (2z -1) operations

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

- 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