17.4 Codifica di canale

Riprendiamo la notazione introdotta al § 15.6.2.1 per i codici a blocco, in cui ad ogni k bit della sequenza di ingresso (da proteggere)

si genera una codeword [939]   [939] Si ricorda che l’insieme delle 2^k codeword costituisce un codebook. con lunghezza n = k + q > k bit, in cui sono stati aggiunti q bit di protezione in funzione dei k del blocco: tale procedura viene indicata come codice (n, k), la cui efficienza è misurata dal tasso di codifica (o code rate)

R_c = kn < 1

che rappresenta la frazione di bit informativi sul totale di quelli trasmessi, nonché l’inverso del fattore di espansione di banda [940]   [940] Notiamo la differenza tra queste tre grandezze dall’aspetto simile: l’efficienza spettrale ρ = ^f_b⁄_B indica quanto una tecnica di modulazione numerica faccia buon uso dello spettro, il rapporto BR esprime l’inverso del grado di utilizzo della banda B di un canale numerico, mentre R_c = ^k⁄_n misura l’efficienza del codice adottato.: la nuova velocità di trasmissione in presenza di codifica vale infatti

f’_b = f_bR_c

Osserviamo che all’aumento della velocità di segnalazione (essendo f’_b > f_b) corrisponde una eguale diminuzione del rapporto ^E_b⁄_N0 =  P_xN₀f’_b = R_cP_xN₀f_b, e conseguentemente si assiste ad un peggioramento della probabilità di errore grezza del decisore: pertanto, la capacità correttiva del codice deve essere tale da compensare anche questo aspetto. Per mantenere limitato l’effetto descritto, così come l’espansione di banda, vorremmo trovare codificatori per cui R_c sia il più possibile vicino ad uno.

• per rivelare l (o meno) errori per codeword occorre d_m ≥ l + 1
• per correggere t (o meno) errori per codeword occorre d_m ≥ 2t + 1

La distanza d_m ed il tasso R_c non possono essere scelti

indipendentemente, dato che per aumentare d_m occorre aumentare i bit di protezione q, a cui corrisponde una diminuzione del valore di R_c. Una quantità che tiene conto di entrambi i termini è il guadagno di codifica asintotico

(21.105) G^a_c = d_mR_c

che esprime il fattore di aumento della potenza di segnale che avrebbe prodotto lo stesso miglioramento in termini di P_e dovuto all’adozione del codice.

17.4.1 Codifica a blocco

Con il termine sistematico si intende un codice che ottiene gli n bit delle codeword x concatenando per primi i k bit da proteggere, indicati con m, a cui seguono i q = n − k bit di protezione, indicati con c. Ovvero come abbiamo implicitamente assunto fino ad ora, anche se si tratta

di una scelta per nulla scontata. Mostreremo più sotto che un codice sistematico è anche lineare; le sue codeword vengono quindi scritte nella forma

x = (m₁ m₂ ⋯ m_k c₁ c₂ ⋯ c_q)

ovvero come un vettore riga partizionato x = (m| c), in modo da poterlo calcolare a partire dal vettore m dei bit da proteggere moltiplicando lo stesso per una matrice generatrice [944]   [944] Questa fantomatica matrice generatrice che cala dall’alto in realtà ha una genesi ben razionale.

Se infatti definiamo una base ortogonale {u_i} per lo spazio k − dimensionale descritto da tutti i possibili vettori m come i k vettori con componenti tutte nulle tranne quella in posizione i − esima e pari ad 1, possiamo allora scrivere un generico vettore m con componenti binarie m_i come una combinazione lineare di vettori della base, ovvero m = ∑^k_i = 1 m_iu_i.

Indicando ora con g_i la codeword (di n elementi) associata a ciascun vettore u_i, otteniamo che ad un generico vettore m è associata la codeword x = ∑^k_i = 1 m_ig_i = m ⋅ G, in cui G è la nostra matrice generatrice di dimensione k × n le cui righe sono pari alle codeword g_i con i = 1, 2, ⋯, k associate ai vettori della base u_i.

k × n con struttura generale G = [I_k| P], in cui I_k è una matrice identità k × k e P è una sotto-matrice di elementi binari k × q. Le codeword si ottengono quindi come x = m ⋅ G, ovvero

(21.107)
[ m₁  ⋯  m_k  c₁  ⋯  c_q ] = [ m₁  ⋯  m_k ] ⋅ ⎡⎢⎢⎢⎣ 1  ⋯   0 p₁₁   ⋯    p_1q             ⋮  1⋮ ⋮ ⋱ ⋮             0  ⋯ 1 p_k1 ⋯ p_kq ⎤⎥⎥⎥⎦

