Computergestützte Verifikation 26.4.2002

CTL* CTL* LTL CTL nur Pfad- formeln Nur Zust.- formeln EX, AX, EF, AF, EG, AG, E( . U . ) A( . U . ) X, F, G, U X, F, G, U, A, E

Lösung: Fairnessannahmen Eine Fairnessannahme ist eine Pfadeigenschaft und Bestandteil der Systembeschreibung. Gültigkeit unter Fairness: A = für jeden Pfad, der alle Fairnessannahmen erfüllt, gilt.... E = es gibt einen Pfad, der alle Fairnessannahmen erfüllt und ... Fairness aktionsbasiert zustandsbasiert

Wie geht es weiter? A) Finite state systems B) Infinite state systems Simulation Gegenbeispiel Fehler- beseitigung Verfeinerung Abstraktion System Modell - + Model Checker Präzisierung Formalisierung Spezifikation log. Formel Überlauf A) Finite state systems B) Infinite state systems

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

Kriterium für Startknoten von SZK 4 1 4 6 2 5 v.lowlink = MIN(v’.dfs | v’ von v erreichbar über beliebig viele Baumkanten, gefolgt von max. einer anderen Kante [v,v’] mit v ~ v’) 4 4 3 3 1 1 4 Satz: v ist genau dann Startknoten einer SZK wenn v.lowlink = v.dfs 1 1 2 5 1 1 3 6 6 4 4

Tarjans Algorithmus Baumkante andere Kante eine SZK VAR Tarj: Stack von Knoten, maxdfs: Nat, weiss: Knotenmenge weiss := V, maxdfs = 0; Tarj := empty stack dfs(v0); dfs(v): v.dfs = v.lowlink = maxdfs; maxdfs += 1; push(v,Tarj);weiss := weiss \ {v} FOR ALL v’ ([v,v’] in E) DO IF v’ in weiss THEN dfs(v’) v.lowlink = MIN(v.lowlink,v’.lowlink) ELSE IF v’ on Tarj THEN v.lowlink = MIN(v.lowlink,v’.dfs) END IF v.lowlink = v.dfs THEN REPEAT v* = pop(Tarj) UNTIL v = v* Baumkante andere Kante eine SZK

3.2 LTL Model Checking

Grundidee LTL-Eigenschaft  Menge derjenigen Pfade, die f erfüllen  Lfw Transitionssystem  Menge derjenigen Pfade, die in TS realisiert werden können  LTSw TS erfüllt f genau dann, wenn jeder Pfad in TS f erfüllt, d.h. LTSw  Lfw

Wie kann man Inklusion entscheiden? LTSw  Lfw  LTSw  Lfw =   LTSw  L¬fw =  Agenda: 1. Automaten, die LTSw und L¬fw akzeptieren 2. Konstruktion eines Schnittautomaten 3. Entscheidung, ob Automat die leere Sprache akzeptiert Problem: Wir reden über unendliche Sequenzen!

Büchi-Automaten = endliche Automaten mit einem für unendliche Sequenzen geeigneten Akzeptierungskriterium B = [X, Z, Z0, d , F] X – Alphabet Z – Zustandsmenge Z0 – Anfangszustandsmenge d: Z x X  2Z F = {F1,...,Fn}, Fi  Z Akzeptierungsmengen unendliche Sequenz p in Xw B akzeptiert p: es ex. unendliche Sequenz z = z0 z1 z2 .... z0  Z0, zi+1  d(zi,xi), Für jedes Fi  F: z enthält unendlich oft Elemente aus Fi  LB

Beispiele X = {a,b,c} b,c a,c a b a A 1 a b B 2 b a b c c Z0 = {1} F1 = {1} C c Z0 = Z F1 = {A,B} F2 = {A,C} LB = {p | nach jedem a in p kommt irgendwann b} LB = {p | in p unendlich oft a oder unendlich of b und c}

Transitionssystem und Büchi-Automat Eine Menge Lw von unendlichen Sequenzen heißt w-regulär, wenn es einen endlichen Büchi-Automaten gibt, der Lw akzeptiert. Beobachtung: Jede Menge von Systemabläufen eines finite state Transitionssystems ist w-regulär. X = Vektoren von booleschen Werten, die als Wahrheits- werte der elementaren Aussagen interpretiert werden {z’ | [z,z’]  E}, falls x den Wahrheitswerten der Aussagen in z entspricht Z = S, Z0 = I, d(z,x) = , sonst F1 = Z, F = {F1}

