Interpretazione astratta

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 𝑒 =𝑖|𝑒∗𝑒
Semantica concreta
 La semantica concreta di questo linguaggio si puo’ descrivere mediante una funzione 𝜇 definita
come:
o 𝜇 ∶ 𝑒𝑥𝑝 → 𝑖𝑛𝑡
𝜇 𝑖
= 𝑖
o
𝜇 𝑒1 ∗ 𝑒2 = 𝜇 𝑒1 × 𝜇 𝑒2
Semantica astratta
 Possiamo considerare una astrazione della semantica concreta (semantica astratta) che calcola
solo il segno delle espressioni
o
o
o
o
𝜎 ∶ 𝑒𝑥𝑝 → +, −,0
× +
+ if 𝑖 > 0
+
+
𝜎 𝑖 = 0 if 𝑖 = 0
0
0
− if 𝑖 < 0
−
−
𝜎 𝑒1 ∗ 𝑒2 = 𝜎 𝑒1 × 𝜎(𝑒2 )
dove × e’ l’operazione astratta che calcola il segno del prodotto
0
0
0
0
−
−
0
+
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 utilizza le proprieta’ della
moltiplicazione tra interi (il prodotto di due positivi e’ positivo, etc.).
𝜇 𝑒 >0
𝜇 𝑒 =0
𝜇 𝑒 <0
⇔
⇔
⇔
𝑠𝑒𝑚𝑎𝑛𝑡𝑖𝑐𝑎
𝑐𝑜𝑛𝑐𝑟𝑒𝑡𝑎
𝜎 𝑒 =+
𝜎 𝑒 =0
𝜎 𝑒 =−
𝑠𝑒𝑚𝑎𝑛𝑡𝑖𝑐𝑎
𝑎𝑠𝑡𝑟𝑎𝑡𝑡𝑎
Concretizzazione
 Possiamo associare ad ogni valore astratto l’insieme dei valori che esso rappresenta:
𝛾 ∶ +,0 − → 𝓅(ℤ)
𝛾 +
𝛾 0
𝛾 −



𝑖∶𝑖>0
0
𝑖∶𝑖<0
La funzione di concretizzazione 𝛾 mappa un valore astratto in un insieme di valori concreti
Indichiamo con 𝒟 il dominio concreto e 𝒜 il dominio astratto
Data una espressione 𝑒, il suo valore calcolato rispetto alla semantica concreta 𝜇, deve
appartenere all’insieme dei valori nella concretizzazione 𝛾 della semantica astratta 𝜎:
𝜇 𝑒 ∈𝛾 𝜎 𝑒

=
=
=
∀𝑒 ⇒ 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:
𝜇 −𝑒
𝜎 −𝑒

dove l’operatore di cambiamento di segno nel dominio astratto − e’ cosi’ definito:
+
−
−

−
+
=
=
𝜇 𝑒1 + 𝜇(𝑒2 )
𝜎 𝑒1 + 𝜎(𝑒2 )
Per poter definire l’operatore di somma nel dominio astratto (+), dobbiamo estendere il
dominio astratto con un nuovo valore ⊤ tale che 𝛾 ⊤ = {𝑖 ∶ 𝑖 ∈ ℤ}
+
+
0
−
⊤

0
0
Aggiungere l’addizione e’ piu’ complesso in quanto il domino astratto non e’ chiuso rispetto a
questa operazione
𝜇 𝑒1 + 𝑒2
𝜎 𝑒1 + 𝑒2

= −𝜇 𝑒
= −𝜎 𝑒
+
+
+
⊤
⊤
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 −⊥ = ⊥
Dominio astratto


