ancora alcune macchine di Turing per risolvere semplici problemi :

Presentazione sul tema: "ancora alcune macchine di Turing per risolvere semplici problemi :"— Transcript della presentazione:

1 ancora alcune macchine di Turing per risolvere semplici problemi :
contenuto: MdT - parte seconda ancora alcune macchine di Turing per risolvere semplici problemi : 8) controllo parentesi ben formate (slide 14) 9) sposta un dato su nastro (slide 27) 10) confronto di due valori interi e test <, =, > (slide 39) 11) dato un numero n calcola il valore 2*n (slide 48) 12) cerca stringa di simboli s2 uguale a una stringa data s1 (slide 57) 13) una "memoria ad accesso diretto" (slide 65) xx) la macchina di Turing programmabile o universale zz) la tesi di Church (slide 80)

2 8. esempio: controllo parentesi ben formate
per l’ esempio seguente (macchina di Turing numero otto) ci servono alcune definizioni preliminari le prossime dieci pagine sono dedicate a questo...

3 premessa - definizione di un insieme:
un insieme di elementi si puo’ definire in modi diversi, * elencando tutti gli elementi dell’insieme (se e’ finito...) es. insieme { 0, 1 } * fornendo una proprieta’ per gli elementi dell’ insieme, es. insieme degli "studenti di ingegneria iscritti al 1.o anno all’univ. di TS", * specificando delle regole per produrre gli elementi, ovvero per costruire (a partire da un elemento dato -uno o piu’) - sistema "generativo" vediamo un esempio di quest’ ultimo modo di procedere.

4 premessa ... sulle stringhe di caratteri...
dato un insieme di caratteri C = {a,b,c,d } (*) definiamo una stringa s come una sequenza di caratteri: es. s1 = d = stringa di un carattere, s2 = abba e’ una stringa di 4 caratteri, s3 = abbccdccbba e’ una stringa di 11 caratteri, definiz: |s| = lunghezza della stringa s = n. di caratteri di s definiz: C * e’ l’insieme di tutte le stringhe che si possono formare con i caratteri di C ( C * <-- leggi " c stellato " ) C * = { s | s = stringa di caratteri appartenenti a C } anche la stringa vuota s0 appartiene a a C * : s0, con |s0| = 0, appartiene a C * ____________________________________ (*){ ... } = insieme degli elementi elencati tra le parentesi graffe

5 un primo esempio di un insieme di stringhe:
sia l’insieme di caratteri di partenza formato dall’unico carattere + allora P = { + } allora l’insieme P stellato P * = { s | s stringa di caratteri di P } e’ l’insieme delle stringhe che si possono formare con + es.: p0 = (stringa vuota, |p0| = 0 ) p1 = (stringa di un carattere, |p1| = 1 ) p4 = (stringa di 4 caratteri, |p4| = 4 ) p7 = (stringa di 7 caratteri, |p7| = 7 ) l’insieme P * e’ infinito

6 un secondo esempio di un insieme di stringhe
A = insieme di due caratteri, parentesi aperta e chiusa: A = { ( ) } allora l’insieme A stellato ... A * = { s | s stringa di caratteri di A } e’ l’ insieme di tutte le stringhe che si possono formare con le due parentesi, ad es.: s0 = (stringa vuota) sx = ( (stringa di un carattere solo) sn = ) ) ) ) (stringa di 4 caratteri) s7 = ( ( ) ( ) ( ) ) (stringa di 8 caratteri) eccetera... A * e’ un insieme infinito: il numero di stringhe che si possono formare con uno o piu’ simboli e’ infinito!

7 continua sugli insiemi di stringhe
consideriamo ad es.: B = { 0 1 } allora l’insieme B stellato B * = { s | s stringa di caratteri di B } e' l' insieme di tutte le stringhe che si possono formare con i simboli 0 ed 1: 0, 1, 00, 01, 10, 11, 000, 001, 010, 100, 011, 101, 110, 111, ecc posso definire un X sottoinsieme di B* (di stringhe di 0 ed 1) aggiungendo una proprieta’ richiesta ad una stringa per essere considerata un elemento di X ovvero “ben formata”: es.: X = stringhe s di B *, tali che il numero degli 1 in s e’ pari. quindi 0, 11, 011, 110, 0011, .., 1111, ... sono elementi di X, mentre 1, 01, 100, 010, ... , 0010, ... non lo sono; le stringhe pari 0, 11, .. sono “ben formate” (apparteng. a X), le altre no.

8 ripetizione ... dei concetti presentati finora
insieme C (finito) di caratteri es { x, y, z } ... una stringa di caratteri su C es s = xxx ... |s| = lunghezza della stringa s es |xxx| = C stellato C* = { s con |s| >= 0, e s=stringa di caratt. di C} da C* definisco altri insiemi X, con X sottoinsieme di C*, introducendo una proprieta’p che chiedo alle stringhe di X: l’insieme X e’ caratterizzato dalla proprieta’ p: definiamo "ben formate" le stringhe di X, cioe’ che sono p, le stringhe di C* che non sono p non appartengono a X non sono ben formate. Nell’es. precedente, B = { 0 1 } B *= { s | s stringa di caratteri di B } X = stringhe s di B *, tali che il numero degli 1 in s e’ pari.

9 cont. stringhe e insiemi e stringhe ben formate ...
B *= { s | s qualunque stringa di caratteri di B } Y = { s | s appart. a B * e tale che |s| = 3 } ovvero: Y = { 111, 110, 101, 011, 100, 010, 001, 000 } D = { 1 } D *= { s | s stringa di caratteri di D } D * = { 1, 11, 111, 1111, 11111, , , ... } W = { s | dove s appartiene a D *, e dove |s| = 4 } allora: W = { } e basta: l’insieme W ha un solo elemento.

10 un insieme di elementi si puo’ definire in modi diversi,
avevamo detto che ... un insieme di elementi si puo’ definire in modi diversi, * elencando tutti gli elementi dell’insieme (se e’ finito...) es. insieme { 0, 1 } * fornendo una proprieta’ per gli elementi dell’insieme, es. insieme degli studenti di ingegneria iscritti al 1.o anno all’univ. di TS, ... abbiamo visto alcuni esempi... ma si puo’ definire un insieme anche in modo “costruttivo” o “generativo”, * specificando delle regole per produrre gli elementi, ovvero per costruire (a partire da elementi dati) dei nuovi elementi dell’insieme... sistema generativo ... vediamo

11 schema generativo (cont. premesse per la m.d.T nr. 8)
defin.di un insieme di stringhe di parentesi “ben formate”: base: ( ) sta in PBF /*/ [pbf = parentesi ben formate ] 1.a regola: se E sta in PBF allora (E) sta in PBF (es. se ( ) ( ) e’ PBF, allora ( ( ) ( ) ) e’ PBF) 2.a regola: se E ed F stanno in PBF allora EF sta in PBF (es. se ( ) e ( ( ) ) sono PBF, allora ( ) ( ( ) ) e’ PBF) limitazione: null’altro sta in PBF. _____________________ /*/ nota: la base ( ) e’ stringa di 2 caratteri, la parentesi aperta “(“ e la “)”

