Università degli studi di Verona Facoltà di Scienze MM. FF. NN.

Relazione sull’articolo:

Proving Existential Termination of

Normal Logic Programs Cordibella Stefano vr031441

Elaborato del corso di Metodi di Specifica Dei Sistemi Software

A.A. 2005-2006

Indice

Introduzione Classi di programmi k-terminazione Trasformazione di base Da RT a ST Il caso della k-terminazione Programmi Logici Normali

Introduzione

Uno dei principali problemi aperti nel campo dell’informatica è lo studio della terminazione dei programmi. Nel campo della programmazione logica la potenza del paradigma, unito al modo in cui esso viene implementato (es. Prolog), rende lo studio della terminazione estremamente difficile. Per questo paradigma si distinguono due tipi di terminazione: esistenziale ed universale.Terminazione esistenziale: è la normale nozione di terminazione dal punto di vista del programmatore: se il programma viene eseguito con un determinato input si deve fermare.Terminazione universale: è una proprietà più forte ed afferma che un programma deve terminare non solo esistenzialmente, ma per ogni invocazione dell’utente, ed inoltre il numero di soluzioni del problema deve essere finito.

Per quanto riguarda la terminazione esistenziale, pochi lavori sono stati presentati e si basano soprattutto su pesanti traduzioni matematiche della semantica operazionale di Prolog in logiche del primo ordine, sulle quali poi dimostrare la proprietà di terminazione attraverso il ragionamento induttivo.

Introduzione

L’autore propone un potente strumento per dimostrare la terminazione esistenziale di programmi logici utilizzando un approccio detto trasformazionale che consiste nel trasformare i programmi considerati in TRS (Term Rewriting Systems).

Il vantaggio principale che ne consegue è che per i TRS lo studio della terminazione è più semplice, a differenza che nei linguaggi di programmazione logica, grazie ai potenti criteri automatici o semiautomatici per decidere la terminazione dei TRS.

Il problema viene affrontato studiando la k-terminazione, che fornisce uno strumento utile per poter verificare anche la terminazione universale dei programmi. In pratica dato un ordinale k un programma k-termina se le sue prime k derivazioni sono finite.

Ecco quindi che la k-terminazione generalizza entrambi i concetti di terminazione, esistenziale ed universale (corrispondenti a 1-terminazione e +1-terminazione).

L’articolo non si limita a considerare il caso di programmi logici definiti, ma considera anche la terminazione dei programmi logici normali, ovvero programmi che hanno interessanti proprietà come la negazione, molto utilizzati nell’ambito dell’intelligenza artificiale.

Introduzione

L’articolo è organizzato come segue:

1. Viene sviluppata la trasformazione verso i TRS per una classe ristretta di programmi, i Regularly Typed (o RT)

2. Si dimostra che la trasformazione al passo 1 preserva la k-terminazione.

3. Si estende poi la sottoclasse considerata alla classe dei programmi Safely Typed (ST) tramite un’opportuna trasformazione.

4. Si considera aquesto punto la k-terminazione rispetto alla terminazione universale.

5. Quindi tutti i risultati fin qui ottenuti vengono estesi alla programmazione logica normale coprendo il caso della negazione.

Classi di programmi

Tutte le classi di programmi considerate nell’articolo sono regolari rispetto alla seguente definizione:

Definizione: è detta regolare se

Definizione: un modo per un predicato n-ario p è un’associazione tra 1,..,n e in, out. Una modalità associa un predicato p ad un modo. Gli argomenti messi in corrispondenza con in vengono detti input, mentre i restanti messi in corrispondenza con out vengono detti output.

La seguente definizione introduce i programmi tipati, nel seguito tratteremo solamente programmi tipati e chiusi per sostituzione.

Definizione: un tipo per un predicato n-ario p è un’associazione tra 1,..,n e Types. Un argomento di un dato predicato è detto di tipo T se è associato dal tipaggio in T.

Nel seguito scriveremo che per indicare che p ha modalità

e tipo .

Per semplicità si assume che siano presenti tutti i tipi più comuni, ad esempio:

Any (tutti i termini), Nat (i termini 0, s(0), s(s(0)), …), Ground (tutti i termini di base), List (tutte le liste).

Classi di programmi

Vengono ora introdotte le principali classi di programmi utilizzate nell’articolo:

Definizione: un programma è detto Safely Typed (ST) se per ogni sua clausola

abbiamo che: ogni termine è utilizzato con un’espressione generica del tipo di se una variabile X occorre due volte in , esiste un tale che

