Setup reminder: linear block error-correcting code is some linear subspace $C$ in $F\_2^N$. (Correcting error means to find a point $c \in C$ which is "nearest" to a given $r$ in $F\_2^N$, $r$ is signal with "errors"). 


Consider two codes which are given as images of some operators: $A: F\_2^k \to F\_2^L$,
$B: F\_2^L \to F\_2^N$. 
Define the code which is "superposition" - image of $BA$. 


**General question** What can be said about the properties of "superposition" code in terms of properties $A$ and $B$ ? E.g. how to construct decoding algorithm for it ? How to estimate error probability ? How to estimate minimal Hamming distance of this code ?


**Specific question** Consider code $A$ is just adding CRC bit: i.e. 
$A: (x\_1, ..., x\_n) \to (x\_1, ..., x\_n, \sum x\_i)$.


And $B$ is some tail-bited convolutional code (say rate 1/2) which means it is given by 
$( \bar y ) \to ( T\_1 \bar y , T\_2 \bar y) $ where $T\_1, T\_2$ are some circulant matrices
with only few non-zero diagonals.


How to estimate minimal Hamming distance of this code ? 


How to decode such a code ?


The problem is that Viterbi algorithm used for decoding convolutional codes is based
on "local" structure of the circulant matrices, while adding the CRC breaks the locality...


How to estimate error probabilty for such a code ? (Say in [AWGN](http://en.wikipedia.org/wiki/AWGN) channel)



Error correcting codes obtained as superposition of two codes e.g. CRC+Convolutional 
You do know how to calculate the minimum distance (=free distance?) of a convolutional code? Cut the first edge from the zero state to the zero state (to disallow the all zeros word), and run Viterbi (but counting the weight, or distance to the all zero word) to the point, where all the states have surviving minimal path of weight at least the weight of the surviving path back to the zero state. I guess this can be tweaked to cover your simplest case of a single parity check bit. Essentially now the "legal" inputs to the convolutional encoder are all the even weight sequences. So in the above algorithm we need to double the state complexity as follows. For each state we maintain two penalties: one for paths of an odd input weight and another for even input weights. Then when you run an iteration of Viterbi algorithm you match the parities according to the value of the new input bit. The stopping condition now applies to both variants of the penalty function, but comparisons are to be made only to the penalty of even input weight paths leading to the zero state.


It should be possible to also enumerate words corresponding to even input weights by a suitable variant of the transfer function or some such generating function.


How to decode? The first possibility that comes to mind is to replace the usual Viterbi algorithm with soft-output Viterbi algorithm (aka SOVA) that outputs, not the most likely path, but instead probabilities for each individual bits (often written as log-likelihood-ratios $LLR\_i=\ln (P(b\_i=0)/P(b\_i=1))$, but that may not be needed here). Then if the
sequence of bit values corresponding to the more likely choice has an even weight, you accept that. If that sequence has an odd weight, you flip the least reliable bit.


[Edit:] Arrgh! I only noticed after rereading that you were interested in tailbiting codes.
The above method for calculating the minimum Hamming weight no longer works. There may be too many pseudocodewords. I'm sure that some algorithms have been developed to attack this, but cannot describe one. The decoding, surprisingly, may not be affected too much by tailbiting. I would begin by studying the sections on tailbiting convolutional codes in
Johannesson & Zigangirov's book.