12 cont. schema generativo (sistema formale generativo)
base: ( ) sta in PBF [ pbf = parentesi ben formate ] 1.a regola: se E sta in PBF allora (E) sta in PBF 2.a regola: se E ed F stanno in PBF allora EF sta in PBF limitazione: null’altro sta in PBF. da questo schema generativo possiamo ricavare [fabbricare] tutte le PBF che vogliamo, partendo dalla stringa di base: ( ) ->1 ( ( ) ) ->1 ( ( ( ) ) ) ->1 ( ( ( ( ) ) ) ) ecc ( a ->1 b significa: applico la regola 1 alla stringa a, e ricavo la stringa b) oppure: ( ) ->2 ( ) ( ) ->1 ( ( ) ( ) ) ->1 ( ( ( ) ( ) ) ) ecc ( ) ->2 ( ) ( ) ->2 ( ) ( ) ( ) ->1 ( ( ) ( ) ( ) ) ecc oppure: ... ( ) ->2 ( ) ( ) ->2 ( ) ( ) ( ) ( ) ->2 ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( )..

13 parentesi ben formate ... problema:
data una stringa di parentesi p , decidere se e’ ben formata oppure no, ovvero decidere se appartiene all'insieme PBF ad es.: ( ), ( ) ( ) ( ), ( ( ( ) ) ), ecc sono p.b.f. ( (, ( ( ) ) ( (, ) (, ecc non sono p.b.f. un metodo per decidere potrebbe essere: 1) calcola la lunghezza della stringa data p, |p|, 2) fabbrica un insieme L di tutte le stringhe ben formate di lunghezza minore o uguale a |p| (a partire dalla base, con le regole di derivazione viste), 3) vedi se la stringa data p sta in questo insieme L: 4) se p appartiene a L, allora p e’ ben formata, altrimenti no. questo metodo funziona perche' vi sono solo regole che allungano le stringhe PBF, e quindi si puo' fare L con un numero finito di passi

14 parentesi ben formate - problema di decisione
MA - lo stesso problema puo’ essere risolto in modo piu’ breve, osservando una proprieta’ fondamentale che hanno tutte le p.b.f.: ogni parentesi chiusa e’preceduta da una parentesi aperta e ogni parentesi aperta e' seguita da una chiusa: ( ), ( ) ( ) ( ), ( ( ( ) ) ), ( ( ) ( ) ) ecc sono p.b.f., ( (, ( ( ) ) ( (, ) (, ( ) ( ) ( ) ) ecc non sono p.b.f. es.: 1) cerco la prima ) nella stringa data ( ( ) ( ) ) 2) sostituisco la prima parentesi ) con un 1: ( ( 1 ( ) ) 3) cerco la prima ( che precede la ) appena cancellata: 4) sostituisco questa ( con un uno: ( 1 1 ( ) ) 5) ripeto da 1, e ottengo via via le stringhe ( )

15 parentesi ben formate - problema di decisione
questo procedimento [elimina le coppie di parentesi ben formate, la prima “)” e la “(“ corrispondente davanti ] dara’ 0) ( ( ) ( ) ) 1) ( ( 1 ( ) ) 1) ( 1 1 ( ) ) 1) ( 1 1 ( 1 ) 1) ( ) 1) ( 1) >> la p e’ una p.b.f. questo procedimento si puo’ formulare in forma di m.d.T. alla fine scriveremo il risultato su nastro in forma di S (si’) oppure N (no). se alla fine rimangono delle parentesi aperte oppure non trovo una ( che preceda una ) appena cancellata, (restano parentesi chiuse) allora la stringa data non e' ben formata

16 1) cerco la prima ) nella stringa data ( ) ) )
due esempi con stringhe non ben formate: 1) cerco la prima ) nella stringa data ( ) ) ) 2) sostituisco la prima parentesi ) con un 1: ( 1 ) ) 3) cerco la prima “(“ che precede la “)” appena cancellata: 4) sostituisco questa ( con un uno: ) ) 5) ripeto da istruzione 1, e ottengo ) 6) ora torno indietro per cancellare una “(“ -ma non la trovo, 7) allora fine: la stringa non e’ ben formata - troppe “)” 1) cerco la prima ) nella stringa data ( ( ( ) 2) sostituisco la prima parentesi ) con un 1: ( ( ( 1 4) sostituisco questa ( con un uno: ( ( 5) ripeto da istruzione 1, e non trovo piu’ ( ( 6) nessuna “)”, torno indietro per vedere se 7) vi sono “(“ rimaste: ci sono -> fine, non e’ ben formata

17 8.) m.d.T.: controllo parentesi ben formate
.. A ( ( ) ( ) ) A .. a a ( a ( + ; ricerca della prima ), scorri le ( a ) b 1 - ; trovata ),cancella,cerca ( corrisp. b ( a 1 + ; trovata ( ... a 1 a 1 + ; se trovi 1 ignora: b 1 b 1 - ; se trovi 1 ignora: avremo la successione: 1) A ( ( ) ( ) ) A . 5) A ( 1 1 ( ) ) A .. a a 2) A ( ( ) ( ) ) A . 6) A ( 1 1 ( ) ) A .. 3) A ( ( ) ( ) ) A . 7) A ( 1 1 ( ) ) A .. 4) A ( ( 1 ( ) ) A . 8) A ( 1 1 ( 1 ) A .. b b

18 8.) m.d.T.: controllo par.ben form. [elimina coppie ( ) ]
.. A ( ( ) ( ) ) A .. a a ( a ( + ;ricerca della prima ) a ) b ;trovata,cancella,cerca ( corrisp. b ( a ;se in b trovi ( e'il paio cercato! a 1 a ;scorri a destra se in a, b 1 b ;a sin.se in b ... avremo: 1) A ( ( ) ( ) ) A ) A ( ) A .. a a 7) A ( 1 1 ( ) ) A ) A ( A .. a b 8) A ( 1 1 ( 1 ) A ) A ( A .. b b 9) A ( ) A ) A ( A .. a b

19 8.) m.d.T.: controllo par.ben form. [elimina coppie ( ) ]
a ( a ( + ;ricerca della prima ) a ) b ;trovata,cancella,cerca ( corrisp. b ( a ;ripeti... se trovi 1 ignora: a 1 a ; b 1 b ; ... avremo la successione: b A h N 0 ; se non trovi ( allora non ok! a A c A - ; 1) A ( ( ) ( ) ) A ) A A .. a a 15) A ( A b 16) A A ) A A .. a a ho finito le ), arrivo fino al delimitatore A -> devo prevedere anche questo caso...mi rimane da controllare se e’rimasta qualche ( “orfana”

20 8.) m.d.T.: controllo par.ben form. [controllo finale]
a ( a ( + ; ricerca della prima ) a ) b 1 - ; trovata,cancella,cerca ( corrisp. a 1 a 1 + ; ignoro gli 1 in mezzo... a A c A - ; stato a,va a destra, nessuna ) trovata ; da controllare se e’rimasta una ( c 1 c 1 - ; scorri verso sinistra ... c A h S 0 ; se non hai trovato nessuna ( -> ok 1) A ( ( ) ( ) ) A ) A A .. a c 15) A A ) A A .. a c 20) A A ) A A .. a c 21) A A ) S A .. c h ho esaminato il dato, la risposta e’ si’.

