Link alle Slide Conferenza La Macchina di Turing - ITIS G. Marconi

ALAN TURING 1912 - 2012 

ESPRESSIVITÀ E COMPLESSITÀ DI UNA IDEA 

Roberto Giacobazzi 

Dipartimento di Informatica 

Università degli Studi di Verona 

Italy 

Mathesis: Verona - 10.03.2012 – p.1/56

Un po’ di storia 

Espressività e complessità 

Automi 

Automi a pila 

Macchine di Turing limitate 

Macchine di Turing ed il limite del calcolabile 

Protezione del codice 

DNA computers 

Quantum computers 

Cosa vedremo 


Breve storia: Le origini 

1900 Hilbert: 23rd: Find a method for deciding the truth or falsity of any 

statement of predicate calculus (decision procedure) 

Programma hilbertiano (1904): riduzione della matematica ad un mero 

calcolo di simboli privi di significato in un sistema di assiomi e regole 

(metamatematica) 

Riduzionismo laplaciano 

Certezza algebrica come manipolazione meccanica di simboli 

(algebristi inglesi: Woodhouse 1801, Boole 1854, Babbage 1834) 

Sviluppo industriale: macchine! 








1930/1 Gödel: Incompletezza e crisi del programma hilbertiano 

Indecidibilità: Proposizioni indecidibili nell’artimetica 

Critica di Poincarè e Weyl (1927) a Hilbert (1905): consistenza della 

metamatematica 

Intuizionismo Brower (1927) 










1936 Turing: Cosa significa "calcolare"? 

Macchina o modello? 

Macchina di Turing (1936) 

Lambda-calclo (1928-36) di Church e Curry 

Funzioni parziali ricorsive (1936) di Kleene 










1936 Turing: Cosa significa "calcolare"? 

Macchina o modello? 

1936 Tesi di Church-turing: Le funzioni intuitivamente calcolabili sono tutte e 

sole le funzioni Turing-calcolabili 

Informatica come scienza dell’informazione 

Indipendenza dalla macchina 

Profonda radice logico-matematica 


Evoluzione storica 

 

 



 

 

 



 

 

 



 

 

 


e prima? 


a) Un algoritmo è di lunghezza finita. 

Il concetto di algoritmo 

b) Esiste un agente di calcolo che porta avanti il calcolo eseguendo le 

istruzioni dell’algoritmo. 

c) L’agente di calcolo ha a disposizione una memoria dove vengono 

immagazzinati i risultati intermedi del calcolo. 

d) Il calcolo avviene per passi discreti. 

e) Il calcolo non è probabilistico. 

f) Non deve esserci alcun limite finito alla lunghezza dei dati di ingresso. 

g) Non deve esserci alcun limite alla quantità di memoria disponibile. 

h) Deve esserci un limite finito alla complessità delle istruzioni eseguibili dal 

dispositivo. 

i) Sono ammesse esecuzioni con un numero di passi illimitato. 


Evitare il paradosso diagonale! 

 

 

La Teoria descrive tutti gli Algoritmi 

Per (a+h): |Algoritmi| = N 

Per (f): Algoritmi : N −→ N 

φ 

Con quale scopo? 

 

A0(x),A1(x),A2(x),A3(x),.... sono una enumerazione degli Algoritmi 

Sia h(x) = Ax(x)+1 ....h ∈ Algoritmi? 


Gödel disse: 

Tarski has stressed in his lecture (and I think justly) 

the great importance of the concept of general 

recursiveness (or Turing’s computability). It seems to 

me that this importance is largely due to the fact that 

with this concept one has for the first time succeeded 

in giving an absolute definition of an interesting 

epistemological notion, i.e. one not depending on the 

formalism chosen. [ . . . ] By a kind of miracle it is not 

necessary to distinguish orders and the diagonal 

procedure does not lead outside the defined notion. 

[K. Gödel, Princeton 1946] 


Informazione e Informatica 


Macchina o modello di calcolo 

Codifica dati in un alfabeto Σ 

Codifica descrizione istantanea 

Codifica programma 

? 






Dispositivo 

Risorse (memoria e tempo) 

Descrizione di transizione di stato 

(tipo di calcolo) 






Collezione di insiemi e relazioni 

Sequenze di simboli 

Funzione di transizione di stato 






Informatica come scienza di modelli 


Sia M una data macchina (o modello di calcolo) 

Sia Σ un alfabeto di simboli 

Una misura della espressività 

Sia σ ∈ Σ ∗ una sequenza finita arbitrariamente lunga di simboli (parola) 

M |= σ se la macchina M termina accettando σ 

Il linguaggio di M: L(M) def 

