Interpretazione astratta By Giulia Costantini (819048) e Giuseppe Maggiore (819050) Contents Interpretazione astratta... 2 Idea generale... 2 Esempio di semantica... 2 Semantica concreta... 2 Semantica astratta... 3 Correttezza... 3 Concretizzazione... 3 Estensione dell esempio di semantica (aggiungiamo TOP)... 3 Esempi... 4 Altra estensione dell esempio di semantica (aggiungiamo BOTTOM)... 5 Dominio astratto... 5 La funzione di astrazione... 5 Definizione generale di interpretazione astratta... 6 Operazioni astratte... 6 Astrazioni come chiusure... 6 Astrazione e concretizzazione... 7 Correttezza... 7 Prova di correttezza... 8 Definzione alternativa... 8 Estensione al nostro tiny language: input... 9 Teorema: la correttezza locale e sufficiente... 9 Estensione al nostro tiny language: comando condizionale... 10 Correttezza del comando condizionale... 10 Estensione al nostro tiny language: ricorsione... 11 Semantica delle funzioni ricorsive... 11 Semantica astratta... 12
Correttezza... 12 Esempio... 13 Riassunto e conclusioni... 13 Astrazione = selezionare una (delle varie) proprieta Interpretazione astratta Una tecnica utilizzata da quasi 30 anni per trattare in modo sistematico astrazioni e approssimazioni Nata per descrivere analisi statiche di programmi imperativi e provarne la correttezza Sviluppata soprattutto su linguaggi dichiarativi (logici e funzionali) Vista oggi come tecnica generale per ragionare su semantiche a diversi livelli di astrazione Applicata con successo a sistemi distribuiti per verifica di programmi (correttezza-sicurezza) Idea generale Il punto di partenza e la semantica concreta o Una funzione che assegna significati ai comandi di un programma in un dominio fissato di comunicazione Si determina un dominio astratto che modella alcune proprieta delle computazioni concrete tralasciando la rimanente informazione Si deriva una semantica astratta che permetta di eseguire il programma sul dominio astratto per calcolare la proprieta che il dominio astratto modella Applicando un algoritmo di punto fisso sara quindi possibile calcolare staticamente una approssimazione corretta della semantica concreta Esempio di semantica Consideriamo un linguaggio molto limitato che permette di operare su moltiplicazioni di interi o e = i e e Semantica concreta La semantica concreta di questo linguaggio si puo descrivere mediante una funzione μ definita come: o μ exp int μ i = i o μ e 1 e 2 = μ e 1 μ e 2
Semantica astratta Possiamo considerare una astrazione della semantica concreta (semantica astratta) che calcola solo il segno delle espressioni o σ exp +,,0 + if i > 0 o σ i = 0 if i = 0 if i < 0 + 0 + + 0 0 0 0 0 0 + o σ e 1 e 2 = σ e 1 σ(e 2 ) o dove e l operazione astratta che calcola il segno del prodotto Correttezza Possiamo dimostrare che questa astrazione e corretta, ovvero che predice correttamente il segno delle operazioni La dimostrazione e per induzione strutturale sull espressione e e utilizza le proprieta della moltiplicazione tra interi (il prodotto di due positivi e positivo, etc.). μ e > 0 σ e = + μ e = 0 σ e = 0 μ e < 0 σ e = semantica concreta semantica astratta Concretizzazione Possiamo associare ad ogni valore astratto l insieme dei valori che esso rappresenta: γ +,0 p(z) γ + = i i > 0 γ 0 = 0 γ = i i < 0 La funzione di concretizzazione γ mappa un valore astratto in un insieme di valori concreti Indichiamo con D il dominio concreto e A il dominio astratto Data una espressione e, il suo valore calcolato rispetto alla semantica concreta μ, deve appartenere all insieme dei valori nella concretizzazione γ della semantica astratta σ: μ e γ σ e e la semantica e' corretta Cio significa che il valore concreto deve essere approssimato dal valore astratto Estensione dell esempio di semantica (aggiungiamo TOP) Aggiungiamo l operatore unario di cambiamento di segno e l operatore di somma:
μ e = μ e σ e = σ e dove l operatore di cambiamento di segno nel dominio astratto e cosi definito: + 0 0 + Aggiungere l addizione e piu complesso in quanto il domino astratto non e chiuso rispetto a questa operazione μ e 1 + e 2 = μ e 1 + μ(e 2 ) σ e 1 + e 2 = σ e 1 + σ(e 2 ) Per poter definire l operatore di somma nel dominio astratto (+), dobbiamo estendere il dominio astratto con un nuovo valore tale che γ = {i i Z} + + 0 + + + 0 + 0 Avendo aggiunto un elemento al dominio astratto, e necessario ridefinire le operazioni astratte viste precedentemente: + 0 + + 0 0 0 0 0 0 0 + 0 + 0 0 + Esempi μ 1 + 2 + 3 = 0 σ 1 + 2 + 3 = + + + + + + =
μ 5 5 + 6 = 31 σ 5 5 + 6 = + + + + = + + Altra estensione dell esempio di semantica (aggiungiamo BOTTOM) Se volessimo aggiungere la divisione intera con resto, incontreremmo problemi nel caso di divisione per 0 Se dividiamo gli interi di un qualche insieme non vuoto per 0 otteniamo l insieme vuoto, rappresentato con γ = + 0 + + 0 0 0 + 0 Dovremmo anche estendere le altre operazioni (di nuovo) ma lo facciamo piu semplicemente elencando le aggiunte alle tabelle: o o o + x = x = = Dominio astratto Il dominio astratto e un reticolo completo L ordine parziale e coerente con la funzione di concretizzazione x y γ x γ(y) Piu siamo in giu nel reticolo, maggiore e la precisione Ogni sottoinsieme ha un lub e un glb (reticolo completo!) La funzione di astrazione Alla funzione di concretizzazione γ corrisponde una funzione di astrazione α La funzione α mappa insiemi di valori concreti nel piu piccolo valore astratto che li rappresenta tutti Rispetto al nostro tiny language: o α p Z A
o α 17,22,3,0 = ( +,0 ) = o α S = i S, i < 0 se ci sono negativi, + i S, i > 0 + se ci sono positivi, 0 i S, i = 0 0 se c'e' lo 0 Definizione generale di interpretazione astratta Una interpretazione astratta consiste in: 1. Un dominio astratto A e un dominio concreto D 2. I domini A, D devono essere reticoli completi, tali che l ordine riflette la precisione (piu piccolo = piu preciso) 3. Funzioni di concretizzazione γ e di astrazione α monotone, che formino una inserzione di Galois a. Es: se ho due valori astratti, il piu grande deve approssimare piu valori 4. Una funzione che astrae correttamente la semantica (definire una versione astratta di tutte le operazioni sul dominio concreto) Inserzione di Galois elemento concreto x p D a A elemento astratto la migliore approssimazione di x contiene x. x γ α x. a = α γ a non posso approssimare meglio di cosi Operazioni astratte Ipotizziamo di avere una funzione f: p(d) p(d) e di volere costruire la corrispondente funzione f # nel dominio astratto, f # A A. Vogliamo che f # sia il modo ottimale per rappresentare f nel dominio astratto, ossia f # = α f γ Se dimostriamo che la relazione e rispettata, o al piu f # sovra-astrae, allora possiamo non andare mai nei valori concreti (computazionalmente pesante) pur avendo le operazioni astratte desiderate. Astrazioni come chiusure Il dominio astratto puo essere ottenuto dividendo il dominio concreto in sottoinsiemi non disgiunti a i La funzione di astrazione cerca di mappare un sottoinsieme arbitrario del dominio nel piu piccolo a i che lo contiene.
Astrazione e concretizzazione Per la correttezza del nostro sistema di astrazione e concretizzazione deve essere vero il diagramma qui a destra Le due equazioni seguenti sono equivalenti valore concreto di una espressione: 3+2 2=7 μ e σ e analisi astratta di e (>0,<0,=0) insieme dei valori che l ' espressione ha secondo l ' analisi astratta σ (ad es: ' e positivo ) γ σ e α μ e astrazione ideale nel reticolo del dominio astratto del valore concreto della espressione e Correttezza Per la correttezza dell analisi sono sufficienti le seguenti condizioni o α, γ formano un inserzione di Galois (sia id = identita'): id = α γ ossia se concretizzo un valore astratto e poi lo astraggo nuovamente ottengo il valore astratto di partenza: α γ + α i i > 0 + id γ α ossia se astraggo un valore concreto e poi concretizzo questo valore astratto, ottengo tutti i valori originali, ma poiche α e una approssimazione, potrebbero comparire nuovi elementi spuri : γ α 1,2 γ + {1,2,3, } o α, γ sono monotone: c 1 c 2 α c 1 α c 2 ; a 1 a 2 γ a 1 γ a 2 o le operazioni astratte op sono corrette localmente op γ s 1,, γ(s n ) γ op s 1,, s n ossia se eseguo una operazione astratta sui valori astratti s 1,, s n allora la concretizzazione di questa operazione mi da un sovrainsieme degli elementi che avrei ottenuto eseguendo l operazione concreta su tutte le concretizzazioni dei valori astratti di partenza la condizione di correttezza locale garantisce che op sia un approssimazione corretta di op per ogni operazione concreta c e sempre una operazione astratta corretta, ossia quella che restitusce sempre l elemento massimo del dominio astratto
A op A γ α p D op p D Prova di correttezza Proviamo per induzione sulla struttura di e che μ e γ σ e μ i = i def.di μ i o Caso base: γ α i inserzione di Galois = γ σ i def.di σ perche' σ i = α i o Passo induttivo: μ e 1 op e 2 = μ e 1 op μ(e 2 ) def.di μ γ σ e 1 op γ σ e 2 per ip.induttiva γ σ e 1 op σ e 2 correttezza locale = γ σ e 1 op e 2 def.di σ Definzione alternativa Possiamo anche definire la correttezza usando l astrazione al posto della concretizzazione: μ e γ σ e α μ e σ e Ossia che le due affermazioni sono equivalenti: o μ e γ σ e che la concretizzazione dell interpretazione astratta e un sovrainsieme dell interpretazione concreta o α μ e σ e che le operazioni astratte σ sono una approssimazione per eccesso dell astrazione vera e propria del risultato concreto μ e γ σ e ipotesi μ e γ σ e α μ e α γ σ e monotonia α μ e σ e α γ = id α μ e σ e ipotesi γ α μ e γ σ e monotonia μ e γ σ e id γ α μ e γ σ e
Estensione al nostro tiny language: input Aggiungiamo input tramite la presenza di variabili libere nelle espressioni: e = i e e e x La firma della funzione semantica diventa μ: Exp Int Int (le espressioni hanno una sola variabile!) Un modo per scrivere questa funzione e pensarla come un insieme di funzioni Int Int indicizzate con espressioni μ i j = i μ x j = j μ e1 e 2 j = μ e1 j μ e2 j = La semantica astratta e data dalla funzione σ: Exp A A, in quanto alla variabile passiamo un valore astratto (es: σ x+3 ( )) Come per la semantica concreta possiamo indicizzare σ σ i j = i σ x j = j σ e1 e 2 j = σ e1 j σ e2 j = dove i = α i Dobbiamo generalizzare le condizioni di correttezza Le seguenti condizioni sono equivalenti: i. μ e i γ σ e α i μ e D γ σ e α α μ e A σ e α La correttezza locale la possiamo anche esprimere mediante la seguente regola: op γ σ e1 j,, γ σ en j γ op σ e1 j,, σ en j Teorema: la correttezza locale e sufficiente μ e j γ σ e j Per induzione sull espressione Casi base: μ i j = i o γ i = γ σ i j
μ x j = j o γ j = γ σ x j Passo induttivo: μ op e1,,e n j = op μ e1 j,, μ en j definizione di μ op γ σ e1 j,, γ σ en j ip.induttiva γ op σ e1 j,, σ en j correttezza locale = γ σ op e1,,e n j definizione di σ Estensione al nostro tiny language: comando condizionale e = if e = e ten e else e Semantica concreta μ if e1 =e 2 ten e 3 else e 4 i = μ e 3 i μ e4 i if μ e1 i = μ e2 i if μ e1 i μ e2 i Semantica astratta σ if e1 =e 2 ten e 3 else e 4 i = σ e3 i σ e4 (i) Si puo fare di meglio se abbiamo informazioni che ci permettono di verificare l uguaglianza tra e 1 ed e 2, ma cio e raro e in generale ci aspettiamo di percorrere contemporaneamente i due rami dell if perdendo inevitabilmente precisione Il motivo per cui imponiamo che il dominio sia un reticolo e perche cosi abbiamo la garanzia dell esistenza del lub ( ) σ if x=3 ten 7 else 8 + = σ 7 + σ 8 + = + Correttezza del comando condizionale Assumiamo che sia vera la condizione dell if, ovvero che si entri nel primo ramo (l altro caso e lasciato come esercizio per il docente...si dimostra analogamente) μ e3 i γ σ e3 i ip.induttiva γ σ e3 i γ σ e4 i γ σ e3 i σ e4 i monotonia di γ e = γ σ if e1 =e 2 ten e 3 else e 4 i per def. della sem.abstr.dell'if
Estensione al nostro tiny language: ricorsione Aggiungiamo funzioni ricorsive (in una sola variabile per semplicita ) che possono essere o Dichiarate o Chiamate program = def f x = e e = f(e) Semantica delle funzioni ricorsive La funzione semantica che abbiamo considerato finora e del tipo μ: Exp Int Int se c'e' divisione per 0 La generalizziamo per tenere conto delle chiamate di funzione μ : Exp e Int Int g Int j Int μ f e g j = g μ e g j μ x g j = j g j = μ e1 g j + μ e2 g j μ e1 +e 2 o Esempio in cui g: x x + 2 μ f x+1 g 4 = g μ x+1 g 4 = g μ x g 4 + μ 1 g 4 = g 4 + 1 = g 5 = 7 Consideriamo una funzione def f = e Definiamo una catena ascendente f 0, f 1, in Int Int dove definiamo μ f = f i i f o = λx. f i+1 = μ e f i Esempio: Sia def f = if x = 0 ten 1 else f(x 1)
f 0 i = i f 1 i = μ if x=0 ten 1 else f x 1 f 0 i μ 1 f 0 i = 1 se i = 0 f 0 i = f 0 μ x 1 f 0 i altrimenti μ f x 1 = = f 0 μ x f 0 i f 0 μ 1 f 0 i = f 0 i f 0 1 = f 2 i = = μ if x=0 ten 1 else f x 1 f 1 i μ 1 f 1 i = 1 se i = 0 f 1 i = f 1 μ x 1 f 1 i altrimenti = μ f x 1 = f 1 μ 0 f 1 i = f 1 0 = 1 se x = 1, ossia [μ 0 f 1 i = 0] f 1 j = altrimenti, ossia j 0 Ricapitolando: μ f = i 0 f i Semantica astratta Dobbiamo estendere la definizione della semantica astratta σ Richiediamo che tutte le funzioni siano monotone σ : Exp A A versione astratta della f A valore astratto dell input A σ f e g (i) = g σ e g i σ x g (i) = i σ e1 +e 2 g (i) = σ e1 g i + σ e2 g (i) Consideriamo una funzione def f = e Definiamo una catena ascendente f 0, f 1, in A A dove definiamo σ f = f i i f 0 = λa. f i+1 = σ e f i Correttezza Elementi corrispondenti nelle due catene sono nella giusta relazione
i. f i j γ f i j f i (j) i 0 i 0 γ f i j le catene convergono f i (j) γ i 0 i 0 f i j monotonia di γ μ f j γ σ f j per definizione Esempio Consideriamo la funzione ricorsiva def f x = if x = 0 ten 1 else x f(x 1) Astrazione (lfp=minimo punto fisso): lfp σ if x = 0 ten 1 else x f x 1 Semplificando lfp λf. λx date f e x. + x f x + Osserviamo che in questo caso l astrazione non porta a nessuna informazione utile (a causa della presenza di ) Le catene ascendenti sono strettamente crescenti fino a che non convergono: f 0 < f 1 < f 2 < f 3 = f 4 = f 5 =...ma non e detto che considerando un singolo valore la catena ascendente concreta sia strettamente crescente: f 0 + < f 1 + = f 2 (+) < f 3 (+) = f 4 (+) = Riassunto e conclusioni Applicare le tecniche di Interpretazione Astratta significa o Definire semantica concreta e astratta del programma: domini e operazioni o Applicare un algoritmo di punto fisso Analisi statica = reticoli + funzioni monotone E una teoria unificante: le tecniche di dataflow e model checking si possono esprimere in termini di Interpretazione Astratta