cerca
Informatica Teorica - Decidibilità
modifica cronologia stampa login logout

Wiki

UniCrema


Materie per semestre

Materie per anno

Materie per laurea


Help

Uni.IT-Decidibilità History

Hide minor edits - Show changes to output

Changed lines 29-30 from:
Anche se così facendo abbiamo già dimostrato il teorema, diamo qualche altro dettaglio implementativo. Anzitutto B non è altro che la quintupla che definisce un DFA, e quindi ''Q, Σ, δ, q'_0_', F''. Quindi M come prima cosa verificherà che B sia effettivamente un DFA (altrimenti RIFIUTA subito), quindi simulerà la stringa w direttamente su di lui. Come? Scrivendo ad ogni passo sul nastro lo stato e la posizione corrente di B sull'ingresso w, che sarà inizialmente q'_0_' e dovrà rispettare ad ogni step la funzione di transizione δ. Quando M arriverà a processare l'ultimo simbolo di w, dovrà verificare se è arrivato in uno degli stati finali accettati dal DFA, e accettare o rifiutare la stringa d'ingresso di conseguenza.
to:
Anche se abbiamo già dimostrato il teorema, diamo qualche altro dettaglio implementativo. Anzitutto B non è altro che la quintupla che definisce un DFA, e quindi ''Q, Σ, δ, q'_0_', F''. Quindi M come prima cosa verificherà che B sia effettivamente un DFA (altrimenti RIFIUTA subito), quindi simulerà la stringa w direttamente su di lui. Come? Scrivendo ad ogni passo sul nastro lo stato e la posizione corrente di B sull'ingresso w, che sarà inizialmente q'_0_' e dovrà rispettare ad ogni step la funzione di transizione δ. Quando M arriverà a processare l'ultimo simbolo di w, dovrà verificare se è arrivato in uno degli stati finali accettati dal DFA, e accettare o rifiutare la stringa d'ingresso di conseguenza.
Changed lines 60-61 from:
Verificare che un DFA non accetti nessuna stringa significa dimostrare che il suo linguaggio è vuoto, ovvero che nessuna stringa gli appartenga. Viceversa, si ricorda che un DFA accetta una stringa se e solo se è possibile raggiungere uno stato finale utilizzando le sue funzioni di transizione.
to:
Verificare che un DFA non accetti nessuna stringa significa dimostrare che il suo linguaggio è vuoto, ovvero che nessuna stringa gli appartiene. Viceversa, si ricorda che un DFA accetta una stringa se e solo se è possibile raggiungere uno stato finale utilizzando le sue funzioni di transizione.
Changed lines 86-87 from:
Per la dimostrazione si procederà a definire un terzo automa a stati finiti che accetti le stringhe di A o quelle di B, ma non entrambe. Per realizzarlo si potranno usare solo le operazioni di intersezione, unione o complemento, perché sono le uniche ad essere chiuse rispetto ai linguaggi regolari. In particolare si utilizzerà la formula della ''differenza simmetrica'':
to:
Per la dimostrazione si procederà a definire un terzo automa a stati finiti C che accetti le stringhe di A o quelle di B, ma non entrambe. Per realizzarlo si potranno usare solo le operazioni di intersezione, unione o complemento, perché sono chiuse rispetto ai linguaggi regolari. In particolare si utilizzerà la formula della ''differenza simmetrica'':
Changed lines 110-111 from:

