TALEN EN CORRECTHEID

Transcriptie

1 TALEN EN CORRECTHEID Syllabus Februari 2004 Prof. dr. D. Janssens 1

2 Algemene Doelstellingen Formeel redeneren over programma s en specificaties: Wat betekent het te zeggen dat een programma correct is? Hoe kan men dat bewijzen? Inzicht verwerven in de semantiek van programma s en programmeertalen, en van de methoden die daarbij gebruikt worden. Definitie van een operationele semantiek op basis van de syntax. Modelleren van softwaresystemen. Om met enige precisie eigenschappen van programma s te kunnen formuleren, en zeker om ze te kunnen bewijzen, is het nodig formele modellen te bouwen van de programma s en hun uitvoering. Handboek (eerste deel) - K. Apt, E.-R. Olderog, Verification of Sequential and Concurrent Programs, Springer-Verlag,

3 Overzicht 1. Programma-logica voor deterministische, sequentiële programma s: operationele semantiek, pre- en postcondities, invarianten van loops. 2. Een model voor concurrente systemen: Petri nets en varianten, typische problemen. Zie ook 3. Modellen voor het ontwerp van software: UML klassediagrammen en message sequence charts. 3

4 1. Programma-logica In dit eerste deel geven we een inleiding in de logica voor programma s, gebaseerd op het werk van T. Hoare (men noemt deze aanpak dan ook vaak Hoare-logica). De fundamentele idee bestaat erin te werken met specificaties die bestaan uit een pre- en een postconditie. Die specificaties kunnen dan al dan niet bewezen worden binnen een bewijssysteem dat op zijn beurt afgeleid wordt uit de gebruikte programmeertaal. We beperken ons tot eenvoudige deterministische, sequentiële programma s, maar de benadering is ook uitgewerkt voor meer algemene talen, met constructies voor parallellisme. Deterministisch: elke configuratie heeft ten hoogste één opvolger-configuratie. Sequentieel: de stappen zijn lineair geordend in de tijd. 4

5 1.1. Syntax We bekijken in dit deel een zeer eenvoudige taal met volgende syntax: S ::= skip u := t S 1 ; S 2 if B then S 1 else S 2 fi while B do S 1 od Hierin is u een simpele of geïndexeerde variabele, t een expressie en B een booleaanse expressie (zie verder). Er zijn twee primitieve instructies, skip en assignment, en drie manieren om daarmee samenstellingen te maken. 5

6 Declaraties laten we buiten beschouwing, de types van de expressies zijn impliciet. if B then S 1 fi staat voor if B then S 1 else skip fi. skip en assignment zijn de primitieve instructies. Een subprogramma van S is een substring van S die zelf een programma is, bv. x := x 1 is een subprogramma van if x = 0 then y := 1 else y := y x; x := x 1 fi. 6

7 Gebruikte gegeventypes: integer boolean T 1 T n T (functie- of hoger type). Bij elk type hoort een domein: de verzameling van alle mogelijke waarden van dat type. Variabelen: getypeerd - elke variabele heeft een welbepaald type simpel of array array: bv. IN IN IN of {i k i l} IN Het type van een array variabele is dus een hoger type. Constanten: elke constante heeft een type (basistype of hoger type) beschikbaar zijn een aantal standaardsymbolen zoals (integer integer), + (integer integer integer), (Boolean Boolean), enz. Dit zijn dus telkens constanten van een hoger type. Als het resultaattype Boolean is, dan spreken we van relatiesymbolen. 7

8 Expressies worden gevormd met behulp van de constanten en variabelen: een simpele variabele van type T is een expressie van type T een constante van basistype T is een expressie van type T als s 1,..., s n expressies zijn van type T 1,..., T n, en op is een constante van type T 1 T n T, dan is op(s 1,..., s n ) een expressie van type T als s 1,..., s n expressies zijn van type T 1,..., T n, en a is een array variabele van type T 1 T n T, dan is a[s 1,...,s n ] een expressie van type T als B een booleaanse expressie is en s 1, s 2 zijn expressies van type T, dan is if B then s 1 elses 2 fi een expressie van type T als s een expressie is van type T, dan is (s) ook een expressie van type T. Een expressie van de vorm a[s 1..., s n ] heet een geïndexeerde variabele. 8

9 Voorbeeld: Als B een booleaanse expressie is, x een integer variabele, found een booleaanse variabele en a een array van type integer boolean boolean, dan is if B a[x + 1, found] then 5 else 7 fi een expressie van type integer. 9

10 1.2. Eigenschappen en specificaties De eigenschappen die ons het meest interesseren zijn gewoonlijk niet zozeer eigenschappen die te maken hebben met de structuur van een programma, als wel eigenschappen die te maken hebben met het gedrag ervan, d.w.z. met de mogelijke uitvoeringen. Sequentiële programma s: 1. De afgeleverde resultaten moeten juist zijn, bv. wanneer een sorteerprogramma stopt, dan moet de invoer inderdaad gesorteerd zijn. 2. Terminatie: van veel programma s verwacht men dat ze, voor elke mogelijke invoer, na een eindig aantal stappen stoppen. 3. Vermijden van fout-situaties: delen door nul, buiten de grenzen van een array gaan, enz. Concurrente programma s: 4. Beheer van gemeenschappelijke resources, vermijden van deadlock. 5. Synchronizatie. 6. Correctheid van (enkel) faire uitvoeringen. 10

11 We zullen ons beperken tot het zgn. verificatieprobleem: Wanneer voldoet een programma P aan een gegeven specificatie Spec? Met een specificatie is hier een eigenschap bedoeld van de uitvoeringen van het programma P; deze eigenschap drukt uit wat van het programma P verwacht wordt. Aanverwante problemen: Syntheseprobleem: schrijf P voor een gegeven Spec. Analyseprobleem: schrijf Spec voor een gegeven P. Optimizatieprobleem: voor gegeven P en Spec, waar P voldoet aan Spec, vind een P die beter is dan P, en die ook voldoet aan Spec. Correctieprobleem: voor gegeven gegeven P en Spec, waar P niet voldoet aan Spec, vind een P die wel voldoet aan Spec en die niet al te veel verschilt van P. 11

12 Om te kunnen definiëren wat een specificatie juist is moet de betekenis van een programma formeel gedefinieerd zijn; we moeten dus precies maken wat we bedoelen met de uitvoeringen van P. Dit gebeurt natuurlijk niet op het niveau van individuele programma s, maar op het niveau van de programmeertaal: de semantiek van de programmeertaal moet vastgelegd worden. Daarvoor bestaan er verschillende methoden: denotationele semantiek (structurele inductie op programma s) en operationele semantiek (regels voor transities tussen configuraties). Wij zullen deze laatste methode gebruiken. 12

13 1.3. Een eenvoudig geval: deterministische eindige automaten Een deterministische eindige automaat (DFA) met een gegeven input kan beschouwd worden als een machine die een eenvoudig programma uitvoert. Het lezen van een letter a kan geïnterpreteerd worden als het uitvoeren van een instructie a, met als effect een toestandsverandering. Neem bv, als alfabet {a, b, c} en als taal L de verzameling van alle woorden waarin de combinatie bc niet voorkomt. Beschouw de DFA M van Figuur??: de begintoestand is q 1, acceptatietoestanden zijn q 1 en q 2. a, c b a, b, c b c a Figuur 1: een DFA M moet de taal L accepteren, en dat kunnen we formuleren als volgt: 13

14 Als w L, dan zal de verwerking van het woord w, vertrekkend van de begintoestand, eindigen in een acceptatietoestand. Als w / L, dan zal de verwerking van het woord w, vertrekkend van de begintoestand eindigen in een toestand die geen acceptatietoestand is. 14

