Parte 4.

Presentazione sul tema: "Parte 4."— Transcript della presentazione:

1 parte 4

2 7. esempio: controllo parentesi ben formate
per l’ esempio seguente (macchina di Turing numero sette) 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’) 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, def.: |s| = lunghezza della stringa s = n. di caratteri di s def.: 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 } s1,s2,s3... appartengono a C * , compresa la stringa vuota s0, n.b.: 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 } = 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 possiamo definire un sottoinsieme X di stringhe di 0 ed 1 aggiungendo una proprieta’ richiesta ad una stringa per essere considerata un elemento di X ovvero “ben formata”: 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”, 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*, introduco una proprieta’ p che richiedo 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 stringa di caratteri di B } Y = { s | s appart. a B *, |s| = 3 } ovvero: Y = { 111, 110, 101, 011, 100, 010, 001, 000 } D = { 1 } D *= { s | s stringa di caratteri di D } W = { s | s appart. a D *, e |s| = 4 } allora: W = { } e basta: l’insieme W ha un solo elemento.

10 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... vediamo

11 schema generativo (cont. premesse per la m.d.T nr. 7)
defin.di un insieme di stringhe di parentesi “ben formate”: base: [pbf = parentesi ben formate ] ( ) sta in PBF /*/ 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 (7.es:contr. parentesi ben formate)
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 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; ad es.: ( ), ( ) ( ) ( ), ( ( ( ) ) ), ecc sono p.b.f., ( (, ( ( ) ) ( (, ) (, ecc non sono p.b.f. un metodo 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

14 parentesi ben formate - problema di decisione
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 ( ), ( ) ( ) ( ), ( ( ( ) ) ), ( ( ) ( ) ) 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).

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) torno indietro per cancellare una “(“ - ma non la trovo, 7) 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 7.o esempio di m.d.T. [...finalmente...]
.. A ( ( ) ( ) ) A .. a 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: 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 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 ;ripeti... se trovi 1 ignora: 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 7.o esempio di m.d.T. [eliminazione coppie ( ) ]
a ( a ( + ;ricerca della prima ) a ) b ;trovata,cancella,cerca ( corrisp. b ( a ;ripeti... se trovi 1 ignora: a 1 a ;scorri a destra se in a, b 1 b ;a sin.se in b 1) A ( ( ) ( ) ) A .. situazione iniziale ... a 15) A ( A .. ho elim. l’ultima ), e b 16) A A .. elim.anche la ( corrisp. ora cerco se c’e’ancora qualche ) da eliminare

20 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: 1) A ( ( ) ( ) ) A ) A ( ) A .. a b 15) A ( A .. 16) A A .. b a 17) A A .. 20) 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”

21 es. numero 7 di m.d.T. [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 - ;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’.

22 es. numero 7 di m.d.T. situazioni stringa NON ok
.. 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’ !! : .. A ( A .. se in c trovo una ( allora c la stringa non e’ok: c ( h N 0 ;caso di stringa errata / prima era: c 1 c 1 - ;scorri verso sinistra ... c A h S 0 ;se non hai trovato nessuna ( -> ok

23 es. numero 7 di m.d.T. situazioni di stringa NON ok
.. 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

24 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. a ) 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 ) ?

25 versione grafica Stop Si S 1 ( b a A c 1 - + - ) A A ( N N stop No
;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 ) ? ; ;c contr.( rimaste c ( h N 0 ; c 1 c 1 - ; c A h S 0 ; c ) ? S 1 ( b a A c 1 - + - ) A A ( N N stop No stop No start

26 7.o esempio di m.d.T. conclusione
L’esempio visto pero’ distrugge i dati: esercizio: modificare l’algoritmo in modo che la macchina NON distrugga i dati (suggerimento: nella verifica delle coppie “)” e “(“ invece di sostituire entrambe le parentesi con un simbolo, si cambi la “)” in un simbolo e la “(“ in un simbolo diverso, per cui alla fine e’ facile ripristinare la situazione iniziale.

27 fine parte 4 fine parte 4

28 parte 5 parte 5

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

30 cont. esempio muovi gli uni (m.d.T num.8)
dato un nastro: * a produrre * h una procedura puo’ essere: cerco l’ultimo 1 a destra, lo cancello e scrivo un 1 a sinistra dopo l’ asterisco; .. e se inizio a cancellare il primo 1 che trovo a destra dell’ asterisco?

31 muovi uni: una strategia errata:
la strategia di cancellare il 1.o 1 a destra dell’* e poi riscrivere a sinistra da’ luogo alla sequenza: * stato a = cerca 1 a a destra dell’ * * scavalco 0 e a cerco 1 a destra * a * vado a cercare 1 * cerco 1 non mi fermo piu’ ...

32 cont. esempio muovi gli uni
dato un nastro: * a produrre * h cerco l’ultimo 1 a destra: 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 applicando queste, ho * cancellato 1, d riscrivo a sin.

33 cont. esempio muovi gli 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 (ho spostato un 1) e ripeto * d * a

34 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 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 ... * cerca ultimo 1.. a * fine dato a dest b * cancella c * riscrivi d

35 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 ... * vai a sinistra d * riscrivi * e ripeti a * di nuovo.. b

36 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 ... * limite dato b * cancella 1 e poi c * riscrivi 1 a sin. d * ripeti: cerco 1 a des a

37 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 * limite dato, b * non c’e’ 1 da cancel- c lare, quindi * stop h

38 esempio muovi gli uni ... versione grafica ?
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 ... ==>> esercizio !

39 versione grafica: a b c d h 1 - + * date le quintuple:
* 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 + ; a b c d h 1 - + *

40 due esempi di operazioni di base: 2) test se a=b
ipotesi sulla rappresentazione di dati: in unario, separati da un *, posiz. iniziale testina in mezzo: * a schema di soluzione: fintanto che a>0 e b>0 sottrai 1 ad entrambi cioe’ fai b <= b-1 e poi fai a <= a-1 quando o a=0 e/o b=0 controlla se entrambi sono zero, se si’ il test risponde S, se no risponde N.

41 test se a=b (m.d.T num.9) es. con a=1, b= 2: ..0 0 1 * 1 1 0 0..
; sottrai 1 a b: a a * b * + ; vai a destra b 1 b 1 + ; scorri il dato b b 0 c 0 - ; oltre il limite di b c 1 d 0 - ; cancella un 1 di b (come muovi 1) ; ora abbiamo: * ; ora sottrai 1 ad a: d 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

42 test se a=b (m.d.T num.9) situazioni finali:
a * b * + ; stato iniziale: * b 1 b 1 + ; a b 0 c 0 - ; oltre b c 1 d 0 - ; b-1 quindi ho: * d 1 d 1 - ; scorri 1 di b d d * d * - ; scavalca *, d 0 e 0 + ; oltre a, e 1 a 0 + ; a-1 : quindi ho: * a 1 a 1 + ; scorri a destra a ; da fare b-1 (se b=1, dopo b=0), ; e poi ancora a-1; ; ma dopo aver fatto b-1 trovo che a=0 ! ; allora era b>0, a=0 quindi aggiungo quintupla e * h < 0 ; scrive risultato a<b

43 test se a=b (m.d.T num.9) se invece ho stato iniziale: 0 1 1 * 1 0 0..
allora dopo aver fatto a b-1 e a-1 avro’la situazione: * ripeto, a vado a fare b-1, cioe’ * b 0 c 0 - ;per fare b b c 1 d 0 - ;ma non trovo 1 -> * c * f * - ;trovo * (b=0!) c ;ora devo controllare se anche a=0 -> stato f: f 0 h = 0 ;trovo 0 a sin dell’*: anche a=0! f 1 h > 0 ;c’e’1 a sin.dell’*: allora a>0,b=0 ; e abbiamo finito...

44 test se a=b (m.d.T num.9) - elenco quintuple
b 1 b 1 + ; scorri dato b a destra b 0 c 0 - ; c 1 d 0 - ; b-1 se possibile d 1 d 1 - ; scorri indietro d * d * - ; d 0 e 0 + ; fino allo zero a sin. di a e 1 a 0 + ; a-1 se possibile a 1 a 1 + ; scorri a fino a * ; casi finali: e * h < 0 ; scrive risultato a<b c * f * - ;trovo * (b=0!) c f 0 h = 0 ;trovo 0 a sin dell’*: anche a=0! f 1 h > 0 ;c’e’1 a sin.dell’*: allora a>0,b=0

45 test se a=b (m.d.T num.9) - elenco quintuple
a * b * + ; vai a vedere dato b a 1 a 1 + ; scorri a destra dato a b 1 b 1 + ; scorri dato b b 0 c 0 - ; sei oltre b c 1 d 0 - ; fai b-1 se si puo’ c * f * - ; non si puo’se trovo *, controlla d 1 d 1 - ; scorri 1 di b d * d * - ; scavalca *, d 0 e 0 + ; oltre a, e 1 a 0 + ; a-1 : e * h < 0 ; scrive risultato a<b f 0 h = 0 ; trovo 0 a sin di * -> anche a=0! f 1 h > 0 ; 1 a sin.dell’*, 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

46 cosa si puo’ fare con una m.d.T.
abbiamo cosi’ verificato che esistono m.di T. per fare n+1 fare a=b? fare copia valore di a in altra parte ... sono le operazioni fondamentali per fare aritmetica intera.. non e’ difficile definire m.d.T. per fare altri “conti” vediamo 2*n

47 calcola 2 * n dato n calcola r = 2 * n ;
ipotesi: n e’ dato in unario; ad es. a cancello 1 e lo sostituisco con due 1 a destra, devo avere un simbolo di separazione tra n e r, ad es. dopo il primo ciclo (fatto n-1, r+2) dopo il secondo ciclo h abbiamo finito...

48 cont. calcolo di 2 * n ... prima versione
; cancello 1 e aggiungo ; a due 1 a destra, a 1 b 0 + fai n-1 e poi vai a destra a fare r+2 b 1 b 1 + ignora 1 di n, scorri fino a 0 in mezzo b 0 c 0 + e cambia stato: sto esaminando r c 1 c 1 + scorri 1 se vi sono gia’(r>0) fino a 0 c 0 d 1 + stato c fai r+1 e poi stato d fai r+1, d 0 e 1 - quindi r+2; ora ritorna a sinistra: ; ho cancellato 1 di n e ; e aggiunto due 1 a r; e 1 e 1 - ignora 1 di r, scorri verso sinist. e 0 f 0 - sullo zero di separazione tra n e r f 1 g 1 - se n>0 cerca primo 1 di n, se n=0->fine g 1 g 1 - scorri 1 di n a sinistra, fino al 0 g 0 a 0 + e ripeti ...

49 cont. prima versione di 2 * n
vers. grafica: 1 + + a b + c 1 1 - g d + h e f 1 1 - -

50 un altro modo di calcolare di 2*n, con - stati e + simboli est.
schema: cambio 1 di n in una x e poi aggiungo a n una x; alla fine se non vi sono piu’ 1 allora trasformo gli x in 1... 1) )0 0 0 x x x 0 0 a c 3) )0 0 0 x x x 0 0 4) )0 0 0 x x x x 0 b d 5) x )0 0 0 x x x x 0 c d 6) x x )0 0 0 x x x x 0 d e 7) x x 0 0 a=cerca limite 0 a destra d b=cambia 1 in x; c=aggiungi 1 d=cerca a sin.1(cont.)o 0(fine)

51 cont. seconda versione di 2 * n
1) a=cerca limite zero a destra a b=cambia uno in x, 2) c=aggiungi 1 d d=va a sinistra e controlla: 14)0 0 0 x x x x 0 se trovi 1 continua ->in c d se trovi 0 hai finito-> in e 15)0 0 0 x x x x 0 e=cambia alla fine x in 1 e 16) x x x 0 19) 20) h

52 cont. seconda versione di 2 * n
esercizi suggeriti: scrivere le quintuple della seconda versione di 2 * n disegnare la versione grafica della seconda versione fine esercizio 2 * n

53 fine parte 5 fine parte 5

54 esercizi da fare altri esercizi suggeriti:
1) m.d.T per fare la somma di due numeri: ad es. con il dato: ...x y 1 1 w a ottenere il risultato: ...x y 0 0 w h 2) macchina per fare il prodotto di due numeri - si usi ad esempio una codifica simile a quella suggerita per la somma;

55 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 4) macchina elimina (azzera) le coppie di uni su un nastro; ad esempio a partire da un nastro del tipo: ...x x ottengo : ...x x

56 cont. esercizi da fare 4) 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 5) 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 una memoria a indirizzo
Il nastro esterno di una macchina di Turing e’ composto da celle adiacenti non numerate per individuare un dato si devono introdurre dei simboli speciali di marcatura (“delimitatori”): “cancella il dato che sta tra due celle contenenti w w w ^ ^

58 continua la memoria a indirizzo
... la nostra tesi e’ che con le m.d.T. si puo’ fare di tutto: 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

59 continua la memoria a indirizzo
m.d.T. che simula una memoria con “celle” numerate, cioe’ con memoria con dati accessibili specificando un indirizzo: “cancella 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.) ... w 2 1 w 4 w 2 2 w 1 w 2 3 w 0 ... ^ ^ ^valore=1, indirizzo=22 dopo l’istruzione detta avremo: ... w 2 1 w 4 w 2 2 w 0 w 2 3 w 0 ... ^ riportiamo di seguito solo parte della soluzione

60 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)

61 parte della 1.a parte della memoria a indirizzi
per il problema “cerca stringa data tra piu’ stringhe” vediamo prima come si risolve il sotto-problema (test): determinare se i = k (con i,k stringhe di tre 0 e 1) : i k .. y x y ... a all’inizio cambio il dato i a sinistra: gli 0 in A, gli 1 in B: .. y A B A x y ... b poi vado a confrontare i caratteri di i e di k uno dopo l’altro: y A B A x y // y A B A x y // ^ ^ // ^ ^ // y A B A x y // ^ ^ // vediamo...

62 cont. memoria a indirizzi / test i = k ?
confronto i caratteri di i e di k uno dopo l’altro: il primo: .. y A B A x y.. b leggo A, scrivo 0 (per ricordare che l’ho gia’ esaminato), passo in stato di scorr. a destra c (indica che devo trovare 0), vado su stringa k a vedere se inizia con uno zero: .. y 0 B A x y.. c la stringa k inizia con 0 (ok), memorizzo (cambio 0 in A), e poi vado indietro a vedere il secondo carattere: .. y 0 B A x A 1 1 y.. trovo B, cioe’ 1, memorizzo b con lo stato di scorrimento .. y 0 1 A x A 1 1 y.. a destra “d” -> cerco un 1 d corrispondente a destra ..

63 cont. mem. a indir. / test i = k ?
confronto i caratteri di i (010) e di k (011) uno dopo l’altro: .. y 0 B A x A 1 1 y.. trovo B, cioe’ 1, memorizzo b con lo stato di scorrimento .. y 0 1 A x A 1 1 y.. a destra “d” -> cerco un 1 d corrispondente a destra .. .. y 0 1 A x A 1 1 y.. => secondo caratt.di k = 1 d ok: registra (1->B), ripeti .. y 0 1 A x A B 1 y.. e=stato ritorno a sinistra e dopo un test ok; .. y 0 1 A x A B 1 y.. terzo carattere di i ? b trovo A =0, cerco a destra .. y x A B 1 y.. terzo carattere di k ... c a cifra di k -> non e’ 0!! -> risposta: le stringhe i e k non sono uguali; fine test.

64 cerca stringa “i” data tra piu’ stringhe “kn“
procedimento: esamino str. kj sulla destra, fino a che trovo una kn coincidente a stringa i data, oppure arrivo a y: y A B A x x x y b inizio: trovo A cioe’ 0 y 0 B A x x x y d cerca 0 corrisp ->trovato y 0 B A x A 1 1 x x y ..ritorna e a sinistra al limite y y 0 B A x A 1 1 x x y ..ripeti b test 2.o car.B cioe’ 1 y 0 1 A x A 1 1 x x y ..in k1 c trovo 1 -> ok, registro,

65 cerca stringa “i” data tra piu’ stringhe “kn“
procedimento: esamino str. kj sulla destra, fino a che trovo una kn coincidente a stringa i data, oppure arrivo a y: y A B A x x x y b situazione di inizio ...trovo le prime due cifre coincidenti: y 0 1 A x A B 1 x x y e ritorno a sinis.e vedo la y 0 1 A x A B 1 x x y terza b cifra di i: e’ A cioe’ 0 y x A B 1 x x y ma la 3.a d cifra di k1 non e’0-> i#k1 y A B A x A B B x x y rimetto b la stringa i come prima,e segue test i = k2

66 cerca stringa “i” data tra piu’ stringhe “kn“
ho fatto il test i=k1, esito NO, segue i=k2 si noti che k1 risulta marcata “gia’vista” y A B A x A B B x x y b si ripete: i primi due caratteri di i sono 0 1, cerca i corrisp. caratteri di k2 , sono 0 1 -> ok, stato dopo il confronto di 2 cifre di i e k2 y 0 1 A x A B B x A B 0 x y ora b vedo se le 3.e y x A B B x A B 0 x y cifre c sono uguali.. trovo che 3.a(i) = 3.a(k2), e ritorno a sin y x A B B x A B A x y per test e su pross. cifra

67 cerca stringa “i” data tra piu’ stringhe “kn“
abbiamo: y A B A x x x y b situazione di inizio ... y A B A x A B B x x y b dopo il primo test, i<>k1 y x A B B x A B A x y dopo il test di 3 cifre di i e k2 riprovo con la prossima [4.a] cifra - che non c’e’: in stato b y x A B B x A B A x y trovo x -> b > concludo che i = k2

68 mdT(a): cerca stringa “i” tra piu’ stringhe “kn“
b test ccerca 0 dcerca 1 eok fnok start A 1 B y - + non trovato x trovato .. y x x x x ..y.. grafo della m.d.T che cerca j tale che i = kj con i = str. data a sin. e kj una delle str. date a destra

69 cerca stringa “i” data tra piu’ stringhe “kn“
la macchina di turing vista risponde (con qualche modifica) al problema: dato un nastro dove c’e’ un archivio di indirizzi (stringhe di 0 e 1 memorizzate con opportuni separatori) e dato un particolare indirizzo (stringa di 0 e 1) trovare nell’archivio la posizione con indirizzo uguale (cioe’ marcare tale indirizzo); ad es. da situazione iniziale: y x x x x y a situazione finale (caso di indirizzo trovato): y x A A A x A A B x A B A x y x da cui..

70 cerca stringa “i” data tra piu’ stringhe “kn“
la macchina di turing ha per definizione la memoria esterna ad accesso sequenziale, (per il nastro, ho a disposizione solo i comandi: sposta la testina rispetto al nastro di una posizione a destra o a sinistra) per accedere ad un dato sul nastro devo scorrere (leggere) tutti i dati tra la posizione corrente della testina ed il dato richiesto. la m.d.T. vista (cerca j tale che i = kj con i, k stringhe date) e’ la premessa per relizzare con la m.d.T. una “memoria ad accesso diretto”, ovvero per poter avere una memoria capace di leggere/scrivere un valore in una “cella” di indirizzo specificato:

71 memoria ad accesso diretto:
= memoria capace di leggere / scrivere un valore in una “cella” di indirizzo specificato: leggi: x <-- MEM[ indirizzo ] scrivi: x --> MEM[ indirizzo ] dove la MEM e’ una memoria di n “celle” numerate, ciascuna 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

72 memoria ad accesso diretto:
= memoria capace di leggere/scrivere un valore in una “cella” di indirizzo specificato; con una m.d.T. simulo una memoria ad accesso diretto con una codifica del tipo: y x x x x dove 010 = indirizzo del dato richiesto alla “memoria”, e dove le celle di memoria hanno il formato seguente: x x le prime tre cifre sono l’ indirizzo (qui 000) e le seconde tre cifre sono il valore (qui 111); ad es. la cella di indirizzo 010 ha (contiene) il valore 101, e la cella di indirizzo 011 contiene il valore 001.

73 m.d.T. “memoria ad accesso diretto”
con la memoria di formato visto, y x x x x a possiamo rispondere alla domanda: qual e’ il valore del dato di numero (o di indirizzo) 010? (qui e’ 101): procedimento: dato un indirizzo i (010) cerca tra gli indirizzi un kj tale che kj = i, con la m.d.T. vista prima: y x A A A B B B x A B A x x poi copia il dato (cioe’ 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

74 mdT (b)/mem.accesso diretto/ parte copia il valore trovato
- + g j k h i l da m.d.T.(a) fine copia 1 A A (copia 0!) B B (copia 1!) y x g cerca primo 0 /1; stati j,h vai a sinist. fino a y (j ricorda 0, h ricor.1); stati k, i scrivono (k scrive A cioe’0, i scive B cioe’ 1); l scorre fino x limite dell’indir.a sin.; poi g scorre a dest. fino 0 /1 del dato da copiare;

75 fine parte 6 fine parte 6

76 La macchina di Turing “U”
ogni macchina di Turing esegue sempre la stessa procedura per interpretare le istruzioni (le quintuple): ripeti quanto segue: 1) leggi s da nastro 2) dati s (nastro) e q (stato interno) cerca tra le quintuple quella che ha questa coppia s,q e ricava s1, q1, d1 [nota: s,q e’ l’indirizzo della quintupla] 3) sostituisci ad s il simbolo s1; 4) cambia stato interno (al posto di q metti q1) 5) sposta la testina secondo la direzione d1 per sempre questa lista di 5 istruzioni e’ la “procedura di imitazione” o l’ “algoritmo di imitazione” --->>

77 cont. “U”, una m.d.T. speciale ...
e’ possibile definire una m.d.T. ”U” che sia in grado di eseguire questo algoritmo di imitazione cioe’ di imitare il funzionamento di una m.d.T. generica “X” inoltre e’ possibile codificare sul nastro di questa m.d.T. ”U” * sia le quintuple di una (generica) m.d.T. “X” * sia la situazione su nastro esterno di “X” ovvero avere una situazione del tipo: (q = stato di “U” ) ..nas..M..tro.yqqssxqqssxqqssxqqssxqqssxy q

78 cont. “U”, una m.d.T. speciale ...
vediamo l a codifica di una m.d.T. generica X sul nastro della m.d.T. speciale U ; ad es.: ..nas..M..tro.yqqssxqqssxqqssxqqssxqqssxy q la porzione yqqssx rappresenta lo stato corrente della macchina X, ovvero qq rappresenta lo stato interno q (di X, rappresentato con qualche codifica, es. in binario), e ss rappresenta il simbolo letto s dal nastro (di X); la cella corrente (del nastro di X) e’marcata da un simbolo apposito M; il contenuto originale di questa cella (che ora e’ M) e’ salvato nella codifica ss nella porzione yqqssx del nastro di U;

79 cont. “U”, una m.d.T. speciale ...
cont. codifica di m.d.T. X sul nastro della m.d.T. U : ..nas..M..tro.yqqssxqqssxqqssxqqssxqqssxy q qq codifica uno stato di X - ad es. se X ha 4 stati, a,b,c,d, la codifica puo’ essere: (a,01; b,10; c,11; d,00) ss codifica un simbolo esterno di X; - ad es. se X ha 4 simboli esterni 0,1,*,x, posso avere la codifica: (0,00; 1,11; *,01; x,10) con sei stati posso definire ad es. la codifica: (a,000; b,001; c,010; d,011; e,100; f,101) ecc

80 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.

81 osservazione di seguito e’ riportata la versione grafica di una m.d.T. universale, si lascia come esercizio l’analisi di tale grafo: si noti che due parti del grafo sono state gia’ esaminate, e sono rispettivamente la parte “cerca indirizzo” (mdT(a) a pag. 15 della parte Turing.6) [locate name nel grafo seguente] e la parte “copia dato” (mdT(b) a pag 21 della parte Turing.6), [copy item nel grafo seguente] ... [vedi M.L. Minsky: "Computation: Finite and Infinite Machines", Prentice Hall 1967, (bibl. del DEEI o del Centro Calcolo , ) cap. 6,7,8.]

82 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

83 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.

84 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

85 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.

86 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! 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).

87 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, ... tesi di Church: 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 - anche se non e’ stato dimostrato che non esiste un formalismo piu’ potente

88 limite ... cosa si puo’ fare con una m.d.T?
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!

89 mdT -> f(i) // f(i) ->? mdT
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 esempio di problema non risolubile per via algoritmica.

90 problema dell’ arresto (halting problem)
dato un programma qualunque (data una m.d.T. qualunque) precisato un dato iniziale (una situazione su nastro) e’ possibile sapere - analizzando il programma / la mdT - 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?

91 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)? 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 7531 giorni magari si ferma dopo il 7532.mo giorno ... forse si puo’ avere la risposta solo ispezionando, analizzando la m.d.T. (chiamiamola mdT”X”) ed i relativi dati ?

92 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)? forse 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: non e’ possibile. segue dimostrazione

93 problema dell’ arresto (halting problem)
il problema dell’arresto non ha soluzione algoritmica, dimostrazione per assurdo: ipotizzo che esista la soluzione, e poi dimostro che cio’ porta ad una contraddizione. ipotizziamo esista una procedura E (magica) ovvero una mdT E (magica) tale che sappia rispondere alla domanda: dati macchina di Turing X e dato D, X e’applicabile a D? cioe’se faccio partire X su D il processo di calcolo sara’ finito? quindi abbiamo E tale che se codifico X e D sul nastro di E (abbiamo visto come si codificano X e D per il caso della mdT Universale) e faccio partire E ottengo la risposta si/no per la domanda se X e’ applicabile a D. (n.b.: applico E al nastro dati (di E) dove sono codificati X e D)

94 problema dell’ arresto (halting problem) (cont.dim.per assurdo)
ipotesi : esiste una mdT E tale che risponda alla domanda: X [mdT generica] e’ applicabile a D [dato generico per X]? E tale che se codifico X e D sul nastro di E (abbiamo visto come si codificano X e D per il caso della mdT Universale) e faccio partire E allora ottengo come risultato di E la risposta si/no per la domanda se X e’ applicabile a D (si noti che applico E al nastro dati (per E) dove sono codificati X e D) : (quintuple di E) (nastro) ...XXXX...DDDD...

95 problema dell’ arresto (halting problem) (cont.dim.per assurdo)
ipotesi : esiste una mdT E tale che se codifico X e D sul nastro di E e faccio partire E allora ottengo la risposta si/no per la domanda se X e’ applicabile a D (quintuple di E) (nastro di E)...XXXX...DDDD... ora, per non avere il fastidio dei doppi dati D,X sul nastro di E consideriamo il problema piu’ limitato: al posto di un generico dato D per la mdT X considero un solo dato particolare C, anzi, scelgo per dato D la rappresentazione stessa di X ... quindi il problema (piu’ limitato) e’: X aplicata a X si fermera’? (*)dal Minsky: applicare X a X ... si immagini la situazione di un tizio che contempla l’ immagine del proprio cervello...

96 problema dell’ arresto (halting problem)
ora la domanda e’: data una mdT X se faccio partire X sul dato particolare che e’ la codifica stessa di X su un nastro di una mdT, la X si fermera’? la situazione iniziale e’: quintuple di X e, sul nastro di X, la rappres. stessa di X: x82y (a,0,...) quintuple f (a,1,...) della (dati su nastro=codifica di X) (b,8,...) mdT. X se faccio partire X sui dati X(= rappresentazione di X) la X si fermera’? abbiamo sostituito al problema dell’applicabilita’ << X e’ applicabile a D ? >> un problema meno generale: << X e’ applicabile a X ? >> cioe’ X applicato a [descrizione di] X si ferma?:

97 problema dell’ arresto (halting problem)
quindi invece della E (magica) di prima, esiste una mdT E tale che sa rispondere alla domanda: X [mdT generica] e’ applicabile a D [dato generico per X]? (1) E (mdT) con ...XXX...DDD.... (nastro di E) ipotizzo l’esistenza di una mdT F (meno potente - ma sempre “magica” ) in grado di rispondere alla domanda: X [mdT generica] e’ applicabile a X ? [X dato particolare per X, cioe’ il dato X e’ la desrizione della stessa X] (2) F (mdT) con ...XXX...FFF.... (nastro di F) anzi, consideriamo la mdT G tale che basta fornirle la sola descrizione di X: (3) G (mdT) con ...XXX (nastro di G) sara’ poi la G stessa a copiare X per avere la situazione (2)

98 problema dell’ arresto (halting problem)
(cont) ipotesi : esiste G tale che (3) G (mdT) con ...XXX (nastro di G) a partire dal dato XXX e’ in grado di rispondere alla domanda (con XXX mdT generica): XXX e’ applicabile al dato XXX ? per ipot. (da dimostrare assurda) esiste G tale che o G si ferma nello stato s scrivendo “S” se XXX e’ applicabile a XXX (ovvero XXX si ferma), o G si ferma in stato n scrivendo “N” se XXX non e’ applicabile a XXX (ovvero XXX non si ferma)

99 problema dell’ arresto (halting problem)
E risponde a: X [mdT qque] e’ applicabile a D [dato qque] ? (1) E (mdT) con ...XXX...DDD.... (nastro di E) F risponde a: X [mdT generica] e’applicabile a X[un dato] ? (2) F (mdT) e XXX...FFF.... (nastro di F) G copia da X il dato X, poi risponde a: X e’ applicabile a X? (3) G (mdT) e XXX (nastro di G) ora modifichiamo la G un po’: sia K la mdT G modificata nel senso seguente: al posto dello stato finale s dove la G scrive “S” [ XXX e’ applicabile a XXX] introduciamo una coppia di stati s,t e due transizioni tra s e t in ciclo infinito : la K e’ una G ... un po’ rovinata, nel senso: dove G si fermava per scrivere S, la K va in ciclo infinito e non si ferma piu’...

100 problema dell’ arresto (halting problem)
quindi abbiamo una K tale che: se fornisco come dato una descrizione di una mdT generica X allora K fa: se X non e’ applicabile a se’ stessa [X non si ferma su X] allora K si ferma e scrive “N”, se invece X e’ applicabile a se’ stessa [X si ferma su X] allora K non si ferma... [nota: la K NON e’ applicabile alle X che si fermano...] cosa succede se applico K a se’ stessa? per ipotesi: se K applicata a se’ stessa si ferma [K sta ora per X di prima] allora K applicata a K non si ferma; se K applicata a se’ stessa NON si ferma [K sta per X di prima] allora K applicata a K si ferma ... siamo in contraddizione!!!

101 problema dell’ arresto (halting problem)
quindi abbiamo: se fornisco a K come dato la descrizione di una generica X allora K fa: se X non e’ applicabile a se’ stessa allora K si ferma e scrive “N”, se invece X e’ applicabile a se’ stessa [X si ferma su X] allora K non si ferma; cioe’ la K NON e’ applicabile alle X che si fermano. cosa succede se applico K a se’ stessa? per ipotesi: se K applicata a se’ stessa si ferma [K sta ora per X di prima] allora K applicata a K non si ferma; se K applicata a se’ stessa NON si ferma [K sta per X di prima] allora K applicata a K si ferma ... siamo in contraddizione !!!

102 problema dell’ arresto (halting problem)
partendo dall’ipotesi dell’esistenza della macchina magica G che risponde si o no al problema dell’arresto di una mdT generica X su un dato particolare (la descriz.della X stessa), siamo poi passati alla G modificata K (che non e’ applicabile alle XXX che si fermano), e siamo arrivati ad una contraddizione: quindi non puo’ esistere K e quindi non puo’ esistere G ... quindi il problema dell’arresto NON e’ risolubile per via algoritmica! ___________________ dal Minsky: “we have only the deepest sympathy for those readers who have not encountered this type of simple yet mind-boggling argument before”

103 problema dell’ arresto (halting problem)
ovvero: 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 ovvero: 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 tale che esso solo leggendo il testo di un generico programma X risponda: si’, questo programma funziona, oppure non, questo programma non funziona ...

104 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.

105 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 ben delimitati ...

106 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)

107 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

108 fine parte 7 e con questo concludiamo questo capitolo sugli
algoritmi e sulle macchine di Turing

109 fine parte 7