Beispiele g0,g0’ (i,i,1) g1 g1’ g0 g0’ g3’ g3 (r,i,1) (i,r,1) g1’ g2 (c,i,0) (r,r,1) (i,c,0) g3 g3’ g1’ g2 g2’ g1 (r,c,0) (c,r,0) 1.pc1 = crit 2. pc2 = crit 3. pc1 = req 4. pc2 = req S: G (pc1  “critical”  pc2  “critical” ) L: G (pc1 = “request”  F pc1 = “critical”) G (pc2 = “request”  F pc2 = “critical”)

Beispiele FFFF (i,i,1) FFFF FFFF FFFW FFWF FWFF WFFF (r,i,1) (i,r,1) (c,i,0) (r,r,1) (i,c,0) WFFW FWWF WFFF FFWW FFWW FWFF (r,c,0) (c,r,0) 1.pc1 = crit 2. pc2 = crit 3. pc1 = req 4. pc2 = req

Büchi-Automaten und LTL Satz: Zu jeder LTL-Formel f gibt es einen Büchi-Automaten mit max 2|f| Zuständen, der genau die unendlichen Sequenzen akzeptiert, die f erfüllen. Beispiele: ?W* * * ?W* ?F* ?W* ?W* 2 ??W* * 1 * 1 1 1 * * G a2 * ?F* F a2 3 X a2 2 * * Z0 = {0}, F = { {0} } Z0 = {0}, F = { {2} } Z0 = {0}, F = { {1} } a2 U a3 Z0 = {0}, F = { {1} }

Automaten für komplexe Formeln (Bsp) * ?F* ?F* ??W* 1 1 2 ??W* ?W* * * G(a2  F a3) Z0 = {0} F = {{0}} * (G F a2)  (G F a3) Z0 = {0} F = { {1,2} }

Zwischenfazit Haben: Büchi-Automat für LTS Büchi-Automat für L¬f Ziel: LTS L¬f =  ? nächster Schritt: geg: B1,B2 ges: B*: LB* = LB1  LB2

Produktautomat Idee: beide Automaten arbeiten parallel, Akzeptierungs- mengen werden nebeneinandergestellt B1 = [X,Z1,Z01,d1,F1] B2 = [X,Z2,Z02,d2,F2] B* = [X,Z*,Z0*,d*,F*] Z* = Z1 x Z2 Z0* = Z01 x Z02 d*([z,z’],x) = d1(z,x) x d2(z’,x) F* = { F x Z2 | F  F1}  { Z1 x F | F  F2} Satz: LB* = LB1  LB2

Beispiel B1: B2: F W,F 1 a W b F c W,F F Z0 = {a} Z0 = {0} F = { {1} } 1 a W b F c W,F F Z0 = {a} Z0 = {0} F = { {1} } F = { {a,b,c} } (a,0) (a,1) (b,0) (b,1) (c,0) (c,1) F W F B* : F F Z0 = {(a,0)} F = { Z, {(a,1),(b,1),(c,1)} }

Emptiness geg.: Büchi-Automat B Frage LB =  ? Lösung: LB  gdw. es gibt eine nichttriv. SZK in B (von einem Initialzustand erreichbar), die aus jeder Akzeptierungsmenge Elemente enthält. nichttriv. = mehrere Zst. oder 1 Zustand mit Schleife “”: Sei p Sequenz, die von B akzeptiert wird. Z* sei Menge der Zustände, die im akzeptierenden Lauf unendlich oft durchlaufen werden. Z* ist stark zusammen- hängend, und enthält Elemente aus jeder Akzeptierungsmenge “”: Konstruiere zur SZK eine Sequenz, die vom Initialzustand zur SZK gelangt, und dort zyklisch alle Zst. durchläuft. Diese Sequenz ist offenbar in LB

LTL Model Checking Geg.: TS (implizit), f. 1. Konstruiere B¬f 2. Konstruiere Produktautomat B* aus TS und B¬f 1 Schritt! 3. Suche in B* nach SZK, die aus jeder Akzeptierungsmenge ein Element enthalten 4. gefunden  “nein”, bilde Gegenbeispiel aus gefundener SZK 5. nicht gefunden  “ja” O(2|f| |TS|)

