Model Checking

Computergestützte Verifikation
5.7.2002
Testen: kann nur die Anwesenheit von Fehlern
feststellen, nicht ihre Abwesenheit. (E. Dijkstra)
Systematische Entwicklungsprozesse: z.B. ISO 9000
Konstruktion: Erzeugen des Systems aus der
Spezifikation
Verifikation: Nachweis der Korrektheit (theoretisch)
Fähigkeit, subtile Fehler zu finden (praktisch)
Was ist Model Checking?
Erschöpfende Durchmusterung der Zustände eines
Systems zur Prüfung einer vorgegebenen Eigenschaft
Grundproblem: Zustandsexplosion
Model Checking: Prinzipskizze
Simulation
Fehlerbeseitigung
System
Abstraktion
Gegenbeispiel
Verfeinerung
Modell
Präzisierung
Spezifikation
Formalisierung
log. Formel
Model Checker
Überlauf
+
1 Systeme
Zustand:
Zusammenfassung aller Systemgrößen, die das weitere
Systemverhalten wesentlich beeinflussen können
Abstraktion
diskrete Systeme = alle Wertebereiche abzaehlbar
kontinuierliche Systeme = alle Wertebereiche dicht
hybride Systeme = sowohl als auch
real-time Systeme = einzige kontinuierliche Größe ist die Zeit
finite state systems = Zustandsraum endlich
2 Temporale Logik
GFf
=
f gilt unendlich oft
.......
FGf
=
f stabilisiert
..........
G ( f u F y) = f führt zu y
..........
Tautologien: F G F f w G F f
GFGfwFGf
Der Berechnungsbaum
s1
s4
s1
s2
s3
s6
s5
s2
s4
s3
s1
s2
s5
s5
s4
s6
s6
s4
CTL* -Pfadquantoren
Wenn f eine Pfadformel ist, so
ist E f eine Zustandsformel
s erfüllt E f gdw. es einen Pfad p
gibt, der bei s beginnt und p ~ f
s
a,b
a,d
c
s~EFc
Wenn f eine Pfadformel ist, so
ist A f eine Zustandsformel
s erfüllt A f gdw. für alle Pfade p,
die bei s beginnen, gilt: p ~ f
s~AXa
Tautologien: A f w  E f
Af uEf
CTL* - Zusammenfassung
CTL*
LTL
nur Pfadformeln
CTL
Nur Zust.formeln
Computation Tree Logic (CTL)
CTL = atomare Zustandsaussagen + Boolesche
Operatoren + Paare
[ Pfadquantor , Temporaloperator ]
AG
(invariant)
AX
(in allen Nachf.)
EG (mgl.weise immer)
EX
(in einem Nachf.)
AF
A( . U . )
EF
E( . U . )
(irgendwann)
(bis)
(möglich)
(bis)
Progress und Fairness
e
d
a
b
p
a
p
p
d
f
c
b
p
e
F p gilt nicht !!?!?!?!
Model Checking für finite state systems
explizit:
explizite Konstruktion eines
Transitionssystems,
das sich in bezug auf die
untersuchte Eigenschaft
äquivalent zum gegebenen
verhält, aber in der Regel
wesentlich kleiner ist.
Eigenschaft wird durch
Graphsuche nach Zeugen/
Gegenbeispielen
verifiziert
symbolisch:
Datenstruktur, die Mengen von
Zuständen bzw. Pfaden
beschreibt,
Operationen, die simultan die
Nachfolger aller Zustände
berechnet
Eigenschaft wird durch
Fixpunktoperationen auf der
symbolischen Datenstruktur
berechnet
6
3 Explizites Model Checking
3.1 Tiefensuche
2
[v,v’] ist Baumkante, falls [v,v’] in T
5
4
3
[v,v’] ist Vorwärtskante, falls [v,v’] in T*\T
1
[v,v’] ist Rückwärtskante, falls [v’,v] in T*
[v,v’] ist Querkante, sonst
0
2
5
1
[v,v’] in Vorwärts v.dfs v’.dfs
3
6
4
0
[v,v’] in Quer  v.dfs > v’.dfs
[v,v’] in Rückwärts  v.dfs > v’.dfs
[v,v’] in Rückwärts  v ~ v’
Kriterium für Startknoten von SZK
4
4
5
21
6
44
3 3
11
v.lowlink = MIN(v’.dfs |
v’ von v erreichbar über beliebig viele
Baumkanten, gefolgt von max. einer
anderen Kante [v,v’] mit v ~ v’)
00
4
5
21
1
1
3
1
6
6
4
4
00
Satz: v ist genau dann Startknoten einer
SZK wenn v.lowlink = v.dfs
3.2 LTL Model Checking
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
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
3.3 CTL Model Checking
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
L(s,A/E(y U c))  ?
Was hilft das?
S
|f| (
O(|S1|)
+
O( |S2|)
+
....
+
O(|Sn|)
S1
S2
Sn
....
)
= O(|f|(|S1| +|S2|+...+ |Sn|))
= O((|f| |TS|)
s0
3.4 Fairness
-Eingabe: eine SZK C, Mengen Fschw und Fst von
Fairnessannahmen
-Ausgabe: eine SZM, die in C enthalten ist und alle
Fairnessannahmen erfüllt (bzw. ø, falls keine ex.)
0. Fall: C trivial  return ø
1. Fall: alle Fairnessannahmen erfüllt (Test ist leicht, siehe vorn)
return C
2. Fall: eine schwache Annahme verletzt (also: kein f-Zst. in C)
 return ø
3. Fall: eine starke Annahme (G F f) u(G F y) ist verletzt
(also: es gibt in C f-Zst., aber keine y-Zst.)
 Streiche alle f-Zst. aus C, zerlege die entstehende Menge
in SZK und rufe den Algorithmus rekursiv für alle Fragmente
auf, bis ein Aufruf eine nichttriviale SZM liefert
3.5 Symmetrie
Grundgedanke: symmetrisch strukturierte Systeme
haben symmetrisches Verhalten
Quellen für Symmetrie:
a) regelmäßig strukturierte Datentypen
b) replizierte Komponenten im Gesamtsystem
Wenn Verhalten bei s bekannt und s’ symmetrisch zu s,
braucht Verhalten bei s’ nicht mehr untersucht werden
technisch: Äquivalenzrelation; Quotienten-Transitionssystem
Beispiel 1
S = { Id, s}
s([x,y,z]) = [y,x,z]
(i,i,1)
(r,i,1)
(i,r,1)
g1
(c,i,0)
(r,r,1)
(c,r,0)
(i,c,0)
(r,c,0)
Beispiel 1
S = { Id, s}
s([x,y,z]) = [y,x,z]
(i,i,1)
(r,i,1)
(c,i,0)
(r,r,1)
(c,r,0)
Symmetrie in Datentypen
Fall 1: Skalare Datentypen
-Menge D von Werten
- nur = ,  in Guards
- := (Zuweisung)
- als Indexmenge von (einfachen) Arrays anderer Datentypen
- Schleifen der Form FOR ALL x  D DO ...
- choose(x)
- keine Konstanten
Seien x1 , ... , xn alle Variablen eines skalaren Datentyps D,
b eine Belegung dieser Variablen mit Werten, und p
eine Permutation auf D.
Setzen p zu einer Symmetrie s fort
Graphautomorphismen
Eine Permutation s: V  V heißt Graphautomorphismus,
falls für alle v,v’ aus V gilt:
1. c(v) = c(s(v))
2. Wenn [v,v’]  E, so [s(v),s(v’)]  E und c([v,v’]) = c([s(v),s(v’)])
Graphautomorphismen des Kommunikationsgraphen induzieren
Symmetrien eines Komponentensystems
Hinter allen Symmetrieansätzen stecken Graphautomorphismen,
z.B. auch hinter Datentypsymmetrie:
=
2
 