15 De verwerking van het woord w of uitvoering van w wordt gedefinieerd door middel van configuraties en stappen tussen die configuraties. Een configuratie van een DFA is een paar (q, w) waar q een toestand is en w het nog te verwerken woord. Er is een stap (of transitie) d.e.s.d wanneer δ(q, a) = q. (q, aw) (q, w) Met behulp van deze begrippen is het mogelijk formeel te bewijzen dat L inderdaad de taal is die geaccepteerd wordt door M. 15

16 1.4. Toestanden (states) De waarde van expressies ligt maar vast als aan de variabelen een waarde toegekend wordt. Zo een toekenning, die uiteraard compatibel moet zijn met de typering, noemen we een eigenlijke toestand (proper state). Een eigenlijke toestand is dus een functie van de variabelen naar de unie van de domeinen. Met σ(t)noteren we de waarde van de expressie t in toestand σ. Voor een booleaanse expressie B noteren we σ = B als B waar is in toestand σ ( σ maakt B waar ). Later zullen we ook oneigenlijke toestanden invoeren, zoals. Als er geen kans is op verwarring spreken we vaak over toestanden als we eigenlijke toestanden bedoelen. We zullen gewoonlijk σ of τ gebruiken om toestanden aan te duiden. Σ is de verzameling van eigenlijke toestanden. 16

17 1.5. Operationele semantiek Een informele beschrijving van de werking van programma s volstaat niet om alle dubbelzinnigheid te vermijden. Daarom geven we een formele definitie van de semantiek van een programma S. Dat is een functie: M[[S]] : Σ states. die gedefinieerd wordt met behulp van configuraties en stappen, in de stijl van wat ook gebeurt bij eindige automaten en Turing machines. Naast de eigenlijke toestanden is er nog een speciale toestand die zal staan voor divergentie (oneindige berekening), dus er geldt states = Σ { }. Configuraties zijn koppels S, σ, waar S staat voor het nog uit te voeren programma en σ voor een eigenlijke toestand. Een eindconfiguratie is een configuratie van de vorm E, σ, waar E staat voor het lege programma, dus E; S = S = S; E. Net zoals we dat gedaan hebben voor automaten en Turing machines, gaan we een stap(of transitie)- relatie definïeren tussen de configuraties: S, σ R, τ 17

18 Er zijn oneindig veel mogelijke toestanden, dus we kunnen de mogelijke stappen niet zomaar opsommen. We bekijken eerst het effect van de enige niet-triviale instructie, nl. de assignment. Een assignment zal een toestand σ wijzigen in één variabele u, en aan die variabele een nieuwe waarde d toekennen. De zo bekomen toestand noteren we met σ[u := d] (update of variant van σ). Formeel: laat σ een eigenlijke toestand zijn, u een variabele van type T en d een waarde van type T. - Als u een simpele variabele is, dan is σ[u := d] de toestand die overeenkomt met σ, behalve dat aan u de waarde d wordt toegekend. - Als u van de vorm a[t 1,...,t n ] is, dan is σ[u := d] de toestand die overeenkomt met σ, behalve dat aan a(σ(t 1 ),...,σ(t n )) de waarde d wordt toegekend. 18

19 Men kan nu de transities bepalen door volgende regels (Hennessy - Plotkin). De eerste twee regels leggen rechtstreeks vast wat er gebeurt bij uitvoering van skip en assignment, de derde drukt het effect van de concatenatie ; uit door aan te geven hoe uit een transitie voor het programma S 1 een transitie voor het programma S 1 ; S kan afgeleid worden. 1. skip, σ E, σ 2. u := t, σ E, σ[u := σ(t)] 3. S 1, σ S 2, τ S 1 ; S, σ S 2 ; S, τ 4. if B then S 1 else S 2 fi, σ S 1, σ, wanneer σ = B 5. if B then S 1 else S 2 fi, σ S 2, σ, wanneer σ = B 6. while B do S od, σ S;while B do S od, σ, wanneer σ = B 7. while B do S od, σ E, σ, wanneer σ = B 19

20 Dit is een hoog niveau beschrijving: skip, assignment en de evaluatie van expressies gebeuren in één stap. Een meer gedetailleerde beschrijving zou bv. kunnen aangeven in welke stappen expressies geëvalueerd worden. Met behulp van de transitie-relatie kunnen we nu het begrip berekening definiëren. Neem een programma S en een eigenlijke toestand σ. Een transitie-rij van S, startend van σ, is een eindige of oneindige rij configuraties S i, σ i, i 0, zo dat S, σ = S 0, σ 0 S 1, σ 1... S i, σ i... Een berekening van S, startend van σ, is een maximale transitie-rij van S, startend van σ. Een berekening van S eindigt in τ als ze eindig is en de laatste configuratie is E, τ. Een berekening divergeert als ze oneindig is. is de transitieve en reflexieve sluiting van. 20

21 Opmerkingen Voor een deterministisch programma S en een eigenlijke toestand σ is er steeds juist één berekening die start van σ. Zeggen dat S kan divergeren vanaf σ betekent dus hetzelfde als zeggen dat S divergeert vanaf σ. Als S E en σ is een eigenlijke toestand, dan bestaat er altijd een opvolger-configuratie voor S, σ. 21

22 Definitie van de semantische functies M[[S]] en M tot [[S]](σ) We kunnen nu uiteindelijk de functie M[[S]] definiëren. Er zijn twee varianten, die enkel verschillen in de manier waarop divergentie in rekening gebracht wordt. We komen later terug op het verschil tussen partiële en totale correctheid. Laat S een deterministisch programma zijn. De partiële correctheids - semantiek van S is de functie M[[S]] gedefiniëerd door: M[[S]](σ) = {τ S, σ E, τ }. De totale correctheids - semantiek van S is de functie M tot [[S]] gedefiniëerd door: M tot [[S]](σ) = M[[S]](σ) { S kan divergeren vanaf σ}. M[[S]](σ) bevat dus ten hoogste één element, en M tot [[S]](σ) bevat altijd precies één element. 22

23 Voorbeeld: Laat S het volgende programma zijn, a[0] := 1;a[1] := 0;while a[x] 0 do x := x + 1 od laat σ een toestand zijn met σ(x) = 0, en laat σ de toestand σ[a[0] := 1][a[1] := 0] zijn. Dan geldt: S, σ a[1] := 0;while a[x] 0 do x := x + 1 od, σ[a[0] := 1] while a[x] 0 do x := x + 1 od, σ x := x + 1;while a[x] 0 do x := x + 1 od, σ while a[x] 0 do x := x + 1 od, σ [x := 1] E, σ [x := 1] Dus S stopt na 5 stappen vanaf σ, en M[[S]](σ) = M tot [[S]](σ) = {σ [x := 1]}. 23

24 Neem hetzelfde programma S en laat τ een toestand zijn met τ(x) = 2, τ(a[i]) = 1 voor 2 i en laat τ de toestand τ[a[0] := 1][a[1] := 0] zijn. Dan is de berekening van S vertrekkend van τ: S, τ a[1] := 0;while a[x] 0 do x := x + 1 od, τ[a[0] := 1] while a[x] 0 do x := x + 1 od, τ x := x + 1;while a[x] 0 do x := x + 1 od, τ while a[x] 0 do x := x + 1 od, τ [x := τ(x) + 1] while a[x] 0 do x := x + 1 od, τ [x := τ(x) + k] Dus S divergeert vanaf τ, en M[[S]](τ) =, M tot [[S]](τ) = { }. 24