Beispiel G F a (negiert: F G ¬a) TS: F 1 W,F F Z0 = {0} F = { {1} } a 1 W,F F Z0 = {0} F = { {1} } a W b F c Z0 = {a} F = { {a,b,c} } (a,0) (a,1) (b,0) (b,1) (c,0) (c,1) W F Z0 = {(a,0)} F = { Z, {(a,1),(b,1),(c,1)} } B* : nur triv. SZK akzeptieren also: Formel wahr

Beispiel G F a (negiert: F G ¬a) TS: F W,F 1 F a W b F c W,F F 1 F a W b F c W,F F Z0 = {a} Z0 = {0} F = { {1} } F = { {a,b,c} } (a,0) (a,1) (b,0) (b,1) (c,0) (c,1) nichttriv. SZK, Formel falsch, Gbsp: a (b c)* W W B* : F F F F F F F F F Z0 = {(a,0)} F = { Z, {(a,1),(b,1),(c,1)} }

On-The-Fly Verifikation LTL-Formel wahr  kompletter Produktautomat wird konstruiert LTL-Formel falsch  Konstruktion des Produktautomaten kann vorzeitig abgebrochen werden  weniger Speicherverbrauch

3.3 CTL Model Checking Spezifisch für LTL: alle Formeln betreffen Pfade Spezifisch für CTL: alle (Teil-)Formeln betreffen Zustände Idee: - Jeder Zustand hat Liste mit Wahrheitswerten aller Teilformeln (  {W,F,?} )  L(s,f) Für die Wertberechnung werden Teilformeln jeweils als atomar angesehen - Werte von Teilformeln werden bei Bedarf berechnet

Rahmenprozedur CTL(s,f) IF L(s,f)  ? THEN RETURN END CASE f AP: berechne L(s,f) END yc: CTL(s,y) IF L(s,y) THEN CTL(s,c); L(s,f) = L(s,c); ELSE L(s,f) = F END ¬y, yc: analog AX y: FOR ALL s’: [s,s’]  E DO CTL(s’,y); IF L(s’,y) = F THEN L(s,f) = F; RETURN; END L(s,f) = W EX y: analog /* Fortsetzung folgt */

Rahmenprozedur (Fortsetzung) (... CASE f) E(y U c) : CheckEU(s,y,c); A(y U c) : CheckAU(s,y,c); EF y, AF y, EG y, AG y: /* über Tautologien */ Also bleiben: CheckAU, CheckEU

CheckAU CheckAU(s,y,c): Suche Gegenbeispiel L(s’,A(y U c)) = W L(s’,c) = F L(s’,y) = F L(s’,A(y U c)) = F L(s’,c) = W L(s’,y) = W L(s’,c) = F L(s’,A(y U c)) = ? s

CheckAU CheckAU(s,y,c): Suche Gegenbeispiel L(s’,A(y U c)) = W L(s’,c) = F L(s’,y) = F L(s’,A(y U c)) = F s’ L(s’,c) = W L(s’,y) = W L(s’,c) = F L(s’,A(y U c)) = ? s Keine Fortsetzung des Pfades kann Gegenbeispiel sein  Backtracking von s’

CheckAU CheckAU(s,y,c): Suche Gegenbeispiel L(s’,A(y U c)) = W L(s’,c) = F L(s’,y) = F s’ L(s’,A(y U c)) = F L(s’,c) = W L(s’,y) = W L(s’,c) = F L(s’,A(y U c)) = ? s Gegenbeispiel gefunden  L(s,A(y U c)) := F, RETURN

CheckAU CheckAU(s,y,c): Suche Gegenbeispiel L(s’,A(y U c)) = W L(s’,c) = F L(s’,y) = F s’ L(s’,A(y U c)) = F L(s’,c) = W L(s’,y) = W L(s’,c) = F L(s’,A(y U c)) = ? s Da jede Fortsetzung bei s’ y U c erfüllt, kann keine Fortsetzung Gegenbeispiel liefern  Backtracking

CheckAU CheckAU(s,y,c): Suche Gegenbeispiel L(s’,A(y U c)) = W L(s’,c) = F L(s’,y) = F L(s’,A(y U c)) = F L(s’,c) = W L(s’,y) = W s’ L(s’,c) = F L(s’,A(y U c)) = ? s Gegenbeispiel gefunden ( = s....s’ + Gegenbeispiel bei s’)  L(s,A(y U c)) = F, RETURN