= 

 

σ ∈ Σ ∗ M |= σ 

L(M) è un insieme di parole (linguaggio) 

M1 è più potente di M2 se L(M2) ⊆ L(M1) 

 


Espressività e Complessità 

Complessità: Quanto è difficile risolvere un problema che sappiamo essere 

risolvibile? 

Espressività Si può risolvere un dato problema con un certo strumento 

(macchina o modello)? 

Difficoltà = consumo risorse (Es: tempo/spazio) 

Cosa è una classe? 

Complessità = Espressività con risorse limitate 

Come limitiamo le risorse? 

Se M è un famiglia di macchine: 

C(M) def 

 

= L ⊆ Σ ∗ ∃M ∈ M : L = L(M) 

Come si struttura la espressività al variare delle macchine? 

Quali proprietà di chiusura caratterizzano le classi? 

 


La gerarchia di Chomsky 

 

 

 

 

 


...mediante procedimenti intuitivamente “calcolabili”!! 

La gerarchia di Chomsky 

 

 

 

 

 


Completezza e classi 

 

La funzione di riduzione −→ ha complessità A 

Se B−completi ⊆ A ⇒ A = B 


Percorrendo la gerarchia: Automi 

 

Legge dal nastro 1 simbolo alla volta 

Esegue transizioni di stato discrete 

 

 

Gli stati sono finiti: n ∈ N fissati a priori! (es. processore) 

Non ha memoria! 


Distinguere numeri pari e numeri dispari 

11111111111111111111111111111111 

 

 

 

 

Un esempio 


Non riesce a contare: a n b n per n ∈ N 

 

 

 

 

a1 a2 a3 ... b1 b2 b3 ... c1 c2 c3 ... accettato! 

a1 a2 a3 ... b1 b2 b3 ... b1 b2 b3 ... c1 c2 c3 ... accettato! 

a1 a2 a3 ... b1 b2 b3 ... b1 b2 b3 ... b1 b2 b3 ... c1 c2 c3 ... accettato! 

.... 

 

Limiti 


Idea 

Aumentiamo la potenza: 

Parallelismo vs non-determinismo 

Permettiamo alla macchina di attivare processi indipendenti e paralleli 

Transizione : Stati −→ 2 Stati 

Ad ogni passo i processi attivati sono finiti < ∞ 

Senza limiti di tempo: Sequenziale = Non−deterministico 

C(ASFD) = C(ASFND) 

Non si aumenta la espressività degli automi amuentandone il grado di 

parallelismo!! 


Il modello non-deterministico 

 


Il modello non-deterministico 

 

 

 

 


Percorrendo la gerarchia: Automi a Pila 

 

Legge dal nastro 1 simbolo alla volta 

 

Esegue transizioni di stato discrete (Automa) 

Gli stati sono finiti: n ∈ N fissati a priori! (Automa) 

Può memorizzare i simboli su una pila (LIFO) 

 

 

Ha una memoria ma limitata nelle azioni (LIFO)! 

 


q0 ε a b c 

Z q0,ZA q0,ZB q1,ε 

A 

B 

Un esempio 

q1 ε a b c 

Z q1,Z q1,Z 

A q1,ε q1,Z q1,Z 

B q1,Z q1,ε q1,Z 

L’automa conta: riconosce le sequenze palindrome: abbcbba!!! 

Risolve il problema a n b n ... 


a bcba 

↓ nastro 

q0 

↕ pila 

Z 

abc b a 

↓ nastro 

q1 

↕ pila 

B A 

⇒ 

⇒ 

a b cba 

↓ nastro 

q0 

↕ pila 

Z A 

abcb a 

↓ nastro 

q1 

↕ pila 

A 

⇒ 

⇒ 

ab c ba 

abcba 

↓ nastro 

q0 

↕ pila 

Z BA 

↓ nastro 

q1 

↕ pila 


Non riesce a confrontare 3 numeri: a n b n c n 

Non-detreminismo è più espressivo del determinismo: 

APND: ww r , esempio: abbabbabba 

APD: wcw r , esempio: abbabcbabba 

C(APD) ⊂ C(APND) 

Gli APD sono i parsers dei moderni compilatori (Grammatice Libere da 

Contesto). 

Limiti 


Percorrendo la gerarchia: MdT limitata in Spazio 

Idea: Memoria libera ma limitata in spazio da f(input) 

 

Legge e scrive sul nastro 1 simbolo alla volta 



 

 


Limiti e proprietà nello spazio 

Nuove classi in spazio: 

Space[f(n)] problemi (linguaggi) risolvibili con f(n) memoria (celle) 