25 We breiden M en M tot uit tot Σ { } door te stellen: M[[S]]( ) = en M tot [[S]]( ) = { }. Verder breiden we M en M tot uit tot verzamelingen van toestanden door te stellen, voor elke X Σ { }: N[[S]](X) = σ X N[[S]](σ), Waar N staat voor hetzij M, hetzij M tot. 25

26 1.6. State- en Correctheids-asserties We hebben nu gedefinieerd wat berekeningen zijn, en bekijken nu welke eigenschappen daarven gebruikt worden om te spreken over de correctheid van programma s. We definieren eerst zgn. state-asserties, dat zijn uitspraken over toestanden. Daarmee worden zgn correctheidsasserties gevormd, die in essentie bestaan uit twee stateasserties, die gebruikt worden als pre-en als postconditie. Correctheids-asserties zijn van de vorm {p} S {q} Dit is een uitspraak over het programma S: als een berekening van S begint in een toestand waarin p geldt, dan kan S enkel kan stoppen in een toestand waarin q geldt. Een correctheids-assertie kan dus gezien worden als een soort contract: q wordt gegarandeerd na afloop op voorwaarde dat p geldt vooraf. Er zijn twee varianten in de interpretatie van correctheidsasserties: zgn partiële en totale correctheid. Ze verschillen in de manier waarop divergentie in rekening gebracht wordt. 26

27 State Asserties State asserties worden gebouwd volgens volgende regels. een booleaanse expressie is een assertie als p en q asserties zijn, dan zijn p, p q, p q, p q en p q dat ook als x een simpele variabele is en p een assertie, dan zijn x : p en x : p ook asserties als p een assertie is, dan is (p) dat ook. Opmerkingen Er wordt dus niet gekwantificeerd over geïndexeerde variabelen. σ = p betekent: p geldt in toestand σ. Gebonden vs. vrije variabelen: f ree(p) is de verz. van vrije variabelen in p. Gebruik de gewone prioriteitsregels om haakjes uit te sparen. 27

28 Correctheids-asserties Vorm: {p}s{q}, waar p en q state-asserties zijn, en S een programma. p heet de preconditie en q de postconditie. Partiële correctheid: {p}s{q} geldt in de zin van partiële correctheid als voor elke eindige berekening S 0, σ 0 S 1, σ 1... S n, σ n zo dat σ 0 = p, geldt dat σ n = q. Dit kan men ook schrijven als M[[S]]([[p]]) [[q]], waar, voor een state assertie r, Dit impliceert / [[r]]. [[r]] = {σ Σ σ = r}. De uitspraak {p}s{q} geldt in de zin van partiële correctheid wordt kortweg genoteerd als = {p}s{q}. 28

29 Totale correctheid: {p}s{q} geldt in de zin van totale correctheid als voor elke berekening b, startend van een toestand σ met σ = p, b eindigt in een toestand τ met τ = q. Dit kan men ook schrijven als M tot [[S]]([[p]]) [[q]]. De preconditie p garandeert nu dus dat de berekening niet divergeert. De uitspraak {p}s{q} geldt in de zin van totale correctheid wordt kortweg genoteerd als = tot {p}s{q}. 29

30 1.7. Redeneren met correctheids-asserties Voorbeeld Te bewijzen: {x = y} x := x + 1; y := y + 1 {x = y} Voor het tweede assignment geldt: {x = y + 1} y := y + 1 {x = y} en voor het eerste assignment: {x + 1 = y + 1} x := x + 1 {x = y + 1}. Aangezien x = y impliceert dat x + 1 = y + 1, mogen we besluiten dat {x = y} x := x + 1; y := y + 1 {x = y} inderdaad geldt. Aangezien het programma duidelijk nooit kan divergeren, geldt de assertie zowel in de zin van partiële correctheid als in de zin van totale correctheid. 30

31 Voorbeeld: gehele deling Beschouw het programma DIV : quo := 0; rem := x; while rem y do rem := rem y; quo := quo + 1 od We wensen aan te tonen: als x en y niet-negatieve gehele getallen zijn en DIV stopt, dan is quo het gehele quotiënt en rem de rest van de deling van x door y. We kunnen dit uitdrukken met de volgende correctheidsformule (partiële correctheid): {x 0 y 0} DIV {quo y+rem = x 0 rem < y}. Merk op dat deze formule uitdrukt wat we willen hebben omdat de waarden van x en y door het programma DIV niet veranderd worden; voor het programma geldt ook T x := 0; y := 1; quo := 0; rem := 0 {x 0 y 0} T {quo y+rem = x 0 rem < y}, maar het is natuurlijk geen correct programma voor de gehele deling. 31

32 Over de assignments kunnen we grosso modo redeneren als in het vorige voorbeeld, maar voor de while-loop hebben we een andere methode nodig. Die bestaat erin op zoek te gaan naar een bruikbare invariant, d.w.z. een assertie die door de body van de loop bewaard wordt: als de invariant waar is bij het begin van de uitvoering van de body, dan is hij ook waar na de uitvoering. Bovendien moet de invariant natuurlijk voldoende relevant zijn om de redenering voor het hele programma erop te kunnen baseren. Het vinden van een goede invariant vergt in het algemeen enig inzicht in de werking van het programma. In dit geval is volgende assertie p een bruikbare invariant: p quo y + rem = x 0 rem. 32

33 Het eerste deel van p, quo y + rem = x, blijft waar na uitvoering van rem := rem y; quo := quo + 1, en aangezien we de body van de while-lus maar uitvoeren als rem y, blijft ook het tweede deel 0 rem waar. Om de redenering te vervolledigen volstaat het aan te tonen dat {x 0 y 0} quo := 0; rem := 0 {p} en in te zien dat op het eind van een eindige berekening geldt dat (rem y), omdat pas dan de loop verlaten wordt, wat samen met p de gevraagde postconditie oplevert. 33

34 We zullen nu aantonen dat de bewijzen gegeven kunnen worden door toepassing van precies vastgelegde bewijsregels: we maken een logisch bewijssysteem voor de correctheids-asserties. Gebruik van een logisch bewijssysteem T met taal L(T): In de formele taal L(T) kunnen beweringen over programma s uitgedrukt worden (bv correctheids-asserties). L(T) kan gezien worden als een specificatietaal. T bestaat uit axioma s (of axiomaschema s) en afleidingsregels. Om een eigenschap p te bewijzen voor een programma S: - druk p uit in de taal L(T) als een formule φ - toon aan dat φ een stelling van T is. De uitspraak φ kan afgeleid worden in G wordt afgekort als G φ 34

35 De regel voor assignment Welk verband moet er zijn tussen p en q om een ware correctheids-assertie te verkrijgen van de vorm {p} u := t {q}? Het blijkt het eenvoudigst te zijn om de redenering te beginnen vanaf q: Als q iets zegt over u, en q is geldig na afloop van het assignment, dan moet diezelfde uitspraak vooraf gegolden hebben voor t. Dus alle correctheidsasserties van volgende vorm zijn geldig: {p[u := t]}u := t{p} Daarin staat de uitdrukking p[u := t] voor de uitdrukking, bekomen uit p door u erin te vervangen(substitueren) door de expressie t. Zolang er geen array-variabelen in t voorkomen, is substitutie een vrij eenvoudige operatie; we komen hier verder op terug. 35

36 voorbeelden De eerder vermelde asserties {x = y + 1} y := y + 1 {x = y} en {x + 1 = y + 1} x := x + 1 {x = y + 1} zijn duidelijk van deze vorm. Deze regel voor assignment is een zgn. axioma-schema: een mogelijk oneindige verzameling van uitspraken die als geldig aangenomen worden. Dit in tegenstelling tot een afleidingsregel, waarbij uit een of meer uitspraken een andere uitspraak wordt afgeleid. 36