21 8) m.d.T. controllo par.ben form. situazioni stringa NON ok
quintuple: c 1 c 1 - ;scorri verso sinistra ... c A h S 0 ;se non hai trovato nessuna ( -> ok c ( h N 0 ;caso di stringa errata esempio di stringa non ben formata: .. A ( ( ) ( ) A situazione non ok: a applico le regole, arrivo a: .. A ( 1 1 ( ) A ..cancello la prima ) e la a sua ( corrispondente .. .. A ( A ..via la seconda ) e la sua ( a corrispondente .. A ( A ..cerca ancora qualche ) a .. non c’e’- vai in stato c .. A ( A ..a controllare se c’e’ una ( c c’e’ una ( e non c'e'piu' ) .. A ( A .. se in c trovo una ( allora c la stringa non e’ok:

22 8) m.d.T. par.ben formate - 2 caso di stringa NON ok
altro esempio di stringa non ben formata: .. A ( ) ( ) ) A situazione non ok: a applico le regole, arrivo a: .. A 1 1 ( ) ) A ..cancello la prima ) e la ( a trovo una ) e cancello.. .. A ) A ..cont. a cercare una ).. a ..trovo una ) e la cancello, .. A A .. cerco la sua ( corrispond. b che pero’ non trovero’: .. A A ..finora avevo: b ( a 1 + b e la b 1 b 1 - .. N A .. se in stato b trovo A->err h agg.quintupla b A h N 0

23 8) m.d.T. par.ben formate rivediamo le quintuple finora definite
; stato a cerca una ) e cancella a ( a ( + ; ricerca di una ) - ignora ( a ) b 1 - ; trovata,cancella,cerca ( corrisp. a 1 a 1 + ; ricerca di una ) - ignora 1 a A c A - ; non ho trovato una ), rimane da ; controllare se e’rimasta una ( ;stato b cerca ( corrispond. ad una ) gia’cancellata b ( a 1 + ; se trovi ( cancella e ripeti b 1 b 1 - ; se trovi 1 ignora: b A h N 0 ; se non trovi ( allora non ok! b ) ? ; un caso che NON si puo’presentare ;stato c controlla se c’e’ una ( singola.. c ( h N 0 ;c’e’ una ( orfana-> stringa errata! c 1 c 1 - ;scorri verso sinistra ... c A h S 0 ;non ho trovato nessuna ( allora ok c ) ? ; un caso che NON si puo’presentare

24 versione grafica di questa MdT:
Stop Si ;a cerca/cancella ) a ( a ( + ; a ) b 1 - ; a 1 a 1 + ; a A c A - ; ;b cerca/canc. ( b ( a 1 + ; b 1 b 1 - ; b A h N 0 ; b ) ;caso imposs. ;c contr.( rimaste c ( h N 0 ; c 1 c 1 - ; c A h S 0 ; c ) ; caso imposs. S 1 ( A 1 - + A - ) A ( b a c N N stop No stop No start nel grafico non sono segnate le transizioni a1 a1 +; b1 b1 -; c1 c1-

25 8.o esempio di m.d.T. osservazione finale:
L’esempio visto pero’ distrugge i dati: esercizio: modificare l’algoritmo in modo che la macchina NON distrugga i dati (provare da soli...) (suggerimento: nella verifica delle coppie “)” e “(“ invece di sostituire entrambe le parentesi con un simbolo, si cambi la “)” in un simbolo x e la “(“ in un simbolo diverso y, e alla fine sara' facile ripristinare la situazione iniziale.

26 Macchine di Turing Abbiamo visto che una MdT puo' realizzare alcune procedure di calcolo semplici, riempi il nastro di uni, come incrementa un numero n di uno, controlla se il numero di uni in una stringa di zeri e uni e' pari controlla se una stringa di ( e di ) e' ben formata; vediamo ancora qualche esempio di MdT che realizzano alcune operazioni tipiche di tutti i calcolatori: sposta un dato, test se un due numeri sono uguali, ecc

27 MdT numero 9 : sposta (muovi) uni
due esempi di operazioni di base: MdT numero 9 : sposta (muovi) uni dato un nastro: * a spostare gli uni dall’altra parte cioe’ produrre * h devo trovare una procedura per ottenere il risultato voluto..

28 MdT numero 9 : sposta (muovi) uni
dato un nastro: * a produrre * h una procedura puo’ essere: cerco il primo 1 che trovo a destra dell’ asterisco, lo cancello e scrivo un 1 a sinistra dopo l’ asterisco: * poi cerco il prossimo a uno a destra dell' * * lo cancello e lo a scrivo a sinistra ...

29 MdT numero 9 : sposta (muovi) uni
una strategia: cancello il primo 1 a destra dell’ * e riscrivo 1 a sinistra * stato a cerca 1 a destra dell'* a cancello il primo uno che trovo * sono in stato c, vai a sinistra c e cerca l' * * scavalco *, passo in stato d d cerco 0 a sinistra dell'* * in stato d cambio 0 in 1, poi e in stato e a destra fino all' *, * ripeto: cerca 1, cancella e a porta 1 a sinistra: * in stato d il 1.o zero a sinist e cambia in 1, in stato e a destra * ho portato tutti gli 1, ripeto a vado a cercare ancora ma: * non c'e'piu'nessun 1, lo stato a a va a destra su nastro vuoto e NON SI FERMA PIU' !!! --> e' una strategia errata; si puo' rimediare: cancello con x e non con 0

30 MdT numero 9 : sposta (muovi) uni
una strategia: cancello il primo 1 a destra dell’ * e riscrivo 1 a sinistra * stato a cerca 1 a destra dell'* a sostituisco il primo 1 con una x * x stato c vai a sinistra c e cerca l' * * x scavalco 0, sempre in stato c c cerco 0 a sinistra dell'* e * x in stato c cambio 0 in 1, poi e in stato e scorri 1 a sin di * * x ripeto: in a, cerca 1,cancella, a e porta 1 a sinistra: * x x in stato c il 1.o zero a sinist e cambia in 1, in stato e, a dest. * x x x ho portato tutti gli 1, ripeto a vado a cercare ancora ma: * x x x non c'e'piu'nessun 1, lo stato a a va a destra fino a zero, e allora * x x x SI FERMA; ora si cancellera' f in f le x a destra dell' *

31 MdT numero 9 : sposta (muovi) uni
meglio: cercare l’ultimo 1 a destra: a * b * + ; scorri a destra e vai in b; stato b indica che b 1 b ; sono a destra del *; in stato b ignora 1 cerca 0 b 0 c ; vai oltre gli uni, allo zero torna a sinistra c 1 d ; in stato c cancella 1; stato d=cancellato 1 dato il nastro qui sotto applico le quintuple scritte sopra: * ) passo, iniziale a * ) in stato b scorri a destra b e cerca lo zero = fine degli uni * ) scorrimento a destra b * ) zero limite degli 1 a destra * ) torno a sinistra su ultimo 1 c * ) cancello 1, e vado a sinistra d a riscrivere 1 dopo l' *

32 MdT numero 9 : sposta (muovi) uni
a * b * + ; scorri a destra - b indica che b 1 b ; sono a destra del *; ignora 1 b 0 c ; oltre gli uni - torna a sinistra c 1 d ; cancella 1; stato d=cancellato 1 d * d * - ; d aggiunge 1 a sinistra... d 1 d ; ignorando 1 d 0 a ; scrivo 1 (ho spostato un 1) e ripeto * ) vado a sinistra scorrendo d gli uni a destra dell' * * ) sono in mezzo, ancora a sin d * ) cerca 0 a sinistra di * d trovato 0 a sinistra di * * ) e scrivo un 1, e ripeto a

33 MdT numero 9 : sposta (muovi) uni
a * b * + ; scorri a destra; stato b indica b 1 b ; che sono a destra del *; ignora 1 b 0 c ; oltre gli uni - torna a sinistra c 1 d ; cancella 1; stato d=cancellato 1 d * d * - ; d aggiunge 1 a sinistra... d 1 d ; ignorando 1 d 0 a ; scrivo 1, passo in stato a, e ripeto * ) passa l' * a * ) in b cerca ultimo 1.. b * ) in b fine dato a dest * ) ritorna a sinistra,cancella c * ) e scrivi 1 a sinistra d

34 MdT numero 9 : sposta (muovi) uni
a * b * + ; scorri a destra stato b indica che b 1 b ; sono a destra del *; ignora 1 b 0 c ; oltre gli uni - torna a sinistra c 1 d ; cancella 1; stato d=cancellato 1 d * d * - ; d aggiunge 1 a sinistra... d 1 d ; ignorando 1 d 0 a ; scrivo 1 e ripeto a 1 a ; se in stato a trovo 1 ignoro ... * vai a sinistra d * riscrivi * e ripeti a * di nuovo.. b

35 MdT numero 9 : sposta (muovi) uni
a * b * + ; scorri a destra - b indica che b 1 b ; sono a destra del *; ignora 1 b 0 c ; oltre gli uni - torna a sinistra c 1 d ; cancella 1; stato d=cancellato 1 d * d * - ; d aggiunge 1 a sinistra... d 1 d ; ignorando 1 d 0 a ; scrivo 1 e ripeto ... a 1 a ; se in stato a trovo 1 ignoro ... * limite dato b * cancella 1 e poi c * riscrivi 1 a sin. d * ripeti: a ripeto, cerco 1 a destra dell'asterisco - ma ora non c'e' piu' nessuno!

36 MdT numero 9 : sposta (muovi) uni
a * b * + ; scorri a destra - b indica che b 1 b ; sono a destra del *; ignora 1 b 0 c ; oltre gli uni - torna a sinistra c 1 d ; cancella 1; stato d=cancellato 1 c * h * 0 ; non c’e’ nessun 1 a destra->stop d * d * - ; d aggiunge 1 a sinistra... d 1 d ; ignorando 1 d 0 a ; scrivo 1 e ripeto ... a 1 a ; se in stato a trovo 1 ignoro ... * ripeti: cerca 1 a des a * sono sul limite dato,torno b a sinistra in c, ma non c'e' 1 * trovo un *, non vi sono 1 da c cancellare, quindi mi fermo: * stop h

37 MdT numero 9 : sposta (muovi) uni
esempio muovi gli uni ... provare a scrivere la versione grafica come esercizio dato un nastro: * a date le quintuple: a * b * + ; scorri a destra - b indica che b 1 b ; sono a destra del *; ignora 1 b 0 c ; oltre gli uni - torna a sinistra c 1 d ; cancella 1; stato d=cancellato 1 c * h * 0 ; non c’e’ nessun 1 a destra->stop d * d * - ; d aggiunge 1 a sinistra... d 1 d ; ignorando 1 d 0 a ; scrivo 1 e ripeto ... a 1 a ; se in stato a trovo 1 ignoro ...

38 MdT numero 9 : sposta (muovi) uni
b c d h 1 - + * versione grafica della MdT num. 9 : * a date le quintuple: a * b * + ; b 1 b 1 + ; b 0 c 0 - ; c 1 d 0 - ; c * h * 0 ; d * d * - ; d 1 d 1 - ; d 0 a 1 + ; a 1 a 1 + ;

39 10) MdT: test se due dati hanno valore uguale
10) esempio: una macchina di Turing per il confronto di due valori numerici, ovvero test se a<b oppure se a=b oppure se a>b

40 10) MdT: test se due dati hanno valore uguale
2.o esempio di operazioni di base: test se a=b ipotesi sulla rappresentazione di dati: in unario, separati da un *, posizione iniziale testina in mezzo: * a schema di soluzione (algoritmo in notazione informale) : fintanto che a>0 e b>0 { sottrai 1 ad entrambi cioe’ fai b-1 e poi fai a-1 } ora, se a=0 oppure b=0 { controlla se entrambi sono zero, se si’ il test risponde S, se no risponde N }