, e ogni termine ha un tipo di base corrispondente.

Definizione: un programma è detto Regularly Typed (RT) se è Safely Typed e per ogni clausola si ha che è una sequenza di variabili e .

k-terminazione

Si supponga che un programma P sia lanciato con goal G. Definiamo la prima risposta ottenuta come nel seguente modo:

1. se il calcolo termina con successo restituendo come risposta

2.Fail se il calcolo termina in maniera anomala

3. se il calcolo non termina.

Da notare che nel caso 1 è possibile reiterare il processo andando a costruire

e così via finché non ritorni Fail o .

Ora diamo la definizione ovvero della semantica di risposta di un programma P con goal G come la sequenza .

Definizione: dato un programma P e un goal G, supponiamo la sua semantica di risposta sia . Allora P è detto esistenzialmente terminante quando riferito a G se (universalmente se ).

In pratica, un programma è esistenzialmente terminante se la sua prima risposta non è , il programma è universalmente terminante se non da mai come risposta.

Trasformazione di base

In questa sezione viene presentata la trasformazione da programmi RT a TRS.

Nel seguito verranno utilizzate le , ovvero liste per contenere generici elementi, utilizzando la notazione . Il simbolo sta ad indicare un dato che non deve essere ulteriormente calcolato. Per finire la notazione si intende una funzione che si aspetta un dato di tipo e restituisce un valore di tipo .

Definizione: data la clausola definiamo FLOW(C) come:

dove .

L’idea che sta dietro a FLOW è che ogni clausola del tipo ci da un modo per calcolare ; l’ output è ottenuto nel seguente modo.

Si inizia con il dato , quindi applicando il primo operatore si calcola (che fornisce in output il valore per ). Così facendo da si ricavano tutti i valori intermedi per calcolare gli altri . Il calcolo prosegue per tutti i ed infine, l’operatore passa l’ultimo risultato

Trasformazione di base

Definizione: Unification Engine

Per ogni termine t il suo motore di unificazione è definito come segue. Sia t’ una linearizzazione di t, allora le regole che definiscono sono:

In sostanza il motore di unificazione di un termine t formalizza nel TRS il concetto di unificazione: esso controlla quando un termine è unificabile o meno con t.

esegue l’unificazione dei termini lineari, mentre la regola ci dice quando un argomento è una variabile, e quindi tutto viene unificato ad essa.

impone invece di avere un unico unificatore per le variabili ripetute.

Trasformazione di baseSiamo ora pronti per dare la definizione formale della trasformazione .

Definizione: Trasformazione

1) Per ogni predicato , prendiamo la definizione di p in P:

Quindi si producono le seguenti regole di riscrittura, ed il corrispondente unification engine:

2) Per ogni , viene prodotto:

Trasformazione di base3) Infine viene generato:

Il comportamento di viene spiegato di seguito.

Come detto in precedenza ogni clausola che definisce un predicato p fornisce un modo per calcolare p. Il punto 1 della trasformazione la prima regola ci dice che per calcolare p dobbiamo avere a disposizione le definizioni dalla prima clausola

( ) fino all’ultima ( ). Tutte queste scelte sono raggruppate in una .

Il simbolo presente nella regola indica il comando di backtracking, che attiva la computazione. Questo comando ha la possibilità di penetrare nella struttura del programma attraverso le regole e generate al punto 2 e al punto 3. La regola indica invece che il comando è idempotente.

Ogni volta che incontra un operatore di (che codifica una certa clausola) cerca di attivarla con la seconda regola del passo 1: deve verificare che la rappresentazione nel TRS dell’atomo scelto nel goal e la rappresentazione della testa della clausola siano unificabili; questo viene fatto dalla

Trasformazione di base

Se il test ha successo la regola viene applicata alla clausola; se non ha successo la regola ci dice che nessun risultato è stato prodotto. La regola (generata al punto 3) dice che se in una lista di scelte è presente un argomento che non ha generato un risultato, quest’ultimo deve essere scartato, e un altro comando di backtracking viene generato e applicato alle rimanenti scelte. Da notare che se invece un risultato viene prodotto, nessun altro comando viene generato e l’esecuzione si ferma.Eventualmente se non fornisce nessun risultato, nessun risultato viene prodotto ( ). Passiamo ora a dimostrare il risultato cercato.Teorema: siano P e G rispettivamente un programma RT e un goal, allora P termina esistenzialmente in riferimento a G se e solo se termina in riferimento a .Teorema: sia P un programma RT; P termina esistenzialmente se e solo se termina.Ecco quindi che dai due teoremi sopraelencati otteniamo la caratterizzazione della terminazione esistenziale per i programmi RT.