37 De regel voor while - loops Bekijk een programma van de vorm while B do S od Hier maken we gebruik van een invariant p: als, voor de body S, de preconditie p B de postconditie p garandeert (m.a.w. S bewaart p op voorwaarde dat B geldt), dan garandeert, voor de hele loop, de preconditie p de postconditie p B. De regel wordt dus: {p B}S{p} {p} while B do S od {p B} Dit is dus wel een afleidingsregel: uit een correctheidsassertie voor S leiden we een correctheids-assertie af voor while B do S od 37

38 1.8 Het bewijssysteem PD (partiële correctheid) 1. skip 2. assignment {p}skip{p} {p[u := t]}u := t{p} 3. compositie 4. conditional 5. loop 6. consequence {p}s 1 {r}, {r}s 2 {q} {p}s 1 ; S 2 {q} {p B}S 1 {q}, {p B}S 2 {q} {p} if B then S 1 else S 2 fi {q} {p B}S{p} {p} while B do S od {p B} p p 1, {p 1 }S{q 1 }, q 1 q {p}s{q} 38

39 Substitutie: expressies Substitutie van een expressie t voor een niet-geïndexeerde variabele u in een expressie s: s[u := t] is de expressie die ontstaat door in s overal u te vervangen door t. Voor geïndexeerde variabelen is de situatie wat complexer: a[1][a[1] := 2] 2 en maar wat met a[0][a[1] := 2] a[0] a[x][a[1] := 2] waar x een variabele is? Voor de hand ligt a[x][a[1] := 2] if x = 1 then 2 else a[x] fi. 39

40 Analoog, voor een integer expressie s: a[s][a[1] := 2] if s = 1 then 2 else a[s] fi maar als a zelf voorkomt in s volstaat dat niet, en moet de substitutie inductief ook op s toegepast worden, en komt er a[s][a[1] := 2] if s[a[1] := 2] = 1 then 2 else a[s[a[1] := 2]] fi Formeel wordt de substitutie in expressies gedefinieerd per inductie op de structuur van een expressie: als s een simpele variabele is: s[u := t] t if s u s otherwise als s een constante is van een basistype: s[u := t] s 40

41 als s op(s 1,..., s n ), voor een constante op van hoger type: s[u := t] op(s 1 [u := t],..., s n [u := t]) als s a[s 1,..., s n ], voor een array a, en u is ofwel een simpele variabele ofwel van de vorm b[t 1,..., t n ] met a b: s[u := t] a[s 1 [u := t],...,s n [u := t]] als s a[s 1,..., s n ], voor een array a, en u a[t 1,..., t n ]: s[u := t] if n i=1 s i [u := t] = t i then t else a[s 1 [u := t],..., s n [u := t]] fi als s if B then s 1 else s 2 fi: s[u := t] if B[u := t] then s 1 [u := t] else s 2 [u := t] fi als s (s 1 ): s[u := t] (s 1 [u := t]) 41

42 Substitutie: voorbeelden Laat a en b arrays zijn van type integer integer en laat x een integer variabele zijn. Dan en a[a[x]] [b[1] := 2] a[a[x] [b[1] := 2]] a[a[x [b[1] := 2]]] a[a[x]] a[a[x]] [a[1] := 2] if a[x] [a[1] := 2] = 1 then 2 else a[a[x] [a[1] := 2]] fi if if x = 1 then 2 else a[x] fi = 1 then 2 else a[if x = 1 then 2 else a[x] fi] fi 42

43 Substitutie in asserties p is een booleaanse expressie: p[u := t] s[u := t] p q: p[u := t] (q[u := t]) p q r: p[u := t] q[u := t] r[u := t] en analoog voor, en, p x : q: p[u := t] y : q[x := y][u := t] waar y van hetzelfde type is als x en niet voorkomt in p, t of u. Analoog voor. p (q): p[u := t] (q[u := t]) 43

44 Substitutielemma Laat p een assertie zijn, s en t expressies, u een simpele of geïndexeerde variabele van hetzelfde type als t, en laat σ een eigenlijke toestand zijn. Dan geldt: 1. σ(s[u := t]) = σ[u := σ(t)](s). 2. σ = p[u := t] d.e.s.d. als σ[u := σ(t)] = p. De operaties update van een toestand en substitutie in een assertie zijn dus nauw met elkaar verbonden. 44

45 1.9 Voorbeeld: gehele deling, met PD Beschouw weer het programma DIV : quo := 0; rem := x; while rem y do rem := rem y; quo := quo + 1 od We moeten volgende correctheids-assertie bewijzen met PD: {x 0 y 0} DIV {quo y+rem = x 0 rem < y}. Met andere woorden, we moeten deze formule afleiden door enkel gebruik te maken van de axiomaschema s en afleidingsregels van PD. 45

46 We kiezen als loop-invariant p de uitspraak p quo y + rem = x 0 rem. Als we de volgende twee formules kunnen afleiden zijn we klaar: {x 0 y 0} quo := 0; rem := x {p} (1) {p rem y} rem := rem y; quo := quo+1 {p} (2) want een toepassing van de loop-regel op (2) levert {p} S 0 {p (rem y)}, (3) met de compositie-regel kunnen we (1) en (3) combineren tot en omdat {x 0 y 0} DIV {p (rem y)} (4) (p (rem y)) (quo y+rem = x 0 rem < y) levert de consequence-regel, toegepast op (4), de gevraagde correctheidsformule. 46

47 bewijs van (1): Twee toepassingen van de assignment-regel leveren {quo y + x = x 0 x} rem := x {p} en {0 y+x = x 0 x} quo := 0 {quo y+x = x 0 x}, de compositieregel geeft dus {0 y + x = x 0 x} quo := 0; rem := x {p} en aangezien (x 0 y 0) (0 y +x = x 0 x) levert de consequence-regel de formule (1). 47

48 bewijs van (2): Twee toepassingen van de assignment-regel leveren {(quo+1) y+rem = x 0 rem} quo := quo+1 {p} en {(quo + 1) y + (rem y) = x 0 (rem y)} rem := rem y {(quo + 1) y + rem = x 0 rem} De compositie-regel geeft dus {(quo + 1) y + (rem y) = x 0 (rem y)} rem := rem y; quo := quo + 1 {p} en aangezien (p rem y) ((quo+1) y+(rem y) = x 0 (rem y)) levert de consequence-regel de gewenste formule (2). 48

49 1.10 Het bewijssysteem TD (totale correctheid) Het verschil met partiële correctheid bestaat erin dat de preconditie nu moet garanderen dat de berekening stopt. Het ligt voor de hand dat we vooral aandacht moeten besteden aan de while-lussen, want dat is de enige instructie die divergentie kan veroorzaken. Het stoppen van een while-lus is gegarandeerd als men een expressie kan vinden waarvan de waarde steeds een geheel getal is, waarvan de waarde bij elke uitvoering van de body van de lus (strict) vermindert, maar waarvan de waarde toch nooit negatief kan worden. De waarde van zo een expressie bij het begin van de uitvoering geeft dan immers een bovengrens voor het aantal keren dat de lus doorlopen kan worden. 49