Il dominio astratto e’ un reticolo completo
L’ordine parziale e’ coerente con la funzione di concretizzazione
𝑥 ≤ 𝑦 ⇔ 𝛾 𝑥 ⊆ 𝛾(𝑦)


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 𝛼∶𝓅 ℤ →𝒜
o
𝛼 17,22,3,0
o
𝛼 𝑆 =⊔
= ⊔ ( +,0 ) = ⊤
−∶ ∃𝑖 ∈ 𝑆, 𝑖 < 0 , +∶ ∃𝑖 ∈ 𝑆, 𝑖 > 0 , 0 ∶ ∃𝑖 ∈ 𝑆, 𝑖 = 0
− se ci sono negativi
+ se ci sono positivi
0 se c'e' lo 0
Definizione generale di interpretazione astratta


Una interpretazione astratta consiste in:
1. Un dominio astratto 𝒜 e un dominio concreto 𝒟
2. I domini 𝒜, 𝒟 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
la migliore
approssimazione
di 𝑥 contiene 𝑥
elemento
concreto
∀𝑥 ∈ 𝓅 𝒟
.
𝑥⊆
𝛾 𝛼 𝑥
∀𝑎 ∈ 𝒜
.
𝑎=
𝛼 𝛾 𝑎
elemento
astratto
non posso
approssimare
meglio di cosi ′
Operazioni astratte