in modo che P produca i q bit di protezione come c = m ⋅ P, in cui sono valide le normali regole di moltiplicazione tra matrici, tranne per l’accortezza di usare la somma modulo due anziché quella convenzionale. Il valore della (generica) j-esima (j = 1, 2, ⋯, q) componente di c si calcola pertanto come

c_j =  m₁ ⋅ p_1j ⊕ m₂ ⋅ p_2j ⊕ ⋯ ⊕ m_k ⋅ p_kj

in cui il prodotto tra cifre binarie equivale all’operatore logico di and.

17.4.1.1 Codice di Hamming

• m	c	w(x)
  0 0 0 0	0 0 0	0
  0 0 0 1	0 1 1	3
  0 0 1 0	1 1 0	3
  0 0 1 1	1 0 1	4
  0 1 0 0	1 1 1	4
  0 1 0 1	1 0 0	3
  0 1 1 0	0 0 1	3
  0 1 1 1	0 1 0	4

  m	c	w(x)
  1 0 0 0	1 0 1	3
  1 0 0 1	1 1 0	4
  1 0 1 0	0 1 1	4
  1 0 1 1	0 0 0	3
  1 1 0 0	0 1 0	3
  1 1 0 1	0 0 1	4
  1 1 1 0	1 0 0	4
  1 1 1 1	1 1 1	7

  Dato che sia m che c assumono tutte le configurazioni possibili, è verificata la linearità del codice (pag. 1), ossia che la somma di una qualunque coppia di codeword corrisponde ad una terza codeword. Notiamo infine che ciascuna della 2^q = 8 triplette di protezione c viene usata nel codebook per due volte, ma associata a coppie di sequenze m da proteggere con valori di distanza di Hamming almeno pari a tre.

Indichiamo ora con y la parola di codice ricevuta; in presenza di errori, risulta y ≠ x. Il metodo diretto per rivelare ed eventualmente correggere gli errori presenti è quello di confrontare gli n bit ricevuti con tutte le possibili 2^k codeword, e se nessuna di queste risulta uguale ad y, scegliere la x̂ con la minima distanza di Hamming, ossia quella per la quale il peso w(y ⊕ x̂) è minimo, ovvero

x̂ = argmin_x{w(y ⊕ x)}

17.4.1.2 Codice ciclico

17.4.1.3 Codice BCH

17.4.1.4 Codice di Reed-Solomon

Un codice di Reed Solomon (N, K) produce codeword di N simboli L − ari ogni K simboli (ognuno di k bit) di informazione prelevati da m; esistono formulazioni