50 Bewijssysteem TD voor totale correctheid: behoud alle regels van PD, maar vervang de loop regel door {p B}S{p} {p B t = z}s{t < z} p t 0 {p} while B do S od {p B} waar t een integer expressie is, en z een integer variabele die niet voorkomt in p, B, t of S. t noemt men vaak een gebonden functie van de loop. Doordat z niet voorkomt in S, zegt de tweede premisse dat de waarde van t strict kleiner wordt door een uitvoering van S (vertrekkend vanaf een toestand waarin p B geldt). Merk ook op dat het volstaat dat t niet-negatief blijft wanneer p geldt. 50

51 Voorbeeld: gehele deling Beschouw weer het programma DIV. We bewijzen nu de volgende correctheidsformule: {x 0 y > 0} DIV {quo y+rem = x 0 rem < y}, dus het geval y = 0 wordt nu uitgesloten in de preconditie. Als loop-invariant nemen we p p y > 0, waar zoals in het vorige voorbeeld p quo y + rem = x 0 rem en we kiezen voor t: t rem. 51

52 We moeten de volgende formules bewijzen: {x 0 y > 0} quo := 0; rem := x {p } (1) en de 3 premissen voor de loop-regel van TD: {p rem y} rem := rem y; quo := quo + 1 {p } (2) {p rem y rem = z} rem := rem y; quo := quo + 1 {rem < z} (3) p rem 0 (4) Dan volgt immers uit de loop-regel voor TD dat {p }S 0 {p (rem y)}, verder, met (1) en de compositie-regel, dat {x 0 y > 0} DIV {p (rem y)}, en wegens (p (rem y)) (quo y+rem = x 0 rem < y) en de consequence-regel volgt dan de gewenste formule. 52

53 (1) en (2) kunnen op dezelfde manier worden bewezen als in het vorige voorbeeld, en (4) is een geldige uitspraak over de integers. Er blijft dus enkel (3) te bewijzen. Twee toepassingen van de assignment-regel geven: {rem < z} quo := quo + 1 {rem < z}, {rem y < z} rem := rem y {rem < z}. (3) volgt nu uit de consequence-regel en (p rem y rem = z) ((rem y) < z) (want p impliceert y > 0). 53

54 1.11 Gezondheid (Soundness) We zeggen dat een bewijssyssteem G gezond is voor partiële correctheid van programma s wanneer voor elke correctheidsformule {p}s{q} geldt: als G {p}s{q} dan = {p}s{q}. G is gezond voor totale correctheid van programma s wanneer voor elke correctheidsformule {p}s{q} geldt: als G {p}s{q} dan = tot {p}s{q}. Vrij vertaald, men mag in G geen onzin kunnen afleiden. Stelling. PD is gezond voor partiële correctheid van programma s en TD is gezond voor totale correctheid van programma s. 54

55 Hoe bewijs je dat? Het volstaat om te redeneren over de axioma s en de afleidingsregels afzonderlijk. Een afleidingsregel φ 1,...,φ k φ k+1 is gezond voor partiële correctheid wanneer uit = φ 1,..., = φ k volgt dat = φ k+1, en analoog voor totale correctheid en = tot. We geven eerst het bewijs voor PD (dus met M en =). 55

56 skip: er geldt, voor elke assertie p, M[[skip]]([[p]]) = [[p]] en dus is het skip-axioma waar. assignment: volgens regel 2 van de operationele semantiek ( ), als M[[u := t]](σ) = {τ}, dan τ = σ[u := σ(t)], en wegens het substitutielemma geldt: Bijgevolg σ = p[u := t] d.e.s.d. als τ = p. M[[u := t]]([[p[u := t]]]) [[p]], dus ook het assignment-axioma is waar - of preciezer, alle instantiaties van het axiomaschema voor assignment zijn waar. 56

57 Voor compositie, conditional en consequence hebben we een paar eigenschappen van M nodig: 1. M[[S]] is monotoon; d.w.z. voor elke X, Y met X Y Σ { } geldt dat M[[S]](X) M[[S]](Y ). 2. M[[S 1 ; S 2 ]](X) = M[[S 2 ]](M[[S 1 ]](X)). 3. M[[(S 1 ; S 2 ); S 3 ]](X) = M[[S 1 ; (S 2 ; S 3 )]](X). 4. M[[if B then S 1 else S 2 fi]](x) = M[[S 1 ]](X [[B]]) M[[S 2 ]](X [[ B]]). Merk op dat deze eigenschappen ook gelden voor M tot. 57

58 compositie: veronderstel dat M[[S 1 ]]([[p]]) [[r]] en M[[S 2 ]]([[r]]) [[q]]. Dan volgt uit de eigenschappen van M dat M[[S 1 ; S 2 ]]([[p]]) = M[[S 2 ]](M[[S 1 ]]([[p]])) M[[S 2 ]]([[r]]) [[q]]. Dus de compositieregel is gezond. conditional en consequence: in grote lijnen zoals de compositieregel. 58

59 Voor het laatste geval, loop, is er nog een extra constructie nodig. Ze komt erop neer dat we het programma while B do S od benaderen door een rij van programma s (while B do S od) k, hoe groter k, hoe beter de benadering. 59

60 Constructie: laat Ω een programma zijn dat vanaf om het even welke toestand divergeert, bv. Ω while true do skip od. Dan wordt, voor elk natuurlijk getal k, het programma (while B do S od) k inductief gedefinieerd door:: (while B do S od) 0 = Ω, (while B do S od) k+1 = if B then S; (while B do S od) k else skip fi. Dan geldt de volgende eigenschap: M[[while B do S od]] = k=0m[[(while B do S od) k ]]. Hiermee kunnen we nu aantonen dat ook de loop-regel gezond is. 60

61 loop, voor PD: veronderstel dat, voor een assertie p, M[[S]]([[p B]]) [[p]]. We bewijzen per inductie dat, voor k 0, M[[(while B do S od) k ]]([[p]]) [[p B]]. dan volgt k=0 en omdat M[[(while B do S od) k ]]([[p]]) [[p B]] M[[while B do S od]] = k=0 M[[(while B do S od) k ]] volgt dan dat M[[while B do S od]]([[p]]) [[p B]], en dus is de loop-regel voor PD gezond. 61

62 Het inductiebewijs gaat als volgt. Basisgeval: voor k = 0 geldt de uitspraak, want M[[Ω]]([[p]]) =. Inductiestap: stel dat de uitspraak geldt voor k 0. Dan geldt M[[(while B do S od) k+1 ]]([[p]]) = M[[if B then S ; (while B do S od) k else skip fi]]([[p]]) = M[[S; (while B do S od) k ]]([[p B]]) M[[skip]]([[p B]]) = M[[(while B do S od) k ]](M[[S]]([[p B]])) [[p B]] M[[(while B do S od) k ]]([[p]]) [[p B]] [[p B]]. Daarmee is bewezen dat PD gezond is, voor partiële correctheid. Vervolgens bekijken we TD, voor totale correctheid. 62

63 De gezondheid van TD kan, behalve voor de Loop-regel, op precies dezelfde manier bewezen worden als voor PD. Voor de Loop-regel kan het als volgt. Neem aan dat M tot [[S]]([[p B]]) [[p]], (1) M tot [[S]]([[p B t = z]]) [[t < z]] en (2) p t 0, (3) waar z niet voorkomt in p, B, t en S. Laat T while B do S od. Het volstaat te bewijzen dat want dan geldt / M tot [[T]]([[p]]) M tot [[T]]([[p]]) = M[[T]]([[p]]) en dus, omdat de loop-regel voor partiële correctheid gezond is, volgt uit (1) dat M tot [[T]]([[p]]) [[p B]]. 63

