1

Computergestützte Verifikation

17.5.2002

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 Symmetrie3.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 SystemeUnabhä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 Reihenfolgestattfinden

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

111211 121 112

311 221 212

444

131 122 113321 231 222 132 213312 123

322 331 232 313 133 223332 323 233

333

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

111121

444

122222

223323333

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 PfadeSatz: 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) vors s1 s2w1 a w2

2. Fall: in w kommt kein a aus ample(s) vors w

a

s1’ s2w1

aw2

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: Sichtbarkeitample(s) enthält entweder keine einzige sichtbare Aktion oderalle Aktionen, die enabled sind (sichtbar wie unsichtbar)

1. Fall: in w kommt ein a aus ample(s) vors s1 s2w1 a w2

s1’ s2 dw1a

w2

a unsichtbar oderw1 leer

2. Fall: in w kommt kein a aus ample(s) vor

s was1’

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 einenZustand s, wo ample(s) alle Aktionen enthält, die in senabled sind

Wirkung: in einem solchen Zustand kann Fall 1 derPfadargumentation angewendet werden.

Jede Aktion des Originalpfades wird irgendwann\ auch im konstruieerten Pfad ausgeführt

12

Implementation von Prinzip # 1Wenn 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 Aktionenauß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) g1 g2 g3

g1’ g2’ g3’

{pc} {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) g1 g2

g1’ g2’ g3’

(r,i,1)

{pc}g3

{pc}

{pc} {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) g1 g2 g3

g1’ g2’ g3’(r,r,1)

{pc}

{pc} {pc}

{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

CB

a

b c CB

b c

ACAB

AA

A

b c

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 einereinzigen 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 invielen typischen Anwendungen exponentiell

Signifikante Zahl unsichtbarer Aktionen notwendig

Für unverteilte Systeme komplett unbrauchbar

Bei verteilten Systemen ist partial order reduction meist dieleistungsfähigere Methode

Beide Reduktionstechniken kombinierbar

19

Varianten für einfache Eigenschaftsklassen

Ziel: Reduktionstechniken, die nicht auf unsichtbare Aktionenangewiesen sind

SeiZustandsprä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)as1

s1 näher an s’ als s

21

AG EF AG EF 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 ausjeder TSZK des orig. Systems mind. 1 Zustand auch in einerTSZK 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

23

3.7 Tools

24

Spin

Eingabesprache: Promela – Prozesse + guarded commands

Spezifikation: LTL oder direkt als Büchi-Automat

Reduktionstechniken: Partial Order Reduction

Sonstige Tricks: Bithashing

http://netlib.bell-labs.com/netlib/spin/whatispin.html

25

Mur

Eingabesprache: Guarded Commands

Spezifikation: Einfache Erreichbarkeitsqueries

Reduktionstechniken: Symmetrie (scalar sets)

sonstige Tricks: parallele Version

http://verify.stanford.edu/dill/murphi.html

26

LoLA

Eingabesprache: Petrinetze (guarded commands der Formx1 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

http://www.informatik.hu-berlin.de/~kschmidt/lola.html

27

Übung

Generiere ein reduziertes Transitionssystem, das Prinzip # 1genü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 := pendingg2[i]: wi = pending sem = 3 sem := 0, key := true, wi := writingg3[i]: wi = writing wi := idle, sem := 3g1’[i]: ri = idle key sem > 0 ri = reading, sem := sem – 1g2’[i]: ri = reading ri := idle, sem := sem + 1