Cicli ed asserzioni. Ordinamento. Dato un intero positivo n ed una sequenza di n elementi a 1,...,a n

Transcript

1 Cicli ed asserzioni 1. Problemi, algoritmi e specifiche Un algoritmo è un metodo di calcolo per risolvere un problema computazionale. Come una ricetta di cucina, descrive il processo che conduce dagli ingredienti (l ingresso) al piatto pronto (l uscita); ma come appunto una ricetta può essere ripetuto quante volte si vuole, per i tutti i casi particolari di ingressi, per i quali produce le relative uscite. Astrattamente un problema computazionale può identificarsi con l insieme R delle coppie: i = caso particolare dell ingresso, r = risposta accettabile per i cioè con la relazione tra i possibili casi e le risposte che si considerano accettabili per ciascuno di essi. Dato che i casi particolari di un problema, o istanze, sono normalmente infiniti, è impossibile definire un problema elencando tutte le coppie istanza, risposta. Si definisce allora un criterio per riconoscere le coppie accettabili: la specifica del problema. Esempi: Massimo comun divisore (MCD). Dati due interi positivi non entrambi nulli n ed m, determinare un intero positivo k tale che 1. k divide sia n che m; 2. per ogni divisore comune h di n ed m, h divide k. Ordinamento. Dato un intero positivo n ed una sequenza di n elementi a 1,...,a n di un insieme linearmente ordinato, trovare una permutazione π di ordine n tale che a π (1),..., a π ( n ) sia una sequenza ordinata non decrescente. Cammino minimo. Date una mappa stradale che riporti località, strade e lunghezze dei percorsi, ed una coppia di località raggiungibili l una dall altra, trovare un percorso che renda minima la lunghezza. Un istanza del problema MCD è una coppia di interi: ad esempio 35, 14 ; una risposta accettabile (nel caso di MCD sempre unica) è 7. Un istanza del problema di ordinamento è 7, 5, 22, 5, con n = 4; una risposta accettabile è la permutazione: { 1a 3,2 a 1,3 a 4,4 a 2, ma anche { 1a 3,2 a 2,3 a 4,4 a 1. Analogamente con certe mappe e certe località può esistere più di un percorso di lunghezza minima. Quindi la specifica di un problema definisce una relazione R, in generale non univoca, tra istanze e risposte, descrivendo in modo preciso che cosa si considera una risposta accettabile. Un algoritmo invece è un metodo deterministico per associare risposte a istanze: se ripetuto più volte sulle stesse istanze, fornisce sempre le stesse risposte. Perciò un algoritmo calcola una funzione F dagli ingressi alle uscite, descrivendo come calcolare una risposta data una certa istanza. Se per ogni i che possa figurare come primo elemento di una coppia in R si ha che i, F(i) R, allora l algoritmo che calcola F è corretto rispetto al problema definito da R. 1

2 2. Il metodo delle asserzioni Una procedura (in C/C++ una funzione) è una realizzazione concreta o implementazione, di un algoritmo. Il problema della specifica per una procedura consiste nel definire che cosa calcoli, ossia nel determinare la funzione input-ouput ad essa associata. Un modo semplice per farlo consiste nell indicare le proprietà essenziali dell output (ma anche di eventuali variabili globali che la procedura può alterare): la post-condizione, sotto l ipotesi che valgano certe proprietà dell ingresso (ovvero delle medesime variabili globali): la pre-condizione. Esempi: int MCD(int n, int m) // pre: n, m positivi non entrambi nulli // post: ritorna k che divide sia n che m e t.c. // per ogni divisore comune h di n ed m, h divide k int Divisione (int n, int m) // pre: n 0, m > 0 // post: ritorna q, r t.c. n = m q + r, con 0 r < m void SelectSort (int v[], int n) // post: ordina distruttivamente ed in // senso non decrescente v[0..n-1] Mentre di solito si riserva il termine algoritmo ai metodi di calcolo la cui esecuzione termina in ogni istanza, una procedura può non terminare (tipicamente per un errore logico). Il criterio di correttezza per le procedure si esprime allora in due modi: Correttezza parziale. Una procedura si dice parzialmente corretta rispetto ad una specifica definita dalla pre-condizione ϕ e dalla post-condizione ψ, se ogni sua esecuzione che inizi in uno stato che rende vera ϕ e che abbia termine produce uno stato che rende vera ψ. Correttezza totale. Una procedura si dice totalmente corretta rispetto ad una specifica definita dalla pre-condizione ϕ e dalla post-condizione ψ, se ogni sua esecuzione che inizi in uno stato che rende vera ϕ termina, ed inoltre produce uno stato che rende vera ψ. dove lo stato non è che una descrizione astratta della memoria in un determinato momento del calcolo, la quale associa a tutti gli identificatori in uso (parametri attuali, variabili globali, variabili locali visibili in quel momento) i rispettivi valori. Le asserzioni furono introdotte da Floyd, e successivamente sviluppate da Hoare ed altri, nell intento sia di fornire una definizione matematicamente precisa della nozione di correttezza, che di realizzare un sistema semiautomatico di verifica dei programmi. Un asserzione è un predicato delle variabili che occorrono in una procedura (e quindi in un programma) esprimibile nella logica del primo ordine, ossia con quantificatori solo sugli individui (non si può dire: per ogni insieme di individui, o esiste una funzione, ma per ogni individuo del tale insieme o per ogni x esiste un 2

3 y così e così ). Nella formulazione di Hoare, una coppia di asserzioni ed un comando C (non importa quanto complesso, e quindi all estremo l intero corpo della procedura) formano una tripla o formula di Hoare: ϕ Cψ se l esecuzione di C iniziata in uno stato che soddisfa ϕ termina, si ottiene uno stato che soddisfa ψ In sostanza la formula di Hoare afferma che la procedura il cui corpo sia comando C è parzialmente corretta rispetto alla pre-condizione ϕ ed alla post-condizione ψ. Per dimostrare che una certa procedura soddisfa la specifica espressa dalle sue pre e post-condizioni si suddivide il comando C nelle sue parti costituenti che siano ancora dei comandi, e si intercalano asserzioni tali che sia più facile dimostrare che esse sono pre e post-condizioni valide relativamente ad un segmento del codice, per poi risalire ad una prova della validità di pre e post-condizioni dell intera procedura. Hoare ha formalizzato tutto ciò in un calcolo delle triple; più semplicemente in questa nota si ricorre alle asserzioni come commenti nel codice per poi argomentare, in modo informale, che ogni volta che il l esecuzione della procedura raggiunge un punto occupato da un asserzione, quella risulta vera dei valori che lo stato assegna agli identificatori in quel momento. Esempio: if (x 0) z = x; else // x < 0 z = -x; // z == x Sebbene possa essere utile descrivere con esattezza pre e post-condizioni di una selezione quando questa presenti molti casi o annodamenti (sottocasi), l uso più interessante è con i cicli. Limitandosi ai cicli while (condizione) comando, cui tutte le altre forme sono riconducibili, il problema consiste nel trovare un asserzione che sia vera prima di ogni possibile esecuzione del corpo (il comando che segue la condizione) dell iterazione. Esempio: void Divisione (int n, int m, int& q, int& r) // pre : n 0, m > 0 // post: n = m * q + r, 0 r < m { r = n; q = 0; while (r m) // n = m * q + r, 0 r (*) { r = r m; // r 0 q = q + 1; // r > m, n = m * q + r, 0 r Dato che n = m q + r = m ( q + 1) + r m e che se r m allora r m 0 se ne deduce che gli assegnamenti ad r e q preservano l asserzione (*). Questa asserzione, che vale trivialmente prima di 3

4 ogni iterazione, varrà anche dopo l ultima se il ciclo termina. D altra parte il ciclo termina perché r, il cui valore iniziale è n cioè un intero positivo, è decrementato progressivamente dell intero positivo non nullo m. Quando il ciclo termina la condizione r m sarà divenuta falsa: combinando la sua negazione con l asserzione (*) si ottiene esattamente la post-condizione dell intera procedura. Nota. Il codice della funzione Divisione utilizza per ritornare i due interi che formano il valore della funzione, la possibilità data dal C++ di passare parametri per riferimento: la notazione del C++: int& q equivale all uso di var q: integer nella stringa dei parametri di una procedura PASCAL. L asserzione (*) dell esempio è un caso particolare di un invariante di ciclo, che è appunto un asserzione vera prima di ogni possibile esecuzione del corpo del ciclo, e quindi anche prima e dopo l intera esecuzione dell iterazione, a meno che il test di controllo del ciclo non possa mai essere soddisfatto (e quindi il ciclo non venga mai eseguito). Osserviamo in conclusione che non esiste l invariante di un ciclo: al contrario ve n è una infinità, visto che ogni tautologia (asserzione sempre vera) è tale; è chiaro però che un invariante interessa se implica una post-condizione del ciclo che sia a sua volta utile per ragionare sul resto della procedura che contiene il ciclo, ed in ultima analisi per stabilire la validità della post-condizione dell intera procedura. 3. Uso delle asserzioni nel progetto di algoritmi iterativi Il metodo delle asserzioni comporta la formalizzazione completa delle proprietà dello stato così come trasformato dai comandi che costituiscono il corpo di una procedura (ovvero di un intero programma). Non è tuttavia plausibile in pratica che un programmatore fornisca una documentazione del risultato del proprio lavoro con un simile grado di dettaglio, né si conoscono procedure automatiche per produrla (anzi: risultati teorici della logica implicano che tali procedure non sono meccanizzabili). L uso pratico delle asserzioni è dunque più simile alla trattazione matematica di un problema, in cui si omettano sistematicamente i passaggi più semplici ma tediosi, per concentrarsi sui passi fondamentali, e si ammettano formulazioni informali (purché precise, tali cioè da essere formalizzabili in linea di principio). In particolare individuare un invariante significativo per un ciclo equivale a fornire una descrizione rigorosa dell idea su cui il ciclo si basa, ed una guida più sicura alla elaborazione dell intera procedura. Esempio Volendo ordinare un vettore v[0..n 1] di n interi supponiamo di averlo suddiviso in due parti: da 0 a i 1 supponiamo sia ordinato in senso non decrescente, mentre da i a n sia fatto di elementi ciascuno dei quali maggiorizzi tutti quelli nel semivettore v[0.. i 1]. E chiaro che questa ipotesi è soddisfatta a vuoto quando il semivettore non ordinato è l intero vettore, cioè in partenza; inoltre essa è la post-condizione di un algoritmo di ordinamento quando è il semivettore ordinato a coincidere con l intero vettore. Il problema diventa adesso quello di estendere la parte ordinata mantenendo le ipotesi sulla partizione del vettore: per far ciò basta individuare l indice del minimo in v[i.. n 1], diciamo k, e scambiare tra loro v[i] e v[k]. Il nuovo elemento in v[i] sarà così maggiore di tutti quelli in v[0.. i 1], onde v[0..i] è ordinato, e minore di tutti quelli in v[i+1.. n 1]. Quindi possiamo incrementare i di 1 conservando la verità delle ipotesi sulla partizione. In conclusione abbiamo costruito la procedura di ordinamento per selezione, (SelectSort): 4

5 void SelectSort (int v[], int n) // post: ordina distruttivamente ed in // senso non decrescente v[0..n-1] { for (int i = 0; i < n; i++) // inv. v[0..i-1] ordinato, gli el.in v[i..n-1] // maggiorizzano quelli in v[0..i-1] { int k = IndiceDelMin (v, i, n); Scambia (v[i], v[k]); dove le funzioni ausiliarie IndiceDelMin e Scambia (scritte a parte per maggior chiarezza) sono: int IndiceDelMin ( int v[], int i, int n) // pre: i < n, quindi v[i..n-1] non e vuoto // post: ritorna l indice del minimo in v[i..n-1] { int indmin = i; for(int j = i + 1; j < n; j++) if (v[j] < v[indmin]) indmin = j; return indmin; void Scambia(int& a, int& b) // post: scambia distruttivamente i valori dei par. { int temp = a; a = b; b = temp; Nota. Il C++ consente la dichiarazione di variabili anche all interno di un blocco (delimitato da { e ) ovvero nel campo di inizializzazione di una clausola for. Visibilità e persistenza sono limitati al blocco, con eventuale oscuramento di variabili con lo stesso nome dichiarate fuori del blocco. L uso più frequente degli invarianti nel disegno di algoritmi iterativi è quando questi si basano sull uso di un accumulatore. Un accumulatore è una o più variabili il cui valore rappresenta l approssimazione corrente di ciò che un ciclo calcola in modo incrementale. Esempi. int Moltiplicazione (int x, int n) // Pre: n intero positivo // Post: ritorna x n { int z = 0, y = n; while (y > 0) // inv. x n = z + x y { z = z + x; y = y - 1; return z; La funzione implementa la moltiplicazione di interi positivi come iterazione della somma. L accumulatore z vale alla i-esima iterazione x i ; la variabile y è un contatore, ossia una variabile il cui incremento/decremento controlla il numero delle iterazioni. Si osservi come l invariante non sia altro che la descrizione della relazione tra valori in ingresso, accumulatore e contatore. 5

6 Nel caso della funzione Divisione, gli accumulatori sono le variabili q ed r, inoltre r è un contatore; anche qui l invariante descrive la relazione tra ingressi, accumulatori e contatore. Per valutare un polinomio di grado n a coefficienti razionali in un punto x si può procedere in modo ovvio: double ValutaPolinomio ( double coeff[], int grado, double x) // pre : il polinomio e rappresentato col vettore // coeff[0..grado] dei suoi coefficienti // post: ritorna il valore del polinomio in x { double y =1, z = coeff[0]; for ( int i = 1; i < grado + 1; i++) // inv. y == x^(i-1), // z == coeff[0] + coeff[1] * x +... // + coeff[i-1] * x^(i-1) { y = y * x; z = z + coeff[i]*y; return z; Tuttavia, se associamo il polinomio secondo la cosiddetta formula di Horner: p ( x) = a + x( a x( a n 1 + xa 0 n allora otteniamo un algoritmo che minimizza il numero delle moltiplicazioni. La sua realizzazione si basa sull uso di un accumulatore che determina l invariante: ))...) z = a a x i+ 1 + i a n x n ( i+ 1) dove i si riferisce alla i-esima iterazione. A partire questo invariante costruiamo la procedura: double Horner (double coeff[], int grado, double x) // pre : il polinomio e rappresentato col vettore // coeff[0..grado] dei suoi coefficienti // post: ritorna il valore del polinomio in x { double z = coeff[grado]; for(int i = grado - 1; i >= 0; i--) // inv. z == coeff[i+1] + coeff[i+2] * x +... // + coeff[grado] * x^(grado-(i+1)) z = z * x + coeff[i]; return z; 6