in grado di produrre codebook sia di natura sistematica che non. La minima distanza del codice è pari a d_m = N − K + 1, ed i metodi di decodifica (su cui non ci addentriamo [957]   [957] Ma si veda ad es. http://scienze-como.uninsubria.it/previtali/Bellini-TeoriaInfoCodiciNote.pdf) permettono di correggere fino a t = d_m − 12 = N − K2 simboli L − ari per codeword; qualora la posizione dei simboli errati sia nota [958]   [958] Come nel caso dei codici a cancellazione, vedi ad es. https://en.wikipedia.org/wiki/Erasure_code può correggere il doppio dei simboli, ossia 2t. Dato che opera a livello di simbolo e non di singolo bit, non soffre del problema legato alle sequenze di errore come invece avviene per il codice di Hamming, almeno finché il numero di errori sul bit consecutivi non supera il valore t ⋅ k, ovvero non coinvolge più di t simboli.

17.4.1.5 Codifica concatenata

Figure 17.15 Schema di codifica concatenata

Ad ogni simbolo di k bit della codeword esterna vengono aggiunti q bit di ridondanza

da parte del codice interno, come mostrato a lato. Gli errori isolati introdotti da parte del canale sono corretti dal decodificatore interno, e se distanti tra loro per più di k + q bit, il codice esterno neanche si accorge di nulla; d’altra parte in assenza del codice interno, il solo codice di RS non sarebbe stato in grado di correggere più di N − K2 errori per codeword, qualora avvenuti ognuno in un simbolo diverso. Al contrario, in presenza di errori ravvicinati è il codice interno di Hamming a non poter fare nulla, anzi ne introduce di ulteriori, ma nello stesso simbolo: in tal caso il codice esterno di RS trova gli errori tutti concentrati in pochi simboli, e provvede alla loro correzione.

Qualora si manifestino sequenze di errore più lunghe di N − K2 ⋅ k bit, il numero di simboli del codice esterno che risultano errati diviene maggiore di quanto

esso non possa correggere, e lo schema precedente non funziona più. Per evitare questa situazione, tra i due stadi di codifica (e di decodifica) si frappone un blocco di interleaving (ed il suo inverso) (vedi § 15.6.2.3), come mostrato sopra.

Le aree grigie in figura rappresentano una lunga sequenza di errore, che il codice interno non riesce a correggere: finché M (detto fattore di interleaving) è maggiore della più lunga sequenza di simboli errati previsti, questi ultimi vanno a finire in codeword (esterne) differenti, e possono dunque essere ancora corretti. Mentre in assenza di interleaver, i simboli errati sarebbero potuti finire tutti dentro la stessa codeword esterna.

17.4.2 Codifica convoluzionale

A differenza della codifica a blocco, questa tecnica produce una sequenza binaria i cui valori dipendono da gruppi di bit di ingresso temporalmente sovrapposti, in analogia formale a quanto avviene con l’integrale di convoluzione, che calcola valori di uscita che dipendono da intervalli di quelli in ingresso, pesati dai valori della risposta

impulsiva. Un generico codice convoluzionale è indicato con la notazione CC(n, k, K), che lo descrive come capace di generare gruppi di n bit di uscita (sequenza {x}) in base alla conoscenza di K simboli di ingresso (sequenza {m}), ognuno composto da k bit.

Lo schema strutturale del codificatore, raffigurato a lato, ospita i K simboli della sequenza di ingresso (di k bit ciascuno) in un registro a scorrimento in cui per ogni nuovo simbolo m_j che entra da sinistra, i precedenti scorrono a destra, ed il più “vecchio” viene dimenticato. Ognuno degli n bit di uscita x_j(i), i = 1, 2, ..., n è calcolato eseguendo una somma modulo 2 tra alcuni dei k ⋅ K bit di ingresso, individuati da un vettore generatore g_i (i = 1, 2, ..., n) costituito da una parola binaria di k ⋅ K bit, zero od uno a seconda se l’i-esimo sommatore modulo due sia connesso (o meno) al corrispondente bit della finestra di ingresso.

Consideriamo il codice convoluzionale il cui schema è mostrato in fig. 17.21-a), che produce due bit di uscita per ogni bit di ingresso in funzione degli ultimi tre, ovvero CC(n, k, K) = CC(2, 1, 3), caratterizzato da un tasso di codifica R_c = kn = 12, da una lunghezza del vincolo L = K ⋅ k = 3, una memoria ν = (K − 1) ⋅ k = 2 ed un numero di stati 2^ν = 4, da ognuno dei quali si dipartono 2^k = 2 transizioni. Se scegliamo come vettori generatori le parole [965]   [965] Il valore di un vettore generatore viene spesso espresso in notazione ottale, dunque nel nostro caso avremmo g₁ = 7₈ e g₂ = 5₈. g₁ = (1 1 1) e g₂ = (1 0 1) si ottiene la tabella della verità di fig. 17.21-b), che mostra i valori di uscita x_j(i) ottenuti eseguendo gli xor descritti dai vettori g_i sulla parola di tre bit costituita dall’ultimo ingresso m_j e dai due precedenti ingressi, indicati come S_j, e che rappresentano appunto la memoria del passato all’istante j. Infine la fig. 17.21-c) rappresenta l’automa ed il diagramma di transizione corrispondente [966]   [966] In accordo allo schema https://it.wikipedia.org/wiki/Macchina_di_Mealy, in cui le transizioni tra stati sono disegnate con linee tratteggiate o continue a seconda se il valore m_j dell’ultimo ingresso sia pari a zero o ad uno, e sono etichettate con la coppia di bit in uscita x_j riportati nella tabella della verità.

a)    

   

   b)    

mj	Sj	xj(1)	xj(2)
0	00	0	0
0	01	1	1
0	10	1	0
0	11	0	1
1	00	1	1
1	01	0	0
1	10	0	1
1	11	1	0

   

c)   

Figure 17.21 a) - architettura del codice convoluzionale CC(2, 1, 3); b) - tabella della verità; c) - diagramma di transizione; le linee tratteggiate indicano uno zero in ingresso