CheckAU CheckAU(s,y,c): Suche Gegenbeispiel L(s’,A(y U c)) = W L(s’,c) = F L(s’,y) = F L(s’,A(y U c)) = F L(s’,c) = W L(s’,y) = W L(s’,c) = F L(s’,A(y U c)) = ? s Gegenbeispiel  L(s, A(y U c)) = F, RETURN

CheckAU CheckAU(s,y,c): Suche Gegenbeispiel L(s’,A(y U c)) = W L(s’,c) = F L(s’,y) = F L(s’,A(y U c)) = F L(s’,c) = W L(s’,y) = W L(s’,c) = F L(s’,A(y U c)) = ? s Suchraum komplett durchsucht, ohne Gegenbeispiel  L(s,A(y U c)) = W

CheckEU CheckEU(s,y,c): Suche Zeugenpfad L(s’,E(y U c)) = W L(s’,c) = F L(s’,y) = F L(s’,E(y U c)) = F L(s’,c) = W L(s’,y) = W L(s’,c) = F L(s’,E(y U c)) = ? s

CheckEU CheckEU(s,y,c): Suche Zeugenpfad L(s’,E(y U c)) = W L(s’,c) = F L(s’,y) = F L(s’,E(y U c)) = F s’ L(s’,c) = W L(s’,y) = W L(s’,c) = F L(s’,E(y U c)) = ? s Zeuge gefunden  L(s’,E(y U c)) = W, RETURN

CheckEU CheckEU(s,y,c): Suche Zeugenpfad L(s’,E(y U c)) = W L(s’,c) = F L(s’,y) = F s’ L(s’,E(y U c)) = F L(s’,c) = W L(s’,y) = W L(s’,c) = F L(s’,E(y U c)) = ? s keine Fortsetzung kann Zeuge sein  Backtracking

CheckEU CheckEU(s,y,c): Suche Zeugenpfad L(s’,E(y U c)) = W L(s’,c) = F L(s’,y) = F s’ L(s’,E(y U c)) = F L(s’,c) = W L(s’,y) = W L(s’,c) = F L(s’,E(y U c)) = ? s Zeuge (= s....s’ + Zeuge bei s’) L(s’,E(y U c)) = W, RETURN

CheckEU CheckEU(s,y,c): Suche Zeugenpfad L(s’,E(y U c)) = W L(s’,c) = F L(s’,y) = F L(s’,E(y U c)) = F L(s’,c) = W L(s’,y) = W s’ L(s’,c) = F L(s’,E(y U c)) = ? s Keine Fortzsetung kann Zeuge sei  Backtracking

CheckEU CheckEU(s,y,c): Suche Zeugenpfad L(s’,E(y U c)) = W L(s’,c) = F L(s’,y) = F L(s’,E(y U c)) = F L(s’,c) = W L(s’,y) = W L(s’,c) = F L(s’,E(y U c)) = ? s Suche komplett ohne Zeuge L(s’,E(y U c)) = F

Zwischenfazit CheckAU und CheckEU L(s,A/E(y U c)) kann durch einfache Tiefensuche ermittelt werden Das würde Laufzeit von O( |f| |TS| |TS| ) = O(|f| |TS|2) liefern: Für jede Teilformel und jeden Zustand eine Tiefensuche Ziel : O((|f| |TS|)

Lineare Gesamtlaufzeit - Idee L(s’,A/E(y U c)) = W L(s’,c) = F L(s’,y) = F ... auch L(s’,A/E(y U c)) für alle während der Suche betretenen Zustände! L(s’,A/E(y U c)) = F L(s’,c) = W L(s’,y) = W L(s’,c) = F L(s’,A/E(y U c)) = ? s Bestimme durch eine einzige Tiefensuche nicht nur L(s,A/E(y U c)) , sondern ....

Was hilft das? L(s,A/E(y U c))  ? S |f| ( O(|S1|) + .... O(|Sn|) ) = O(|f|(|S1| +|S2|+...+ |Sn|)) .... = O((|f| |TS|) s0

Übung 1 Konstruiere einen Büchi-Automat, der genau die Sequenzen akzeptiert, die (G a)  (F G b) erfüllen

Übung 2 Konstruiere den Produktautomat, der entsteht, wenn die Formel F a  G F b auf folgendem Transitionssystem verifiziert wird: a b (Der untere Zustand ist einziger Initialzustand)

Übung 3 Finde das kleinstmögliche Transitionssystem, das folgende LTL-Formeln erfüllt.... G F b F G a a U b ... und folgende LTL-Formeln nicht erfüllt: G b G a a X a