1  3
=
 =
4
=
incr
1
=
incr
=
2
incr
3 =
incr
4 =
Komplexität des Automorphismenproblems
eng verwandt: Graphisomorphie
NP
NPV
Ein Graph kann exponentiell
viele Automorphismen haben
?
?
P
Konzept für Erzeugendensystem
U1
U2
U3
U1  U2  U3  ...  Un = {e}
Eindeutige Darstellung:
Jedes Element g von G besitzt genau eine Darstellung
der Form
g = g1 o g2 o... o gn mit gi aus einem der von
Ui in U(i-1) generierten Orbit
Automorphismenberechnung
1
poly
4
6
2
8
1
7 8
5
a
b
f a
c
e
R*
3
R*
D
R*
R*
D
R*
D
R*
R*
R*
R*
2
3
2
3
3
8
3
8
c
c
c
c
exp
= #Ai  #Bi
ist selten  meistens poly. Laufzeit!!!
Orbitproblem
id
g11 g12 g13 g14
geg: s
id
g21 g22 g23
g31 g32
ges: canrep(s)
1. s1 := MIN{g1i-1(s), i = ...}
2. s2 := MIN{g2i-1(s1), i = ...}
3. s3 := MIN{g3i-1(s2), i = ...}
........
n. sn := MIN{g1i-1(s[n-1]), i = ...}
canrep(s) := sn
3.6 Partial Order Reduction
Unabhängigkeitsrelation I zwischen Aktionen:
[a,b] in I gdw. keine der beiden Aktionen kann die EnablingBedingung der anderen ändern, und Resultat der Hintereinanderausführung von a und b ist unabhängig von der
Reihenfolge
s1
s’
s
s2
z.B. [g,g’] in I gdw. vorkommende Variablen disjunkt
Unabhängige Aktionen tragen wesentlich zur
Zustandsraumexplosion bei.
Prinzip # 1: Unabhängigkeit
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.
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”
Erstes Prinzip und unendliche Pfade
Satz: Wenn das originale TS einen unendlichen Pfad enthält,
so auch das reduzierte.
w
s
1. Fall: in w kommt ein a aus ample(s) vor
w1
w2
s
s1 a s2
a
w1
w2
s1’
s2
2. Fall: in w kommt kein a aus ample(s) vor
w
s
a
w
s1’
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
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
w1
w2
s
s1 a s2
a
w1
w2
d
s1’
s2
a unsichtbar oder
w1 leer
2. Fall: in w kommt kein a aus ample(s) vor
s
a
s1’
w
a unsichtbar
w
diejenigen sichtbaren Aktionen, die aus dem Originalpfad in
den reduzierten Pfad übernommen werden, bleiben in der
gleichen Reihenfolge
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 konstruierten Pfad ausgeführt
4. Symbolisches Model Checking
4.1 BDD
Mengen
größe
N
0
N
Y
4
N
Y
8
Elemente in Menge
Y
N
12
Y
16
BDD
Größe
Implementation von APPLY
a
b
C
f
c
d
e
N
Y
g