Come si può verificare, ogni stato ha solo due transizioni, e dunque per ogni ingresso sono possibili solo due valori dei quattro 4 che sarebbero possibili con due bit; inoltre questi valori differiscono in entrambi i bit [967]   [967] La dipendenza di x_j da (m_j, S_j) è legata alla scelta dei generatori g_i. Nel caso in cui un valore x_j(i) sia sempre uguale ad uno dei k bit di m_j, il codice diviene sistematico..

Per meglio visualizzare le possibili sequenze di stati si adotta una rappresentazione detta diagramma a traliccio (trellis) del codificatore, ottenuta a partire dalla riorganizzazione grafica del diagramma di transizione (fig. 17.21-c)) come mostrato a sin. in fig. 17.22-a). Il traliccio è quello al centro, costituito da nodi disposti su tante righe quanti sono gli stati dell’automa, e tante colonne quanti sono gli istanti temporali che vogliamo considerare. I collegamenti tra colonne del traliccio corrispondono alle transizioni dell’automa: ponendo uno stato iniziale S_j = 0 = 00, si costruisce la colonna j = 1 riportando le due possibili transizioni, tratteggiata o continua a seconda che sia entrato uno zero od un uno, e si etichettano le transizioni con la parola x_j emessa in uscita. Il processo si ripete per tutti gli istanti temporali. In basso in figura è riportata una possibile sequenza codificata {x} trasmessa, in corrispondenza della quale l’effettivo percorso attraversato nel traliccio, e dunque la successione di stati {S} associata, è rappresentato dalle linee blu e più spesse.

   

Figure 17.22 a) - diagramma a traliccio e sequenza x trasmessa; b) - costi d_H per la sequenza ricevuta; le linee tratteggiate indicano uno zero in ingresso

17.4.2.1 Criterio di decodifica

Come già osservato non tutte le sequenze di stati (e di uscite) sono ammissibili; indichiamo con X il loro insieme. Consideriamo quindi la sequenza {x̃} osservata all’uscita di un canale rumoroso, e contenente errori. In virtù dei vincoli, nel caso di errori sufficientemente isolati non esiste una sequenza di stati {S} in grado di produrre esattamente la sequenza ricevuta {x̃}, e la correzione degli errori consiste nel trovare la sequenza {Ŝ} ammissibile e tale che la corrispondente uscita {x̂} sia la più simile a {x̃}.

La metrica adottata è la distanza di Hamming [968]   [968] Questo caso viene indicato con il termine hard-decision decoding in quanto il ricevitore ha già operato una decisione (quantizzazione) rispetto a x̃. Al contrario, se i valori ricevuti sono passati come sono al decodificatore di Viterbi, questo può correttamente valutare le probabilità p(x̃ ⁄ ^x) ed operare in modalità soft decoding, conseguendo prestazioni migliori. d_H(^x, x̃) tra le due sequenze, ossia il numero di bit diversi tra le due, ed il criterio di decodifica viene definito come

(21.109) {x̂} = argmin_{{x} ∈ X} {d_H(x, x̃)}

All’estremità destra di figura 17.24 viene indicato il percorso di minimo costo, e la corrispondente d_H(x, x̃) minima.

Figure 17.24 Decodifica di Viterbi come percorso di minimo costo

In effetti l’algoritmo calcola solamente la d_H minima, e per risalire alla sequenza di stati (e dunque di uscite) che l’ha prodotta, occorre (per ogni nodo del traliccio) memorizzare l’indice del nodo nella colonna precedente da cui parte l’arco che ha determinato il minor costo locale. Una volta individuato (all’ultima colonna) il nodo in cui termina il percorso di minor costo, svolgendo all’indietro la catena dei puntatori si trova la sequenza di stati {S} ottima (percorso verde a tratto spesso), e da questa in base alla fig. 17.22-a) sia la {m} che la {x̃}, che come si vede è quella esatta.

Tabelle:
  m(p, q)                       # ingresso m sull’arco da Sp a Sq
  x(p, q)                       # uscita x sull’arco da Sp a Sq
  A(p, q)                       # presenza di transizione da Sp a Sq
 
Inizializza:
per tutti gli stati p = 1, 2, ⋯2ν
  CJ(p) = 0
 
Iterazione:
per tutti gli istanti j = 1, 2, ⋯, J
  per tutti gli stati q = 1, 2, ⋯2ν
    CM(q) = CJ(q)             # miglior costo parziale al tempo j − 1
    CJ(q) = ∞                  # miglior costo fino a (q, j)
    per tutti gli stati p = 1, 2, ⋯, 2υ
      se A(p, q) =  = 1          # esiste transizione da p a q
        c = dH(x(p, q), x̃j) + CM(p)  # ipotesi da valutare
        se c < CJ(q)
          CJ(q) = c
          BP(q, j) = p          # backpointer al vincitore
 