41 10) MdT : test se a=b es. con a=1, b= 2:
dato a dato b ; sottrai 1 a b: * a * b * + ; vai a destra a b 1 b 1 + ; scorri il dato b cerca ultimo 1 b 0 c 0 - ; sono oltre il limite di b, torna a sin c 1 d 0 - ; cancella un 1 di b (come nella muovi 1) ; ora abbiamo: * ; ora sottrai 1 ad a: d d 1 d 1 - ; scorri a sinistra per fare a-1 d * d * - ; scavalca *,vai a vedere dato a d 0 e 0 + ; sei oltre a, ritorna a destra e 1 a 0 + ; fatto b-1 e anche a-1 : ripeti a 1 a 1 + ; scorri il dato a ... fino all’ * ; ora abbiamo: * ; a

42 10) MdT: test se a=b vediamo avanti ... caso a<b :
; sottrai 1 a b: * a * b * + ; vai a destra a b 1 b 1 + ; scorri il dato b cerca ultimo 1 b 0 c 0 - ; sono oltre il limite di b, torna a sin c 1 d 0 - ; cancella un 1 di b (come muovi 1) ; ora sottrai 1 ad a: d 1 d 1 - ; scorri a sinistra d * d * - ; scavalca *,vai a vedere dato a d 0 e 0 + ; sei oltre a, ritorna a destra e 1 a 0 + ; fatto b-1 e anche a-1 : ripeti a 1 a 1 + ; scorri il dato a ... fino all’ * ; ora abbiamo: * ; a ; il ciclo si ripete finche o a oppure b vanno a zero: ; se dopo aver fatto b-1 non trovo alcun 1 in a, ovvero ; se dopo d0 e0+ (torna a destra dopo trovato 0 a sin di a) ; cioe' se dopo aver fatto b-1 trovo che a=0 ? ; allora e' b>0, a=0 quindi aggiungo quintupla che e * h < 0 ; "scrive" il risultato, ovvero "minore" a<b