Se ci mettessimo a fare tutte le derivazioni di G per vedere se una di queste è una derivazione di w
, nel caso in cui questo non fosse vero potremmo andare avanti all'infinito. L'alternativa è usare la grammatica G in forma normale di Chomsky, perché in questo caso le derivazioni di w sarebbero solo 2n-1 (dove n è la lunghezza della stringa), e avremmo la garanzia di trovare una soluzione in un numero finito di passi.\\
to:
Metterci a fare tutte le derivazioni di G per vedere se una di queste è una derivazione di w sarebbe folle, perché nel caso in cui non fosse vero potremmo andare avanti all'infinito. L'alternativa è usare la grammatica G in forma normale di Chomsky, perché in questo caso le derivazioni di w sarebbero solo 2n-1 (dove n è la lunghezza della stringa), e avremmo la garanzia di trovare una soluzione in un numero finito di passi.\\
Changed lines 133-134 from:
Come prima cosa dovremo scorrere la CFG e marcare tutti i terminali. Successivamente si passa a scansionare le regole, e se da una di queste risulta che una variabile può essere sostituita da terminali segnati, marchiamo anche lei. L'operazione va ripetuta marcando tutte le variabili ottenute a partire da simboli (terminali/variabili) già marcati. Se si arriva a marcare anche la variabile iniziale significa che da lei posso raggiungere una sequenza composta solo da terminali, quindi la MdT R che risolve E'_CFG_' dovrà rifiutare tale eventualità.
to:
Come prima cosa dovremo scorrere la CFG e marcare tutti i terminali. Successivamente si passa a scansionare le regole, e se da una di queste risulta che una variabile può essere sostituita da terminali marcati, marchiamo anche lei. L'operazione va ripetuta marcando tutte le variabili ottenute a partire da simboli (terminali/variabili) già marcati. Se si arriva a marcare anche la variabile iniziale significa che da lei posso raggiungere una sequenza composta solo da terminali, quindi la MdT R che risolve E'_CFG_' dovrà rifiutare tale eventualità.
Changed lines 139-140 from:
-->3. marca ogni variabile A in cui G abbia una regola ''A->U'_1_'...U'_k_''' in cui ogni U'_1_', ... , U'_k_' sia già marcato;
to:
-->3. marca ogni variabile A in cui G abbia una regola ''A->U'_1_'...U'_k_''' in cui ogni U'_1_', ... , U'_k_'
--->
sia già marcato;
Changed lines 174-179 from:
L'indecidibilità la dimostriamo con il '''metodo della diagonalizzazione''' scoperto dal matematico Cantor per misurare la dimensione di insiemi infiniti. Poiché in collezioni infinite non è possibile contare gli elementi che ne fanno parte, per capire se due insiemi sono della stessa dimensione si verifica se è possibile mettere in corrispondenza gli elementi dell'uno con quelli dell'altro. Più formalmente, due insiemi infiniti A e B sono della stessa dimensione se esiste una ''corrispondenza'' f:A->B. Per corrispondenza si intende una funzione biettiva da A a B, quindi ogni elemento di A può corrispondere a un solo elemento di B, e ogni elemento di B ha un unico di elemento di A che corrisponde ad esso.

Facciamo un esempio: l'insieme N dei numeri naturali ha la stessa dimensione dell'insieme E dei numeri naturali pari? Esiste una corrispondenza f tra i due? Sì: f(n) = 2n.

Anche se sembra che ci stiamo
allontanando dall'obiettivo (dimostrare che A'_TM_' è indecidibile), dobbiamo introdurre un po' di teoremi e dimostrazioni di tipo matematico. Torneranno utilissime poi.
to:
L'indecidibilità la dimostriamo con il '''metodo della diagonalizzazione''' scoperto dal matematico Cantor per misurare la dimensione degli insiemi infiniti. Poiché in collezioni infinite non è possibile contare gli elementi che ne fanno parte, per capire se due insiemi sono della stessa dimensione si verifica se è possibile mettere in corrispondenza gli elementi dell'uno con quelli dell'altro. Più formalmente, due insiemi infiniti A e B sono della stessa dimensione se esiste una ''corrispondenza'' f:A->B. Per corrispondenza si intende una funzione biettiva da A a B, quindi ogni elemento di A può corrispondere a un solo elemento di B, e ogni elemento di B ha un unico di elemento di A che corrisponde ad esso.

Facciamo un esempio: l'insieme N dei numeri naturali ha la stessa dimensione dell'insieme E dei numeri naturali pari? Esiste una corrispondenza f tra i due? Sì: f(n) = 2n. Quindi hanno stessa dimensione.

Anche se sembrerà di starci
allontanando dall'obiettivo (dimostrare che A'_TM_' è indecidibile), dobbiamo introdurre un po' di teoremi e dimostrazioni di tipo matematico. Torneranno utilissime poi.
Changed lines 191-192 from:
Trovare una corrispondenza tra i due insiemi non è banale, ma comunque possibile. Come prima cosa creiamo una matrice bidimensionale |N|x|N| e scriviamo in ogni cella (i,j) il numero razionale i/j. A questo punto creiamo una lista di numeri spostandoci sulle diagonali ed evitando le ripetizioni (ad esempio 1/1 e 2/2 sono lo stesso valore), secondo lo schema mostrato in figura:
to:
Trovare una corrispondenza tra i due insiemi non è banale, ma comunque possibile. Come prima cosa creiamo una matrice bidimensionale |N|x|N| e scriviamo in ogni cella (i,j) il numero razionale i/j. A questo punto creiamo una lista di numeri spostandoci sulle diagonali ed evitando le ripetizioni (ad esempio 1/1 e 2/2 sono lo stesso valore, quindi li contiamo una sola volta), secondo lo schema mostrato in figura:
Changed lines 206-207 from:
Supponiamo che f(n) sia una corrispondenza tra R ed N, e costruiamoci su misura una x che appartenga ad R ma non abbia corrispondente in N. Per capire come, partiamo da un esempio:
to:
Supponiamo che f(n) sia una corrispondenza tra R ed N, e costruiamoci su misura una x che appartenga ad R ma non abbia corrispondenza in N. Per capire come, partiamo da un esempio:
Changed lines 215-216 from:
Questa costruzione ci dà garanzia che x sia diverso da qualsiasi elemento di R messo in corrispondenza con N (da una fantomatica f(n) che per assurdo abbiamo supposto esistesse). Dato che x sfugge alla corrispondenza pur appartenendo all'insieme dei numeri reali, R ed N non sono della stessa dimensione e in particolare R non è contabile.
to:
Questa costruzione ci dà garanzia che x sia diverso da qualsiasi elemento di R messo in corrispondenza con N (da una fantomatica f(n) che per assurdo abbiamo supposto esistesse). Dato che x sfugge alla corrispondenza pur appartenendo all'insieme dei numeri reali, R ed N non sono della stessa dimensione, e in particolare R non è contabile.
Changed lines 228-229 from:
La chiave della dimostrazione è che l'insieme dei linguaggi possibili non è contabile, mentre quello delle macchine di Turing sì; dato che una MdT riconosce un solo linguaggio, alcuni linguaggi rimarranno tagliati fuori: quelli non Turing-riconoscibili. Questo ci basterebbe se fossimo al bar a parlare di Turing-riconoscibilità, ma siccome - e per fortuna - non lo siamo dobbiamo verificare ogni affermazione.
to:
La chiave della dimostrazione è che l'insieme dei linguaggi possibili non è contabile, mentre quello delle macchine di Turing sì; dato che una MdT riconosce un solo linguaggio, alcuni linguaggi rimarranno tagliati fuori: quelli non Turing-riconoscibili. Questa spiegazione ci basterebbe se fossimo al bar a parlare di Turing-riconoscibilità, ma siccome - e per fortuna - non lo siamo dobbiamo verificare ogni affermazione.
Changed lines 231-232 from:
Dato un generico alfabeto &#931;, l'insieme di tutte le stringhe &#931;'^*^' da lui definite è contabile perché è possibile fare una lista di tutte le stringhe di una certa lunghezza (finita). Dal momento che ogni MdT può essere codificata come una stringa <M>, anche l'insieme delle MdT è contabile.
to:
Dato un generico alfabeto &#931;, l'insieme di tutte le stringhe &#931;'^*^' da lui definite è contabile perché è possibile fare una lista di tutte le stringhe di una certa lunghezza (che è finita). Dal momento che ogni MdT può essere codificata come una stringa <M>, anche l'insieme delle MdT è contabile.
Changed line 253 from:
Anche in questo caso la dimostrazione sarà per assurdo.\\
to:
Anche in questo caso la dimostrazione avverrà per assurdo.\\
Changed line 257 from:
Supponiamo di avere un decisore H del linguaggio, tale che:
to:
Supponiamo di avere un decisore H del linguaggio tale che:
Changed line 282 from:
Mi sembra di sentirvi dire: "E in tutto questo la diagonalizzazione dove sta?". Avete ragione a chiederlo, a chi interessa uscire all'aria aperta?\\
to:
Mi sembra di sentirvi dire: "E in tutto questo la diagonalizzazione dove sta?".\\
Changed line 239 from:
->[@ A = { 0, 1, 01, 11, 000, 010, ...}
to:
->A = { 0, 1, 01, 11, 000, 010, ...}
Changed lines 238-240 from:
->&#931;'^*^'[@ = {&#949;, 0, 1, 00, 01, 10, 11, 000, 001, 010, ...}@]
->[@ A = { 0, 1, 01, 11, 000, 010, ...}@]
->X'_A_'[@ = 0 1 1 0 1 0 1 1 0 1 ...@]
to:
->&#931;'^*^'= {&#949;, 0, 1, 00, 01, 10, 11, 000, 001, 010, ...}
->[@ A = { 0, 1, 01, 11, 000, 010, ...}
->X'_A_' = 0 1 1 0 1 0 1 1 0 1 ...
Changed lines 188-189 from:
Per la dimostrazione usiamo come esempio quello dei numeri razionali positivi Q, così definibili:
[@Q = {(m/n) | m,n &#8712; N}@]
to:
Per la dimostrazione usiamo come esempio quello dei numeri razionali positivi Q, così definibili:\\
''
Q = {(m/n) | m,n &#8712; N}''
Changed lines 189-190 from:
[@Q = {(m/n) | m,n &#1013; N}@]
to:
[@Q = {(m/n) | m,n &#8712; N}@]
Changed line 205 from:
Dimostriamo il teorema per assurdo, sostenendo che R è contabile e che quindi esiste una sua corrispondenza con N. Questo ci semplifica la vita, perché basterà trovare una x&#1013;R che non sia compresa nella corrispondenza per mostrare la contraddizione della tesi.\\
to:
Dimostriamo il teorema per assurdo, sostenendo che R è contabile e che quindi esiste una sua corrispondenza con N. Questo ci semplifica la vita, perché basterà trovare una x&#8712;R che non sia compresa nella corrispondenza per mostrare la contraddizione della tesi.\\
Changed lines 152-153 from:
Sia A un qualsiasi linguaggio libero dal contesto generato dalla CFG G. Per la dimostrazione sfruttiamo la MdT S definita nel teorema di A'_CFG_', e scriviamo la macchina di Touring M'_G_' che decide A:
to:
Sia A un qualsiasi linguaggio libero dal contesto generato dalla CFG G. Per la dimostrazione sfruttiamo la MdT S definita nel teorema di A'_CFG_', e scriviamo la macchina di Turing M'_G_' che decide A:
Changed lines 160-162 from:
Non è meraviglioso?

...to be continued
to:
!!Teorema 8 - sull'indecidibilità dell'Halting Problem
Non tutti i problemi sono algoritmicamente risolvibili, e il più famoso di questi è l' '''Halting Problem''': dato un programma ed una precisa specifica di cosa il programma debba fare, verificare che il programma funzioni come specificato. Il tutto si può ridurre al problema di verificare se una MdT accetta una data stringa in ingresso:\\
''A'_TM_' = {<M,w> | M è una MdT e M accetta w}''

A'_TM_' è Turing-riconoscibile, e infatti scrivere una MdT U che lo riconosca è decisamente semplice:

>>left bgcolor=#fbf3ff width=auto border='2px solid #cccccc' padding=5px<<
U = "su ingresso <M,w>:
# esegui M sull'ingresso w;
# se M entra nello stato di accettazione, allora ACCETTA; se M entra invece nello stato di rifiuto, RIFIUTA."
>><<

Qual è il problema allora? Che se M non termina su w, allora la macchina va in loop sull'ingresso <M,w>. Il fatto che non possa uscire da questo loop rende il problema '''indecidibile'''.

L'indecidibilità la dimostriamo con il '''metodo della diagonalizzazione''' scoperto dal matematico Cantor per misurare la dimensione di insiemi infiniti. Poiché in collezioni infinite non è possibile contare gli elementi che ne fanno parte, per capire se due insiemi sono della stessa dimensione si verifica se è possibile mettere in corrispondenza gli elementi dell'uno con quelli dell'altro. Più formalmente, due insiemi infiniti A e B sono della stessa dimensione se esiste una ''corrispondenza'' f:A->B. Per corrispondenza si intende una funzione biettiva da A a B, quindi ogni elemento di A può corrispondere a un solo elemento di B, e ogni elemento di B ha un unico di elemento di A che corrisponde ad esso.

Facciamo un esempio: l'insieme N dei numeri naturali ha la stessa dimensione dell'insieme E dei numeri naturali pari? Esiste una corrispondenza f tra i due? Sì: f(n) = 2n.

Anche se sembra che ci stiamo allontanando dall'obiettivo (dimostrare che A'_TM_' è indecidibile), dobbiamo introdurre un po' di teoremi e dimostrazioni di tipo matematico. Torneranno utilissime poi.

!!!Insiemi contabili

>>left bgcolor=#f5f9fc width=auto border='2px solid #cccccc' padding=5px<<
Un insieme A è detto contabile se è finito o se ha la stessa dimensione di N.
>><<

'''Dimostrazione'''

Per la dimostrazione usiamo come esempio quello dei numeri razionali positivi Q, così definibili:
[@Q = {(m/n) | m,n &#1013; N}@]

Trovare una corrispondenza tra i due insiemi non è banale, ma comunque possibile. Come prima cosa creiamo una matrice bidimensionale |N|x|N| e scriviamo in ogni cella (i,j) il numero razionale i/j. A questo punto creiamo una lista di numeri spostandoci sulle diagonali ed evitando le ripetizioni (ad esempio 1/1 e 2/2 sono lo stesso valore), secondo lo schema mostrato in figura:

%center%Attach:IT-diagon.gif

Questa lista dimostra l'esistenza di una corrispondenza tra N e Q, quindi i due insiemi infiniti hanno la stessa dimensione.

!!!Insiemi non contabili - Teorema

>>left bgcolor=#f5f9fc width=auto border='2px solid #cccccc' padding=5px<<
L'insieme dei numeri reali R non è contabile.
>><<

'''Dimostrazione'''

Dimostriamo il teorema per assurdo, sostenendo che R è contabile e che quindi esiste una sua corrispondenza con N. Questo ci semplifica la vita, perché basterà trovare una x&#1013;R che non sia compresa nella corrispondenza per mostrare la contraddizione della tesi.\\
Supponiamo che f(n) sia una corrispondenza tra R ed N, e costruiamoci su misura una x che appartenga ad R ma non abbia corrispondente in N. Per capire come, partiamo da un esempio:

%center%Attach:IT-noncont1.gif

Costruiamo la x in questo modo: '' x = 0 , c'_1_' c'_2_' ... c'_n_' ''\\
dove la cifra decimale c'_i_' deve essere diversa dalla i-sima cifra decimale dell'i-simo elemento. Riprendendo il nostro esempio:

%center%Attach:IT-noncont2.gif

Questa costruzione ci dà garanzia che x sia diverso da qualsiasi elemento di R messo in corrispondenza con N (da una fantomatica f(n) che per assurdo abbiamo supposto esistesse). Dato che x sfugge alla corrispondenza pur appartenendo all'insieme dei numeri reali, R ed N non sono della stessa dimensione e in particolare R non è contabile.

Si noti che in questa dimostrazione si è sfruttato ancora un metodo che sfrutta la diagonali. Benedetto Cantor.

!!!!Insiemi non contabili - Corollario
Ci stiamo finalmente avvicinando al nostro obiettivo: dimostrare che A'_TM_' non è decidibile. Ci serve ancora quest'ultimo teorema:

>>left bgcolor=#f5f9fc width=auto border='2px solid #cccccc' padding=5px<<
Alcuni linguaggi non sono Turing-riconoscibili.
>><<

'''Dimostrazione'''

La chiave della dimostrazione è che l'insieme dei linguaggi possibili non è contabile, mentre quello delle macchine di Turing sì; dato che una MdT riconosce un solo linguaggio, alcuni linguaggi rimarranno tagliati fuori: quelli non Turing-riconoscibili. Questo ci basterebbe se fossimo al bar a parlare di Turing-riconoscibilità, ma siccome - e per fortuna - non lo siamo dobbiamo verificare ogni affermazione.

''I. L'insieme delle MdT è contabile''\\
Dato un generico alfabeto &#931;, l'insieme di tutte le stringhe &#931;'^*^' da lui definite è contabile perché è possibile fare una lista di tutte le stringhe di una certa lunghezza (finita). Dal momento che ogni MdT può essere codificata come una stringa <M>, anche l'insieme delle MdT è contabile.

''II. L'insieme dei linguaggi non è contabile''\\
Definiamo ''sequenza binaria infinita'' una sequenza infinita di 0 e di 1, ad esempio 01011010010101011010110101011010110..\\
Definiamo B l'insieme di tutte le sequenze binarie infinite, e si può dimostrare che non è contabile utilizzando lo stesso metodo della diagonalizzazione usato per l'insieme dei numeri reali R. \\
Definiamo ora L l'insieme dei linguaggi definiti sull'alfabeto &#931; e cerchiamo una relazione tra L e B. Lo scopo è chiaro: se la troviamo abbiamo dimostrato che l'insieme dei linguaggi non è contabile.\\
Dato un linguaggio A appartenente ad L, definiamo ''sequenza caratteristica'' di A (X'_A_') la sequenza binaria in cui ogni bit vale 1 se A usa una possibile stringa del linguaggio, 0 altrimenti. Facciamo un esempio:
->&#931;'^*^'[@ = {&#949;, 0, 1, 00, 01, 10, 11, 000, 001, 010, ...}@]
->[@ A = { 0, 1, 01, 11, 000, 010, ...}@]
->X'_A_'[@ = 0 1 1 0 1 0 1 1 0 1 ...@]

Possiamo quindi affermare che esiste una funzione f:L->B, dove f(A) è la sequenza caratteristica di A che è unica in B. L'esistenza della funzione ci permette finalmente di sostenere che se B non è contabile nemmeno l'insieme dei linguaggi L lo è.

!!!Non decidibilità di A'_TM_'
Ci siamo, possiamo dimostrare che:

>>left bgcolor=#f5f9fc width=auto border='2px solid #cccccc' padding=5px<<
A'_TM_' è non decidibile.
>><<

'''Dimostrazione'''

Anche in questo caso la dimostrazione sarà per assurdo.\\
Ricordiamo che:\\
''A'_TM_' = {<M,w> | M è una MdT e M accetta w}''

Supponiamo di avere un decisore H del linguaggio, tale che:
[@
H(<M,w>) = / ACCETTA se M accetta w
\ RIFIUTA se M non accetta w@]

Costruiamo ora una MdT D che usi H come sottoprocedura e faccia esattamente l'opposto:

>>left bgcolor=#fbf3ff width=auto border='2px solid #cccccc' padding=5px<<
D: "su ingresso <M>:
# esegui H sull'ingresso <M,<M>>; ''(dove M è la stringa che descrive la MdT)''
# se H accetta, allora RIFIUTA; altrimenti ACCETTA."
>><<

Il comportamento di D è quindi il seguente:
[@
D(<M>) = / ACCETTA se M non accetta <M>
\ RIFIUTA se M accetta <M>@]

Cosa succede se chiediamo a D di girare su sé stesso?
[@
D(<D>) = / ACCETTA se D non accetta <D> ????
\ RIFIUTA se D accetta <D> ????@]

In entrambi i casi il decisore ciocca, perché dovrebbe tenere il comportamento opposto a sé stesso. Siamo dunque arrivati a una contraddizione, dimostrando così per assurdo che A'_TM_' non è decidibile.

Mi sembra di sentirvi dire: "E in tutto questo la diagonalizzazione dove sta?". Avete ragione a chiederlo, a chi interessa uscire all'aria aperta?\\
Ri-rappresentiamo il tutto con una bella matrice: come indice di ogni riga mettiamo la MdT M'_i_', e come indice delle colonne la stringa <M'_j_'>. Se una M'_i_' accetta una stringa <M'_j_'>, scriveremo [@accetta@] nella cella (i,j), [@rifiuta@] altrimenti. Aggiungiamo poi un'ultima riga per il decisore D, e un'ultima colonna per la stringa <D> che lo descrive. La riga D è riempita scrivendo l'opposto delle celle che si trovano sulla diagonale della stessa colonna. Bene: che diavolo scriviamo nella cella che incrocia D e <D>? Appunto. Abbiamo così ritrovato la stessa contraddizione di prima su una diagonale, e questo non può che renderci felici.

%center%Attach:IT-atmnondec.gif

!!Teorema 9 - sui linguaggi co-Turing riconoscibili
Un linguaggio è ''non-Turing riconoscibile'' o '''co-Turing riconoscibile''' se è il complemento di un linguaggio Turing-riconoscibile.

>>left bgcolor=#f5f9fc width=auto border='2px solid #cccccc' padding=5px<<
Un linguaggio è decidibile se e solo se è Turing-riconoscibile e co-Turing riconoscibile.
>><<

'''Dimostrazione'''

Per abbreviare, consideriamo un linguaggio A e chiamiamo:
* A'_dec_': "A decidibile";
* A'_Tu_': "A Turing-riconoscibile";
* A'_coTu_': "A co-Turing-riconoscibile".

Dimostriamo entrambi i sensi del "se e solo se".

''I. Se A'_dec_' allora A'_Tu_' &#923; A'_coTu_' ''\\
Se un linguaggio A è decidibile è per forza di cose anche Turing-riconoscibile, e dato che il complemento di un linguaggio decidibile è anch'esso decidibile, A sarà anche co-Turing-riconoscibile.

''I. Se A'_Tu_' &#923; A'_coTu_' allora A'_dec_' ''\\
Introduciamo il riconoscitore M'_1_' per il linguaggio A, e il riconoscitore M'_2_' per il complemento del linguaggio A. Definiamo ora una MdT M che sia decisore per A:

>>left bgcolor=#fbf3ff width=auto border='2px solid #cccccc' padding=5px<<
M: "su ingresso w:
# esegui M'_1_' e M'_2_' in parallelo sull'ingresso w; ''(M dovrà dunque avere due nastri, uno per decisore)''
# se M'_1_' accetta, allora ACCETTA; se M'_2_' accetta, allora RIFIUTA."
>><<

Dimostriamo che M è un decisore per A:
* dato che ogni stringa w può essere in A o nel suo complemento, o M'_1_' o M'_2_' la accetteranno;
* dato che M termina quando o M'_1_' o M'_2_' accettano, M terminerà sicuramente.
Per entrambi i motivi, M è un decisore di A, e quindi A è decidibile.

!!Teorema 10 - corollario al Teorema 9

>>left bgcolor=#f5f9fc width=auto border='2px solid #cccccc' padding=5px<<
Il complemento di A'_TM_' è Turing-riconoscibile.
>><<

'''Dimostrazione'''

Visto che A'_TM_' non è decidibile, o A'_TM_' o il suo complemento saranno sicuramente non riconoscibili. Dato però che all'inizio del paragrafo sul Teorema 8 abbiamo dimostrato che A'_TM_' è Turing-riconoscibile, il suo complemento non può esserlo, o per il Teorema 9 A'_TM_' diventerebbe decidibile.
Added lines 1-165:
(:title Informatica Teorica - Decidibilità:)
[[Torna alla pagina di Informatica Teorica-> Informatica Teorica]]
----

%titolo%''':: Informatica Teorica - Decidibilità ::'''

%center% %sottotitolo% Appunti & Dimostrazioni del 21 Aprile

!!Teorema 1 - A'_DFA_' è decidibile
Sia dato il problema di verificare se un automa a stati finiti deterministico accetta una stringa. Più formalmente:\\
''A'_DFA_' = {<B,w> | B è un DFA che accetta la stringa in ingresso w}''

Si dimostri il seguente teorema:

>>left bgcolor=#f5f9fc width=auto border='2px solid #cccccc' padding=5px<<
A'_DFA_' è un linguaggio decidibile.
>><<

'''Dimostrazione'''

Dobbiamo trovare una MdT deterministica che lo risolva:

>>left bgcolor=#fbf3ff width=auto border='2px solid #cccccc' padding=5px<<
M = "su ingresso <B,w>:
# simula B su w;
# se la simulazione finisce in uno stato finale, allora ACCETTA; altrimenti RIFIUTA."
>><<

Anche se così facendo abbiamo già dimostrato il teorema, diamo qualche altro dettaglio implementativo. Anzitutto B non è altro che la quintupla che definisce un DFA, e quindi ''Q, &#931;, &#948;, q'_0_', F''. Quindi M come prima cosa verificherà che B sia effettivamente un DFA (altrimenti RIFIUTA subito), quindi simulerà la stringa w direttamente su di lui. Come? Scrivendo ad ogni passo sul nastro lo stato e la posizione corrente di B sull'ingresso w, che sarà inizialmente q'_0_' e dovrà rispettare ad ogni step la funzione di transizione &#948;. Quando M arriverà a processare l'ultimo simbolo di w, dovrà verificare se è arrivato in uno degli stati finali accettati dal DFA, e accettare o rifiutare la stringa d'ingresso di conseguenza.

!!Teorema 2 - A'_NFA_' è decidibile

>>left bgcolor=#f5f9fc width=auto border='2px solid #cccccc' padding=5px<<
A'_NFA_' è un linguaggio decidibile.
>><<

'''Dimostrazione'''

Quello che cambia rispetto al Teorema 1 è che ora abbiamo a che fare con un automa non deterministico. Poco male, sapendo che ogni NFA ha un DFA corrispondente, definiamo la MdT non deterministica che lo risolve:

>>left bgcolor=#fbf3ff width=auto border='2px solid #cccccc' padding=5px<<
N = "su ingresso <B,w>:
# converti NFA B in DFA C;
# esegui M sull'ingresso <C,w>;
# se M accetta, allora ACCETTA; altrimenti RIFIUTA."
>><<

!!Teorema 3 - E'_DFA_' è decidibile
Il problema '''Emptiness''' verifica se un automa a stati finiti non accetta alcuna stringa, ovvero:\\
''E'_DFA_' = {<A> | A è un DFA e L(A)=0}''

Si dimostri ora il seguente teorema:

>>left bgcolor=#f5f9fc width=auto border='2px solid #cccccc' padding=5px<<
E'_DFA_' è un linguaggio decidibile.
>><<

'''Dimostrazione'''

Verificare che un DFA non accetti nessuna stringa significa dimostrare che il suo linguaggio è vuoto, ovvero che nessuna stringa gli appartenga. Viceversa, si ricorda che un DFA accetta una stringa se e solo se è possibile raggiungere uno stato finale utilizzando le sue funzioni di transizione.

Diventa dunque facile definire una MdT deterministica T che risolva E'_DFA_':

>>left bgcolor=#fbf3ff width=auto border='2px solid #cccccc' padding=5px<<
T = "su ingresso <A>: ''(dove A è un DFA)''
->1. marca lo stato iniziale di A;
->2. ripeti finché non trovi nuovi stati marcati:
-->3. marca un nuovo stato con transizione proveniente da uno stato già marcato
->4. se lo stato finale è marcato allora RIFIUTA; altrimenti ACCETTA."
>><<

Il punto (4) è ovvio: se si avesse uno stato finale marcato significherebbe che una stringa è accettata dal DFA in ingresso, e quindi T deve rifiutare.

!!Teorema 4 - EQ'_DFA_' è decidibile
Il problema '''Equivalence''' verifica se due automi a stati finiti riconoscono lo stesso linguaggio, ovvero:\\
''EQ'_DFA_' = {<A,B> | A e B sono due DFA L(A)=L(B)}''

Si dimostri ora il seguente teorema:

>>left bgcolor=#f5f9fc width=auto border='2px solid #cccccc' padding=5px<<
EQ'_DFA_' è un linguaggio decidibile.
>><<

'''Dimostrazione'''

Per la dimostrazione si procederà a definire un terzo automa a stati finiti che accetti le stringhe di A o quelle di B, ma non entrambe. Per realizzarlo si potranno usare solo le operazioni di intersezione, unione o complemento, perché sono le uniche ad essere chiuse rispetto ai linguaggi regolari. In particolare si utilizzerà la formula della ''differenza simmetrica'':

%center%Attach:IT-diffsimm.gif

In particolare: L(C)=0 se e solo se L(A)=L(B). Il problema EQ'_DFA_' su A e B può essere dunque ricondotto a un problema di E'_DFA_' su C! Costruiamo allora la MdT deterministica F che risolve EQ'_DFA_':

>>left bgcolor=#fbf3ff width=auto border='2px solid #cccccc' padding=5px<<
F = "su ingresso <A,B>:
# costruisci C;
# esegui la MdT T su <C>;
# se T accetta, allora ACCETTA; altrimenti RIFIUTA."
>><<

!!Teorema 5 - A'_CFG_' è decidibile
Passiamo ora dai problemi decidibili relativi a linguaggi regolari a quelli relativi a linguaggi liberi dal contesto. Cominciamo col problema A'_CFG_' che consiste nel determinare se una grammatica libera dal contesto (CFG) genera una particolare stringa, ovvero:\\
''A'_CFG_' = {<G,w> | G è una CFG che genera la stringa w}''

Dimostriamo il seguente teorema:

>>left bgcolor=#f5f9fc width=auto border='2px solid #cccccc' padding=5px<<
A'_CFG_' è un linguaggio decidibile.
>><<

'''Dimostrazione'''

Se ci mettessimo a fare tutte le derivazioni di G per vedere se una di queste è una derivazione di w, nel caso in cui questo non fosse vero potremmo andare avanti all'infinito. L'alternativa è usare la grammatica G in forma normale di Chomsky, perché in questo caso le derivazioni di w sarebbero solo 2n-1 (dove n è la lunghezza della stringa), e avremmo la garanzia di trovare una soluzione in un numero finito di passi.\\
Costruiamo allora la MdT S che risolve A'_CFG_':

>>left bgcolor=#fbf3ff width=auto border='2px solid #cccccc' padding=5px<<
S = "su ingresso <G,w>:
# converti G nella forma equivalente di Chomsky;
# fai una lista di tutte le derivazioni di 2n-1 passi, dove n=|w|;
# se una derivazione genera w, allora ACCETTA; altrimenti RIFIUTA."
>><<

!!Teorema 6 - E'_CFG_' è decidibile
Consideriamo il problema di Emptiness per grammatiche libere dal contesto, che si pone l'obiettivo di verificare se una CFG non genera alcuna stringa. Più formalmente:\\
''E'_CFG_' = {<G> | G è una CFG e L(G)=0}''

Dimostriamo il teorema:

>>left bgcolor=#f5f9fc width=auto border='2px solid #cccccc' padding=5px<<
E'_CFG_' è un linguaggio decidibile.
>><<

'''Dimostrazione'''

Per verificare se la grammatica è vuota dobbiamo dimostrare di non riuscire ad arrivare ad una stringa composta solo da terminali. \\
Come prima cosa dovremo scorrere la CFG e marcare tutti i terminali. Successivamente si passa a scansionare le regole, e se da una di queste risulta che una variabile può essere sostituita da terminali segnati, marchiamo anche lei. L'operazione va ripetuta marcando tutte le variabili ottenute a partire da simboli (terminali/variabili) già marcati. Se si arriva a marcare anche la variabile iniziale significa che da lei posso raggiungere una sequenza composta solo da terminali, quindi la MdT R che risolve E'_CFG_' dovrà rifiutare tale eventualità.

>>left bgcolor=#fbf3ff width=auto border='2px solid #cccccc' padding=5px<<
R = "su ingresso <G>:
->1. marca i simboli terminali di G;
->2. ripeti finché non ci sono nuove variabili marcate:
-->3. marca ogni variabile A in cui G abbia una regola ''A->U'_1_'...U'_k_''' in cui ogni U'_1_', ... , U'_k_' sia già marcato;
->4. se la variabile iniziale non è marcata, allora ACCETTA; altrimenti RIFIUTA."
>><<

!!Teorema 7 - sulla decidibilità dei linguaggi liberi dal contesto

>>left bgcolor=#f5f9fc width=auto border='2px solid #cccccc' padding=5px<<
Ogni linguaggio libero dal contesto è decidibile.
>><<

'''Dimostrazione'''

Sia A un qualsiasi linguaggio libero dal contesto generato dalla CFG G. Per la dimostrazione sfruttiamo la MdT S definita nel teorema di A'_CFG_', e scriviamo la macchina di Touring M'_G_' che decide A:

>>left bgcolor=#fbf3ff width=auto border='2px solid #cccccc' padding=5px<<
M'_G_' = "su ingresso w:
# esegui S su ingresso <G,w>;
# se S accetta, allora ACCETTA; altrimenti RIFIUTA."
>><<

Non è meraviglioso?

...to be continued

----
[[Torna alla pagina di Informatica Teorica-> Informatica Teorica]]