64 Uit het ongerijmde: veronderstel dat er een toestand σ bestaat met σ = p en de berekening van T startend vanaf σ is oneindig. Uit (3) volgt dat σ(t) 0. Men kan nu σ zo kiezen dat de twee eigenschappen gelden voor σ, maar dat de waarde van σ(t) minimaal is. M.a.w, er bestaat geen toestand waarvoor de twee eigenschappen gelden en waarvoor de waarde van t kleiner is dan σ(t). Aangezien de berekening oneindig is, moet σ = B, zodat σ = p B. Laat τ de toestand σ[z := σ(t)] zijn. τ verschilt dus enkel van σ doordat z een andere waarde heeft. De veronderstelling over z impliceert dat τ(t) = σ(t) = τ(z) en dus τ = t = z. 64

65 De berekening van T startend vanaf τ (i.p.v. σ) is ook oneindig, en bovendien, ook weer door de veronderstelling dat z niet voorkomt in p of B, τ = p B, want σ = p B. We besluiten dus dat τ [[p B t = z]]. Uiteraard geldt dat [[p B t = z]] [[p B]], en wegens de monotoniciteit van M tot, M tot [[S]]([[p B t = z]]) M tot [[S]]([[p B]]). Dus, wegens (1), M tot [[S]]([[p B t = z]]) [[p]]. en wegens (2) geldt bijgevolg dat M tot [[S]]([[p B t = z]]) [[p]] [[t < z]] = [[p t < z]]. 65

66 Dit betekent dat er een toestand σ 1 bestaat zo dat en S, τ E, σ 1 σ 1 = p t < z. Uit de regels voor de semantiek volgt nu T, τ S; T, τ T, σ 1 maar dat leidt tot een tegenspraak met de keuze van σ: de berekening van T startend van σ 1 is oneindig (want dat is gewoon het laatste deel van de berekening van T startend van τ, en die is oneindig), en σ 1 (t) < σ 1 (z) = τ(z) = σ(t) terwijl die waarde juist minimaal was voor σ. 66

67 1.12 Proof Outlines (partiële correctheid) Proof outlines leveren een meer hanteerbare presentatie van de bewijzen; die worden nu gegeven in de vorm van een programmatekst, geannoteerd met state-asserties. Voorbeeld waar {x 0 y 0} quo := 0; rem := x; { inv : p} while rem y do {p rem y} rem := rem y; quo := quo + 1 od {p rem < y} {quo y + rem = x 0 rem < y} p quo y + rem = x 0 rem. Twee opeenvolgende asserties {q 1 }{q 2 } staan voor een toepassing van de consequence-regel, gebruikmakend van het feit dat q 1 q 2. 67

68 Regels voor het vormen van proof outlines Men kan een volledig stel regels geven voor de vorming van correcte proof-outlines; de regels komen overeen met die van PD, en dus met de syntax. 1. {p} skip {p} 2. {p[u := t]} u := t {p} {p}s 1{r}, {r}s 2{q} {p}s 1; {r}s 2{q} {p B}S 1{q}, {p B}S 2{q} {p} if B then {p B}S 1{q} else {p B}S 2{q} fi {q} {p B}S {p} { inv : p} while B do {p B}S {p} od {p B} p p 1, {p 1 }S {q 1 }, q 1 q {p}{p 1 }S {q 1 }{q} {p}s {q} 7. {p}s {q}, waar S uit S ontstaat door annotaties van de vorm {r} (dus niet van de vorm { inv : r}) weg te laten. 68

69 Soms hebben we proof outlines nodig die volledig zijn in de zin dat er voldoende asserties in staan: een proof outline {p}s {q} is standaard indien in S elk subprogramma T van S voorafgegaan wordt door precies één assertie; die noemen we dan pre(t). Zoals voor de hand ligt, kan men met proof outlines precies hetzelfde bewijzen als met het systeem PD. Dat wordt formeel uitgedrukt door volgende stelling. Stelling. 1. Laat {p}s {q} een proof outline zijn voor partiële correctheid. Dan PD {p}s{q}. 2. Indien PD {p}s{q}, dan bestaat er een standaard proof outline voor partiële correctheid van de vorm {p}s {q}. 69

70 Wanneer {p}s {q} een proof outline is, en tijdens de uitvoering van het programma S vertrekkend van een toestand waarin p geldt, wordt een punt bereikt dat geannoteerd is met een assertie, dan geldt die assertie in de bereikte toestand. Anders gezegd, de asserties gelden altijd als in het programma het punt bereikt wordt waar ze staan, op voorwaarde dat de preconditie voldaan is bij het begin van de berekening. Dit wordt uitgedrukt door volgende stelling. Stelling. Laat {p}s {q} een standaard proof outline zijn voor partiële correctheid, en veronderstel dat S, σ R, τ met σ een toestand waarin p geldt. Indien R at(t, S) voor een subprogramma T van S, dan τ = pre(t). Indien R E dan τ = q. Bewijs. (schets) bewijs eerst dat ofwel R at(t, S), ofwel R E. Dan per inductie op de lengte van de berekening. 70

71 De notatie at(t, S) laat toe om te spreken over ëen plaats in het programma S : met ëen plaats bedoelen we het begin van een bepaald subprogramma T, en die plaats identificeren we met het programma dat nog moet uitgevoerd worden op het ogenblik dat we aan T beginnen. Dat sluit goed aan bij de manier waarop we configuraties hebben gedefinieerd. De verschillende mogelijkheden leiden tot volgende definitie. Laat T een subprogramma zijn van S. Het programma at(t, S) is gedefiniëerd door: 1. Als S S 1 ; S 2 en T is een subprogramma van S 1, dan is at(t, S) at(t, S 1 ); S 2 en als T een subprogramma is van S 2, dan is at(t, S) at(t, S 2 ). 2. Als S if B then S 1 else S 2 fi en T is een subprogramma van S i, i = 1, 2, dan at(t, S) at(t, S i ). 3. Als S while B do S od en T is een subprogramma van S, dan at(t, S) at(t, S ); S 4. Als T S dan at(t, S) S. 71

72 Voorbeeld Laat S het volgende programma zijn: while x 0 od if y 0 then x := x 1 else y := y 2 fi od en laat T het onderlijnde subprogramma zijn. Dan is at(t, S) y := y 2; S wat men bekomt door achtereenvolgens regels 4, 2 en 3 toe te passen. 72

73 Proof Outlines: totale correctheid Om proof outlines te vormen die corresponderen met het systeem TD, ipv PD, moeten we rekening houden met het feit dat de loop-regel anders is. We voeren het nieuwe symbool bd in en vervangen regel 5 door: {p B}S {p} {p B t = z}s {t < z} p t 0 { inv : p}{ bd : t}while B do{p B}S {p}od{p B} waar t een integer expressie is en z een variabele die niet voorkomt in p, t, B of S. Merk op dat de proof outline nu niet meer alle informatie bevat die nodig is voor een volledig bewijs: meer bepaald komt S niet voor in de conclusie van de nieuwe regel. De manier waarop bewezen kan worden dat de waarde van de gebonden functie t strict daalt, wordt dus weggelaten. 73

74 Voorbeeld (DIV ): waar {x 0 y > 0} quo := 0; rem := x; { inv : p } { bd : rem} while rem y do {p rem y} rem := rem y; quo := quo + 1 {p } od {p rem < y} {quo y + rem = x 0 rem < y} p quo y + rem = x rem 0 y > 0. 74