B
h
=
i
Y
A
Y
N
af
bg
ch
eN
dY
YN
NN
O ( |BDD1| |BDD2| )
eN
Ni
NY
NN
N
dY
YN
NN
eN
bg
NY
Ni
ch
af
Y
Y
N
A
B
Y
A
A
C
YN
A
YA
BA
B
C
Model Checking EU
geg: SATf, SAT y
ges: SATE(f U y)
Z := SAT y
do
Z := Z  (SATf  SATEX Z)
until nothing changes
SATE(f U y) :=Z
Berechnen kleinsten Fixpunkt eines monoton wachsenden
Mengenoperators
Partitionierung der Übergangsrelation
Idee: T ist meistens Konjunktion Teilformeln
Beispiel:
T1: x0’ w  x0
T2: x1’ w (¬ x1 w x0)
T3: x2’ w (¬ x2 w(x0  x1))
T w T1  T2  T3
Partitionen kleiner als T, günstigenfalls auch in der Summe
mindestens: Eine Partition hängt normalerweise nicht von
allen Variablen ab, ist also auf jeden Fall flacher
als das BDD von T
Nutzt das?
4.2 SAT-basiertes Model Checking
Ansatz: Übersetze das Model Checking Problem in
ein aussagenlogisches Erfüllbarkeitsproblem und
löse dieses.
Inhalt
4.2.1 Ein effizienter SAT-Solver
4.2.2 Noch ein effizienter SAT-Solver
4.2.3 LTL Model Checking als SAT-Problem
SAT-Solver für CNF
(Suche nach erfüllender Belegung)
Ausgangspunkt: Algorithmus von Davis-Putnam aus den 60ern
(xyz)  (¬xy)  (¬yz)  (¬x¬y¬z)
x
¬x
decide
(y)  (¬yz)  (¬y¬z) (yz)  (¬yz)
unit
z
pure literal
y
propagation
propagation
(z)  (¬z)
leere Klauselmenge
z
= SAT!
()
leere Klausel = Konflikt
 Backtracking zur letzten offenen Entscheidung