Lo spazio non dipende dal numero di nastri! 

Tape compression: Space[f(n)] = Space[c·f(n)] con c > 0 

Aumentando la codifica dell’alfabeto e degli stati! 

Se f(n) ≤ g(n) allora Space[f(n)] ⊆ Space[g(n)] 

Cosa succede se confrontiamo determinismo SpaceD con 

non-determinismo SpaceN? 


Classi e proprietà nello spazio 

EXPSpace = 

c>0 SpaceD[2 c·n ] 

PSpace = 

c>0 SpaceD[n c ] 

NPSpace = 

c>0 SpaceN[n c ] 

LSpace = SpaceD[logn] 

NLSpace = SpaceN[logn] 

LSpace ⊆ NLSpace ⊆ PSpace ⊆ NPSpace ⊆ EXPSpace 

Nello spazio determinismo equivale a non-determinismo (...quasi sempre) 

PSpace = NPSpace 

LSpace ? = NLSpace 


Percorrendo la gerarchia: MdT limitata in Tempo 

Idea: Memoria libera ma limitata in tempo da f(input) 

 



 

 


Esegue per al più f(input) passi 

1994 Deneba Systems, Inc. 


Limiti e proprietà nel tempo 

Nuove classi in tempo: 

Time[f(n)] problemi (linguaggi) risolvibili in f(n) passi 

Es: moltiplicazione è in Time[n 2 ], sorting in Time[n logn] 

Speed-up: Time[f(n)] = Time[c·f(n)] con c > 0. 

Il tempo dipende in minima misura dal numero di nastri 

Multitape M, monotape N: TimeN ≤ c·(TimeM) 2 

Cosa succede se confrontiamo determinismo TimeD con 

non-determinismo TimeN? 


Classi e proprietà nel tempo 

PTime = 

c>0 TimeD[n c ] 

NPTime = 

c>0 TimeN[n c ] 

EXPTime = 

c>0 TimeD[2 n·c ] 

NEXP = 

c>0 TimeN[2 n·c ] 

Nel tempo determinismo e non-determinismo correlati? 

PTime ⊆ NPTime ⊆ PSpace 

PTime ? = NPTime 

PTime ⊂ EXPTime 

Church-Turing Thesis: a function computable in 

polynomial time in any reasonable computational 

model using a reasonable time complexity measure is 

computable by a deterministic Turing Machine in 

polynomial time. 


Percorrendo la gerarchia: MdT 

Idea: Nessun limite di tempo/spazio alla gestione della memoria 




Ha tempo e spazio ∞ 

Ammettimo non-determinismo 

Chiaramente (tesi di Church): 

C(MdTD) = C(MdTND) 


MdT: Il modello 


Limiti e Proprietà assolute 

Il problema della terminazione 

Ogni programma P ha una sua codifica nei dati: 〈P〉 ∈ Dati 

La macchina è universale (interprete): 

 

P(x) se P(x) termina 

Int(P,x) = 

↑ altrimenti 

La macchina può divergere!! 

 

 

(P,x) P(x) converge 

 

non è decidibile 

Se lo fosse, allora sia D(P,x) il programma che decide se P(x)↓ 

 

↑ se D(P,〈P〉) = Y 

Costruiamo H(P) = 

1 se D(P,〈P〉) = N 

H(〈H〉)↓ sse D(H,〈H〉) = N sse H(〈H〉)↑ 

Assurdo! 


E senza limiti? 

Nessun limite di tempo e spazio ....il problema è quello di Turing del 

1936!! 

Possiamo solo dire se un problema è calcolabile! 

Turing argument: 

ammette una soluzione algoritmica 

tutto ruota intorno alla Macchina di Turing Universale! 

Assumiamo termination(P) termina e dice true iff P 

termina su tutti gli inputs 

E che ne è di: 

P ≡ while termination(P){ null } ? 


La gerarchia rivista 

 

 

 

 

 


Le Storie di Erodoto... 

Nascondere informazioni 

Watermarks introdotti per la prima volta a Bologna, nel 1282! 

Il termine "digital watermark" fu introdotto nel 1992 da Tirkel e Osborne, 

nel paper: A.Z.Tirkel, G.A. Rankin, R.M. Van Schyndel, W.J. Ho, N.R.A. 

Mee, C.F. Osborne. “Electronic Water Mark”. DICTA 93, Macquarie 

University. p. 666-673 

Nel SW: F. Cohen. Operating system protection through program 

evolution. Computer & Security 12(6):56-584, 1993. 


Offuscamento: l’idea 


Offuscamento: l’idea 


Oggetti da nascondere? 

data objects 

source code 