75 1.13 Volledigheid Een bewijssysteem G is volledig voor partiële correctheid indien = {p}s{q} impliceert dat G {p}s{q}. Een bewijssysteem G is volledig voor totale correctheid indien = tot {p}s{q} impliceert dat G {p}s{q}. Informeel betekent volledigheid dus dat het bewijssysteem sterk genoeg is om alle ware correctheids-asserties (van de variant die we beschouwen) of te kunnen leiden met de axiomaschema s en regels. Volledigheid is vooral belangrijk omdat het betekent dat men, wanneer men constateert dat een bepaalde correctheids-assertie niet afleidbaar is, daaruit mag concluderen dat ze niet waar is. 75

76 Er zijn verschillende redenen denkbaar waarom de systemen PD en TD eventueel niet compleet zouden kunnen zijn: 1. Het is niet mogelijk alle asserties van de vorm p 1 p 2, gebruikt in de consequence-regel, te bewijzen (Gödel). Dit bezwaar omzeilen we door alle ware uitspraken van die vorm mee als axioma s van G te beschouwen. 2. De taal van asserties en expressies is niet sterk genoeg om de verzamelingen van toestanden en de gebonden functies die we nodig hebben uit te drukken. We nemen aan dat deze moeilijkheid zich niet voordoet (zie verder). Voor gebonden functies is dat nochtans niet vanzelfsprekend. 3. De afleidingsregels volstaan gewoon niet om alle benodigde bewijzen te leveren. Dit is de meest fundamentele van de drie redenen, en het is dan ook aan deze dat we de meeste aandacht geven. 76

77 Laat S een deterministisch programma zijn, Φ een verzameling van eigenlijke toestanden en p een assertie. wlp(s, Φ) = {σ M[[S]](σ) Φ} wp(s, Φ) = {σ M tot [[S]](σ) Φ} p definieert Φ als [[p]] = Φ. Stelling. Als S een deterministisch programma is en q een assertie, dan 1. bestaat er een assertie p die wlp(s, [[q]]) definieert, 2. bestaat er een assertie p die wp(s, [[q]]) definieert. Bewijs. (Gödelizatie: men stelt een p op waarin S en q gecodeerd zijn) We noteren met wlp(s, q) en wp(s, q) asserties die resp. wlp(s, [[q]]) en wp(s, [[q]]) definiëren. Merk op dat wlp(s, Φ) en wp(s, Φ) verzamelingen van toestanden zijn, en dat wlp(s, q) en wp(s, q) asserties zijn. 77

78 Volgende eigenschappen van wlp zijn min of meer evident. 1. wlp(skip, q) q 2. wlp(u := t; q) q[u := t] 3. wlp(s 1 ; S 2, q) wlp(s 1, wlp(s 2, q)) 4. wlp(if B then S 1 else S 2 if, q) (B wlp(s 1, q)) ( B wlp(s 2, q)) 5. als S while B do S 1 od, dan wlp(s, q) B wlp(s 1, wlp(s, q)) 6. als S while B do S 1 od, dan wlp(s, q) B q 7. = {p}s{q} d.e.s.d. als p wlp(s, q) Analoge uitspraken gelden als men wlp vervangt door wp en = door = tot. (7) brengt de geldigheid van een correctheidsformule terug tot de geldigheid van één assertie. 78

79 Bewijs van (5): wlp(s, q) B karakterizeert alle toestanden waarvoor σ = B en M[[S]](σ) = q. Dus als σ = wlp(s, q) B dan geldt, wegens de regel voor de semantiek van while, M[[S 1 ; S]](σ) = q en dus ook en en dus en tenslotte M[[S]](M[[S 1 ]](σ)) = q M[[S 1 ]](σ) wlp(s, [[q]]) σ = wlp(s 1, wlp(s, q)) (wlp(s, q) B) wlp(s 1, wlp(s, q)). 79

80 Eigenschappen (5) en (7) impliceren dat wlp(s, q) een loop-invariant is: als S while B do S 1 od, dan levert een toepassing van (7) op wlp(s, q) B wlp(s 1, wlp(s, q)) immers {wlp(s, q) B}S 1 {wlp(s, q)}. 80

81 Het is zoals gezegd niet evident dat de gebonden functies die we nodig hebben in bewijzen van totale correctheid kunnen uitgedrukt worden m.b.v. expressies. Meer bepaald zal TD maar volledig zijn als de taal van beschikbare gehele expressies expressief is. Meer precies: Laat S while B do S 1 od en laat x een variabele zijn die niet voorkomt in S. Laat S x x := 0;while B do x := x + 1; S 1 od en laat σ een eigenlijke toestand zijn zodat S niet divergeert vanaf σ. Dan M tot [[S x ]](σ) = {τ}, τ. Laat nu iter(s, σ) de waarde τ(x) zijn. iter(s, σ) is dus het aantal keer dat de body S 1 van de lus uitgevoerd wordt, vertrekkend van toestand σ. De verzameling van integer expressies is expressief als er voor elke while-loop S een expressie t bestaat zodat, voor elke toestand σ met M tot [[S x ]](σ) { }, geldt dat σ(t) = iter(s, σ). 81

82 Stelling. 1. PD is volledig: meer bepaald, {wlp(s, p)}s{p} kan afgeleid worden. 2. Als de verzameling van integer expressies expressief is, dan is TD ook volledig. 82

83 1.14 Bijkomende axioma s en afleidingsregels Om bewijzen korter en meer leesbaar te maken is het nuttig extra regels aan PD of TD toe te voegen, ook al zijn die regels niet nodig om het systeem volledig te maken. Van elke extra regel moet natuurlijk wel nagegaan worden of hij gezond is. Voor een assertie p is free(p) de verzameling van variabelen die vrij voorkomt in p, en voor een programma S is change(s) de verzameling van variabelen die ergens in S voorkomt aan de linkerkant van een assignment. 1. Invariantie (alleen voor partiële correctheid) Als free(p) change(s) = dan {p}s{p} 2. Disjunctie {p}s{q}, {r}s{q} {p r}s{q} 3. Conjunctie {p 1 }S{q 1 }, {p 2 }S{q 2 } {p 1 p 2 }S{q 1 q 2 } 83

84 4. -introductie Als x niet voorkomt in S of in free(q), dan {p}s{q} { x : p}s{q} 5. Invariantie als f ree(p) change(s) =, dan {r}s{q} {p r}s{p q} 84

85 1.15 Enkele voorbeelden 1. Opzoeken van de langste prefix van een woord x in een lijst D. Gegeven: een woord x en een lijst D 1, D 2,...,D n van woorden. D is alfabetisch gerangschikt. Gevraagd: de index i van het langste woord in de lijst D dat prefix is van x. We nemen uiteraard aan dat we nu ook met letters kunnen werken (en niet alleen met integers), en dat het alfabet geordend is. D j is het j-de woord van D. x[k] is de k-de letter van x. x[1..k] is de prefix van lengte k van x. x[1..0] is het lege woord ɛ. D[i, k] is de k-de letter van het woord D i. len(y) is de lengte van het woord y. Het predikaat prefix(y, z) is waar als het woord y een prefix is van het woord z. Het predikaat langsteprefix(j, y) is waar als D j de langste prefix van y is die voorkomt in D. 85

86 Voor x = c a p ɛ D 1 a a a b c a b e a d a m a m t a z b b d e b d e f b d f b h b k c i = p c a c a r c a t c a t a c a t b c a t c q c u p D 22 86

87 i := 0; k := 1; p := 0; q := n + 1; while (k len(x)) (p < q) do (A) r := p; u := q; while r < u do (B) m := (r + u) div 2; if len(d m ) < k then r := m + 1 else if D[m, k] < x[k] then r := m + 1 else u := m fi fi od p := r; (X) r := p; u := q; while r < u do (C) m := (r + u) div 2; if D[m, k] x[k] then r := m + 1 else u := m fi od q := r; if (p < q) (len(d[p]) = k) then i := p; k := k + 1 od 87