43 10) MdT : test se a=b se lo stato iniziale e' come a destra (a>b) allora si procede a cancellare un uno a destra (dal dato b, eseguo b-1) e anche a sinistra (dato a, eseguo a-1), come riportato nella traccia di esecuzione qui a destra: traccia gia' seguita prima, ripeto: in stato b cerco fine dato b, quindi uno zero, con (b 0) siamo sul limite destro, torno a sinistra di una posizione in stato c e cancello l'uno piu' a destra di b poi in stato d cerco lo zero limite di a a sinistra, torno indietro in stato e e cancello l'uno piu' a sinistra di a, e ritorno nello stato a; * a b c * d e *

44 10) MdT : test se a=b, caso a>b
dopo aver cancellato un 1 da b e e anche da a, avro’la situazione in rosso, vado a fare b-1, al solito cerco zero dopo gli uni di b, qui trovo subito zero, torno a sinist. in stato c per cancellare un 1 di b, ma trovo * (non 1) caso b=0; se in c trovo asterisco, passo in stato f c * f * - ; ora so che il dato b e' zero devo controllare se anche a=0, passo in stato f, vado a sinistra sul dato a: se in stato f trovo un uno a sinistra di * f 1 h > 0 ; allora a>0,b=0, e' a>b, scrivo > e abbiamo finito... f 0 h = 0 ; se trovo 0 a sin dell’*: allora anche a=0! abbiamo finito, a=b=0 * a ... * e * b c f > * h

45 10) MdT : test se a=b, caso a==b
a * b * + ;situazione iniziale b 1 b 1 + ;scorri b a destra b 0 c 0 - ;quando trovi 0 in b, ;vai in stato c e c 1 d 0 - ;fai b-1 se possibile d 1 d 1 - ;scorri a sinistra dopo b-1 d * d * - ;scavalca asterisco in mezzo d 0 e 0 + ;fino allo zero a sin. di a e 1 a 0 + ;fai a-1 se possibile a 1 a 1 + ;scorri uni di a fino * ; restano da vedere i casi finali: ; se dopo fatto b-1 trovo che a=0,cioe' e * h < 0 ;scrive risultato a<b c * f * - ;se cerco di fare b-1, trovo ; * allora b=0, vado controllare a : f 0 h = 0 ;trovo 0 a sin dell’*: anche a=0! f 1 h > 0 ;c’e’1 a sin.di *: allora a>0,b=0 si osservi che le quintuple con la coppia s,q= f * a 0 c 0 e 0 non possono presentarsi ..0 1 * a .... ..0 1 * e ..0 0 * b c f ..0 = * h

46 10) MdT : test se a=b, caso a<b
..0 1 * a cancella uno: dopo b-1, a-1 ho: ..0 0 * a e ripeti.. b c ..0 0 * d e ..0 0 < h a * b * + ;situazione iniziale b 1 b 1 + ;scorri b a destra b 0 c 0 - ;quando trovi 0 in b, ;vai in stato c e c 1 d 0 - ;fai b-1 se possibile d 1 d 1 - ;scorri a sinistra dopo b-1 d * d * - ;scavalca asterisco in mezzo d 0 e 0 + ;fino allo zero a sin. di a e 1 a 0 + ;fai a-1 se possibile a 1 a 1 + ;scorri uni di a fino * ; resta da vedere i casi finali: ; se dopo fatto b-1 trovo che a=0,cioe' e * h < 0 ;scrive risultato a<b c * f * - ;se cerco di fare b-1, trovo ; * allora b=0, vado controllare a : f 0 h = 0 ;trovo 0 a sin dell’*: anche a=0! f 1 h > 0 ;c’e’1 a sin.di *: allora a>0,b=0

47 10) MdT : test se a=b; rivediamo le quintuple:
a * b * + ;situazione iniziale b 1 b 1 + ;scorri b a destra in cerca dello zero di fine b b 0 c 0 - ;quando trovi 0 dopo b, vai in stato c, vai a sin c 1 d 0 - ;se trovi 1 allora fai b-1 e poi in stato d,a sin d 1 d 1 - ;dopo b-1 scorri a sinistra gli 1 di b e/o di a d * d * - ;scavalca asterisco in mezzo d 0 e 0 + ;fino allo zero a sinistra di a e 1 a 0 + ;c'e' almeno un 1 di a, faccio a-1 se possibile a 1 a 1 + ;scorri a destra gli 1 di a fino * ; casi finali: ; (e,*) e'il caso a=0 dopo fatto b-1 cioe': e * h < 0 ;dopo b-1 e senza a-1, scrive risultato a<b ; (c,*) e'il caso b=0, si deve controllare se a e'zero o no: c * f * - ;devo controllare a: in stato f (b=0) ho: f 0 h = 0 ;trovo 0 a sin dell’*: anche a=0, a e b uguali ! f 1 h > 0 ;c’e’ un 1 a sin.di *: allora a>0,b=0, quindi a>b ; non tutte le coppie (q,s) sono presenti: le coppie ; (q,s) = (f *), (a 0), (c 0), (e 0) non possono presentarsi ; si lascia come esercizio la verifica di questo...

48 esercizio 11) dato un numero n calcolare il valore 2*n

49 esercizio 11) dato un numero n calcolare il valore 2*n
dobbiamo prima specificare la codifica, ad es.: 0 0 0 A B a dato n=3; per ogni 1 del dato n scrivo due 1 a destra di B: 0 0 0 A B 0 0 0 A B 0 0 0 A B h si lascia allo studente l'esercizio ...

50 cosa si puo’ fare con una m.d.T.
abbiamo cosi’ verificato che esistono m.di T. per fare n+1 fare test se a=b? fare copia del valore di a in un altra parte ... sono le operazioni fondamentali per fare aritmetica intera.. non e’ difficile definire m.d.T. per fare altri “conti” vedremo che con le MdT si possono risolvere molti problemi anche piu' complicati ...

51 esercizi suggeriti 1) m.d.T per fare la somma di due numeri A e B:
ad es. con il dato (A e B in unario, delimitati da x,y,w) : ...x y 1 1 w a ottenere il risultato: ...x y 0 0 w h (i dati originali qui non vengono conservati)

52 esercizi suggeriti 2) macchina per fare il prodotto di due numeri
ad es. con il dato A=3, B=2 codificato ad es. con: ..x111y11w a ottengo il risultato: ..x000y00w z h

53 cont. esercizi da fare 3) macchina per compattare una stringa di zeri e uni, delimitata dal simbolo x. Ad es. dato ... x x a ottengo il risultato (le celle su nastro non sono numerate!) : ... x x h nota che una cella della memoria a nastro esterna non puo' "sparire", ma puo' solo cambiare valore !