Decodifica:
best = ∞
per tutti gli stati q = 1, 2, ⋯2ν
  se CJ(q) < best
    best = CJ(q)
    w = q                     # indice stato terminale
per tutti gli istanti j = J, ⋯, 2, 1
  p = BP(w, j)                 # miglior predecessore
  emette m(p, w)              # messaggio m scritto al contrario
  w = p

• l’esempio adottato si mostra in grado di correggere un errore pur impiegando un coding rate pari ad 12, migliore (ad es.) di quello ⎛⎝13⎞⎠ del codice a ripetizione;
• la d_H del miglior percorso corrisponde al numero di bit errati (nel caso in cui siano stati corretti) nella x̃ ricevuta, il che permette al decodificatore di stimare la qualità del collegamento;
• si verifica errore se esiste una x̂ ≠ x ammissibile e tale che d_H(^x, x̃) è minore di d_H(x, x̃). In tal caso la sequenza erroneamente decodificata x̂ contiene errori a pacchetto;
• le capacità di correzione del codice migliorano aumentando la d_H tra le possibili sequenze {x}. La minima distanza d_m tra sequenze codificate è denominata distanza libera, e può essere trovata come la d_H tra una {x⁰} tutta nulla ({x⁰} = {000000000}) e quella con il minor numero di uni, che si diparte e ritorna (nel traliccio) dallo/allo stato 00: nell’esempio di fig. 17.22a) si ottiene d_m = 5. Il decodificatore è in grado di correggere fino a d_m − 12 errori che si presentano in un intervallo pari al vincolo del codice L. Il codice del nostro esempio può dunque correggere 2 bit errati su 5;
• la distanza libera d_m aumenta con il rapporto Kk, in quanto la matrice di transizione tra stati diviene più sparsa, ed i valori di {x} sono più interdipendenti;
• se il miglioramento di cui sopra è ottenuto aumentando K, ciò equivale ad estendere nel tempo la memoria del codificatore, ma senza per questo alterare il tasso di codifica R_c = kn;
• in presenza di un flusso di dati continuo non ha senso attendere un istante finale (che non esiste) per poter individuare il percorso di minimo costo. In tal caso la decodifica parziale avviene con riferimento ad una colonna del traliccio temporalmente abbastanza lontana dall’ultimo istante j di ingresso, ad es. cinque volte la lunghezza del vincolo L, liberando di conseguenza la memoria occupata dai puntatori precedenti;
• dato che ad ogni istante-colonna sono scartati i percorsi che si incontrano con uno migliore, il numero di percorsi sopravvissuti è sempre pari al numero di stati 2^ν;
• all’aumentare del numero 2^ν di stati aumenta la complessità e l’occupazione di memoria dell’algoritmo di Viterbi, che può essere sostituito da tecniche di ricerca a fascio (beam search) che estendono solo i percorsi parziali più promettenti, ossia con minor costo parziale.

17.4.2.2 Tail biting

17.4.2.3 Decodifica a decisione soffice

La figura che segue riporta i valori della P^bit_e residua

per la decodifica di Viterbi di un CC con R_c = ¹⁄₂ al variare della lunghezza del vincolo L, il cui bitstream viene trasmesso mediante modulazione qpsk, in funzione del rapporto ^E_b⁄_N0 in ricezione. Osserviamo il conseguimento di un guadagno di codifica (pag. 1) che per una P_e = 10^− 5 va da circa 3.5 a 6 dB per le diverse scelte di L, che corrispondono a tralicci da 4 a 256 stati.

17.4.2.4 Altri schemi di codifica convoluzionale

Lo schema riportato nell’esempio di fig. 17.21 non è l’unico possibile. Anche se permette di variare il tasso di codifica R_c = kn variando i valori di k ed n, questi impattano anche su complessità del traliccio, lunghezza del vincolo L e distanza libera d_m; per

garantirsi la massima libertà di azione sui parametri della codifica, sono state definite anche architetture differenti. Lo schema riportato a lato ad esempio dispone i k = 2 bit di ingresso su due diversi rami, ed impiegando tre generatori, consegue un tasso R_c = kn = 23 con 64 stati, K = 8 ed L = 8.