Ipotizziamo di avere una funzione 𝑓: 𝓅(𝒟) → 𝓅(𝒟) e di volere costruire la corrispondente
funzione 𝑓 # nel dominio astratto, 𝑓 # ∶ 𝒜 → 𝒜.
Vogliamo che 𝑓 # sia il modo ottimale per rappresentare 𝑓 nel dominio astratto, ossia
𝑓# = 𝛼 ∘ 𝑓 ∘ 𝛾
Se dimostriamo che la relazione e’ rispettata, o al piu’ 𝑓 # 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 𝑎𝑖
La funzione di astrazione cerca di mappare un sottoinsieme arbitrario del dominio nel piu’
piccolo 𝑎𝑖 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
insieme dei valori
che l' espressione
ha secondo l' analisi
astratta 𝜎 (ad es: ' 𝑒 positivo ′ )
valore
concreto
di una
espressione:
3+2∗2=7
𝜇 𝑒
𝜎 𝑒
analisi
astratta
di 𝑒
(>0,<0,=0)
∈
≥
𝛾 𝜎 𝑒
𝛼 𝜇 𝑒
astrazione ideale nel
reticolo del dominio
astratto del valore
concreto della
espressione 𝑒
Correttezza

Per la correttezza dell’analisi sono sufficienti le seguenti condizioni
o 𝛼, 𝛾 formano un’inserzione di Galois (sia 𝑖𝑑 = identita'):
 𝑖𝑑 = 𝛼 ∘ 𝛾 ossia se concretizzo un valore astratto e poi lo astraggo nuovamente
ottengo il valore astratto di partenza: 𝛼 𝛾 ′+′ → 𝛼 𝑖 ∶ 𝑖 > 0 →′ + ′
 𝑖𝑑 ≤ 𝛾 ∘ 𝛼 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: 𝑐1 ⊆ 𝑐2 ⇒ 𝛼 𝑐1 ≤ 𝛼 𝑐2 ; 𝑎1 ≤ 𝑎2 ⇒ 𝛾 𝑎1 ⊆ 𝛾 𝑎2
o le operazioni astratte 𝑜𝑝 sono corrette localmente
 𝑜𝑝 𝛾 𝑠1 , … , 𝛾(𝑠𝑛 ) ⊆ 𝛾 𝑜𝑝 𝑠1 , … , 𝑠𝑛 ossia se eseguo una operazione
astratta sui valori astratti 𝑠1 , … , 𝑠𝑛 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 𝑜𝑝 sia un’approssimazione
corretta di 𝑜𝑝
 per ogni operazione concreta c’e’ sempre una operazione astratta corretta,
ossia quella che restitusce sempre l’elemento massimo del dominio astratto

𝑜𝑝
𝒜
𝛾↓
→
𝒜
↑𝛼
𝑜𝑝
𝓅 𝒟
→
𝓅 𝒟
Prova di correttezza
 Proviamo per induzione sulla struttura di 𝑒 che 𝜇 𝑒 ∈ 𝛾 𝜎 𝑒
𝜇 𝑖 =
𝑖
def.di 𝜇
∈
𝑖
o Caso base:
⊆ 𝛾 𝛼 𝑖
inserzione di Galois
=
𝛾 𝜎 𝑖
𝜇 𝑒1 𝑜𝑝 𝑒2
o
Passo induttivo:
def.di 𝜎 perche' 𝜎 𝑖 = 𝛼 𝑖
=
𝜇 𝑒1 𝑜𝑝 𝜇(𝑒2 )
∈ 𝛾 𝜎 𝑒1 𝑜𝑝 𝛾 𝜎 𝑒2
def.di 𝜇
per ip.induttiva
⊆
𝛾 𝜎 𝑒1 𝑜𝑝 𝜎 𝑒2
correttezza locale
=
𝛾 𝜎 𝑒1 𝑜𝑝 𝑒2
def.di 𝜎
Definzione alternativa
 Possiamo anche definire la correttezza usando l’astrazione al posto della concretizzazione:
𝜇 𝑒 ∈𝛾 𝜎 𝑒



⇔ 𝛼 𝜇 𝑒
≤𝜎 𝑒
Ossia che le due affermazioni sono equivalenti:
o 𝜇 𝑒 ∈ 𝛾 𝜎 𝑒 che la concretizzazione dell’interpretazione astratta e’ un sovrainsieme
dell’interpretazione concreta
o 𝛼 𝜇 𝑒
≤ 𝜎 𝑒 che le operazioni astratte 𝜎 sono una approssimazione per eccesso
dell’astrazione vera e propria del risultato concreto
⇒
𝜇 𝑒
∈
𝛾 𝜎 𝑒
𝜇 𝑒
⊆
𝛾 𝜎 𝑒
ipotesi
𝛼 𝜇 𝑒
≤ 𝛼 𝛾 𝜎 𝑒
monotonia
𝛼 𝜇 𝑒
≤
𝛼 ∘ 𝛾 = 𝑖𝑑
𝜎 𝑒
⇐
𝛼 𝜇 𝑒
𝛾 𝛼 𝜇 𝑒
≤
⊆
𝜎 𝑒
𝛾 𝜎 𝑒
ipotesi
monotonia
𝜇 𝑒
⊆
𝛾 𝜎 𝑒
𝑖𝑑 ≤ 𝛾 ∘ 𝛼
𝜇 𝑒
∈
𝛾 𝜎 𝑒
Estensione al nostro tiny language: input

Aggiungiamo input tramite la presenza di variabili libere nelle espressioni:
𝑒 = 𝑖 𝑒 ∗ 𝑒 − 𝑒| … |𝑥


La firma della funzione semantica diventa 𝜇: 𝐸𝑥𝑝 → 𝐼𝑛𝑡 → 𝐼𝑛𝑡 (le espressioni hanno una sola
variabile!)
Un modo per scrivere questa funzione e’ pensarla come un insieme di funzioni 𝐼𝑛𝑡 → 𝐼𝑛𝑡
indicizzate con espressioni
𝜇𝑖 𝑗
𝜇𝑥 𝑗
𝜇𝑒1 ∗𝑒2 𝑗
…




La semantica astratta e’ data dalla funzione 𝜎: 𝐸𝑥𝑝 → 𝒜 → 𝒜, in quanto alla variabile passiamo
un valore astratto (es: 𝜎𝑥+3 (−))
Come per la semantica concreta possiamo indicizzare 𝜎
𝜎𝑖 𝑗
=
𝑖
𝜎𝑥 𝑗
=
𝑗
𝜎𝑒1 ∗𝑒2 𝑗 = 𝜎𝑒1 𝑗 ∗ 𝜎𝑒2 𝑗
…
=
…
dove 𝑖 = 𝛼 𝑖
Dobbiamo generalizzare le condizioni di correttezza
Le seguenti condizioni sono equivalenti:
∀ 𝑖 . 𝜇𝑒 𝑖
𝜇𝑒
𝛼 ∘ 𝜇𝑒

=
𝑖
=
𝑗
= 𝜇𝑒1 𝑗 ∗ 𝜇𝑒2 𝑗
=
…
∈
⊆𝒟
≤𝒜
𝛾 𝜎𝑒 𝛼 𝑖
𝛾 ∘ 𝜎𝑒 ∘ 𝛼
𝜎𝑒 ∘ 𝛼
La correttezza locale la possiamo anche esprimere mediante la seguente regola:
𝑜𝑝 𝛾 𝜎𝑒1 𝑗
, … , 𝛾 𝜎𝑒𝑛 𝑗
⊆ 𝛾 𝑜𝑝 𝜎𝑒1 𝑗 , … , 𝜎𝑒𝑛 𝑗
Teorema: la correttezza locale e’ sufficiente
𝜇𝑒 𝑗 ∈ 𝛾 𝜎𝑒 𝑗


Per induzione sull’espressione
Casi base:
𝜇𝑖 𝑗 =
𝑖
∈
𝛾 𝑖
o
= 𝛾 𝜎𝑖 𝑗
𝜇𝑥 𝑗
o
=
∈
𝑗
𝛾 𝑗
= 𝛾 𝜎𝑥 𝑗

Passo induttivo:
𝜇𝑜𝑝
𝑒1 ,…,𝑒𝑛
𝑗
=
∈
⊆
𝑜𝑝 𝜇𝑒1 𝑗 , … , 𝜇𝑒𝑛 𝑗
𝑜𝑝 𝛾 𝜎𝑒1 𝑗
definizione di 𝜇
, … , 𝛾 𝜎𝑒𝑛 𝑗
ip.induttiva
𝛾 𝑜𝑝 𝜎𝑒1 𝑗 , … , 𝜎𝑒𝑛 𝑗
=
𝛾 𝜎𝑜𝑝
𝑒1 ,…,𝑒𝑛
correttezza locale
𝑗
definizione di 𝜎
Estensione al nostro tiny language: comando condizionale
𝑒 = ⋯ ∣ 𝑖𝑓 𝑒 = 𝑒 𝑡𝑕𝑒𝑛 𝑒 𝑒𝑙𝑠𝑒 𝑒 ∣ ⋯

Semantica concreta
𝜇𝑖𝑓 𝑒1 =𝑒2 𝑡𝑕𝑒𝑛 𝑒3 𝑒𝑙𝑠𝑒 𝑒4 𝑖 =

𝜇𝑒3 𝑖
𝜇𝑒4 𝑖
𝑖𝑓 𝜇𝑒1 𝑖 = 𝜇𝑒2 𝑖
𝑖𝑓 𝜇𝑒1 𝑖 ≠ 𝜇𝑒2 𝑖
Semantica astratta
𝜎𝑖𝑓 𝑒1 =𝑒2 𝑡𝑕𝑒𝑛 𝑒3 𝑒𝑙𝑠𝑒 𝑒4 𝑖 = 𝜎𝑒3 𝑖 ⊔ 𝜎𝑒4 (𝑖)


Si puo’ fare di meglio se abbiamo informazioni che ci permettono di verificare l’uguaglianza tra
𝑒1 ed 𝑒2 , ma cio’ e’ raro e in generale ci aspettiamo di “percorrere contemporaneamente” i due
rami dell’𝑖𝑓 perdendo inevitabilmente precisione
Il motivo per cui imponiamo che il dominio sia un reticolo e’ perche’ cosi’ abbiamo la garanzia
dell’esistenza del lub (⊔)
𝜎𝑖𝑓 𝑥=3 𝑡𝑕𝑒𝑛 7 𝑒𝑙𝑠𝑒 8 + = 𝜎7 + ⊔ 𝜎8 + = +
Correttezza del comando condizionale
 Assumiamo che sia vera la condizione dell’𝑖𝑓, ovvero che si entri nel primo ramo (l’altro caso e’
lasciato come esercizio per il docente ...si dimostra analogamente)
𝜇𝑒3 𝑖
∈
⊆
⊆
𝛾 𝜎𝑒3 𝑖
𝛾 𝜎𝑒3 𝑖
ip.induttiva
⊔ 𝛾 𝜎𝑒4 𝑖
𝛾 𝜎𝑒3 𝑖 ⊔ 𝜎𝑒4 𝑖
= 𝛾 𝜎𝑖𝑓 𝑒1 =𝑒2 𝑡𝑕𝑒𝑛 𝑒3 𝑒𝑙𝑠𝑒 𝑒4 𝑖
monotonia di 𝛾 e ⊔
per def. della sem.abstr.dell'𝑖𝑓
Estensione al nostro tiny language: ricorsione

Aggiungiamo funzioni ricorsive (in una sola variabile per semplicita’) che possono essere
o Dichiarate
o Chiamate
𝑝𝑟𝑜𝑔𝑟𝑎𝑚 ∷= def 𝑓 𝑥 = 𝑒
𝑒 ∷= ⋯ ∣ 𝑓(𝑒)
Semantica delle funzioni ricorsive
 La funzione semantica che abbiamo considerato finora e’ del tipo 𝜇: 𝐸𝑥𝑝 → 𝐼𝑛𝑡 → 𝐼𝑛𝑡⊥
⊥ se c'e'
divisione
per 0

La generalizziamo per tenere conto delle chiamate di funzione
𝜇′ : 𝐸𝑥𝑝 → 𝐼𝑛𝑡 → 𝐼𝑛𝑡⊥ → 𝐼𝑛𝑡 → 𝐼𝑛𝑡⊥
𝑒
𝜇𝑓′ 𝑒 𝑔 𝑗
𝜇𝑥′ 𝑔 𝑗
′
𝜇𝑒1 +𝑒2 𝑔 𝑗
o
𝑔
𝑗
=
𝑔 𝜇𝑒′ 𝑔 𝑗
=
𝑗
= 𝜇𝑒′ 1 𝑔 𝑗 + 𝜇𝑒′ 2 𝑔 𝑗
Esempio in cui 𝑔: 𝑥 ↦ 𝑥 + 2
𝜇𝑓′
𝑥+1
𝑔 4
′
𝑔 𝜇𝑥+1
𝑔 4
=
= 𝑔 𝜇𝑥′ 𝑔 4 + 𝜇1′ 𝑔 4
=
𝑔 4+1
=
𝑔 5
=
7


Consideriamo una funzione def 𝑓 = 𝑒
Definiamo una catena ascendente 𝑓0 , 𝑓1 , … in 𝐼𝑛𝑡 → 𝐼𝑛𝑡⊥ dove
𝑓𝑜
𝑓𝑖+1

definiamo 𝜇𝑓 =
𝑖
𝑓𝑖
Esempio:
 Sia def 𝑓 = 𝑖𝑓 𝑥 = 0 𝑡𝑕𝑒𝑛 1 𝑒𝑙𝑠𝑒 𝑓(𝑥 − 1)
= 𝜆𝑥. ⊥
…
= 𝜇𝑒′ 𝑓𝑖
𝑓0 𝑖
𝑓1 𝑖
=
=
⊥ ∀𝑖
𝜇1′
′
𝜇𝑖𝑓
𝑥=0 𝑡𝑕𝑒𝑛 1 𝑒𝑙𝑠𝑒 𝑓 𝑥−1
𝑓0 𝑖
𝑓0 𝑖
=
=
𝜇𝑓′ 𝑥−1
𝜇1′ 𝑓1 𝑖
𝜇𝑓′ 𝑥−1 𝑓1 𝑖
=
=
𝑓1 𝜇0′ 𝑓1 𝑖
𝑓1 𝑗
=

𝑓0 𝑖
= 𝑓1 0 = 1 se 𝑥 = 1, ossia [𝜇0′ 𝑓1 𝑖 = 0]
=
⊥
altrimenti, ossia 𝑗 ≠ 0
Ricapitolando:
𝜇 𝑓 =
𝑓𝑖
𝑖≥0
Semantica astratta
 Dobbiamo estendere la definizione della semantica astratta 𝜎
 Richiediamo che tutte le funzioni siano monotone
𝜎 ′ : 𝐸𝑥𝑝 → 𝒜 → 𝒜 →
versione
astratta
della 𝑓
𝜎𝑓′
𝑒
𝑔 (𝑖)
𝒜
→𝒜
valore
astratto
dell ′ input
𝑔 𝜎𝑒′ 𝑔 𝑖
=
𝜎𝑥′ 𝑔 (𝑖)
=
𝑖
′
′
𝜎𝑒1 +𝑒2 𝑔 (𝑖) = 𝜎𝑒1 𝑔 𝑖 + 𝜎𝑒′ 2 𝑔 (𝑖)
…

Consideriamo una funzione def 𝑓 = 𝑒

Definiamo una catena ascendente 𝑓0 , 𝑓1 , … in 𝒜 → 𝒜 dove
𝑓0
𝑓𝑖+1

se 𝑖 = 0
altrimenti
=
𝑓0 𝑖 − 𝑓0 𝜇1′ 𝑓0 𝑖
=
𝑓0 𝑖 − 𝑓0 1
=
⊥ −⊥
=
⊥
′
𝜇𝑖𝑓
𝑥=0 𝑡𝑕𝑒𝑛 1 𝑒𝑙𝑠𝑒 𝑓 𝑥−1 𝑓1 𝑖
1
′
𝑓1 𝜇𝑥−1
𝑓1 𝑖
=
=
1
′
𝑓0 𝜇𝑥−1
𝑓0 𝜇𝑥′
=
𝑓2 𝑖
𝑓0 𝑖
definiamo 𝜎𝑓 =
𝑖
= 𝜆𝑎. ⊥
…
= 𝜎𝑒′ 𝑓𝑖
𝑓𝑖
Correttezza
 Elementi corrispondenti nelle due catene sono nella giusta relazione
se 𝑖 = 0
altrimenti
∀𝑖 . 𝑓𝑖 𝑗 ∈ 𝛾 𝑓𝑖 𝑗
⇒
𝑓𝑖 (𝑗) ∈
𝑖≥0
⇒
le catene convergono
𝑖≥0
𝑓𝑖 (𝑗) ∈ 𝛾
𝑖≥0
⇒
𝛾 𝑓𝑖 𝑗
𝑓𝑖 𝑗
monotonia di 𝛾
𝑖≥0
𝜇𝑓 𝑗 ∈ 𝛾 𝜎𝑓 𝑗
per definizione
Esempio
 Consideriamo la funzione ricorsiva def 𝑓 𝑥 = 𝑖𝑓 𝑥 = 0 𝑡𝑕𝑒𝑛 1 𝑒𝑙𝑠𝑒 𝑥 ∗ 𝑓(𝑥 − 1)
 Astrazione (lfp=minimo punto fisso):
𝑙𝑓𝑝 𝜎 ′ 𝑖𝑓 𝑥 = 0 𝑡𝑕𝑒𝑛 1 𝑒𝑙𝑠𝑒 𝑥 ∗ 𝑓 𝑥 − 1

Semplificando
𝑙𝑓𝑝
𝜆𝑓. 𝜆𝑥 . + ⊔ 𝑥 × 𝑓 𝑥 + −
date 𝑓 e 𝑥


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:
𝑓0 < 𝑓1 < 𝑓2 < 𝑓3 = 𝑓4 = 𝑓5 = ⋯

...ma non e’ detto che considerando un singolo valore la catena ascendente concreta sia
strettamente crescente:
𝑓0 + < 𝑓1 + = 𝑓2 (+) < 𝑓3 (+) = 𝑓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