88 Verklaring: Er worden telkens langere prefixen van x gezocht (k). p en q begrenzen het deel van D dat bestaat uit woorden die beginnen met x[1..k]. Als x[1..k] zelf voorkomt in D (dus niet enkel als prefix), dan is dat op plaats p. Het aanpassen van p en q gebeurt telkens met een binary search. 88

89 Invarianten: I A = (0 p q n + 1) (0 i n) (p > 0 (prefix(x[1..k 1], D[j]) p j < q)) (i > 0 langsteprefix(i, x[1..k 1])) I B = I A (p r u q) (1 j < r) D j < x[1..k] (u j < n) D j > x[1..k] I C = (analoog aan I B ) Op punt (X) geldt: I A prefix(x[1..k], D[j]) p j < q. Deze uitspraken bevatten uiteraard maar een deel van de informatie die nodig is om over het algoritme te redeneren: zo blijft de lijst D bv. gesorteerd. 89

90 2. Minimum-weight Spanning Tree Gegeven: een samenhangende, ongerichte graaf G = (V, E, w) met gewichten voor de pijlen. Gevraagd: een minimum-weight spanning tree voor G: een boom, bestaande uit pijlen van G, die alle knopen van G bevat, en waarvan het totale gewicht minimaal is. Algoritme (Kruskal) k := 0; F := {C v v V }; met C v de triviale boom bestaande uit enkel de knoop v H := E; while (k V 1) do e := een pijl in H met w(e) minimaal ; H := H {e}; if e verbindt twee verschillende componenten in F then merge die twee componenten ; K := k + 1; fi od 90

91 1.16 Parallellisme Vooral bij parallelle programma s is het vaak moeilijk uit te maken of ze correct zijn, zelfs al bestaan ze maar uit enkele lijnen. Een parallel programma bestaat uit twee of meer component-programma s, die op verschillende processoren worden uitgevoerd, in het algemeen zonder volledige synchronizatie. Het gevolg is dat de berekeningen van de afzonderlijke component-programma s a.h.w. in elkaar geschoven worden, zonder dat a priori vastligt hoe dat in mekaar schuiven juist gebeurt. Men heeft dus in principe minder informatie dan in het sequentiële geval, waar de volgorde waarin de instructies zullen uitgevoerd worden wel bekend is. 91

92 Voorbeeld. Laat f : ZZ ZZ een functie zijn. We zoeken een programma dat een nulpunt vindt (zet found op true), als er nulpunten bestaan. Er moet in parallel gezocht wordt naar positieve en niet-positieve nulpunten. De parallelle samenstelling van programma s S 1 en S 2 wordt genoteerd als [S 1 S 2 ]. Eerste voorstel: Z 1 [S 1 S 2 ], waar S 1 found := false; x := 0; while found do x := x + 1; found := f(x) = 0 od en S 2 found := false; y := 1; while found do y := y 1; found := f(y) = 0 od 92

93 Het vorige programma voldoet niet: het is mogelijk dat found op true gezet is door S 1, en door S 2 weer false wordt. Tweede voorstel: Z 2 found := false; [S 1 S 2 ], waar S 1 x := 0; while found do x := x + 1; found := f(x) = 0 od en S 2 y := 1; while found do y := y 1; found := f(y) = 0 od 93

94 Z 2 voldoet nog steeds niet: het kan nog steeds dat S 2 de variabele found terug op false zet! Derde voorstel: vervang het onconditionele assignment f ound := f(x) = 0 door het conditionele if f(x) = 0 then found := true fi, en analoog voor y. Dus Z 3 found := false; [S 1 S 2 ], waar S 1 x := 0; while found do x := x + 1; if f(x) = 0 then found := true fi od en S 2 y := 1; while found do y := y 1; if f(y) = 0 then found := true fi od 94

95 Z 3 voldoet weer niet: stel dat f bv. alleen positieve nulpunten heeft, en dat S 1 nooit geactiveerd wordt. Later zullen we zo een situatie uitsluiten door fairness te veronderstellen. Zonder die veronderstelling is Z 3 geen correcte oplossing. Om het probleem op te lossen zonder de fairness-eis, voeren we een nieuwe constructie in: await B then R end, waar B een booleaanse expressie is en R een programma (R bevat zelf geen await). Bij uitvoering van deze constructie wordt eerst B geëvalueerd. Indien het resultaat true is, dan wordt R in zijn geheel, zonder onderbreking, uigevoerd. Anders wordt het proces dat de await uitvoert gedeactiveerd, en wordt later opnieuw B geëvalueerd. 95

96 Een volgende voorstel is: waar Z 4 turn := 1; found := false; [S 1 S 2 ], S 1 x := 0; while found do await turn = 1 then turn := 2 end; x := x + 1; if f(x) = 0 then found := true fi od en S 2 y := 1; while found do await turn = 2 then turn := 1 end; y := y 1; if f(y) = 0 then found := true fi od 96

97 Er is nu een situatie mogelijk waarin S 2 staat te wachten in zijn await (turn = 1), dat S 1 vervolgens een nulpunt vindt (zonder dat turn op 2 gezet wordt!), en dat S 2 dus voor eeuwig staat te wachten. Dit verschijnsel noemt men deadlock, en het is gewoonlijk ongewenst. Z 4 voldoet dus nog steeds niet. Indien we turn resetten op het einde van elke component, dan krijgen we wel een goede oplossing: Z 5 turn := 1; found := false; [S 1 S 2 ], S 1 x := 0; while found do await turn = 1 then turn := 2 end; x := x + 1; if f(x) = 0 then found := true fi od; turn := 2 S 2 y := 1; while found do await turn = 2 then turn := 1 end; y := y 1; if f(y) = 0 then found := true fi od; turn := 1 97

98 Z 5 is een correcte oplossing, maar ze kan toch nog verbeterd worden. Om zoveel mogelijk parallellisme mogelijk te maken is het nuttig de R in await B then R end zo kort mogelijk te houden. In dit geval kunnen we R leeg maken (gebruik wait als afkorting voor await B then end). De finale oplossing wordt: Z 6 turn := 1; found := false; [S 1 S 2 ], S 1 x := 0; while found do wait turn = 1; turn := 2 ; x := x + 1; if f(x) = 0 then found := true fi od; turn := 2 S 2 y := 1; while found do wait turn = 2; turn := 1 ; y := y 1 ; if f(y) = 0 then found := true fi od; turn := 1 98

99 Het is niet zo evident in te zien dat Z 6 correct is. Een mogelijke redenering vertrekt van het feit dat Z 5 correct is, en toont aan dat het verschil ongevaarlijk is. Wat is nu dat verschil? In Z 6 kan bv, tussen de wait turn = 1 en de turn := 2 van S 1, de component S 2 instructies uitvoeren. Wanneer deze laatste niet verwijzen naar de variabele turn, dan is er geen probleem, omdat zulke instructies net zo goed na de turn := 2 hadden kunen gebeuren. De turn := 1 op lijn 4 van S 2 kan onmogelijk op dit punt uitgevoerd zijn (waarom?), en dus moeten we enkel met de turn := 1 op de laatste lijn van S 2 rekening houden. Wanneer die uitgevoerd wordt staat found al op true en zal S 1 ook eindigen. Er is nood aan een overzichtelijker manier om over dit soort programma s te redeneren, een manier die meer zekerheid biedt. Een mogelijkheid bestaat erin om bewijssystemen zoals PD en TD uit te breiden naar parallelle programma s, maar het dient gezegd dat de systemen daardoor aanzienlijk complexer worden. 99