1 Computergestützte Verifikation

2 Model Checking für finite state systems explizit:symbolisch: 3.1: Tiefensuche 3.2: LTL-Model Checking 3.3: CTL-Model Checking 3.5: Reduktion durch Symmetrie 3.6: Partial Order Reduction 3.7: Tools 4.1: BDD-basiertes CTL-Model Checking 4.2: SAT-basiertes Model Checking 4.3: Tools 3.4: Fairness Kapitel 3 Kapitel 4

3 Verteilte Systeme Unabhängigkeitsrelation I zwischen Aktionen: [a,b] in I gdw. keine der beiden Aktionen kann die Enabling- Bedingung der anderen ändern, und Resultat der Hinterein- anderausführung von a und b ist unabhängig von der Reihenfolge s s1 s2 s z.B. [g,g] in I gdw. vorkommende Variablen disjunkt Unabhängige Aktionen tragen wesentlich zur Zustandsraumexplosion bei.

4 Ansatz bekämpfe Zustandsraumexplosion durch Unabhängigkeit unabhängige Aktionen können in beliebiger Reihenfolge stattfinden Reihenfolge ist oft unerheblich für Eigenschaft reduziere, wo möglich, die Anzahl der Reihenfolgen, in denen unabhängige Aktionen ausgeführt werden

5 Ample sets Sei s Zustand. ample(s) ist eine (wenn möglich) nichtleere Teilmenge der Aktionen, die bei s enabled sind Reduziertes Transitionssystem: verfolge bei s nur die Aktionen in ample(s)

6 Reduziertes Transitionssystem

7 Weiteres Vorgehen 1. Studieren Prinzipien, die Ample sets erfüllen müssen, um LTL-Eigenschaften zu bewahren 2. Implementationsfragen 3. Wie es bei CTL(*) aussieht 4. Varianten für einfache Eigenschaftsklassen

8 Prinzip # 1: Unabhängigkeit Alle Aktionen, die in s enabled sind und nicht in ample(s), sind von jeder Aktion in ample(s) unabhängig Stattfinden der ausgeschlossenen Aktionen wird auf Nachfolgezustände vertröstet Für jeden bei s beginnenden Pfad des originalen Systems: Keine Aktion, die von einer Aktion in ample(s) abhängig ist, kommt vor einer Aktion aus ample(s) vor.

9 Erstes Prinzip und unendliche Pfade Satz: Wenn das originale TS einen unendlichen Pfad enthält, so auch das reduzierte. s w 1. Fall: in w kommt ein a aus ample(s) vor s s1s2 w1a w2 2. Fall: in w kommt kein a aus ample(s) vor s w a s1 s2 w1 a w2 Wenn bei s unendl. Pfad ausführbar ist, so gibt es im red. TS einen Nachfolger von s, bei dem ein unendl. Pfad ausführbar ist. Rest: Induktion s1 w

10 Prinzip # 2: Sichtbarkeit ample(s) enthält entweder keine einzige sichtbare Aktion oder alle Aktionen, die enabled sind (sichtbar wie unsichtbar) 1. Fall: in w kommt ein a aus ample(s) vor s s1s2 w1a w2 s1 s2 d w1 a w2 a unsichtbar oder w1 leer 2. Fall: in w kommt kein a aus ample(s) vor s w a s1 w a unsichtbar diejenigen sichtbaren Aktionen, die aus dem Originalpfad in den reduzierten Pfad übernommen werden, bleiben in der gleichen Reihenfolge

11 Prinzip # 3: Nichtignorierung Jeder Kreis im reduzierten Transitionssystem enthält einen Zustand s, wo ample(s) alle Aktionen enthält, die in s enabled sind Wirkung: in einem solchen Zustand kann Fall 1 der Pfadargumentation angewendet werden. Jede Aktion des Originalpfades wird irgendwann\ auch im konstruieerten Pfad ausgeführt

12 Implementation von Prinzip # 1 Wenn ample*(s) folgende Bedingungen erfüllt: (E) Wenn g in ample*(s) und en(g,s), so sind alle von g abhängigen Aktionen in ample*(s) (D) Wenn g in ample*(s) und ¬en(g,s), so sind für ein U mit ¬en(g,s,U) alle Aktionen aus wrup(g,U) in ample*(s) dann erfüllt ample(s) := ample*(s) en(s) Prinzip # 1: Wenn g in ample(s), so sind alle abhängigen Aktionen in ample*(s) (E) Wenn g in ample*(s) und disabled, so können Aktionen außerhalb ample*(s) g nicht aktivieren. Algorithmus: Ersetze sind drin durch müssen auch rein, löse Nichtdeterminismus bei der Wahl von U irgendwie auf.

13 Beispiel: Wechselseitiger Ausschluß g1: pc1 =idle pc1 := req g2: pc1 = req sem = 1 sem := 0, pc1 := crit g3: pc1 = crit sem := 1, pc1 := idle g1: pc2 =idle pc2 := req g2: pc2 = req sem = 1 sem := 0, pc2 := crit g3: pc2 = crit sem := 1, pc2 := idle unabhängig: [g1,g1], [g3,g3], [g1,g2], [g1,g2], [g1,g3], [g1,g3], und umgekehrt. (i,i,1) g1g2g3 g1g2g3 {pc} (r,i,1)

