Codificación de bloque lineal

anon

Clarification activity	Teoría de la información
Author(s)	José María Díaz Nafría
Creation date	Dec 2023
Status	🔵 Ready to publish

Un código de bloque lineal es un método de codificación de datos en el que los mensajes se transforman en bloques de mayor longitud mediante operaciones lineales sobre cuerpos finitos, de modo que las palabras de código forman un subespacio vectorial y permiten detectar y, en muchos casos, corregir errores de transmisión.

¿Por qué hablamos de paridad en códigos de bloque lineales?

La primera y más sencilla aproximación al control de errores, en términos históricos y prácticos, consiste en añadir un bit de paridad a cada bloque de unos pocos bits en el que se divide un flujo de datos para asegurar que todos los bloques de códigos válidos que se intenta transmitir por el canal cuentan con un número par de unos. De esa manera la mera constatación de la paridad de los códigos a la salida del canal digital permite identificar si se han producido o no errores en la transmisión (o mejor dicho, si los errores producidos en el canal son detectables).

Figura 1: Ejemplo de codificación de bloque lineal por bit de paridad con detección de error.

Obsérvese que, por una parte, se trata de convertir un bloque de datos, que podemos considerar como el mensaje a transmitir, en un código de dimensión mayor añadiendo un digito adicional que determinamos mediante la suma en módulo dos del número de unos del mensaje. Este resultado, como puede verse en la fig.1, es el que agregamos al código, lo que hace que todos los códigos válidos tengan un número par de unos, y en recepción hacemos exactamente la misma operación, de modo que si el resultado es uno, esto nos sirve de indicación de que algo ha ido mal en la transmisión. Por tanto, las operaciones de transformación de mensajes en códigos son lineales y definidas en algebra de cuerpos finitos, y podemos hacer operaciones también lineales que nos permiten distinguir el subespacio de códigos válidos dentro de un espacio más amplio de códigos recibidos (y potencialmente corruptos), lo que hace que este tipo de codificación cuente con todos los elementos de la codificación de bloque lineal según lo que se había discutido en el artículo de codificación de bloque. Por otra parte, se trata de una aproximación muy elemental que permite detectar errores pero no corregirlos, sin embargo, las técnicas del mismo tipo desarrolladas a lo largo de varias décadas y discutidas a continuación en sus aspectos elementales permiten hacerlo mucho mejor.

Definiciones

Según se había definido en el artículo sobre codificación de bloque (§3), un código de bloque para el control de errores se reduce a una aplicación $f:{{ℱ}}^k⟶{{ℱ}}^n$, sobre el alfabeto ${ℱ}=\{0,1,...,q-1\}$, quedando abierto el modo en el que se establece la correspondencia entre los elementos de un espacio y otro. Sin embargo, cuando nos restringimos a la codificación de bloque lineal, que es la que aquí nos ocupa, la relación que se establece entre los elementos es más sencilla y sistemática, gracias a la utilización de operaciones algebraicas simples (de suma y producto) con los elementos del conjunto ${ℱ}$, lo que facilita tanto su análisis como la realización de los codificadores y decodificadores.

Debido a que los elementos del alfabeto son finitos (y muy frecuentemente binarios) las operaciones algebraicas y los espacios vectoriales formados a partir de ellas se definen sobre cuerpos finitos o de Galois, que denotamos como $GF(q)$, donde $q$ es número de elementos u orden del cuerpo. No obstante, como en general los elementos del alfabeto o bien son binarios o agrupaciones binarias, serán de nuestra incumbencia los cuerpos finitos $GF(2^m)$, con $m>1\in \mathbb{\mathbb{N}}$, y $GF(2)$ cuando nos restrinjamos a códigos binarios. De un modo u otro, podremos expresar los códigos de bloque compuestos por $n$ elementos del alfabeto ${ℱ}$ (de $q$ símbolos) como subespacios dentro de espacio vectorial ${{ℒ}}_n=(\{GF(q){\}}^n,+,\cdot )$ de dimensión $n$ construido sobre un cuerpo finito $GF(q)$ en virtud de las operaciones de suma ($+$) y producto ($\cdot$). Esta caracterización general de los espacios vectoriales en los que representaremos las operaciones de codificación nos permite ofrecer una definición sintética de los códigos de bloque linealesː

Definición 1: código de bloque lineal

un código de bloque ${𝒞}[n,k]$ es lineal si el conjunto de palabras de código es un subespacio vectorial de ${{ℒ}}_n$de dimensión $k$.