Da ST a RT

Estendiamo ora i risultati precedentemente ottenuti alla classe dei programmi RT usando una trasformazione da ST a RT.

Data la clausola definiamo come il numero di che non soddisfano le condizioni RT. È chiaro che è una misura di quanto la clausola non sia RT, in altre parole quanti atomi nella clausola sono sono RT. può banalmente essere estesa ad un programma P nel seguente modo: .

Viene definita ora la trasformazione C che trasforma programmi safely typed in programmi regularly typed.

Definizione : Trasformazione C

Sia P un programma ST. Se P è anche di tipo RT la trasformazione C lo lascia invariato ( C(P)=P ).

Se invece P non è del tipo RT, ovvero prendiamo una clausola C di P con

Dato un i tale che non verifichi le condizioni RT, rimpiazziamo C con le seguenti due clausole:

Da ST a RT

Dove sono nuove variabili e è un nuovo simbolo di predicato.

Non è difficile provare che il nuovo programma è ancora ST e

Ripetendo quindi il processo otterremo un programma Q con (quindi RT) e tale che

L’intuizione di questa trasformazione è di ‘aggiustare’ gli atomi che violano la proprietà: se non va bene, viene forzato ad essere RT inserendo al posto di nuove variabili, dopodiché si controlla che queste variabili siano state istanziate a qualcosa di unificabile con attraverso il nuovo predicato EQ.

Da ST a RT

Possiamo quindi analizzare la terminazione dei programmi RT applicando la trasformazione ed estendendo i due teoremi visti in precedenza.

Teorema: siano P e G un programma ST e un goal; allora P termina esistenzialmente riferito a G se termina riferito a .

Teorema: sia P un programma ST: P termina esistenzialmente se termina.

Il caso della k-terminazione

In questa sezione vengono proposti risultati che riguardano tutte le possibilità offerte dalla k-terminazione rispetto alla terminazione universale.

Iniziamo subito enunciando un teorema dove ed sono due nuovi simboli.

Teorema: siano P e G un programma RT e un goal. Per ogni k t.c. 0 < k < P

k-termina in riferimento a G se e solo se

termina riferito a

L’intuizione consiste nel considerare la riduzione nel TRS non sui termini originali

ma sui termini che contano quante risposte sono state generate. Il contatore viene memorizzato nel primo argomento di inizialmente impostato al valore k-1. Ad ogni risposta generata, grazie alle regole aggiunte il contatore viene decrementato e viene forzata un’operazione di backtracking

finché non vengono trovate tutte le k risposte.

Il caso della k-terminazione

Con la tecnica appena introdotta ci spostiamo ora al caso più interessante della terminazione universale.

Teorema: Siano P e G un programma RT e un goal. P termina universalmente riferito a G se e solo se

termina riferito a .

Programmi Logici Normali

Dopo aver analizzato i programmi logici definiti ci spostiamo ora sui programmi logici normali, comprendenti proprietà di negazione. Possiamo a questo punto estendere le classi di programmi logici definiti, utilizzati fino ad ora, induttivamente sul numero di letterali negativi:

Definizione: Una clausola è normal safely typed (NST) se e solo se è ST, oppure:

se la clausola è nella forma

allora entrambe e

sono NST.

Un programma è NST se lo è ogni sua clausola.

Considerazioni analoghe vanno fatte per la classe dei programmi normal regularly typed (NRT).

A questo punto bisogna estendere la definizione di per affrontare la negazione.

La modifica è abbastanza semplice ed estende la definizione di FLOW in questo modo: se un predicato della clausola è negato, ad esempio nella forma

allora nei termini generati compariranno le funzioni composte; dove

è definito come segue:

Programmi Logici Normali

La spiegazione di queste regole è assolutamente naturale: dato che si verifica se e solo se finitamente fallisce, nel TRS prima calcoliamo

e poi applichiamo l’operatore not: se nessuna risposta viene restituita il risultato sarà [] dalla regola ; mentre se viene ritornato un risultato esso non genera nessun risultato, grazie alle altre due regole.

In questo modo abbiamo ottenuto una nuova trasformazione di base che estende dagli regularly typed ai normal regularly typed.

Tutte le trasformazioni e tutti i risultati visti finora possono essere estesi ai programmi logici normali, tenendo presente la corrispondenza

e .