### Topics

### features

### Publications

### Issue Archive

# Truncation Depth Rule-of-Thumb for Convolutional Codes

- Monday, 05 January 2009

### The new rule is more accurate and tight at high signal-to-noise ratios.

In this innovation, it is shown that a commonly
used rule of thumb (that the truncation
depth of a convolutional code should
be five times the memory length, *m*, of the
code) is accurate only for rate 1/2 codes.
In fact, the truncation depth should be 2.5
*m*/(1 – *r*), where *r* is the code rate. The
accuracy of this new rule is demonstrated
by tabulating the distance properties of a
large set of known codes. This new rule was
derived by bounding the losses due to truncation
as a function of the code rate.

The bound derives from a result on random
trellis codes in G.D. Forney, Jr.’s
“Convolutional codes II: Maximum likelihood
decoding,” *Information and Control*,
vol. 25:222-266 (1974). An (*M*, ν) trellis is
a trellis corresponding to a shift register of
length ν where each register contains a *M*-vector
and the input is an *M*-ary sequence
(the corresponding trellis contains *M*v
states). An (*M*, ν, *n*) trellis code augments
an (*M*, ν) trellis by assigning *n* channel
symbols to each edge. The rate of the
code is *r* = log_{2} (*M*)/*n* bits/symbol. A random
trellis code is an (*M*, ν, *n*) trellis in
which each channel symbol on each edge
is chosen randomly and independently
according to some distribution *p*. When *M*
= *q ^{k}* the (

*M*, ν,

*n*) trellis corresponds to a rate log

_{2}(

*q*)>

*k*/

*n*nonsystematic convolutional code over GF(

*q*) with

*k*equal constraint lengths ν

_{i}= ν, 1 <

*i*<

*k*. The memory of this code is

*m*= max

_{i}ν

_{i}= ν. It is presumed that the code is decoded via the Viterbi algorithm with decisions on edges of the trellis made after a delay of

*T*trellis stages. A truncation error occurs when an incorrect edge is chosen that would not have been chosen with an infinite truncation depth.

In the case of punctured codes, the
truncation depth on the mother code
trellis should be increased as the rate
increases. Punctured code can be created
by forming (*q ^{k}*, ν,

*n*) code by puncturing a (

*q*, ν

^{k}_{1},

*n*

_{1}) mother code, where

*k*

_{1}divides

*k*and ν = ν

_{1}

*k*

_{1}/

*k*. This resulting code is the daughter code. The two codes are represented with the same number of states, with

*k*/

*k*

_{1}stages of the mother code corresponding to 1 stage of the daughter code. The required truncation depth on the daughter code trellis corresponds to a truncation depth on the mother code trellis of

1> ν

_{1}/(1 –

*r*)

i.e., the truncation depth on the mother code goes as the memory of the mother code scaled by one minus the rate of the punctured code.

With regard to particular codes, a good indicator of the required truncation depth is the path length at which all paths that diverge from a particular path have accumulated the minimum distance of the code. It is shown that the new rule of thumb provides an accurate prediction of this depth for codes of varying rates.

*This work was done by Bruce Moision of
Caltech for NASA’s Jet Propulsion Laboratory.
NPO-45009*

### This Brief includes a Technical Support Package (TSP).

** Truncation Depth Rule-of-Thumb Convolutional Codes** (reference NPO-45009) is currently available for download from the TSP library.

Please Login at the top of the page to download.

### White Papers

| ||||||