• En el caso binario, el espacio vectorial ${{ℒ}}_n=(\{0,1{\}}^n,+,\cdot )$, de dimensión $n$, está definido sobre un cuerpo finito $GF(2)$, es decir, el de símbolos binarios combinados mediante operaciones $+$ y $\cdot$, que a su vez coinciden con las de suma y producto de módulo 2, o las operaciones lógicas de disyunción exclusiva (XOR) y conjunción (AND) del álgebra de Boole.
• En el caso no binario, el espacio vectorial ${{ℒ}}_n=(\{GF(2^m){\}}^n,+,\cdot )$, de dimensión $n$, está definido sobre un cuerpo finito $GF(2^m)$ donde $m\in \mathbb{\mathbb{N}}$, $m>1$. Aquí cada uno de los $2^m$ elementos del cuerpo finito puede representarse mediante un polinomio ${\alpha }^i$ de grado menor o igual que$m-1$ː ${\alpha }^i=a_1(X)=a_{i,0}+a_{i,1}X+...+a_{i,m-1}{X}^{m-1}$ donde $i=0,1,2,...,2^m-1$.

Como los códigos válidos, ${𝒞}[n,k]$, constituyen un subespacio de ${{ℒ}}_n$ de dimensión $k$, éste puede caracterizarse plenamente mediante los $k$ vectores de una de sus bases, $\{{\mathit{g}}_1,...,{\mathit{g}}_k\}$, por tanto, cualquier $\mathit{v}\in {𝒞}[n,k]$ podemos expresarlo en términos de dicha base:

$\mathit{v}=u_1{\mathit{g}}_1+...+u_k{\mathit{g}}_k=\sum _{i=1}^k{u}_i{\mathit{g}}_i=\mathit{u}\mathit{G}$, donde $\mathit{G}$ es la denominada matriz generadora:

${\mathit{G}}_{k\times n}=\left(\begin{array}{cccc}{g}_{1,1}& g_{1,2}& \cdots & g_{1,n}\\ g_{2,1}& g_{2,2}& \cdots & g_{2,n}\\ ⋮& ⋮& \ddots & ⋮\\ g_{k,1}& g_{k,2}& \cdots & g_{k,n}\end{array}\right)$(1)

Donde cabe observar que como la dimensión de $\mathit{u}$ es $k$, es decir la de los mensajes, podemos hacer que $\mathit{u}$ coincida precisamente con los mensajes, y en consecuencia $\mathit{G}$ representa la transformación $f:{{ℱ}}^k⟶{{ℱ}}^n$, que podemos representar como $\mathit{v}=\mathit{u}\mathit{G}$.

Definición 2: matriz generadora

Llamamos matriz generadora a la constituida por k vectores independientes del espacio de código ${𝒞}[n,k]$.

Códigos sistemáticos

Atendiendo a las definiciones 1 y 2 y considerando queː (i) cualquier operación de intercambio de filas o columnas supone un mero cambio del orden de los vectores o sus coordenadas; (ii) que las suma de filas suponen una combinación lineal de la base de vectores; y (iii) que el producto por un escalar no nulo supondría un mero cambio de escala en alguna de las direcciones, es, por tanto, evidente que estas operaciones no cambian en sí el espacio vectorial de códigos, cuyas propiedades seguirán siendo las mismas. En consecuencia, siempre es posible encontrar una matriz equivalente ${\mathit{G}}^{\prime }=\mathit{F}\cdot \mathit{G}\cdot \mathit{T}$ (donde $\mathit{F}$ y $\mathit{T}$ reflejan la transformación correspondiente a las operaciones antes referidas) que responda a la siguiente forma:

