La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

1 MdT - parte seconda ancora alcune macchine di Turing per risolvere semplici problemi : 8) controllo parentesi ben formate (slide 14) 9) sposta un dato.

Presentazioni simili


Presentazione sul tema: "1 MdT - parte seconda ancora alcune macchine di Turing per risolvere semplici problemi : 8) controllo parentesi ben formate (slide 14) 9) sposta un dato."— Transcript della presentazione:

1 1 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) contenuto:

2 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 3 premessa - definizione di un insieme: un insieme di elementi si puo definire in modi diversi, * elencando tutti gli elementi dellinsieme (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 alluniv. 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 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 linsieme 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 5 un primo esempio di un insieme di stringhe: sia linsieme di caratteri di partenza formato dallunico carattere + allora P = { + } allora linsieme P stellato P * = { s | s stringa di caratteri di P } e linsieme 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 ) linsieme P * e infinito

6 6 un secondo esempio di un insieme di stringhe A = insieme di due caratteri, parentesi aperta e chiusa: A = { ( ) } allora linsieme 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 7 continua sugli insiemi di stringhe consideriamo ad es.: B = { 0 1 } allora linsieme 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 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| = 3... 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 proprietap che chiedo alle stringhe di X: linsieme 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. Nelles. 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 9 cont. stringhe e insiemi e stringhe ben formate... es.: B = { 0 1 } 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 } es.: 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 = { 1111 } e basta: linsieme W ha un solo elemento.

10 10 avevamo detto che... un insieme di elementi si puo definire in modi diversi, * elencando tutti gli elementi dellinsieme (se e finito...) es. insieme { 0, 1 } * fornendo una proprieta per gli elementi dellinsieme, es. insieme degli studenti di ingegneria iscritti al 1.o anno alluniv. 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 dellinsieme... sistema generativo... vediamo