54 cont. esercizi da fare 4) macchina azzera le coppie di uni sul nastro esterno; ad esempio a partire da un nastro del tipo: ...x x a ottengo : ...x x h

55 cont. esercizi da fare 5) macchina che conta le stringhe contenenti una coppia di zeri, ad es. dal nastro dato: ..x x x x y a produce: ... y 1 1 z h

56 cont. esercizi da fare 6) macchina somma due numeri in base dieci;
ad esempio a partire dal nastro ..x x x produce il nastro: ..x x x x (nota: per calcolare a+b con a,b codificati in base 10 si usi il procedimento ripeti a<-a+1; b<-b-1 fino_a_che b=0 )

57 cont. esercizi da fare 7) macchina che cerca una stringa uguale ad una stringa data, tutte le stringhe sono composte da soli 0 e 1 e sono delimitate da un simbolo x .. z 0 0 z 1 1 x 1 0 x 1 0 x 0 0 x .. a la stringa data 0 0 sta tra due z, ed e' uguale alla quarta stringa dopo la z; il problema dovra' essere scomposto in problemi piu' semplici; lo stato interno (o la sequenza di stati interni) ricordera' il simbolo letto dopo z, che sara' ad es sostituito con un simbolo diverso, ad es. 0 diventa a, 1 diventa b, di seguito in stato q dopo avere riconosciuto che il primo simbolo dopo x e' uguale al 1.o simbolo dopo il 3.o x .. z a 0 z 1 1 x 1 0 x 1 0 x a 0 x .. q

58 cosa si puo’ fare con una m.d.T.
abbiamo cosi’ verificato che esistono m.di T. che sanno risolvere alcuni problemi : n+1, test se a=b?, (si potrebbe vedere anche le operazioni di somma a+b, e prodotto a*b ), copia del valore di a in un altra parte (a := b) ... ... queste sono alcune delle operazioni fondamentali per fare aritmetica intera.. non e’ difficile definire m.d.T. per fare altri “conti”

59 cosa si puo’ fare con una m.d.T. ?

60 si puo' simulare un calcolatore con una MdT ?
si puo' dimostrare che e' possibile simulare un calcolatore digitale con una M.di T.; in particolare, si possono costruire MdT per simulare i singoli componenti del calcolatore, come la memoria centrale, l' unita' centrale, una memoria a disco ... vediamo un cenno sul problema di simulare la memoria centrale del calcolatore con una MdT

61 si puo' simulare un calcolatore con una MdT ?
problema: simulare la memoria centrale del calcolatore con una MdT la memoria centrale del calcolatore e' molto diversa dalla memoria a nastro di una MdT; la memoria centrale e' un dispositivo HW fatto di celle di memoria (di formato fisso) ciascuna con un indirizzo ed e' in grado di fare due operazioni: memorizza D e leggi D "scrivi un dato D nella cella di memoria di indirizzo A" "leggi un dato D dalla cella di memoria di indirizzo A" per accedere ad un dato si deve o basta dare l'indirizzo della cella di memoria dove sta il dato stesso;

62 memoria ad accesso diretto:
= memoria capace di leggere / scrivere un valore (un dato) x in una “cella” di indirizzo specificato indiri : leggi: x <-- MEM[ indiri ] scrivi: x --> MEM[ indiri ] dove la MEM e’ una memoria di n “celle” numerate, con indirizzi (numeri cella) da zero a n, e con ciascuna cella in grado di memorizzare un valore: 123 313 001 313 456 006 199 995 1 2 3 4 5 6 7 8 MEM[ 4 ] = 313 => il valore contenuto nella cella 4 e’ 313 indirizzo del valore 313 contenuto della cella di indirizzo 4

63 una memoria a indirizzo? ma la m.di T. non lo e' !
La memoria nastro esterno di una macchina di Turing e’ composta da celle adiacenti non numerate, l'accesso ad una cella e' sequenziale, passando prima per tutte le celle intermedie.. per individuare un dato si introducono dei simboli speciali di marcatura (“delimitatori”), ad es.: “cancella il dato che sta tra due celle contenenti w w w ^ ^

64 una memoria a indirizzo
Es: una MdT con un po'di dati sul nastro esterno, separati dal simbolo x, 00x01011x00x111x1001x0101x00 a (=posizione testina e stato interno) allora per arrivare al 4.o dato 1001 devo scorrere (leggere / riscrivere) i primi tre; ... ma: una MdT puo' simulare la memoria a indirizzi con un sistema di codifica del tipo seguente (A,B,C sono simboli delimitatori) : A B C . . . dove la parte tra A e B e' l'indirizzo, e la parte tra B e C e' il dato

65 continua la memoria a indirizzo
in particolare, vediamo ora una m.d.T. che simula il comportamento di una memoria con celle numerate, individuabili dal numero di cella di memoria o indirizzo: cioe’ un “dispositivo” che sa fare le due operazioni di base per ogni dispositivo di memoria: scrivi (registra) in memoria un dato DDD all’ indirizzo III leggi dalla memoria il valore che c’e’ all’indirizzo III

66 continua la memoria a indirizzo
m.d.T. che simula una memoria con “celle” numerate, cioe’ con memoria con dati accessibili specificando un indirizzo: “azzera il dato nella “cella” di numero 22”: date tre “celle” di memoria di indirizzo 21, 22 e 23 (con valori 4, 1 e 0 rispett.) . 2 2 x 2 1 w 4 w 2 2 w 1 w 2 3 w 0 ... ^ ^ ^valore=1, indirizzo=22 dopo l’istruzione detta avremo: . 2 2 x 2 1 w 4 w 2 2 w 0 w 2 3 w 0 ... ^ riportiamo di seguito solo parte della soluzione; nota: per selezionare il dato giusto devo trovare quale indirzzo e' uguale all'indirizzo dato 22;

67 continua la memoria a indirizzo
prima parte del problema della memoria a indirizzo: dato un insieme di stringhe di tre caratteri separate da x e delimitate da y trovare la stringa uguale alla stringa data: .. y x x x y .. ^ ^ ^ | | | dato str. a valore coincid. procedimento: esamino i caratteri della stringa data uno dopo l’altro, ricordando sia su nastro sia con uno stato di scorrimento diverso se ho letto un 0 oppure un 1: cerco poi a destra la prima stringa non ancora esaminata e vedo se ha gli stessi caratteri: se si, e’ la stringa cercata, se no, continuo (fino al delimitatore delle stringe y)

68 m.d.T. “memoria ad accesso diretto”
formato codifica della memoria con indirizzi e dati a tre cifre: y x x x x a si puo' fare una MdT per rispondere alla domanda: qual e’ il valore del dato di numero (o di indirizzo) 010? (qui e’ 101) con il procedimento: 1) dato un indirizzo i (010) cerca tra gli indirizzi un kj tale che kj = i, (m.d.T. cerca stringa=), e ho ad es y x A A A B B B x A B A x x 2) poi copia il dato (la stringa 1 0 1) al posto dell’indirizzo i : y B A B x A A A B B B x A B A B A B x x i e abbiamo il dato cercato (dato memorizz in cella di indir 010) non riporto la MdT che risolve questo problema (6 stati, 15 istr)

