Principio di composizione delle MT

Principio di composizione delle MT
La definizioni date fanno riferimento a situazioni in cui la macchina sia capace di
risolvere problemi singoli. E’ possibile far sì che macchine progettate per problemi
elementari possano essere combinate in modo da svolgere compiti più complessi.
Intuitivamente, è possibile far subentrare ad una macchina A che si arresta un’altra
macchina B a seconda del simbolo osservato nello stato finale della macchina A.
Ogni macchina può essere vista come un dispositivo capace di risolvere un
problema dato avendo al suo interno il programma di macchina “cablato”.
Volendo fare il parallelo con i moderni calcolatori è come se il programma fosse
memorizzato in una memoria ROM.
Esempio di composizione
Vengono messe assieme le macchine
relative all’esempio 2 e all’esempio 3.
Esempio3
Esempio2
!
q0
q1
q q2 2
!
0
D
q#
1 q0
"
1
D
2 q0
2
D
q#
q##
3
D
q##
4 q0
4
D
5 q0
3 q0
5
D
q#
q#
q##
qq
#
6
D
qq#
7 q0
7
D
8 q0
8
D
q# q
q#
q##
q#
q#
9
D
q#
q#
0S
"
S q1
a
D
"Sq2
6 q0
9q0
1 q0
S
q0
D
q1
q2
Dq0
| q1
|
"Dq2
S
D
*
" q#
S
D
Contatore di una sequenza di caratteri
Lo stato di stop della prima macchina
viene convertito nello stato iniziale
della seconda.
Eventualmente si procede ad una
ridenominazione degli stati.
Somma di due
numeri, separati dal
carattere *, dati
come sequenza di
caratteri |
Esempio di composizione
q3
q4
q5
0
D
q#
1 q3
1
D
q#
2 q3
2
D
q#
3 q3
3
D
q#
4 q3
4
D
q#
5 q3
5
D
q#
6 q3
6
D
q#
7 q3
7
D
q#
8 q3
8
D
q#
9 q3
9
D
q#
0S
1
S q4
q#
1 q3
D
"Sq5
S
!
Macchina che accetta due serie di sbarre
separate da un carattere *, ne calcola
la somma e trasforma la somma come
numero decimale.
La macchina inizia la sua computazione
sommando sequenze di caratteri |
separati dal carattere *. Lo stato di stop,
individuato dalla coppia con (q0 , *) attiva
la scansione della stringa di caratteri | per
poterli contare
q
0
q
1
Dq
q
2
|q
"
D
|
"Dq
S
D
"q
S
D
*
0
2
3
Tesi di Church-Turing
Il principio di Composizione rende possibile la costruzione di macchine che risolvono problemi
di notevole complessità.
Ipotesi fondamentale della Teoria degli Algoritmi.
Tutti gli algoritmi possono essere formulati sotto forma di matrici funzionali e quindi eseguiti dalla
corrispondente macchina di Turing.
L’ipotesi non si riferisce solo agli algoritmi già scoperti, ma anche a tutti quelli che si potranno
scoprire nel futuro.
Questa ipotesi risulta indimostrabile in quanto alla nozione (vaga) di “tutti gli algoritmi”
corrisponde la nozione (matematica) di Macchina di Turing.
Tuttavia
1. Tutti gli algoritmi conosciuti possono essere espressi come matrici funzionali
2. Tutte le definizioni formali di algoritmo (Algoritmi normali di Markov, Funzioni ricorsive di
Kleene e Godel etc.) arrivano alle stesse conclusioni.
Teorema di Jacopini-Bohm
In particolare, il Teorema di Jacopini-Bohm (1966) mostra che ogni funzione
calcolabile con una macchina di Turing è anche calcolabile con un
programma scritto in un linguaggio che compone sottoprogrammi con tre
operatori:
- esecuzione sequenziale di due sottoprogrammi ( …;…)
- scelta dell’esecuzione tra due sottoprogrammi a seconda del valore di una
condizione booleana (if … then … else)
- esecuzione ripetuta di un sottorogramma fino a che una variabile booleana è
vera (while…)
Questo teorema implica che tutti i normali linguaggi di programmazione sono
TURING-EQUIVALENT, hanno cioè la stessa potenza espressiva delle
Macchine di Turing.
Macchina di Turing Universale
Per le Macchine di Turing viste fino ad ora si fa l’implicita assunzione che siano dispositivi
“hardware” in cui il programma (la matrice funzionale) è cablato al loro interno.
E’ possibile tuttavia costruire una macchina U (Macchina di Turing Universale) capace di
accettare in ingresso una macchina di Turing M con il proprio input w e simularne l’esecuzione.
Cioè:
U(”M” “w”) = “M(w)”
“M(w)” è una stringa che rappresenta il
risultato della Macchina M sull’ingresso w.
In altre parole il comportamento della macchina universale U è tale che essa si ferma
se e solo se M si ferma sul’input w.
La macchina di Turing Universale si comporta analogamente ad un qualunque computer
attuale nel senso che accetta in input una stringa “M”, “w” che è assimilabile perciò
all’usuale programma seguito dai propri dati di ingresso.
Occorre tuttavia precisare in che modo si possa codificare una Macchina di Turing sul
nastro.
(Una) codifica di una Macchina di Turing
L’obiettivo è quello di esprimere in una stringa binaria ogni possibile macchina di Turing.
Lo schema di codifica potrebbe essere il seguente:
Simbolo
Codice
s0
s1
s2
...........
sn
!
1
11
111
.........
1n+1
1n+2
q0
q1
1
11
.......
..........
n+2
qY
S
D
F
Codifica dei simboli di nastro
(la potenza si riferisce alla
concatenazione dei simboli)
Codifica degli stati
1
1
11
111
Codifica degli spostamenti
Esempio di Codifica
Macchina che accetta stringhe che iniziano con 0 oppure con 11
Si definisce una funzione di
codifica EN(x) che codifica il
simbolo x.
Una transizione
!(q , x) = (y, d, q )
i
j
con
d #{S,D,F} e x, y #{0,1, "}
viene codificata nel seguente modo
EN(q ) 0 EN(x) 0 EN(y) 0 EN(d) 0 EN(q )
i
j
simbolo
!
q
0
"
Dq
q
1
q
2
1
0
q
Y
1
Dq
2
q
Y
0
1
"
q
0
q
1
q
2
q
Y
S
D
F
codice
1
11
111
1
11
111
1111
1
11
111
simbolo
Esempio di codifica cont
Pertanto le quattro transizioni indicate nella matrice funzionale sono
così codificate
!(q , ") = (",D,q )
!(q0,0) = 0, F, q 1
!(q1,1) = (1,D,qY)
!(q1,1) = 1, F, q2
2
Y
1 0 111 0 111 0 11 0 11
11 0
1 0 1 0 111 0 1111
11 0 11 0 11 0 11 0 111
111 0 11 0 11 0 111 0 1111
0
1
q
q0
q1
q2
SY
D
F
codice
1
11
111
1
11
111
1111
1
11
111
Si fa la convenzione che due transizioni siano separate tra di loro dalla coppia 00 e che l’inizio e la fine
della stringa di codifica della matrice di transizione sia rappresentata da 000, pertanto:
000 101110111011 011 00 1101010111 01111 00 11011 011 0110111 00111011011011101111000
Ne deriva che, ad esempio se vogliamo attivare la macchina M con un input 11, la stringa:
000 101110111011 011 00 1101010111 01111 00 11011 011 0110111 0011101101101110111100011
non è altro che la stringa “M” “w”, che può essere interpretata come la macchina con matrice
funzionale M applicata alla stringa di input 11.
Enumerazione di Macchine di Turing
- Il sistema di codifica di una macchina di Turing ci porta a dire che queste possono essere
enumerate, cioé è possibile costruire una corrispondenza tra le stringhe binarie
che rappresentano le macchine di Turing e i naturali.
- E’ sempre possibile mettere in relazione ciascuna macchina con il proprio input o, detto in
altre parole, tutte le stringhe di input accettate dalla MT costituiscono il linguaggio riconosciuto
dalla macchina stessa.
L(Mj) = { w #!" | q w |$ * x q y con q# Z }
0
w
wk . . . . ws
M
Mi
.
.
Mj
0 0 0 1 0 0 1 0 . . . .
. . . . . . . .
0 1 0 0 0 1 0 0 . . . .
Una volta enumerate tutte le stringhe wi di !", per ogni Mj è possibile
definire il suo vettore caratteristico cioé un vettore che ha un 1 in
corrispondenza delle stringhe wi che sono accettate dalla macchina Mj e che
appartengono quindi al linguaggio L(Mj ).
Problema della terminazione
TEOREMA: E’ indecidibile dire se una macchina di Turing termina la sua computazione
La dimostrazione si fa per assurdo. Sia H una Macchina di Turing che risolve il problema, ciò
significa che:
1. L’input di H è costituito dalla stringa ”M” ”w”
2. Una stringa è accettata da H se la computazione di M termina altrimenti la stringa è rifiutata
M si ferma
con input w
"M""w"
H
HALT/accettazione
HALT/rigetto
M non si ferma
con input w
A partire da H si costruisce la macchina H’ che effettua le stesse computazioni di H eccetto
che H’ cicla indefinitivamente se H termine in uno stato di accettazione.
L’idea per la costruzione di H’ è quella di creare una macchina che si ferma se la macchina di
input non si ferma e non si ferma se la macchina di input si ferma.
Ciò si può facilmente ottenere se ad esempio si addizionano ad H transizioni che
muovono la testina indefinitivamente a destra se H raggiunge lo stato di accettazione.
Problema della terminazione cont.
M si ferma
con input w
"M""w"
H'
LOOP
HALT/rigetto
M non si ferma
con input w
Il passo successivo è quello di combinare la macchina H’ con una macchina Copia che sia
capace di replicare il suo input.
M si ferma
con input M
LOOP
M
COPIA
"M "M"
D
H'
HALT/rigetto
M non si ferma
con input M
La macchina D accetta in input una matrice funzionale ne crea una copia e fornisce la
coppia “M” “M” in ingresso ad H’ la cui esecuzione da parte di H’ produce la stringa
“M(M)” ovvero il risultato della M applicata a se stessa.
Problema della terminazione cont.
Poiché è possibile codificare ogni macchina di Turing come stringa binaria anche la macchina D
può essere codificata e data in input a D stessa.
D si ferma
con input D
LOOP
D
COPIA
"D" "D"
D
H'
HALT/rigetto
D non si ferma
con input D
Si ha contraddizione in quanto la macchina D si ferma se si verifica la condizione che D
non si ferma sull’input D. Oppure D non si ferma se D si ferma sull’input D.
La macchina universale
Una immediata conseguenza della dimostrazione è la seguente
Corollario
il linguaggio LH = {M (w) | M rappresenta una macchina di Turing che si ferma con input w}
sull’alfabeto {0,1}* è un linguaggio non ricorsivo [e quindi non decidibilie].
L in altre parole è costituito dalle stringhe che rappresentano una MT seguita dall’input da
H
essa accettato ovvero che corrispondono ai valori 1 del vettore caratteristico della MT.
Tuttavia è possibile dimostrare il seguente
Teorema: il linguaggio LH è ricorsivamente enumerabile [e quindi semidecidibile].
Sapendo perciò che un linguaggio ricorsivo è anche ricorsivamente numerabile si avrà l’importante
risultato:
Corollario: la classe dei linguaggi ricorsivi è contenuta in modo proprio nella classe dei linguaggi
ricorsivamente enumerabili ovvero LR ! LRE
La dimostrazione del teorema si basa su una macchina universale che lavora secondo il
seguente schema
M si ferma
con input w
"M""w"
U
Accettazione
Loop
M non si ferma
con input w
In sintesi si deve dimostrare che la
macchina universale U simula
perfettamente ogni altra Macchina di Turing
Ricorsiva enumerabilità di LH
La dimostrazione verrà fatta con una macchina a tre nastri. Nel nastro 1 verrà codificato l’input
mentre il nastro 3 verrà usato per effettuare la simulazione dell’esecuzione della macchina M.
Una computazione della macchina U viene ad essere definita nel seguente modo:
1. Se la stringa di input non è della forma “M” “w”, U si muove indefinitivamente verso destra.
2. Viene ricopiata la stringa w sul nastro 3, la testina viene quindi riposizionata a sinistra al primo
carattere, cosicché sul nastro 3 viene ad essere definita la configurazione iniziale di una
computazione di M con input w.
3. viene scritto sul nastro 2 lo stato q (il simbolo 1 nella nostra codifica)
0
4. Passo di simulazione. La transizione di M viene determinata dal simbolo x scandito sul nastro 3
e lo stato qi codificato sul nastro 2.
a) Viene scandito il nastro 1 alla ricerca della coppia EN(qi ) EN (x) se tale transizione non esiste
U si ferma e accetta l’input (configurazione finale).
b) Assunto che il nastro 1 contenga la transizione EN(q ) 0 EN(x) 0 EN(y)0 EN(d) 0 EN(q )
i
j
i) EN(qi) è rimpiazzato da EN(qj) sul nastro 2
ii) il simbolo y è scritto sul nastro 3
iii) la testina del nastro 3 è mossa nella direzione specificata da d
5. si ripete il passo di simulazione (punti 4 e 5)
La simulazione della macchina U accetta stringhe in LH mentre per stringhe in {0,1}* - LH
cicla indefinitivamente. Poiché L = L(U) L è ricorsivamente enumerabile essendo
H
H
ricorsivamente enumerabile L(U).
Indecidibilità del Linguaggio di diagonalizzazione
Ld = tutte le stringhe wi tali che
wi non è in L(Mi)
Ld = { wi ! "* | wi ! L(Mi}
Teorema il linguaggio Ld è non ricorsivamente enumerabile
w
M
wj
ws
Mi
0 0 0 1 0 0 1 0 . . .
.
Mj
0 0 1 0 1 0 0 1
0 1 0 0 0 1 0 0 . . . .
Supponiamo Ld = L(M) per una macchina M,
allora deve esistere una Macchina di Turing nella
enumerazione ovvero un indice i che individua
la macchina Mi che riconosce wi ! Ld
- se wi ! Ld allora Mi accetta wi pertanto per
definizione di Ld wi non è in Ld poiché Ld contiene
solo stringhe wj tale che Mj non accetta wj
- se wi ! Ld allora Mi non accetta wi pertanto per
definizione di Ld wi è in Ld
Evidentemente si ha contraddizione poiché wi non può essere o non essere in Ld