$$\mathit{G}{\text{'}}_{k\times n}=({\mathit{I}}_k|{\mathit{A}}_{k\times (n-k)})=\left(\begin{array}{ccccccc}1& 0& \cdots & 0& a_{1,1}& \cdots & a_{1,n-k}\\ 0& 1& \cdots & 0& a_{2,1}& \cdots & a_{2,n-k}\\ ⋮& ⋮& \ddots & ⋮& ⋮& \ddots & ⋮\\ 0& 0& \cdots & 1& a_{k,1}& \cdots & a_{k,n-k}\end{array}\right)$$(2)

Resulta evidente, de acuerdo a la definición 1, que si empleamos una matriz generadora que responda a la misma forma que ${\mathit{G}}^{\prime }$ para transformar los mensajes en palabras de código, el inicio de estas palabras estará compuesto por el mensaje mismo. Igualmente observamos que los $n-k$ símbolos restantes resultan de aplicar la matriz $\mathit{A}$ a los mensajes (aplicación que en general no es inyectiva debido a las dimensiones generalmente discordantes de ambos espacios). Por generalización de la técnica de introducir un bit de paridad para detectar de forma sencilla errores producidos en la transmisión símbolos, hablamos de dígitos de paridad y de matriz o submatriz de paridad.

Obsérvese que podríamos haber argumentado lo mismo para llegar a otro código equivalente ${\mathit{G}}^{″}=({\mathit{A}}_{k\times (n-k)}|{\mathit{I}}_k)$en el que los códigos también contienen la palabra de datos, pero al final del mismo. En ambos casos hablamos de códigos sistemáticos y según la justificación anterior se trata en ambos casos de códigos totalmente equivalentes, en cuanto a las propiedades del espacio vectorial de códigos, pero que facilitan la decodificación al permitir extraer los datos una vez corregidos los errores que se hubieran producido en el canal, si es que eso fuera posible. Esto hace que el estudio de los códigos sistemáticos sea equivalente al de estudiar los códigos de bloque lineales en general.

Definición 3: código sistemático

Llamamos códigos sistemáticos a aquellos en los que la palabra de código contiene los mensajes, $\mathit{v}=[\mathit{u}|\mathit{p}]$ y su matriz generadora responde a alguna a las formas $({\mathit{I}}_k|{\mathit{A}}_{k\times (n-k)})$ o $({\mathit{A}}_{k\times (n-k)}|{\mathit{I}}_k)$.

Control de paridad y síndrome

Como decíamos al principio, los bits de paridad permitían identificar la ausencia de errores detectables en el canal digital mediante una simple cuenta de la paridad observada en los códigos recibidos (o suma en módulo 2 del número de unos), de modo que si esta cuenta es nula el código la transmisión se da por exitosa. Esta idea se generaliza en lo que llamamos prueba o test de paridad, que extiende esta idea recurriendo a la matriz de control de paridad que definimos en términos de una condición similar:

Definición 4: matriz de control de paridad

Llamamos matriz de control de paridad $\mathit{H}$ a aquella que verifica que el producto de un código válido por dicha matriz es nulo, es decir,$\mathit{v}\cdot {\mathit{H}}^T=\mathit{u}\cdot \mathit{G}\cdot {\mathit{H}}^T=\mathit{0}$.

Como $\mathit{v}$ tiene un valor arbitrario, será entonces necesario que $\mathit{G}\cdot {\mathit{H}}^T=\mathit{0}$, lo que, atendiendo a la forma de las matrices generadoras de los códigos sistemáticos (para paridad al final del bloque, se cumple con una matriz de la siguiente forma:

${\mathit{H}}_{(n-k)\times n}=({\mathit{-}\mathit{A}}^T|{\mathit{I}}_{n-k})=\left(\begin{array}{ccccccc}-a_{1,1}& \cdots & -a_{k,1}& 1& 0& \cdots & 0\\ -a_{1,2}& \cdots & -a_{k,2}& 0& 1& \cdots & 0\\ ⋮& \ddots & ⋮& ⋮& ⋮& \ddots & ⋮\\ -a_{1,n-k}& \cdots & -a_{k,n-k}& 0& 0& \cdots & 1\end{array}\right)$(3)

Como puede fácilmente probarse: $\mathit{G}\cdot {\mathit{H}}^T=\left[\begin{array}{c}{\mathit{I}}_k|{\mathit{A}}_{k\times (n-k)}\end{array}\right]\cdot \left[\begin{array}{c}-{\mathit{A}}_{k\times (n-k)}\\ {\mathit{I}}_{n-k}\end{array}\right]=-{\mathit{A}}_{k\times (n-k)}+{\mathit{A}}_{k\times (n-k)}={\mathit{0}}_{k\times (n-k)}$

En consecuencia, la recepción de un código válido puede comprobarse $\mathit{v}\cdot {\mathit{H}}^T=\mathit{u}\cdot \mathit{G}\cdot {\mathit{H}}^T={\mathit{u}}_{1\times k}\cdot {\mathit{0}}_{k\times (n-k)}={\mathit{0}}_{1\times (n-k)}$, prueba que denominamos prueba o test de paridad.

Si aplicamos dicha prueba a un código eventualmente corrupto que podemos describir como $\mathit{z}=\mathit{v}+\mathit{e}$, donde $\mathit{e}$ representa los errores que se hayan podido cometer en el canal digital: $\mathit{z}\cdot {\mathit{H}}^T=(\mathit{v}\mathit{+}\mathit{e})\cdot {\mathit{H}}^T={\mathit{e}}_{1\times n}\cdot {\mathit{H}}_{k\times (n-k)}={\mathit{s}}_{1\times (n-k)}$, cuyo resultado se denomina síndrome, razón por la cual la operación de cálculo del mismo se denomina también prueba o test de síndrome, que extiende el concepto de test de paridad al permitir no sólo distinguir si se ha producido error o no en la transmisión, sino también poder identificar y corregir algunos errores.

Definición 5: síndrome

Para un código ${𝒞}[n,k]$ con matriz de comprobación de paridad $\mathit{H}$, llamamos síndrome de un vector $\mathit{z}$ de dimensión $n$ (i.e. $\mathit{z}\in {{ℒ}}_n$) al vector $\mathit{s}=\mathit{z}\cdot {\mathit{H}}^T$, cuya dimensión es $n-k$ (i.e. $\mathit{s}\in {{ℒ}}_{n-k}$).

Obsérvese, que en la medida que $\mathit{s}$ tiene dimensión $n-k$, es posible hacer más distinciones que la de haberse o no no producido errores (detectables) en el canal digital. Existe además una relación biunívoca entre errores corregibles y síndromes, lo que constituye una propiedad fundamental de los códigos de bloque lineales. Por tanto, si conocemos esta relación, nos será posible corregir los errores que se hayan producido en el canal.

Propiedades fundamentales de los códigos de bloque lineales

Un código binario C[n,k] es:

• capaz de corregir $2^{n-k}$ vectores de error.
• capaz de detectar $2^n-2^k$ vectores de error.

Corrección de errores

Si se recibe un código válido se dará por bueno, de lo contrario tratamos de encontrar el código $v_i$ que minimice el error, lo que se conoce como criterio de Máximo A Posteriori ó MAP, por maximizar el acierto para el código efectivamente recibido. Sin embargo, cuando la probabilidad de transmisión de todos los códigos es igual, este criterio se puede transformar —en virtud del teorema de Bayes— en el de Máxima Verosimilitud o MV, según el cual se busca el código válido que maximiza la probabilidad de recibir el código efectivamente recibido:

$\underset{i}{\max }\{P(v_i\mid z){\}}_{\text{MAP}}\stackrel{p(v_i)=p(v_j)}{⟶}\underset{i}{\max }\{P(z\mid v_i){\}}_{\text{MV}}$(4)

Si podemos considerar independencia en la sucesión de bits y sus errores, el criterio de maxima verosimilitud puede expresarse en términos de la probabilidad de error de bits de código, $P_{BC}$, que caracteriza el canal binario que además supondremos simétrico:

$\underset{i}{\max }\{\prod _{m=1}^{n}P({\mathit{z}}_m|{\mathit{v}}_{im})\}=\underset{i}{\max }\{P_{BC}^{{\mathrm{\Delta }}_{z,i}}(1-P_{BC}{)}^{n-{\mathrm{\Delta }}_{z,i}}\}$(5)

donde ${\mathrm{\Delta }}_{z,i}$ es la diferencia en nº de bits entre el bloque recibido y el código válido ${\mathit{v}}_{\mathit{i}}$

Como a su vez la probabilidad de error de bits de código es menor que 1, y de hecho lo normal es que sea mucho menor, la maximización de la probabilidad de acierto en la corrección de errores equivale a la minimización de ${\mathrm{\Delta }}_{z,i}$, lo que podemos expresar en términos de la distancia y peso Hamming que se definen como:

Definición 6: Distancia Hamming

Llamamos distancia Hamming, que designamos como $d_H$ o simplemente $d$ y a la diferencia en número de bits que hemos denotado como ${\mathrm{\Delta }}_{z,i}\in {\mathbb{\mathbb{N}}}_0$ y que podemos expresar algebraicamente, usando una suma acumulada como:$d_H(\mathit{z},{\mathit{v}}_{\mathit{i}})=(\mathit{z}-{\mathit{v}}_{\mathit{i}})\cdot (\mathit{z}-{\mathit{v}}_{\mathit{i}}{)}^T{|}_{GF(2)}=(\mathit{z}+{\mathit{v}}_{\mathit{i}})\cdot (\mathit{z}+{\mathit{v}}_{\mathit{i}}{)}^T=<\mathit{z}+{\mathit{v}}_{\mathit{i}},\mathit{z}+{\mathit{v}}_{\mathit{i}}>$, donde $<{\mathit{z}}_i,{\mathit{z}}_j>$ representa un producto escalar

Definición 7: Peso Hamming

Llamamos peso Hamming, que denotamos como $w_H$, a la distancia Hamming al código 0: $w_H(\mathit{v})=d_H(\mathit{v},\mathit{0})$, con $d_H,w_H\in {\mathbb{\mathbb{N}}}_0$.

En consecuencia, $d_H(\mathit{z},\mathit{v})=w_H(\mathit{z}+\mathit{v})$, lo que nos permite reexpresar el criterio de máxima verosimilitud como:

$\underset{i}{\max }\{P({\mathit{v}}_i|\mathit{z})\}\stackrel{\begin{array}{l}\text{sim}\acute{\text{e}}\text{trico}\\ \text{sin mem.}\end{array}}{⟶}\underset{i}{\min }\{d_H(\mathit{z},{\mathit{u}}_i)\}=\underset{i}{\min }\{w_H(\mathit{z}+{\mathit{u}}_i)\}$(6)

Figura 2: Decodificación de código de bloque lineal por búsqueda exhaustiva según el criterio de máxima verosimilitud.

Recurriendo a estas definiciones, la figura 2 representa el esquema de decodificación de acuerdo al criterio de máxima verosimilitud, que presupone la comparación con el conjunto de códigos válidos, razón por la que se habla de búsqueda exhaustiva.

Figura 3: Decodificación mediante tabla de síndromes y patrones de error corregibles.

De acuerdo a las propiedades fundamentales antes referidas, puede fácilmente probarse que el esquema anterior es equivalente al de disponer de una tabla de patrones de errores corregibles y sus síndrome correspondientes. La decodificación consistiría en dicho caso en la determinación del síndrome y la lectura de su correspondiente patrón de error (que al agotar todos los síndromes posibles se puede organizar en una memoria en la que las direcciones coincidan con los valores de los síndromes). La conveniencia de recurrir a un método u otro dependerá del tamaño de las tablas requeridas y de la complejidad de la búsqueda asociada.

Debido a que los errores más frecuentes que no pueden corregirse corresponden a los que transforman un código válido en otro igualmente válido, aquellos códigos que se encuentran más próximos serán a su vez los más frecuentes. Por esta razón la distancia mínima entre códigos válidos, en términos de los bits que los diferencia, constituye un parámetro fundamental de los códigos, que denominamos distancia mínima.

Definición 8: Distancia mínima

Llamamos distancia mínima de un código de bloque lineal, que denotamos como $d_{\min }$, a $d_{min}=\underset{\mathrm{\forall }i\ne j}{\min }\{d({\mathit{u}}_i,{\mathit{u}}_j)\}$, que en virtud de las propiedades de los códigos lineales equivale al mínimo de los pesos Hamming de los códigos válidos: $d_{\min }=\underset{\mathrm{\forall }i\ne j}{\min }\{w({\mathit{u}}_i+{\mathit{u}}_j)\}{|}_{\text{C.L.}}=\underset{\mathrm{\forall }k\ne 0}{\min }\{w({\mathit{u}}_k)\}$

Figura 4: Determinación de la distancia mínima de un conjunto de tres códigos en función de la distancia de Hamming entre ellos.

La figura 4 ilustra el sentido de la distancia mínima para conjunto de tres códigos cuya separación se expresa en términos de distancia de Hamming.

De acuerdo a esta caracterización, es evidente que no tenemos garantías de poder corregir errores cuyo peso Hamming sea igual o mayor que $d_{\min }$, así como tampoco tenemos garantía de poder corregir errores cuya distancia sea mayor o igual a que se encuentren a una distancia podremos al menos corregir $d_{\min }/2$ (el entero superior). Y en sentido contrario, podemos tener la certeza de que todos los errores cuyo peso Hamming sea:

• $e\le d_{\min }-1$ son errores detectables

• $t\le \lfloor \frac{d_{\min }-1}{2}\rfloor$son errores corregibles.

Cuando un código es capaz de corregir sólo los errores de peso Hamming $t$ hablamos de códigos perfectos.

Definición 9: Códigos perfectos

Llamamos códigos perfectos a los códigos de bloque lineal que sólo pueden corregir los errores de peso Hamming menores que $t$ (es decir, las esferas de radio $t$ entorno a todo $v_i$ cubren todo el espacio ${{ℒ}}_n$).

Probabilidad de error tras la decodificación

Figura 5ː Esquema de codificación y decodificación para códigos de bloque lineales para el control de errores.

La figura 5 sintetiza el proceso de codificación, transmisión a través de canales ruidosos y decodificación según los esquemas antes descritos. Nos interesará poder determinar el promedio de errores remanentes tras el proceso de corrección, ya que éste será el que sea entregado a las etapas subsiguientes de la cadena de recepción digital.

Teniendo en cuenta esta caracterización de los códigos de bloque lineales, es posible determinar la probabilidad de error de bloque tras el proceso de corrección de errores ($P_M$), descartando todos los casos de errores que con seguridad podemos corregir (lo que por tanto se trata de una cota superior del error):

$P_M\le \sum _{j=t+1}^n(\genfrac{}{}{0ex}{}{\text{nº combinaciones}}{j\text{ errores}})\cdot P(j\text{ errores en }n)=\sum _{j=t+1}^n(\genfrac{}{}{0ex}{}{n}{j})\cdot P_{BC}^j(1-P_{BC}{)}^{n-j}$(7)

Que presupone un canal simétrico. Si a su vez se considera que para cada elemento del sumatorio anterior el número de bits erróneos dentro del bloque es j —suponemos que los errores se distribuyen por igual entre los bits de paridad y los de datos— entonces la contribución a la probabilidad de error de bit de cada sumando es $j/n$, con lo cual la probabilidad de error de bit tras la decodificación ($P_B$) será:

$P_B\lesssim \sum _{j=t+1}^n\frac{j}{n}(\genfrac{}{}{0ex}{}{\text{n}}{j})\cdot P_{BC}^j(1-P_{BC}{)}^{n-j}$(8)

De manera estricta, sabemos que la probabilidad de error de bloque (o mensaje) es:

$P_M=\sum _{j=t+1}^n(1-{\alpha }_j)P_{BC}^j(1-P_{BC}{)}^{n-j}=1-\sum _{i=0}^n{\alpha }_i\cdot P_{BC}^j(1-P_{BC}{)}^{n-j}$(9)

donde ${\alpha }_i$ es el número de errores corregibles cuyo peso Hamming es $i$. Sin embargo, ${\alpha }_i$ se desconoce para la mayor parte de los códigos conocidos, razón por la cual la aproximación (8) nos ofrece una orientación de aplicación general.

Ejemplo

Supongamos que a la salida de un canal binario simétrico y sin memoria la probabilidad de error es $P_{BC}=10^{-4}$. Si se emplea un código Golay extendido (24,12), cuya distancia mínima $d_{\min }=8$, podemos determinar la probabilidad de error a la salida del codificador usando las relaciones anteriores y las propiedades fundamentales de los códigos.

El número de síndromes diferentes es: $2^{24-12}=4096$, mientras que las combinaciones de errores de 1, 2 y 3 bits en el bloque de 24 bits es: $(\genfrac{}{}{0ex}{}{24}{1})+(\genfrac{}{}{0ex}{}{24}{2})+(\genfrac{}{}{0ex}{}{24}{3})=2324$. En consecuencia habrá 1771 patrones de error con peso Hamming 4 que corresponde a errores corregibles.

Según estas dimensiones y el valor indicado para la probabilidad de error de bit de código, p, la probabilidad de error de mensaje o bloque será:

$P_M=1-\{(1-p{)}^{24}+(\genfrac{}{}{0ex}{}{24}{1})p(1-p{)}^{23}+(\genfrac{}{}{0ex}{}{24}{2})p^2(1-p{)}^{22}+(\genfrac{}{}{0ex}{}{24}{3})p^3(1-p{)}^{21}+1771p^4(1-p{)}^{20}\}=8.84\cdot 10^{-13}$

Y la probabilidad de error de bit tras la decodificación:

$P_B\cong \frac{4}{24}[(\genfrac{}{}{0ex}{}{24}{4})-1771]p^4(1-p{)}^{20}+\frac{5}{24}(\genfrac{}{}{0ex}{}{24}{5})p^5(1-p{)}^{19}+\frac{6}{24}(\genfrac{}{}{0ex}{}{24}{6})p^6(1-p{)}^{18}+...=1.47\cdot 10^{-13}$