Simple Rules
0 w (y u z)
y/1
z/0
x w (0 u z)
x/1
x w (x u z)
x/1
x w (y u 1)
x/1
x w (y u 0)
x/¬y
x w (y u y)
x/1
x w (1 u z)
x/z
Dilemma rule
s
s(x/0)
Ableitung 1
s(x/1)
Zusammenführen der
Zweige  Vermeide
redundante Arbeit in
verschiedenen Zweigen
Ableitung 2
s1
s2
s1s2
= Eine der Subst., falls andere zu Konflikt führt;
= diejenigen Subst., die in beiden Zweigen gleich sind, sonst
SAT-basiertes Model Checking
Idee: Übersetze Model Checking Problem in ein
Erfüllbarkeitsproblem
Ausgangspunkt:
boolesche Kodierung des Zustandsraums, analog
zu BDD-basiertem Model Checking
Zustandsüberführungsrelation als boolesche Formel
T(x , x’), ebenfalls analog BDD-Methode
Beschränkte Semantik von LTL
Idee: beschreiben Gegenbeispiel der Länge k
k
1
k
1
l
Ziel: Wenn beschränkter Pfad f erfüllt, so auch jede unendliche
Fortzsetzung
Lassopfade: beschr. Semantik = originale Semantik
kreisfrei:
p k F f w  i  k: p(i) k-i f
p k G f w false
die anderen Operatoren so, wie man es sich denkt
Übersetzung der Semantik
I(x(0))  T(x(0),x(1))  ...  T(x(k-1),x(k))  f0k
kreisfrei:
pik
:= p(x(i))
f yik := fik  yik
¬ fik
G fik
:= false
F fik
:=
X fik
:= falls i < k, dann fi+1k sonst false
j=ik fjk
f U yik := j=ik ( yjk  n=jk fnk)
:=
Prinzipskizze
-
Analyse
Gegenbeispiel
Abstraktionsverfeinerung
Inf. State
Modell
ABSTRAKTION
Fin. State
Modell
Formel
Infinite State Model Checker
Fin. State
Model Checker
+
5. Real-Time Systeme
c2  20000
klick
kaputt
klick c2 hell
aus klick c1 ein
c2>10000
c1  3
klick
c1>3
Uhren c1, c2
Uhrenmenge C
lineare Constraints: ci  k oder ci - cj  k
(k in Nat,  in {=,<,>,,,} können boolesch verknüpft sein
Invarianten (gleiche Syntax)
Resets = Uhren, die auf 0 gesetzt werden
Pfade in Timed Automata
Problem: Zeitkonvergente Pfade “Zeno-Verhalten”
d1  d2  d3  d4  ....
1/2
1/4
1/8
1/16
Def: Nur die zeitdivergenten Pfade bilden die Semantik
von Timed Automata
(Annahme analog zu Fairness)
Regionen
c2
2
1
0
1
2
3
c1
Regionengraph
b) Zeitverlauf
{0} < ......... < {c2,c42,c200}
{0,c2,c42,c200} < .......


{0,c2,c42,200} < ........
{0} < {c2,c42,c200} < .......
Zonen
Problem des Regionengraphs: Zu viele Regionen
 neue Idee: größere Einheiten