69 memoria a indirizzi su supporto fisico a memoria sequenziale
negli anni 60 sono stati realizzati sistemi di memoria a nastro magnetico formattato a zone di memoria di ampiezza fissa e con indirizzo registrato accanto il dato; il sistema era in grado di trovare il dato di indirizzo k cercando su nastro (con ricerca sequenziale) la zona con indirizzo k e quindi il dato corrispondente (memoria associativa, ogni dato ha registrato anche l'indirizzo che lo individua (o chiave) ) questo sistema non ha avuto successo ...

70 una macchina di Turing "programmabile"
tutte le M.di T "sanno" (per definizione) eseguire solo un algoritmo, cioe' quello "prefissato" nella memoria delle quintuple (che e' a sola lettura, non modificabile); e quindi una M di T ha UN programma; ma: e' possibile codificare una qualunque macchina di Turing (quintuple, nastro, memoria dello stato, posizione testina) su un nastro esterno di una particolare m.d.T., che chiameremo m.d.T Universale; si puo' costruire un insieme di quintuple per realizzare le azioni richieste per una qualunque m.d.T., cioe' l'algoritmo di imitazione a questo punto abbiamo una m.d.T. "programmabile", detta m.d.T. "Universale"

71 cont. “U”, una m.d.T. speciale ...
la m.d.T. “U” o “Universale” e’ una macchina che in effetti sa eseguire un solo algoritmo, (come del resto ogni m.d.T., per definizione) e cioe’ la procedura di imitazione della m.d.T. “X” che e’ codificata sul suo nastro: “dato stato q corrente e simbolo s corrente [di X!] codificati subito a destra della cella y sul nastro [di U!] cerca tra le quintuple [di X] codificate su nastro [di U] quella che comincia con la coppia q,s uguale; a questo punto sostituisci q1 al posto di q [sul nastro U, a dest.di y] e s1 al posto di M [sul nastro di U, dove prima era s], e poi “sposta” M a destra o a sinistra [sul nastro di U], ovvero copia s che trovi nella nuova “cella corrente” di X a destra di y, e metti al suo posto M.

72 osservazione per chi e' interessato all'argomento vedere ad es. M.L. Minsky: "Computation: Finite and Infinite Machines", Prentice Hall 1967, cap. 6,7,8., questi argomenti saranno ripresi in altri corsi di seguito e’ riportata la versione grafica di una m.d.T. universale, solo a titolo di curiosita' !!

73 La macchina di Turing Universale - vers. grafica
locate name (quintuple) - + g j k h i l da m.d.T.(a) fine copia 1 A A (copia 0!) B B (copa 1!) y x M COPY item, replace name restore machine condition region start a B 1 - A trovato y X + B A 1 b test ccerca 0 - + 1 S Replace s with s1, move position, repeat A B M + + 1 to start (repeat) 1 dcerca 1 B y A - eok B A fnok + 23 stati, 5 simboli non trovato -halt x y La macchina di Turing Universale - vers. grafica

74 segue un discorso generale sulle M.d.T., sull'applicabilita',
m.d.T e algoritmi segue un discorso generale sulle M.d.T., sull'applicabilita', sugli algoritmi e sulle funzioni effettivamente calcolabili

75 applicabile ( mdT applicabile ad un dato)
definizione di applicabile diremo che una mdT “T” e’ applicabile al dato D se fatta partire T con un nastro su cui e’ codificato D da’ luogo ad una computazione che finisce in un numero finito di passi, ovvero T e’ applicabile a D se produce in un numero finito di passi un risultato R.

76 calcolabile Un algoritmo puo’ essere pensato come una funzione f che a partire da dei dati (*) produce dei risultati (*) quindi come: y = f(x) con x (dato) e y(risultato) interi, diremo che f e’ T calcolabile se esiste una m.d.T. T tale che fatta partire con un nastro su cui e’ codificato x produce in un numero finito di passi un nastro su cui e’ codificato y; diremo che f e’ P calcolabile se esiste un Programma C++ P tale che fatto partire con il dato x produce in un numero finito di passi il risultato y; ____________________________________________________________________ (*)n.b: un dato (ad es. formato da 1000 numeri in virgola mobile di 10 cifre ciascuno) puo’ esser sempre pensato codificato come UN UNICO intero ... di cifre ! -> posso sempre pensare y = f(x) come una funzione da num. intero a num. intero - e' un discorso gia' fatto nell'introduzione agli algoritmi ;-)

77 mdT “T” <=> f(intero) -> intero parziale
diremo che f(x)->y e’ T (o P) calcolabile se esiste una m.d.T. (o un programma C++) applicabile a x e che produce (in un numero finito di passi) il risultato y; nota: una mdT “T” puo’ essere applicabile ad alcuni dati, che chiameremo Da = insieme dati per cui T si ferma, Da = {d, T(d) si ferma}, ma non applicabile ad altri: Dn = ins.dati per cui T non ferma: Dn = {d, T(d) non si ferma}: Associo ad ogni dato d della mdT “T” un intero k -> l’insieme degli interi I risulta suddiviso in due sottoinsiemi, Ka che corrisponde ai dati Da (su cui T e’ applicabile), e Kn che corrisponde ai dati Dn (su cui T non e’ applicabile) Ad ogni mdT “T” corrisponde una f(k) che e’ definita per k appartenenete a Ka, ma non e’ definita per k di Kn.

78 le m.d.T sono meno potenti del C++?
Si puo’ dimostrare che l’insieme delle funzioni T calcolabili, coincide con l’insieme delle funzioni C++ calcolabili, cioe’ per ogni mdT esiste un programma C++ corrispondente, e viceversa... ovvero: i due formalismi sono altrettanto potenti! cioe' se si puo' risolvere un problema con il linguaggio C++ (con un calcolatore digitale) lo stesso problema si puo' risolvere con il formalismo delle MdT (e in particolare i diversi linguaggi di programmazione procedurali (o imperativi) hanno la stessa potenza: quello che si puo' risolvere in Visual Basic si puo' risolvere in C++ oppure in Java ecc ecc )

79 le m.d.T sono meno potenti del C++?
Si puo’ dimostrare che per ogni mdT esiste un programma C++ corrispondente, e viceversa... Definiamo una procedura effettivamente computabile una procedura che si puo’ esprimere con una m.d.T. oppure con un programma C++ algoritmo = procedura effettivamente computabile = = mdT ( tale che si ferma !! ) = programma C++ ( tale che si ferma !! ) (oppure con uno dei molti formalismi definiti da vari autori, o con uno dei moltissimi linguaggi di programmazione).

80 sono tutti formalismi di pari potenza
tesi di Church: linguaggi di programmazione... Ada, Basic, C++, Cobol, Java, Logo, Euclid, Lisp, Modula, Oberon, Pascal, PL / I, Smalltalk, ... e altri linguaggi... formalismi... di Church, di Kleene, di Markov, di McCarthy, di Post, di Turing, ... ogni algoritmo si puo' scrivere in uno qualunque di questi formalismi : tesi di Church: sono tutti formalismi di pari potenza (ipotesi fondamentale della teoria degli algoritmi)

