Codici a blocco lineari - matrice generatrice, forma sistematica e bound di Singleton

La tabella $\mathbf b\to\mathbf c$ di un codice a blocco (Controllo d'errore - ARQ, FEC e codici a blocco sul canale binario simmetricoPer proteggere i bit dagli errori si può chiedere la ritrasmissione (ARQ, serve il canale di ritorno), aggiungere ridondanza per correggere (FEC) o unire le due cose (HARQ). Un codice a blocco $(n,k)$ trasforma $k$ bit in una parola di $n>k$ bit scelta tra $2^k$ parole su $2^n$ sequenze; modulatore, canale e demodulatore equivalgono a un canale binario simmetrico senza memoria con probabilità d'errore sul bit $P_{bit}$. Per $P_{bit}<\frac12$ il decodificatore ML sceglie la parola a minima distanza di Hamming; con distanza minima $d_{min}$ si correggono sempre $t=\lfloor\frac{d_{min}-1}{2}\rfloor$ errori e se ne rivelano sempre $d_{min}-1$. Il tasso è $R=\frac kn$ e la probabilità d'errore di parola è limitata da $P(\text{più di }t\text{ errori})$. L'ARQ ha efficienza $S_{SW}$, $S_{GBN}$, $S_{SR}$ in funzione di $t_P$, $t_A$, $\tau_P$ e $p$.Controllo d'errore - ARQ, FEC e codici a blocco sul canale binario simmetrico →) occupa $2^k\cdot n$ bit: già per $k=57$ è impensabile. Se il codice ha una struttura algebrica basta una matrice di $nk$ bit, e anche la decodifica (Matrice di controllo di parità, sindrome e cosetLa matrice di controllo di parità $H$ ($\ell\times n$) soddisfa $H\mathbf r=\mathbf 0\iff\mathbf r\in\mathcal C$; per un codice con generatrice $G$ ($n\times k$) vale $HG=0$ con $\operatorname{rango}(H)=n-k$, e se $G=\begin{bmatrix}I_k\A\end{bmatrix}$ allora $H=[A\mid I_{n-k}]$. La distanza minima è il minimo numero di colonne di $H$ linearmente dipendenti. La sindrome $\boldsymbol\sigma=H\boldsymbol\gamma$ della sequenza ricevuta $\boldsymbol\gamma=\mathbf c+\boldsymbol\varepsilon$ vale $H\boldsymbol\varepsilon$: dipende solo dall'errore. Le sequenze con la stessa sindrome formano un coset ($2^{n-k}$ coset di $2^k$ sequenze) e il decodificatore a minima distanza sceglie il coset leader, l'errore di peso minimo del coset: $\hat{\mathbf c}=\boldsymbol\gamma+\boldsymbol\varepsilon_{min}$. La probabilità di decodifica corretta sul BSC è la somma delle probabilità dei coset leader.Matrice di controllo di parità, sindrome e coset →) diventa un calcolo. I codici con questa struttura sono i codici lineari.

Versione per Ing. Elettronica (stessa teoria con i vettori scritti per riga, $\mathbf c=\mathbf mG$, $G$ di dimensioni $k\times n$): Codici a blocco lineari - matrice generatrice, controllo di parità, sindrome e codici di HammingUn codice a blocco è lineare se la somma (bit a bit, modulo 2) di due parole di codice è una parola di codice. Si descrive con la matrice generatrice $G$ ($k\times n$, $\mathbf c=\mathbf mG$) e con la matrice di controllo di parità $H$ ($(n-k)\times n$, $G H^T=0$); in forma sistematica $G=[I_k\mid P]$ e $H=[P^T\mid I_{n-k}]$. La distanza minima è il peso minimo delle parole non nulle. La sindrome $\mathbf s=\mathbf rH^T$ dipende solo dall'errore: se è nulla la parola è valida, altrimenti identifica l'errore (un solo errore ha per sindrome la colonna di $H$ corrispondente). I codici di Hamming $(2^m-1,,2^m-1-m)$ hanno $d_{min}=3$.Codici a blocco lineari - matrice generatrice, controllo di parità, sindrome e codici di Hamming →. Le due convenzioni sono legate dalla trasposta: la $G$ di questa nota è la trasposta della $G$ di quella nota. Per Ing. delle Telecomunicazioni: Codici a blocco lineari e sindromeUn codice a blocco è lineare se la somma (XOR) di due parole di codice è una parola di codice: allora le parole formano un sottospazio di $\mathbb Z_2^n$. Si descrive con la matrice generatrice $G$ ($n\times k$, $\mathbf c=G\mathbf b$; in forma sistematica $G=\binom{I_k}{A}$) e con la matrice di controllo $H$ ($(n-k)\times n$, $H\mathbf c=\mathbf 0$ se e solo se $\mathbf c\in\mathcal C$; per $G$ sistematica $H=[A\mid I_{n-k}]$). La distanza minima è il peso minimo delle parole non nulle e vale $d_{min}\le n-k+1$ (Singleton). La sindrome $\boldsymbol\sigma=H\tilde{\mathbf c}$ dipende solo dall'errore; la decodifica a distanza minima è $\hat{\mathbf c}=\tilde{\mathbf c}-\varepsilon(\boldsymbol\sigma)$, dove $\varepsilon(\boldsymbol\sigma)$ è il coset leader (vettore di peso minimo con quella sindrome).Codici a blocco lineari e sindrome →.

1. Lo spazio delle sequenze binarie

Le sequenze $\mathbf x=[x_1,\dots,x_n]^T$ con $x_i\in\{0,1\}$ formano uno spazio vettoriale sul campo binario $\{0,1\}$ (CampiUn campo è un insieme di numeri con somma e prodotto che rispettano le regole usuali (associativa, commutativa, neutri, opposti, inversi, distributiva): è ciò che serve per risolvere le equazioni di primo grado. Esempi: Q, R, C e i campi finiti.Campi →, Spazi vettorialiUno spazio vettoriale su un campo K è un insieme con una somma di vettori e un prodotto per scalari che rispettano 7 proprietà. Esempi fondamentali: K^n (somma componente per componente), le funzioni da R in R, i polinomi.Spazi vettoriali →), con le operazioni modulo 2:

• somma (senza riporto): $\mathbf z=\mathbf x+\mathbf y$ con $z_i=(x_i+y_i)_2=x_i\oplus y_i$ (XOR: $0+0=0$, $0+1=1$, $1+1=0$);
• prodotto per uno scalare $\alpha\in\{0,1\}$: $\alpha\mathbf x=[\alpha x_1,\dots,\alpha x_n]^T$ (moltiplicare per $0$ dà la sequenza nulla, per $1$ lascia invariata).

Conseguenza della regola $1+1=0$: ogni sequenza è l'opposto di se stessa, $\mathbf y+\mathbf y=\mathbf 0$ (si somma con se stessa e si ottiene la sequenza nulla; per esempio $01001110+01001110=00000000$). Quindi la differenza coincide con la somma: $$\mathbf x-\mathbf y=\mathbf x+\mathbf y.$$ È il motivo per cui nei conti modulo 2 i segni meno non servono mai.

Definizione. La norma (peso) di Hamming $\|\mathbf x\|_H=w_H(\mathbf x)$ è il numero di $1$ presenti nella sequenza. Valgono $\|\mathbf x\|_H\ge0$, $\|\mathbf x\|_H=0\iff\mathbf x=\mathbf0$, $\|\alpha\mathbf x\|_H=|\alpha|\,\|\mathbf x\|_H$ e la disuguaglianza triangolare $\|\mathbf x+\mathbf y\|_H\le\|\mathbf x\|_H+\|\mathbf y\|_H$.

La distanza di Hamming è la norma della differenza: $d_H(\mathbf x,\mathbf y)=\|\mathbf x-\mathbf y\|_H=\|\mathbf x+\mathbf y\|_H$ (la somma ha un $1$ proprio dove i due bit differiscono).

2. Codice lineare

Definizione. Un codice a blocco $\mathcal C=\{\mathbf c_1,\dots,\mathbf c_{2^k}\}$ è lineare se è un sottospazio lineare dello spazio delle sequenze di lunghezza $n$ (Sottospazi vettorialiUn sottospazio vettoriale è un sottoinsieme che è spazio vettoriale con le stesse operazioni: basta che sia chiuso per somma e per prodotto per scalari. Deve contenere il vettore nullo. In R^2 i sottospazi sono {0}, le rette per l'origine e tutto R^2.Sottospazi vettoriali →): contiene la parola nulla e la somma di due parole qualunque è ancora una parola.

Quindi $|\mathcal C|=2^k$ con $k$ dimensione del sottospazio. Per negare la linearità basta un controesempio: la parola nulla assente, oppure due parole la cui somma non è una parola.

Esempio. $\{001,010,111,101\}$: $k=2$, $n=3$. Non è lineare perché $\mathbf 0\notin\mathcal C$, e anche perché $001+010=011\notin\mathcal C$. Invece $\{000,011,101,110\}$ è lineare: la somma di due parole diverse e non nulle è la terza ($011+101=110$).

Quando il codice è dato da equazioni $c_i=f_i(b_1,\dots,b_k)$ si guarda se ogni $c_i$ è una somma modulo 2 di bit di informazione:

• un termine costante, per esempio $c_3=b_1+1+b_2$, rende il codice non lineare (con $\mathbf b=\mathbf 0$ la parola non è nulla);
• un prodotto di bit, per esempio $c=b_1b_2$, lo rende non lineare;
• un quadrato $b_i^2$ vale $b_i$ ($0^2=0$, $1^2=1$), quindi non rompe la linearità; lo stesso per $(b_1+b_2+b_3)^2=b_1+b_2+b_3$;
• il peso di Hamming modulo 2, $\|\mathbf b\|_H\bmod2$, è $b_1+\dots+b_k$ modulo 2: è un bit di parità, quindi lineare.

Esempio (da un tema d'esame). $c_1=b_1+b_2,\ c_2=b_3,\ c_3=b_1+1+b_2,\ c_4=b_1+b_3,\ c_5=b_2$: è un codice $(5,3)$ con $8$ parole tutte diverse (quindi decodificabile) ma non lineare, per il $+1$ nel terzo bit. Non esiste una matrice che lo rappresenti come $\mathbf c=G\mathbf b$.

Un codice non lineare può comunque essere un buon codice; ma serve la tabella intera e perde le scorciatoie di calcolo di questa nota.

3. Matrice generatrice

Definizione. Una matrice $G$ di dimensioni $n\times k$ è la matrice generatrice di un codice lineare se ha rango $k$ e $$\mathbf c=G\,\mathbf b\iff\mathbf c\in\mathcal C\qquad(\mathbf b\in\{0,1\}^k).$$ Il bit $i$-esimo della parola è il prodotto della riga $i$ di $G$ per $\mathbf b$: $c_i=\mathbf G_{i,\cdot}\,\mathbf b$ (somma modulo 2).

Il rango $k$ (colonne linearmente indipendenti, Combinazioni lineari e dipendenza lineareUna combinazione lineare è una somma di vettori moltiplicati per scalari. I vettori sono linearmente indipendenti se l'unica combinazione che dà il vettore nullo è quella con tutti i coefficienti nulli; altrimenti sono dipendenti, e allora uno di essi è combinazione lineare degli altri.Combinazioni lineari e dipendenza lineare →) garantisce che a $\mathbf b$ diversi corrispondano parole diverse, quindi $2^k$ parole.

Se $\mathbf b$ è la sequenza con un solo $1$ in posizione $i$, $G\mathbf b$ è la colonna $i$ di $G$: ogni colonna di $G$ è una parola di codice, e il codice è l'insieme di tutte le somme di colonne (il sottospazio generato, Generatori e basiDei vettori generano V se ogni vettore di V è loro combinazione lineare; una base è un insieme di generatori linearmente indipendenti, e allora ogni vettore si scrive in modo unico come combinazione dei vettori di base. Lemma dello scambio: i vettori indipendenti non sono mai più dei generatori.Generatori e basi →).

Esempio. $G=\begin{bmatrix}1&0\\0&1\\1&1\end{bmatrix}$, $n=3$, $k=2$. Le equazioni sono $c_1=b_1$, $c_2=b_2$, $c_3=b_1\oplus b_2$ e le parole sono $\{000,011,101,110\}$ (per $\mathbf b=00,01,10,11$). È il codice a parità pari: il terzo bit rende pari il numero di $1$.

La $G$ non è unica. Il codice $\{0000,0101,1011,1110\}$ ($n=4$, $k=2$) si genera con una qualunque coppia di colonne scelte tra le tre parole non nulle: $$\begin{bmatrix}1&1\\0&1\\1&1\\1&0\end{bmatrix},\qquad\begin{bmatrix}0&1\\1&1\\0&1\\1&0\end{bmatrix},\qquad\begin{bmatrix}0&1\\1&0\\0&1\\1&1\end{bmatrix}.$$ (le tre matrici sono state controllate enumerando le $4$ parole). La probabilità d'errore di parola su un canale qualunque dipende solo dall'insieme delle parole $\mathcal C$ e non da quale $\mathbf b$ corrisponde a quale $\mathbf c$: cambiare $G$ senza cambiare $\mathcal C$ è irrilevante per le prestazioni.

Trasformazioni di $G$.

• Operazioni sulle colonne (scambiare due colonne, sommare una colonna a un'altra): sostituiscono una base del sottospazio con un'altra base dello stesso sottospazio. Il codice $\mathcal C$ non cambia, cambia solo la corrispondenza $\mathbf b\to\mathbf c$.
• Permutazioni delle righe: scambiare le righe $i$ e $j$ scambia i bit $c_i$ e $c_j$ di tutte le parole. Si ottiene un codice diverso (altre parole), ma con la stessa distanza minima e, se il canale è senza memoria, la stessa probabilità d'errore: i bit sono tutti equivalenti.

Esempio. Da $G=\begin{bmatrix}1&0\\0&1\\1&0\\1&1\end{bmatrix}$ (parole $0000,\,1011,\,0101,\,1110$) scambiando le righe $1$ e $4$ si ottengono le parole $0000,\,1011,\,1100,\,0111$: insieme diverso, $d_{min}=2$ in entrambi i casi.

4. Forma sistematica

Definizione. $G$ è in forma sistematica se $$G=\begin{bmatrix}I_k\\A\end{bmatrix},\qquad A\ \text{di dimensioni }(n-k)\times k,\qquad G\mathbf b=\begin{bmatrix}\mathbf b\\A\mathbf b\end{bmatrix}.$$ I primi $k$ bit della parola sono i bit di informazione, gli altri $n-k$ sono i bit di parità $\mathbf p=A\mathbf b$.

Il vantaggio è che la decodifica, una volta trovata la parola, restituisce $\hat{\mathbf b}$ leggendo i primi $k$ bit. Una $G$ qualunque si porta sempre in forma sistematica con combinazioni delle colonne e permutazioni delle righe. Quando basta toccare le colonne il codice non cambia.

Esempio (tema d'esame del 9 gennaio 2026). Il codice $c_1=b_1$, $c_2=b_1+b_2$, $c_3=b_3$, $c_4=b_1+b_2+b_3$, $c_5=b_2+b_3$ ha $$G'=\begin{bmatrix}1&0&0\\1&1&0\\0&0&1\\1&1&1\\0&1&1\end{bmatrix}.$$ Le prime tre righe non sono l'identità (la seconda riga è $[1,1,0]$). Sommando la seconda colonna alla prima (operazione sulle colonne: il codice è lo stesso) la prima colonna diventa $[1,0,0,0,1]^T$ e $$G=\begin{bmatrix}1&0&0\\0&1&0\\0&0&1\\0&1&1\\1&1&1\end{bmatrix},\qquad A=\begin{bmatrix}0&1&1\\1&1&1\end{bmatrix}.$$ Con Python si controlla che $G'$ e $G$ producono le stesse $8$ parole.

Se la parte alta di $G$ non è l'identità e per qualche posizione manca una riga del tipo $[0,\dots,1,\dots,0]$, le sole permutazioni delle righe non bastano: servono combinazioni delle colonne (vedi l'esercizio Esercizio - codice (8,4) non sistematico, sistematica equivalente e cascata di due codici (esame del 23 gennaio 2024, es. 172)).

5. Peso di Hamming e distanza minima

Definizione. Il peso di Hamming del codice è $w_H(\mathcal C)=\min_{\mathbf c\in\mathcal C,\ \mathbf c\ne\mathbf0}w_H(\mathbf c)$, il minimo numero di $1$ tra le parole non nulle.

Teorema. In un codice lineare la distanza minima è uguale al peso minimo: $d_{min}=w_H(\mathcal C)$.

Dimostrazione. $d_{min}=\min_{\mathbf c_i\ne\mathbf c_j}d_H(\mathbf c_i,\mathbf c_j)=\min_{\mathbf c_i\ne\mathbf c_j}\|\mathbf c_i-\mathbf c_j\|_H$. Il codice è lineare, quindi $\mathbf c_i-\mathbf c_j=\mathbf c_i+\mathbf c_j$ è una parola di codice, non nulla perché $\mathbf c_i\ne\mathbf c_j$; viceversa ogni parola non nulla $\mathbf c$ si ottiene come $\mathbf c-\mathbf 0$ con $\mathbf 0\in\mathcal C$. Quindi il minimo sulle coppie è il minimo sulle parole non nulle: $\min_{\mathbf c\ne\mathbf 0}\|\mathbf c\|_H=w_H(\mathcal C)$. $\square$

In pratica si elencano le $2^k-1$ parole non nulle (invece delle $\binom{2^k}{2}$ coppie) e si prende il peso minore. Ogni colonna di $G$ è una parola, quindi $$d_{min}\le\min_{\text{colonne}}w_H.$$ Il bound può non essere raggiunto, perché una somma di colonne può pesare meno di ogni colonna: $G=\begin{bmatrix}I_3\\ \hline1\ 1\ 1\\1\ 1\ 1\\1\ 1\ 1\end{bmatrix}$ ($n=6$, $k=3$) ha tutte le colonne di peso $4$, ma la somma della seconda e della terza colonna è $[0,1,1,0,0,0]^T$ di peso $2$: $d_{min}=2$ (le $8$ parole hanno pesi $0,2,2,2,4,4,4,6$, controllato con Python).

Esempio (codice $(7,3)$ sistematico). Con $c_4=c_1+c_2$, $c_5=c_1+c_3$, $c_6=c_2+c_3$, $c_7=c_1+c_2+c_3$: le $7$ parole non nulle hanno tutte peso $4$ ($b=100\to1001101$, $\dots$). Quindi $d_{min}=4$: il codice rivela $3$ errori e ne corregge $1$ (controllato con Python).

6. Bound di Singleton

Teorema (bound di Singleton). Per un codice lineare $(n,k)$ $$d_{min}\le n-k+1.$$

Dimostrazione. Si sceglie una $G$ in forma sistematica (si può sempre: cambia al più l'ordine dei bit, non $d_{min}$). La colonna $i$ è $\begin{bmatrix}\mathbf e_i\\A_{\cdot,i}\end{bmatrix}$, con $\mathbf e_i$ il vettore con un solo $1$ in posizione $i$ e $A_{\cdot,i}$ lunga $n-k$. Il suo peso è al più $1+(n-k)$. Essendo una parola di codice, $d_{min}\le w_H\le1+n-k$. $\square$

Si usa in due modi.

• Per scartare un codice. Per correggere $t$ errori serve $d_{min}\ge2t+1$, quindi $2t+1\le n-k+1$, cioè $n-k\ge2t$: servono almeno $2t$ bit di parità. Per esempio un codice lineare con $k=2$ e $n=4$ non può correggere $2$ errori: servirebbe $d_{min}\ge5$ ma $n-k+1=3$.
• Per sapere cosa si può ottenere. Con $k=2$, $n=5$ si ha $d_{min}\le4$; vediamo cosa si ottiene davvero.

Esempio (lezione). Si trovino $a,b,c,d\in\{0,1\}$ che massimizzano gli errori corretti per $G=\begin{bmatrix}0&c\\1&d\\a&1\\0&1\\b&1\end{bmatrix}$ ($n=5$, $k=2$).

Le tre parole non nulle sono le due colonne e la loro somma: $\mathbf g_1=[0,1,a,0,b]^T$, $\mathbf g_2=[c,d,1,1,1]^T$ e $\mathbf g_1+\mathbf g_2=[c,\,1+d,\,a+1,\,1,\,b+1]^T$. Si vuole che ciascuna abbia peso $\ge3$.

1. $\mathbf g_1$ ha peso $1+a+b\le3$: per avere $3$ servono $a=b=1$.
2. Con $a=b=1$ la somma vale $[c,\,1+d,\,0,\,1,\,0]^T$ e pesa $c+(1+d)+1$: per avere $3$ servono $c=1$ e $d=0$.
3. Con $c=1$, $d=0$: $\mathbf g_2=[1,0,1,1,1]^T$ pesa $4$.

Quindi $d_{min}=3$ (il massimo, con $a=b=c=1$, $d=0$; Singleton ammetterebbe $4$ ma non è raggiungibile: lo si verifica provando tutte le $16$ scelte con Python, solo questa dà $3$, negli altri casi $d_{min}\le2$). Il codice corregge $t=1$ errore. Scambiando le prime due colonne si ha la forma sistematica $G=\begin{bmatrix}1&0\\0&1\\1&1\\1&0\\1&1\end{bmatrix}$ con parole $00000,\,01101,\,10111,\,11010$ e pesi $3,4,3$.

Casi in cui il bound è raggiunto (codici a distanza massima, MDS):

• codice a ripetizione $(n,1)$: $\mathbf c=[b,b,\dots,b]^T$, $d_{min}=n=n-1+1$ (corregge $\lfloor\frac{n-1}2\rfloor$ errori, ma $R=\frac1n$);
• codice a parità singola $(k+1,k)$ (sezione 7): $d_{min}=2=(k+1)-k+1$.

7. Codice a parità singola

Con $n=k+1$ il bound dà $d_{min}\le2$, quindi il meglio che si può fare è $d_{min}=2$: rivelare sempre $1$ errore e non correggerne nessuno. Lo ottiene il codice che aggiunge un bit di parità $$c_{k+1}=b_1\oplus b_2\oplus\dots\oplus b_k,\qquad G=\begin{bmatrix}I_k\\1\ 1\ \cdots\ 1\end{bmatrix}\ \ (k+1\text{ righe},\ k\text{ colonne}).$$ Il numero di $1$ di ogni parola è pari (parità pari), quindi un numero dispari di errori (di cui $1$) si rivela sempre e un numero pari no. Tutte le parole non nulle hanno peso pari, il minimo è $2$ (per esempio $\mathbf b=10\dots0$ dà peso $2$). Per $k=3$ le $7$ parole non nulle hanno pesi $2,2,2,2,2,2,4$.

Con più bit di parità la scelta migliore dipende da quanti errori si vogliono rivelare o correggere: Singleton dice che $d_{min}$ cresce al massimo di $1$ per ogni bit di parità aggiunto.

Errori comuni

• Credere che un codice sia lineare perché contiene la parola nulla o perché la somma di una coppia è una parola: serve la chiusura per tutte le somme.
• Considerare lineare un codice con un termine costante ($+1$) o con prodotti di bit; non considerare lineare un codice con $b_i^2$ (che vale $b_i$).
• Scambiare righe e colonne di $G$: le operazioni sulle colonne non cambiano il codice, le permutazioni delle righe cambiano le parole ma non le prestazioni.
• Calcolare $d_{min}$ prendendo il minimo peso delle colonne di $G$ invece del minimo su tutte le parole non nulle (somme di colonne comprese).
• Dimenticare che $G$ è $n\times k$ in questo corso ($\mathbf c=G\mathbf b$), non $k\times n$.

Domande d'esame

1. È lineare il codice $c_1=b_2$, $c_2=b_1$, $c_3=b_3$, $c_4=b_2^2+b_3^2$, $c_5=b_1+b_2$, $c_6=(b_1+b_2+b_3)^2$? Quali sono $G$ e il rate? Sì: i quadrati valgono i bit stessi, quindi ogni $c_i$ è una somma di bit. Rate $\frac36=\frac12$. $G$ ha righe $[0,1,0],[1,0,0],[0,0,1],[0,1,1],[1,1,0],[1,1,1]$ (Esercizio - codice (6,3) da equazioni con quadrati e matrice di controllo di parità (secondo compitino del 14 gennaio 2025, es. 185)).
2. Dimostrare che per un codice lineare $d_{min}$ è il peso minimo. Le differenze di parole sono parole; la distanza tra $\mathbf c_i$ e $\mathbf c_j$ è il peso di $\mathbf c_i+\mathbf c_j\ne\mathbf 0$.
3. Può un codice lineare binario con $k=2$ e $n=4$ correggere $2$ errori? No: servirebbe $d_{min}\ge5$, ma Singleton dà $d_{min}\le n-k+1=3$.

Esercizi svolti

• Esercizio - codice (5,3) non sistematico, matrice di parità e sindrome su BSC (secondo compitino del 9 gennaio 2026, es. 195): equazioni con peso di Hamming modulo 2, forma sistematica con operazioni sulle colonne.
• Esercizio - codice (6,3) da equazioni con quadrati e matrice di controllo di parità (secondo compitino del 14 gennaio 2025, es. 185): equazioni con quadrati, linearità, forma sistematica e decodifica.
• Esercizio - codice (8,4) non sistematico, sistematica equivalente e cascata di due codici (esame del 23 gennaio 2024, es. 172): matrice generatrice non sistematica, sistematica equivalente e cascata di due codici.
• Esercizio - codice non lineare a quattro parole, distanza 2 e bound di Singleton (esame del 21 giugno 2023, es. 159): codice non lineare e impossibilità di correggere due errori con quattro parole.