Zone = Menge von Uhrenstellungen, die durch eine Konjunktion
von Uhrenconstraints (ci  k oder ci - cj  k,  in {=,<,>,,,
beschreibbar ist
Vereinfachende Annahmen: Constraints und Invarianten im
Timed Automaton seien nur per Konjunktion verknüpft
 sind ihreserseits Zonen
geometrische Veranschaulichung
c2
c2 – c1  0
c1>2
c1 – c2 < 4
c2  3
c1  4
0
c2 > 1
c1
Berechnung engerer Constraints
c1 – 0  4
+ 0 - c2 < -1
c1 – c2 < 3
c1 – c2 < 4
c1 – c2 < 3
c1 – 0  4
0 - c2 < -1
c1
6 Abstraktion
geg: 2 Systeme C und A
Verbindung wird über eine Relation r hergestellt
rot
gelb
Bremse
r
Gas
grün
Simulation
r ist Simulationsrelation, wenn für alle c,a,c’:
Wenn c r a und c  c’ in C, so ex. ein a’ mit
c’ r a’ und a  a’ in A
C
r
A
Simulation und Computation Tree
rot
gelb
Bremse
r
Gas
grün
Bewahrung von ACTL*
Fazit: Berechnungsbaum von C findet sich “als Teilbaum”
des Berechnungsbaums von A wieder


ACTL* quantifiziert nur
universell über Pfade

Satz: Wenn C A simuliert, so gilt jede ACTL*-Eigenschaft
von A auch in C
Konstruktion von Abstraktionen
geg: Konkretes System C = [S,E], Menge A von abstrakten
Zuständen, Relation r von C in A
ges: E’, so daß r Simulationsrelation zwischen C und A wird
Lösung: a  a’ gdw. es gibt c,c’ mit c r a und c’ r a’ und
c  c’
“Existential Abstraction”

Bisimulation
Wenn sowohl r als auch r-1 Simulationsrelationen sind,
heißen C und A bisimilar, und r heißt Bisimulationsrelation
“bisimilar” ist schärfer als “A simuliert C und C simuliert A”!
Bisimulation und CTL(*)
Satz 1: Wenn A und C bisimilar sind, so erfüllen sie die
gleichen CTL*-Formeln
Satz 2: Wenn A und C die gleichen CTL-Formeln erfüllen,
so sind sie bisimilar
Das heißt: Wenn es eine CTL*-Formel gibt, die A und C
unterscheidet, so gibt es bereits eine CTL-Formel.
7 Abstraktionsverfeinerung
7.1 allgemeine Verfeinerung
geg.: simulierende Abstraktionsrelation
z.B. Zonengraph
ges.: mögl. grobe Verfeinerung, die zus. Bedingungen
erfüllt.
z.B. Bisimulation
oder Vererbung von ACTL* in die
andere Richtung
oder Bewahrung weiterer
Elementaraussagen
Mittel: Spaltung von abstrakten Zuständen
Propagierung
Spaltung eines abstrakten Zustandes kann weitere
Spaltungen notwendig machen  Pr
opagation nach
rückwärts...
... bis sich nix mehr ändert
7.2 Gegenbeispielgesteuerte AV
erfüllbare Pfadformel
nicht erfüllbare Pfadformel
dead end state = erreichbar von einem konkreten Zustand im
ersten abstrakten Zustand
bad state = hat Nachfolger
Verfeinerung = trenne dead end und bad states
8. Softwareverifikation
1. komplexe Datentypen und Expressions
2. Pointer und dynamische Datenstrukturen
3. Prozeduren und Rekursion
4. Bibliotheken
typedef struct cell{
int val;
struct cell* next;
} * list;
Predicate
Abstraction
void partition() {
bool b1,b2,b3,b4;
b1 = unknown();
b3 = unknown();
b2 = true;
b4 = unknown();
list partition(list *l, int v) {
skip;
list curr, prev, newl, nextCurr;
while(*) {
assume(!b1);
curr = * l;
skip;
prev = NULL;
if(*) {
newl = NULL;
assume(b3)
while( curr != NULL) {
if(*) {
nextCurr = curr -> next;
assume(!b2);
if(curr -> val > v) {
skip;
if(prev != NULL) {
}
prev -> next = nextCurr;
if(*) {
}
skip;
if(curr == *l) {
}
*l = nextCurr;
skip;
}
L:
skip;
curr -> next = newl;
} else {
L:
newl = curr;
b1: curr==NULL
assume(!b3);
} else {
b2: prev==NULL
b2 = b1;
prev = curr;
b3: curr->val>v
b4 = b3;
}
b4: prev->val>v
}
curr = nextCurr;
b1 = unknown();
}
b3 = unknown();
return newl; AG(@L ucurr!=NULL AND curr->val>v
}
AND (prev->val<=v OR prev=NULL))
}
assume(b1);
AG(@L u!b1 AND b2 AND (!b3 OR b4))
}
Abstract Interpretation
,  und “kleinster Fixpunkt” = unendliche Vereinigung
= Rechnen auf vollständigem Verband
[M, , ] ist Verband, falls – beide Operationen komm., ass.
- Absorption
ggf. neutrale Elemente


vollständig = abgeschlossen geg. unendliche Vereinigung
Verband induziert Halbordnung: x  y gdw. x  y = x
(gdw. x  y = y)
 ist gr. untere Schranke,  ist kl. obere Schranke von 
“passend” = Galois-Verbindung
Konkret: [C,,]
Abstrakt: [A,,]
Abstraktionsfunktion
a: C  A
Konkretisierungsfunktion g: A  C
(a,g) ist Galoisverbindung, wenn
a(x)  Y gdw. x  g(Y)
Insbesondere: z  g(a(z))
a(g(Z))  Z
a – “präziseste Abstraktion”
(x := z, Y := a(z) )
(x := g(Z)), Y := Z )
g – “liberalste Interpretation”
Fixpunktberechnung
nutzt nur etwas, wenn sie in endlich vielen Schritten
terminiert
Variante 1: endlicher abstrakter Verband
Variante 2: Terminierung forcieren  Widening
Shape-Analysis
Insert in Liste:
x : nichtleere Liste
x
malloc(y)
y
x
y -> n = x
y
x
x=y
xy
Coarsening
xy
Slicing
1 read(n);
2 i := 1;
3 sum := 0;
4 product := 1;

5 while i <= n do
(product,10)
6 sum := sum + 1;
7 product := product * i;
8 i := i + 1;
end
9 write(sum);
10 write(product);
1 read(n);
2 i := 1;
4 product := 1;
5 while i <= n do
7 product := product * i;
8 i := i + 1;
end
10 write(product);
9.1 Hybride Systeme
hybrid = kontinuierliche + diskrete Variablen
Hybrider Automat:
h>= max
h’ [ -0.8,0.9]
h’ [ -0.5,0.7]
h <= min
Einlaufen
Auslaufen
(Der hier ist ein linearer Automat: x’ [c1,c2])
9.2 Kompositionale Verifikation
System in Komponenten zerlegen
Komponenten verifizieren
Eigenschaft des Gesamtsystems schlußfolgern
 Assume-Guarantee-Reasoning
Induktion
A) f gilt für System mit 0 oder 1 Komponente
 Model Checking