14 Beispiel: Wechselseitiger Ausschluß g1: pc1 =idle pc1 := req g2: pc1 = req sem = 1 sem := 0, pc1 := crit g3: pc1 = crit sem := 1, pc1 := idle g1: pc2 =idle pc2 := req g2: pc2 = req sem = 1 sem := 0, pc2 := crit g3: pc2 = crit sem := 1, pc2 := idle unabhängig: [g1,g1], [g3,g3], [g1,g2], [g1,g2], [g1,g3], [g1,g3], und umgekehrt. (i,i,1) g1g2 g1g2g3 (r,i,1) {pc} g3 {pc} (r,r,1)

15 Beispiel: Wechselseitiger Ausschluß g1: pc1 =idle pc1 := req g2: pc1 = req sem = 1 sem := 0, pc1 := crit g3: pc1 = crit sem := 1, pc1 := idle g1: pc2 =idle pc2 := req g2: pc2 = req sem = 1 sem := 0, pc2 := crit g3: pc2 = crit sem := 1, pc2 := idle unabhängig: [g1,g1], [g3,g3], [g1,g2], [g1,g2], [g1,g3], [g1,g3], und umgekehrt. (i,i,1) g1g2g3 g1g2g3 (r,r,1) {pc} (c,r,0) (r,c,0) (r,i,1)(i,r,1) p.o. red: 6/8 symm: 5/8 p.o red + symm: 4/8

16 Wie sieht es bei CTL(*) aus? A C B a bc C B bc AC AB AA A bc a a a a a rot + blau = voll rot = reduziert Prinzipien 1-3 erfüllt EF( A EF B EF C)

17 Wie sieht es bei CTL(*) aus? Problem: CTL(*) ist sensitiv gegenüber dem Zeitpunkt, wo Pfade verzweigen Reduktion darf Verzweigungspunkte nicht verschieben Prinzip CTL*: ample(s) besteht entweder aus einer einzigen Aktion, die superdeterministisch ist und unsichtbar, oder aus allen aktivierten Aktionen (deterministisch in allen Zuständen)

18 Vorläufige Zusammenfassung linearer Overhead zur Bestimmung von ample sets Umfang der Reduktion schwer prognostizierbar, aber in vielen typischen Anwendungen exponentiell Signifikante Zahl unsichtbarer Aktionen notwendig Für unverteilte Systeme komplett unbrauchbar Bei verteilten Systemen ist partial order reduction meist die leistungsfähigere Methode Beide Reduktionstechniken kombinierbar

19 Varianten für einfache Eigenschaftsklassen Ziel: Reduktionstechniken, die nicht auf unsichtbare Aktionen angewiesen sind Sei Zustandsprädikat (Formel ohne Temporaloperationen) wrup(s, ) = Menge von Aktionen, so daß jeder Weg von s zu einem s mit s mind. eine Aktion aus wrup(s, ) enthält. Sei s Satz: Originales TS erfüllt EF gdw. ein reduziertes, das Prinzip # 1 befolgt und wo jedes ample*(s) auch wrup(s, ) enthält.

20 Beweis s s0 orig. red. s aus wrup(s, ) 1. aus ample(s) a s1 s1 näher an s als s

21 AG EF AG EF TS AG EF gdw. terminale SZK C s C: s TS EF AG gdw. terminale SZK C s C: s TS EF AG EF gdw. terminale SZK C s C: s TS AG EF AG gdw. terminale SZK C s C: s TS AG EF AG EF gdw. TS AG EF TS EF AG EF AG gdw. TS EF AG Sei Zustandsprädikat Satz: Wenn red. TS Prinzipen #1 und #3 erfüllt, so ist aus jeder TSZK des orig. Systems mind. 1 Zustand auch in einer TSZK des red. Systems enthalten, und jede TSZK des red. Systems ist Teilmenge einer TSZK des orig. Systems.

22 Verifikation TSZK-bezogender Eigenschaften 1. Schritt. konstruiere red. TS nach Prinzipien #1 und #3 2. Schritt. Wähle ein si aus jeder TSZK Ci 3. Schritt. Prüfe si EF bzw. si EF ¬ für alle si nach der wrup-Methode

Tools

24 Spin Eingabesprache: Promela – Prozesse + guarded commands Spezifikation: LTL oder direkt als Büchi-Automat Reduktionstechniken: Partial Order Reduction Sonstige Tricks: Bithashing

25 Mur Eingabesprache: Guarded Commands Spezifikation: Einfache Erreichbarkeitsqueries Reduktionstechniken: Symmetrie (scalar sets) sonstige Tricks: parallele Version

26 LoLA Eingabesprache: Petrinetze (guarded commands der Form x1 k1... xm km x1 := x1 – k1,...,xm := xm – km, y1 : y1 : l1,..., yn := yn+ln ) Reduktionstechniken: stubborn sets, Symmetrien (Automorphismen) Spezifikation: CTL, viele kleine Eigenschaftsklassen sonstige Tricks: Petrinetzspezifische Tricks, parallele Version, Bithashing

27 Übung Generiere ein reduziertes Transitionssystem, das Prinzip # 1 genügt, zu folgendem Programm Var w1, w2: {idle, pending, writing} Var r1,r2,r3:{idle,reading} Var sem: {0,1,2,3} Var key: bool init(wi) = init(ri) = idle, init(sem) = 3, init(key) = true g1[i]: wi = idle key key := false, wi := pending g2[i]: wi = pending sem = 3 sem := 0, key := true, wi := writing g3[i]: wi = writing wi := idle, sem := 3 g1[i]: ri = idle key sem > 0 ri = reading, sem := sem – 1 g2[i]: ri = reading ri := idle, sem := sem + 1