control mechanisms 

module organization 

function names 

values (crypto keys, license etc). 

Dove sono gestite queste entità? 

Il significato di “essere a fuoco” 

.... nella Semantica!!! 

La semantica concreta di un programma formalizza (è un modello 

matematico) le possibili esecuzioni del programma in ogni possibile 

ambiente di utilizzo! 


La semantica 


Oscurità come imprecisione 

Offuscare un programma significa rendere un interprete impreciso 

ρ è una approssimazione di Σ (dati, stati, tracce di stati etc) 

Una trasformazione τ : P → P tale che [[P]] = [[τ(P)]] (stessa funzione) 

ρ([[τ(P)]]) ❁ [[τ(P)]] ρ imprecisione! 




P : x = a∗b 

Sign è approssimazione di ℘(Z): 

... ... 

0− 

℘(Z) 

0+ 

... 

{−1,−3,−4} {2,3,5} 

... 0 1 ... 

∅ 

0− 

℘(Z) 

∅ 

0 

0+ 




P : x = a∗b 

Sign è approssimazione di ℘(Z): 

... ... 

0− 

℘(Z) 

0+ 

... 

{−1,−3,−4} {2,3,5} 

... 0 1 ... 

∅ 

0− 

℘(Z) 

∅ 

0 

0+ 




x = 0; 

P : x = a∗b −→ τ(P) : if b ≤ 0 then {a =−a; b =−b}; 

while b = 0 {x = a+x; b = b−1} 

Sign è preciso per P: 

[[P]] Sign = λa, b. Sign(a∗b) 

Sign è impreciso per τ(P): 

[[τ(P)]] Sign 

= λa, b. 

0 if a = 0∨b = 0 

℘(Z) otherwise 

C’e’ un modo per ottenere τ(P) da P? 


Programmi che manipolano programmi? 

Y. Futamura, Partial Evaluation of Computation Process, 1971 

Considerate due linguaggi (abstract machines): S e T con dati comuni 

Interprete: ∀ℓ ∈ {S,T } 

int S : S.prog×data −→ data∪{↑} such that int S ∈ S.prog 

int T : T .prog×data −→ data∪{↑} such that int T ∈ S.prog 

∀P ∈ ℓ.prog, ∀d ∈ data : [P] ℓ (d) = [int ℓ ] S (P,d) 

Specializzazione: ∀ℓ ∈ {S,T } 

Idea: 

spec S : S.prog×data −→ S.prog such that spec S ∈ S.prog 

spec T : S.prog×data −→ T .prog such that spec T ∈ S.prog 

∀P ∈ S.prog, ∀d,s ∈ data : [P] S (s,d) = [[spec ℓ ] S (P,s)] ℓ (d) 

S source language (open) 

T secrete architecture (secret) 


Offuscamento per interpretazione? 

Y. Futamura, Partial Evaluation of Computation Process, 1971 

Offuscare P è compilare da S a T e quindi di nuovo in S: 

[P] S (d) = [int S ] S (P,d) 

= [[spec T ] S (int S ,P)] T (d) 

= [int T ] S ([spec T ] S (int S ,P),d) 

= [[spec S ] S (int T , [spec T ] S (int S ,P))] S (d) 

obf(P) = [spec S ] S (int T , [spec T ] S (int S ,P)) ∈ S.prog 

Per attaccare obf(P) devi capire la relazione tra S e T 


[Cloackware 2000] 

Code Flattening 

Idea: “riordina” o “dissimula” il control flow di P, senza cambiarne la semantica 


Struttura di un self-interpreter: Turing!!! 

input P,d; Program to be interpreted, and its data 

pc := 2; Initialise program counter and store 

store := [in ↦→ d,out ↦→ 0,x1 ↦→ 0,...]; 

while pc < length(P) do 

instruction := lookup(P,pc); Find the pc-th instruction 

case instruction of Dispatch on syntax 

skip : pc := pc+1; 

x := e : store := store[x ↦→ eval(e,store)]; pc := pc+1; 

... endw ; 

output store[out]; 

eval(e,store) = case e of Function to evaluate expressions 

constant : e 

variable : store(e) 

e1+e2 : eval(e1,store)+eval(e2,store) 

e1−e2 : eval(e1,store)−eval(e2,store) 

e1∗e2 : eval(e1,store)∗eval(e2,store) ... 


Il seguente programma “appiattito” P ′ ha 

solo 1 loop e 

un explicit program counter pc 

Original program P: Flattened program P ′ : 

1. input x; 

2. y := 2; 

3. while x > 0 do 

4. y := y+2; 

5. x := x−1 

endw 

6. output y; 