I)
Wenn f für System mit max. k Komponenten, so
auch mit k+1 Komponenten
kompliziert. Meist manuell.
z.B.:
Versuche, 2 oder mehr Komponenten derart zu abstrahieren,
daß sich Resultat wie 1 Komponente verhält
....
.....
Small Model Properties
Viele Logiken, auch temporale, haben Eigenschaften
der Form
Wenn f in irgendeinem Modell gilt, so gibt es auch ein
Modell der Größe k, wo f gilt.
k z.B. Anzahl der freien Variablen in f
Parametrisiertes Problem kann auf endlich viele
Model Checking Probleme reduziert werden
9.4 Security-Protokolle
Betrachten nicht: Verschlüsselung/Entschlüsselung,
sondern vor allem: Verbindungsaufbau, Authentifizierung,...
“Perfekte Verschlüsselung”
= Inhalt einer verschlüsselten Nachricht ist ohne
Schlüssel nicht verfügbar
“Begrenzter Zufall”
= Wenn eine Zufallszahl (“Nonce”) Bestandteil einer
verschlüsselten Nachricht ist, gibt es keine Möglichkeit,
den Wert dieser Zahl zu ermitteln, als die Nachricht zu
entschlüsseln.
Beide Annahmen falsch, aber sinnvoll.
9.5 Worst-Case-Execution-Time-Analyse
geg: Programm, Prozessor, Taktfrequenz
ges: max. Abarbeitungszeit T:
jede Ausführung braucht garantiert nicht länger als T
T möglichst klein
Probleme im Low-Level und im High-Level-Bereich
kompositionale
Verifikation
parametrisierte
Systeme
Induktion
Assume/Guarantee
Small Model Props
Hardware
Protokolle
Real-Time
Hybrid
Software
Security
System
allgemein (Bismulation)
gegenbeispielgesteuert
(dead end/bad states)
Verfeinerung
Gegenbeispiel
Simulation
Fairness
Bisimulation
guarded commands
Abstract Interpretation
nextstate
Existential Abstraction
Transitionssystem
Predicate Abstraction
Polyhedral Abstraction (Zonen)
Abstraktion
Regionen
Symmetrie
Slicing
Shapes
Spezifikation
symbolische Beschreibungen
SAT-basiertes MC,
Abstraktionsverfeinerung
explizites MC:
-Tiefensuche
-CTL-Algorithmus
-LTL-Algorithmus
(Büchi-Automat)
-Symmetrie
-Partial Order Reduction
-Fairness
-
Modell
verteilt
enabled
zeno
Timed Automata
Hybrid Automata
Formalisierung
Sicherheit
Lebendigkeit
log. Formel
Pfad, ,
Computation Tree
Model Checker
CTL*
LTL
CTL
ACTL
symbolisches MC:
-BDD-basiert
-Fixpunktoperationen
Widening/Narrowing
-Fairness
-SAT-basiert
-SAT-Checker
Model Checking aus Anwendersicht
-Wahl der richtigen Tools/Methoden für den konkreten
Anwendungsfall
verteilt? (ja  Partial Order Reduction  explizites MC)
komplexe Daten? (ja  symbolisch, predicate abstraction oder
abstract interpretation)
Zeit? Vielleicht nur Timeouts (ja  Fairnessannahme, sonst RT)
kont. Anteile  hybrid oder diskrete Abstraktion
Regelmäßige Struktur  Symmetrie oder parametrisiert
Vermeidung schwieriger Operationen (z.B. Mult. bei BDD)
Bewußte, saubere Abstraktion
-Realistische Erwartungshaltung für Resultate
(Laufzeit, Platz, Lösungsgüte)
- Krisenmanagement (z.B. Weitere Abstraktion)
Model Checking aus Theoriesicht
-Logiken und ihre Eigenschaften
small model prop, Gegenbeispielstruktur, Entscheidbarkeit,
Komplexität
-Automatentheorie
-Beziehungen zwischen Systemen
Simulation/Bisimulation/Abstraktion
-Rechtfertigung von Algorithmen (Korrektheit/Vollständigkeit)
z.B. Partial Order Reduction, Bounded Semantics,
Model Checking aus Entwicklersicht
-vielseitig verwendbare Datenstrukturen/Algorithmen
- Graphen, SZK, Automorphismen
- BDD und Fixpunktoperationen
- Automaten
- Constraints und Linaer Programming/Constraint Programming
- Aussagenlogik und SAT-Checking
-Prinzipien zur Effizienzsteigerung
- dynamisches Programmieren (z.B. im expliziten CTL-Alg.)
- Lerntechniken, Heuristiken (z.B. beim SAT-Checking)
- Das “Low Hanging Fruit” Prinzip
- domainspezifische Annahmen
- teile und herrsche (z.B. explizite Fairness)
....
Austausch mit anderen Disziplinen
Komplexitätstheorie
(Rechtfertigung “unsauberer”
Verfahren)
Theorembeweisen
(Software-Verifikation,
Predicate Abstraction,
Entscheidungsprobleme
- SAT
- Bitvektor
- Pressburger, .... )
Logik
(Syntax, Semantik,
Expressivität,
Entscheidbarkeit)
Automatentheorie
Prozeßalgebra
(Komposition, Minimierung,
(Simulation, Bisimulation,
Expressivität)
Partial Order Reduction,
Fairness,
Systembeschreibungssprachen)
Graphtheorie
(SZK, Automorphismen)
Model Checking
Schaltkreisentwurf
(BDD)
Lineare Optimierung/Constraint Programmin
(Lösung von Constraint-Problemen)
Static Analysis
(Abstract Interpretation,
Alias-Analyse, Shape-Analysis,
Slicing)
usw usf
Letzte Folie
Erfolg = solide theoretische Basis
+ Interdisziplinäres Herangehen
+ gesunder Prgmatismus