11 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: nullaltro sta in PBF. _____________________ /*/ nota: la base ( ) e stringa di 2 caratteri, la parentesi aperta ( e la )

12 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: nullaltro 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 oppure: ( ) -> 2 ( ) ( ) -> 2 ( ) ( ) ( ) -> 1 ( ( ) ( ) ( ) ) ecc oppure:... ( ) -> 2 ( ) ( ) -> 2 ( ) ( ) ( ) ( ) -> 2 ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( )..

13 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 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 epreceduta 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 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) ( ) >> 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 16 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: 1 1 ) ) 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 3) cerco la prima ( che precede la ) appena cancellata: 4) sostituisco questa ( con un uno: ( ( 1 1 5) ripeto da istruzione 1, e non trovo piu ( ( 1 1 6) nessuna ), torno indietro per vedere se 7) vi sono ( rimaste: ci sono -> fine, non e ben formata

17 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 2) A ( ( ) ( ) ) A. 6) A ( 1 1 ( ) ) A.. a 3) A ( ( ) ( ) ) A. 7) A ( 1 1 ( ) ) A.. a 4) A ( ( 1 ( ) ) A. 8) A ( 1 1 ( 1 ) A.. b

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

19 19 8.) m.d.T.: controllo par.ben form. [elimina coppie ( ) ] a ( a ( + ;ricerca della prima ) a ) b 1 - ;trovata,cancella,cerca ( corrisp. b ( a 1 + ;ripeti... se trovi 1 ignora: a 1 a 1 + ; b 1 b 1 - ;... avremo la successione: b A h N 0 ; se non trovi ( allora non ok! a A c A - ; 1) A ( ( ) ( ) ) A... 17) A A.. a a 15) A ( A..... b 16) 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 erimasta qualche ( orfana

20 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 erimasta una ( c 1 c 1 - ; scorri verso sinistra... c A h S 0 ; se non hai trovato nessuna ( -> ok 1) A ( ( ) ( ) ) A. 22) A A.. a c 15) A A.. 26) A A.. a c 20) A A.. 27) A A.. a c 21) A A.. 28) S A.. c h ho esaminato il dato, la risposta e si.

21 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 ce- vai in stato c.. A ( A..a controllare se ce una ( c.. ce una ( e non c'e'piu' ).. A ( A.. se in c trovo una ( allora c.. la stringa non eok:

22 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 N A.. se in stato b trovo A->err h.. agg.quintupla b A h N 0

23 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 erimasta una ( ;stato b cerca ( corrispond. ad una ) giacancellata 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 puopresentare ;stato c controlla se ce una ( singola.. c ( h N 0 ;ce 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 puopresentare

24 24 versione grafica di questa MdT: ;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. + - bac - A ) 1 start stop No A N ( N ( 1 A S Stop Si nel grafico non sono segnate le transizioni a1 a1 +; b1 b1 -; c1 c1-

25 25 8.o esempio di m.d.T. osservazione finale: Lesempio visto pero distrugge i dati: esercizio: modificare lalgoritmo 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 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 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 dallaltra parte cioe produrre * h devo trovare una procedura per ottenere il risultato voluto..

28 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 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 1... 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 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 1... 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 31 MdT numero 9 : sposta (muovi) uni meglio: cercare lultimo 1 a destra: a * b * + ; scorri a destra e vai in b; stato b indica che b 1 b 1 + ; sono a destra del *; in stato b ignora 1 cerca 0 b 0 c 0 - ; vai oltre gli uni, allo zero torna a sinistra c 1 d 0 - ; 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 b * ) torno a sinistra su ultimo 1 c * ) cancello 1, e vado a sinistra d a riscrivere 1 dopo l' *

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

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

35 35 a * b * + ; scorri a destra - b indica che b 1 b 1 + ; sono a destra del *; ignora 1 b 0 c 0 - ; oltre gli uni - torna a sinistra c 1 d 0 - ; cancella 1; stato d=cancellato 1 d * d * - ; d aggiunge 1 a sinistra... d 1 d 1 - ; ignorando 1 d 0 a 1 + ; scrivo 1 e ripeto... a 1 a 1 + ; 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! MdT numero 9 : sposta (muovi) uni

36 36 a * b * + ; scorri a destra - b indica che b 1 b 1 + ; sono a destra del *; ignora 1 b 0 c 0 - ; oltre gli uni - torna a sinistra c 1 d 0 - ; cancella 1; stato d=cancellato 1 c * h * 0 ; non ce nessun 1 a destra->stop d * d * - ; d aggiunge 1 a sinistra... d 1 d 1 - ; ignorando 1 d 0 a 1 + ; scrivo 1 e ripeto... a 1 a 1 + ; 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' * trovo un *, non vi sono 1 da c cancellare, quindi mi fermo: * stop h MdT numero 9 : sposta (muovi) uni

37 37 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 1 + ; sono a destra del *; ignora 1 b 0 c 0 - ; oltre gli uni - torna a sinistra c 1 d 0 - ; cancella 1; stato d=cancellato 1 c * h * 0 ; non ce nessun 1 a destra->stop d * d * - ; d aggiunge 1 a sinistra... d 1 d 1 - ; ignorando 1 d 0 a 1 + ; scrivo 1 e ripeto... a 1 a 1 + ; se in stato a trovo 1 ignoro... MdT numero 9 : sposta (muovi) uni

38 38 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 + ; a b cd h * * 0 * * 0 MdT numero 9 : sposta (muovi) uni

39 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

40 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 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 42 10) MdT: test se a=b vediamo avanti... caso a0, a=0 quindi aggiungo quintupla che e * h < 0 ; "scrive" il risultato, ovvero "minore" a

43 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 * b * c * d * d * d * d * e * a

44 44 10) MdT : test se a=b, caso a>b dopo aver cancellato un 1 da b e e anche da a, avrola 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= * a * e * a * a * b * c * f > * h

45 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 0 ;ce1 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 * e..0 0 * a..0 0 * b..0 0 * c..0 0 * f..0 = * h

46 46 10) MdT : test se a=b, caso a 0 ;ce1 a sin.di *: allora a>0,b= * a cancella uno: dopo b-1, a-1 ho:..0 0 * a e ripeti * b..0 0 * b..0 0 * c..0 0 * d..0 0 * d..0 0 * e..0 0 < h

47 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 0 ;ce 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 48 esercizio 11) dato un numero n calcolare il valore 2*n

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

50 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 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 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 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 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 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 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 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 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 59 cosa si puo fare con una m.d.T. ?

60 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 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 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: indirizzo del valore 313 contenuto della cella di indirizzo 4 MEM[ 4 ] = 313 => il valore contenuto nella cella 4 e 313

63 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 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 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 ce allindirizzo III

66 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 listruzione 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 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 laltro, 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 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 k j tale che k j = i, (m.d.T. cerca stringa=), e ho ad es y x A A A B B B x A B A x x a 2) poi copia il dato (la stringa 1 0 1) al posto dellindirizzo 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 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 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 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 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 73 La macchina di Turing Universale - vers. grafica a b test c cerca 0 d cerca 1 e ok f nok start 0 A 1 B A 0 B 1 0 A 1 B y non trovato -halt y x y 1 B 0 A trovato X - + g jk hi l da m.d.T.(a) fine copia A A A (copia 0!) B B B (copa 1!) y y x A M M B B 1 A 0 + COPY item, replace name restore machine condition region S Replace s with s1, move position, repeat A B S 1 A 0 0 B1 + + S A S B M M M M B 1 A 0 to start (repeat) 23 stati, 5 simboli locate name (quintuple)

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

75 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 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 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 -> linsieme 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 78 le m.d.T sono meno potenti del C++? Si puo dimostrare che linsieme delle funzioni T calcolabili, coincide con linsieme 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 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 80 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 81 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 linsieme delle funzioni calcolabili da ciascuno di essi e lo stesso ( ma - non e stato dimostrato che non esiste un formalismo piu potente )

82 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 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 linsieme 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 84 per ogni mdT c'e' una f(i), ma per ogni f(i) c'e' mdT ? e' sufficiente osservare che linsieme 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 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 86 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... problema dell arresto (halting problem)

87 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 mdTX) 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 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 dellarresto non e risolubile per via algoritmica ovvero: non ce 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 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 dellarresto 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 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 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) allultimo (stato finale, con il risultato)

92 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 93 e con questo concludiamo questo capitolo sugli algoritmi e sulle macchine di Turing

94 94 fine


Scaricare ppt "1 MdT - parte seconda ancora alcune macchine di Turing per risolvere semplici problemi : 8) controllo parentesi ben formate (slide 14) 9) sposta un dato."

Presentazioni simili


Annunci Google