7. end 

1. input x; 2. pc := 2; 

3. while pc < 6 do 

Esempio 

4. case pc of 

2 : 5. y := 2; 6. pc := 3; 

3 : 7. if x > 0 then 8. pc := 4 else 9. pc := 6; 

4 : 10. y := y+2; 11. pc := 5; 

5 : 12. x := x−1; 13. pc := 3; 

endw 

14. output y 

15. end 


ALAN TURING NEL FUTURO 


Idea: parallelismo massivo e alta densità di informazione 

DNA: Deoxyribonucleic Acid 

Operazioni: annealing, melting, ligation, 

polymerase extension, polymerase chain reaction 

(PCR) 

Annealing: formazione di sequenze bilineari 

“opposte” 

Melting = Annealing −1 

Ligation: concatenazione 

PCR: amplificazione 

Adelman 1994: DNA Computer!!! 

DNA Computing 


DNA Computing: La tecnologia 

Supercomputers DNA-computers 

Velocità: 10 12 FLOPS 10 20 ?OPS 

Energia: 1 joule ≈ 10 9 OPS 1 joule ≈ 2.19 19 ?OPS 

Memoria: 1 bit ≈ 10 12 nm 3 

1 bit ≈ 1nm 3 


DNA Computing: TSP 

Problema: determinare un ciclo hamiltoniano (TSP) in un grafo 

TSP ∈ NPTime 

 

 

 

 

 

 



Problema: determinare un ciclo hamiltoniano (TSP) in un grafo 

TSP ∈ NPTime 

 

 

 

 

 

 



Idea: Codificare il grafo su DNA mediante basi complementari e calcolare 

mediante merge & anneal 

c(Bologna) = AAAGGG c(Livorno) = CGGTGC 

c(Torino) = CCGATG c(Roma) = TTAAGG 

c(Padova) = CGTCCA c(Napoli) = GATACT 

c(Roma → NA) = AGGGAT c(NA → Roma) = ACTTTA 

etc... 

 

Scarico la complessità in tempo sullo spazio!! 


Quantum Computing 

Idea: Sovrapposizione coerente (di un numero esponenziale) di stati induce 

parallelismo: esplorazione simultanea di tutte le soluzioni 

Spazio degli stati = Spazio di Hilbert 

Spazio vettoriale di dimensione finita sui complessi C n 

Un qbit è C 2 

Oltre a 2 stati |0> def 

= 

 

1 

0 

 

e |1> def 

= 

dalle sovrapposizioni lineari |ψ> def 

= λ1 

λ1,λ2 ∈ C 

Quantum-computers 

Sono un modello più che una tecnologia!! 

 

 

0 

1 

1 

0 

 

 

ci sono infiniti stati dati 

+λ2 

 

0 

1 

 

con 


Quantum Computing: parallelismo 

Idea: un qbit rappresenta i punti di una sfera (di Bloch). 

MdT quantistica 

Processore a stati finiti (n. finito di qbits) 

Nastro: numero infinito di qbits 


Quantum Computing: PTime ⊂ QPTime 

Idea: La macchina può essere contemporaneamente in piú stati: parallelismo 

quantistico 

Algoritmo Deutsch-Jozsa 

Determinare se una funzione su n-bits f : {0,1} n → {0,1} è costante o 

bilanciata 

Classico: richiede 2 n +1 tests 

Quantistico: sovrapposizione di n+1 qbit: se bilanciata, i contributi 

positivi e negativi delle ampiezze di elidono! ...è in QPTime 

Tesi di Church-Turing rivisitata? 

Ogni sistema fisico finitamente realizzabile può essere simulato da 

un modello di macchina computazionale universale che opera con 

mezzi finiti 

Shor 1994 ha dimostrato che Prime ∈ QPTime!! 

Problema principale: QPTime ? = NPTime? 


PTime ? = NPTime ....il problema aperto! 

DNA-computers 

Sono una tecnologia più che un modello 

Smart drugs! (Shapiro 2004) 

Giustificazioni computazionali ai processi naturali (UNIVR!!) 

Quantum-computers 

Sono un modello più che una tecnologia 

Sono più poteneti e “realizzabili” di modelli randomizzati 

Sono stati costruiti poco più di 10 qbits (1999-2010) 

È in fase di studio 1 registro da 100 qbit!! 

Fondamentale per RSA (Prime ∈ QPTime!!) 

E domani? 

Correzione errori: errori di 10 −4 per operazione sono tollerabili 


Grazie!

Link alle Slide Conferenza La Macchina di Turing - ITIS G. Marconi

Create successful ePaper yourself

Delete template?

Save as template?