Anche se non è stata affrontata la parte di teoria che descrive i CC in termini di risposta impulsiva e risposta in frequenza, non può sfuggire la similitudine tra le architetture illustrate e quelle dei filtri fir, pur se in logica modulo due. Ma esiste anche la possibilità di realizzare un CC ricorsivo, in cui cioè sono presenti operazioni xor

all’indietro e non solo in avanti, come nello schema mostrato in figura [978]   [978] In particolare, lo schema illustrato viene impiegato nella telefonia lte (ETSI TS 136 212) nell’ambito della codifica turbo, vedi § 17.5.1. che consegue R_c = ¹⁄₂, e che è anche sistematico in quanto un bit di uscita su due replica quello di ingresso.

17.4.2.5 Codice perforato

Modificare completamente l’architettura del codificatore non sembra la scelta migliore per poter variare R_c, dato che ciò comporta la totale modifica del traliccio su cui è basata la decodifica. Una diversa opzione è quella di omettere del tutto la trasmissione di alcuni dei bit presenti nella sequenza codificata, operazione nota come perforazione (puncturing) del codice: ad esempio eliminare un bit ogni tre dall’uscita di un CC con R_c = ¹⁄₂ determina un nuovo R_c = ³⁄₄, dato che servono ora tre bit di ingresso per produrne quatto di uscita, anziché sei. Ovviamente in questo

caso le capacità correttive peggiorano, ma il processo di decodifica può aver luogo comunque dato che il ricevitore conosce le posizioni non trasmesse, e per esse considera una distanza neutra pari a 0.5, come esemplificato alla tabella a lato, dove con δ_i si indica la distanza (hard o soft) tra l’i − esimo bit nella sequenza ricostruita, e le corrispondenti ipotesi espresse dal traliccio.

   

Rc	1⁄2	2⁄3	3⁄4	5⁄6	7⁄8
matrice di	1	10	101	10101	1000101
perforazione	1	11	110	11010	1111010
dm	10	6	5	4	3

17.4.2.6 Concatenazione Solomon-Viterbi

17.4.2.7 Viterbi con uscite soffici

Adottiamo per semplicità un CC sui cui nodi del traliccio convergono due sole transizioni, e prendiamo in considerazione un istante i in cui per ognuno dei 2^ν stati [981]   [981] Si è volutamente mantenuta la notazione introdotta al § 17.4.2. s_i occorre scegliere tra due ipotesi di percorso parziale, che indicizziamo con h = 1, 2. Indicando con δ un istante del passato per il quale tutti i 2^ν percorsi superstiti condividono con elevata probabilità un medesimo progenitore (vedi fig. 17.30)

Figure 17.30 Traliccio con cui illustrare il funzionamento di sova.
Due percorsi convergono su uno stesso stato s_i,
e le sequenze informative associate differiscono in due istanti

la decisione all’istante i avviene confrontando i costi parziali

(21.114)
C_h = ⎲⎳ⁱ_{j = i − δ} d_E(y_j, x^(h)_j)         h = 1, 2

in cui y_j è la parola (soft) di n bit ricevuta all’istante j ed x^(h)_j è la parola (con valori ±1) emessa allo stesso istante dal codice in corrispondenza del h−esimo percorso. Ricordando quanto discusso al § 17.4.2.3, la (21.114) è legata in modo diretto alla verosimiglianza logaritmica − ln (p(y ⁄ x^(h))) delle ipotesi x^(h) avendo osservato y; pertanto è lecito assumere che

Prob{percorso h} ≈ e^− C_h      h = 1, 2

indicando con  ≈  una qualunque relazione monotona crescente. Assumendo ora h = 1 l’indice del miglior percorso e h = 2 di quello scartato (e dunque C₁ < C₂), la probabilità di aver scelto il percorso sbagliato è pari a

(21.115)
p_si = e^− C₂e^− C₁ + e^− C₂ = 11 + e^{C₂ − C₁} = 11 + e^Δ

con Δ = C₂ − C₁ ≥ 0. Dunque p_si è pari a 0.5 quando C₂ = C₁ mentre tende a zero qualora C₂ ≫ C₁; in altre parole quanto più i due costi sono simili, tanto più la decisione potrebbe essere errata.

Licenza Creative Commons BY-NC-SA	Ottieni il PDF o la Stampa Storia Blog
	Trasmissione dei Segnali e Sistemi di Telecomunicazione è un progetto ventennale di cultura libera evoluto fino alla forma attuale
Come vedi non c'è traccia di pubblicità, ma in compenso adoriamo le Donazioni