81 tesi di Church: tesi di Church: i formalismi definiti finora per scrivere algoritmi sono tutti formalismi di pari potenza (ipotesi fondamentale della teoria degli algoritmi) per i formalismi finora costruiti e’ stato dimostrato che l’insieme delle funzioni calcolabili da ciascuno di essi e’ lo stesso ( ma - non e’ stato dimostrato che non esiste un formalismo piu’ potente )

82 limiti infine, ancora un dubbio:
... cosa si puo’ fare con una m.d.T? ovvero: cosa si puo' risolvere con un algoritmo? si puo' formulare un problema in modo che si possa cercare di risolverlo per via algoritmica (ad es. con un programma in C++) e poi scoprire che non si puo' risolvere? esistono problemi non risolubili per via algoritmica? esistono problemi per cui non si potra' mai scrivere un programma che li risolva?

83 limite ... cosa si puo’ fare con una m.d.T?
si puo' dimostrare che esistono problemi (esprimibili in forma adatta per una m.d.T./un progr C++) non risolubili per via algoritmica, ovvero per i quali non esiste una m.d.T. (o un programma C++) osservazione molto semplice: 1) si noti che l’insieme delle funzioni da intero a intero - F i ( N ) -> N { dove ogni F i fa corrispondere ad un generico numero intero k un (altro) numero intero m, se F i e’ definita su k, altrimenti non fa corrispondere nulla } [ -->> quante sono le possibili coppie (intero - intero) ? ] cioe’ di TUTTE le possibili funzioni che fanno corrispondere un numero intero m ad un altro numero intero k non e’ numerabile!

84 per ogni mdT c'e' una f(i) , ma per ogni f(i) c'e' mdT ? e' sufficiente osservare che l’insieme di TUTTE le funzioni da intero a intero F i ( N ) -> N non e’ numerabile, mentre: l’ insieme delle m.d.T.(o dei progr. C++) e’ numerabile quindi: la gran parte delle funzioni da intero a intero NON sono esprimibili con una m.d.T., ovvero gran parte delle f(i)->i non ha una mdT corrispondente! molti problemi NON hanno soluzione algoritmica; vediamo un problema non risolubile per via algoritmica.

85 problema dell’ arresto (halting problem)
dato un programma qualunque (data una m.d.T. qualunque) con un dato iniziale fissato (una situazione su nastro) ci si chiede se solo analizzando il programma / la mdT - (senza esecuzione) e’ possibile sapere se il processo di calcolo che avra’ luogo - fatto partire il calcolatore (fatta partire la m.d.T) su quel dato - produrra’ un risultato entro un numero finito di passi ? cioe’ se si fermera’? cioe’ -- se il programma (la m.d.T.) e’ applicabile a quei dati?

86 problema dell’ arresto (halting problem)
problema: “data una mdT X e un nastro dati D, se faccio partire X con i dati D la mdT X si fermera’ dopo un numero finito di passi (cioe’ X e’ applicabile a D)? x82y (a,0,...) quintuple f (a,1,...) della (dati D su nastro) (b,8,...) mdT. X risposta “ingenua”: faccio partire il programma: se dopo un po’ si ferma allora la m.d.T.X e’ applicabile a quei dati D, se non si ferma allora X non e’ applicabile a D. ma ... non e’ una buona risposta! in effetti non posso sapere se una MdT che lavora da giorni magari si ferma dopo il mo giorno ...

87 problema dell’ arresto (halting problem)
problema: “data una mdT X e un nastro dati D, se faccio partire X con i dati D la mdT X si fermera’ dopo un numero finito di passi (cioe’ e’ X applicabile a D)? si puo’ avere la risposta solo ispezionando, analizzando la m.d.T. (chiamiamola mdT”X”) ed i relativi dati ? esprimiamo il problema cosi’: “ dati una mdT X e un nastro dati D, e’ possibile sapere - solo analizzando X e D, senza far partire la macchina - se la mdT X, fatta partire con i dati D, si fermera’ dopo un numero finito di passi ? (cioe’ se X e’ applicabile a D ?) risposta: si puo' dimostrare che non e’ possibile (ma noi per ora non analizziamo la dimostrazione)

88 problema dell’ arresto (halting problem)
quindi : dato un generico programma P con i suoi dati D non e’ possibile determinare ( con un programma “magico” G ) se il programma P e’ applicabile al dato generico D quindi: il problema dell’arresto non e’ risolubile per via algoritmica ovvero: non c’e’ una procedura effettiva (un algoritmo, una mdT, un programma C++...) per stabilire se una procedura X e’ realmente effettiva (algoritmo che si ferma in un numero finito di passi) oppure no. ovvero: non e’ possibile costruire un programma G (un compilatore magico) tale che esso solo leggendo il testo di un generico programma X risponda: si’, questo programma funziona, oppure no, questo programma non funziona ...

89 problema dell’ arresto (halting problem)
ma attenzione - se e’ vero che: dato un generico programma P non e’ possibile determinare con un programma “magico” G se il programma P e’ applicabile ad un dato generico D cioe’ se si fermera’ - questo non significa che non esistano particolari tipi di programmi / dati per i quali invece esiste la soluzione ovvero: il problema dell’arresto per un programma qualunque applicato ad un dato qualunque e’ troppo generale per avere una soluzione algoritmica, ma ... esistono casi particolari per i quali esiste una soluzione algoritmica.

90 problema dell’ arresto (halting problem)
nota: il fatto che esistono problemi non risolubili per via algoritmica pone un limite a quello che si puo’ fare con gli algoritmi (e con i calcolatori); questo tipicamente succede per problemi di natura troppo generale; rimane da stabilire di volta in volta se un particolare problema e’ risolubile... sara’ oggetto del nostro corso lo studio della soluzione di alcuni problemi abbastanza semplici e ben delimitati ...

91 riassumiamo alcuni concetti:
procedura di calcolo=lista di istruzioni=progr.C++=mdT mdT: stato iniziale: nastro con dati D, stato q e posiz.testina. istruzioni: quintuple; mdT applicabile a D se si ferma; processo di calcolo = procedimento di calcolo = insieme degli stati di una mdT, dal primo (stato iniziale, con il dato di partenza) all’ultimo (stato finale, con il risultato)

92 riassumiamo alcuni concetti:
algoritmo = discrizione completa, eseguibile, finita, non ambigua di un procedimento di calcolo che a partire da dei dati D da’ luogo ad un procedimento di calcolo finito, che in un numero finito di passi produce un risultato R. algoritmo = una mdT X che a partire da dei dati D si ferma e produce un risult. R in un n.ro finito di passi (X e’ applicabile a D); algoritmo = una mdT applicabile = procedura effettivamente computabile = un programma che produce un risultato in un numero finito di passi

93 e con questo concludiamo questo capitolo sugli
algoritmi e sulle macchine di Turing

94 fine