Computergestützte Verifikation 5.7.2002

Korrektheit 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 Gegenbeispiel - Simulation Fehler- beseitigung Präzisierung Verfeinerung System Spezifikation Abstraktion Modell Model Checker + Überlauf Formalisierung log. Formel

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 inifinite state systems = Zustandsraum unendlich

2 Temporale Logik G F f = f gilt unendlich oft ....... F G f = f stabilisiert .......... G ( f u F y) = f führt zu y .......... Tautologien: F G F f w G F f G F G f w F G f

Der Berechnungsbaum s1 s1 s5 s6 s4 s2 s1 s4 s5 s3 s2 s6 s5 s3 s2 s4 s6

CTL* -Pfadquantoren Wenn f eine Pfadformel ist, so ist E f eine Zustandsformel s s erfüllt E f gdw. es einen Pfad p gibt, der bei s beginnt und p ~ f Wenn f eine Pfadformel ist, so ist A f eine Zustandsformel a,b a,d s erfüllt A f gdw. für alle Pfade p, die bei s beginnen, gilt: p ~ f c Tautologien: A f w  E f A f u E f s ~ E F c s ~ A X a

CTL* - Zusammenfassung LTL CTL nur Pfad- formeln Nur Zust.- formeln

Computation Tree Logic (CTL) CTL = atomare Zustandsaussagen + Boolesche Operatoren + Paare [ Pfadquantor , Temporaloperator ] AG (invariant) AF (irgendwann) AX (in allen Nachf.) A( . U . ) (bis) EG (mgl.weise immer) EF (möglich) EX (in einem Nachf.) E( . U . ) (bis)

Progress und Fairness d e a b p p p a d f c b e F p gilt nicht !!?!?!?! p

Model Checking für finite state systems explizit: symbolisch: explizite Konstruktion eines Transitionssystems, Datenstruktur, die Mengen von Zuständen bzw. Pfaden beschreibt, Operationen, die simultan die Nachfolger aller Zustände berechnet das sich in bezug auf die untersuchte Eigenschaft äquivalent zum gegebenen verhält, aber in der Regel wesentlich kleiner ist. Eigenschaft wird durch Fixpunktoperationen auf der symbolischen Datenstruktur berechnet Eigenschaft wird durch Graphsuche nach Zeugen/ Gegenbeispielen verifiziert

3 Explizites Model Checking 3.1 Tiefensuche 6 2 5 [v,v’] ist Baumkante, falls [v,v’] in T 4 [v,v’] ist Vorwärtskante, falls [v,v’] in T*\T 3 1 [v,v’] ist Rückwärtskante, falls [v’,v] in T* [v,v’] ist Querkante, sonst 2 5 [v,v’] in Quer  v.dfs > v’.dfs 1 [v,v’] in Vorwärts v.dfs v’.dfs 3 [v,v’] in Rückwärts  v.dfs > v’.dfs 6 4 [v,v’] in Rückwärts  v ~ v’

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

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

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

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) (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: regelmäßig strukturierte Datentypen 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) (i,c,0) (r,c,0) (c,r,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: c(v) = c(s(v)) 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: 1 2 4 3 =  1 2 4 3 = incr

Komplexität des Automorphismenproblems eng verwandt: Graphisomorphie NP NPV ? Ein Graph kann exponentiell viele Automorphismen haben ? P

Konzept für Erzeugendensystem 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 poly 4 3 1 2 8 1 6 7 8 5 a b f a e c R* D R* R* R* D D R* R* R* R* R* 8 3 2 c 8 3 2 c exp = #Ai  #Bi ist selten  meistens poly. Laufzeit!!!

Orbitproblem id id geg: s ges: canrep(s) g11 g12 g13 g14 g21 g22 g23 g31 g32 geg: s ges: canrep(s) 1. s1 := MIN{g1i-1(s), i = ...} ........ n. sn := MIN{g1i-1(s[n-1]), i = ...} 2. s2 := MIN{g2i-1(s1), i = ...} 3. s3 := MIN{g3i-1(s2), 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 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.

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. s w 1. Fall: in w kommt ein a aus ample(s) vor s s1 s2 w1 a w2 s1’ s2 w1 a w2 2. Fall: in w kommt kein a aus ample(s) vor s w a s1’ w 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 s s1 s2 w1 a w2 s1’ d a unsichtbar oder w1 leer 2. Fall: in w kommt kein a aus ample(s) vor s w a s1’ a unsichtbar 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 Y N BDD Größe N N Y Y N Y 4 8 12 16 Elemente in Menge

Implementation von APPLY C B A C f bg B B c b g h = A eN A  i d e N Y N NN NN N Y N Y dY Y af Y N A Y A B Ni A bg ch YN YN Y dY eN eN Ni NY NY Y NN ch A af C O ( |BDD1| |BDD2| )

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’   x0 T2: x1’  (¬ x1  x0) T3: x2’  (¬ x2 (x0  x1)) T  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) (z)  (¬z) y unit propagation z leere Klauselmenge = SAT! pure literal propagation z () leere Klausel = Konflikt  Backtracking zur letzten offenen Entscheidung

Simple Rules 0  (y  z) x  (y  1) x  (1  z) y/1 z/0 x/1 x/z x  (y  y) x/1 x/1

Dilemma rule Zusammenführen der Zweige  Vermeide redundante Arbeit in verschiedenen Zweigen s s(x/0) s(x/1) s1 s2 Ableitung 1 Ableitung 2 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 1 l k 1 k Ziel: Wenn beschränkter Pfad f erfüllt, so auch jede unendliche Fortzsetzung Lassopfade: beschr. Semantik = originale Semantik kreisfrei: k F f   i  k: p(i) k-i f k G f  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 := ¬  fik G fik := false F fik := j=ik fjk X fik := falls i < k, dann fi+1k sonst false f U yik := j=ik ( yjk  n=jk fnk)

Prinzipskizze - + Infinite State Model Checker Analyse Gegenbeispiel Abstraktions- verfeinerung Inf. State Modell Formel ABSTRAKTION Fin. State Modell + Fin. State Model Checker Infinite State Model Checker

5. Real-Time Systeme Invarianten (gleiche Syntax) c2  20000 klick Resets = Uhren, die auf 0 gesetzt werden c1 c2 klick aus ein klick hell kaputt lineare Constraints: ci  k oder ci - cj  k (k in Nat,  in {=,<,>,,,} können boolesch verknüpft sein) c1>3 c1  3 c2>10000 klick Uhren c1, c2 Uhrenmenge C

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 1 2 3 c1

Regionengraph b) Zeitverlauf {0} < ......... < {c2,c42,c200}  {0,c2,c42,200} < ........ {0,c2,c42,c200} < .......  {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 – c1  0 c1>2 c1 – c2 < 4 c2  3 c2 > 1 c1  4 c1

Berechnung engerer Constraints c1 – c2 < 3 c1 – c2 < 4 c1 – c2 < 3 0 - c2 < -1 c1 – 0  4 c1

6 Abstraktion geg: 2 Systeme C und A Verbindung wird über eine Relation r hergestellt rot gelb grün Gas Bremse r

Simulation 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 A r

Simulation und Computation Tree rot Bremse r gelb 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 dead end state = erreichbar von einem konkreten Zustand im ersten abstrakten Zustand bad state = hat Nachfolger erfüllbare Pfadformel nicht erfüllbare Pfadformel Verfeinerung = trenne dead end und bad states

8. Softwareverifikation komplexe Datentypen und Expressions Pointer und dynamische Datenstrukturen Prozeduren und Rekursion 4. Bibliotheken

Predicate Abstraction void partition() { bool b1,b2,b3,b4; b1 = unknown(); b3 = unknown(); b2 = true; b4 = unknown(); skip; while(*) { assume(!b1); if(*) { assume(b3) if(*) { assume(!b2); } L: skip; } else { assume(!b3); b2 = b1; b4 = b3; assume(b1); Predicate Abstraction typedef struct cell{ int val; struct cell* next; } * list; list partition(list *l, int v) { list curr, prev, newl, nextCurr; curr = * l; prev = NULL; newl = NULL; while( curr != NULL) { nextCurr = curr -> next; if(curr -> val > v) { if(prev != NULL) { prev -> next = nextCurr; } if(curr == *l) { *l = nextCurr; curr -> next = newl; L: newl = curr; } else { prev = curr; curr = nextCurr; return newl; b1: curr==NULL b2: prev==NULL b3: curr->val>v b4: prev->val>v AG(@L curr!=NULL AND curr->val>v AND (prev->val<=v OR prev=NULL)) AG(@L !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)) (x := z, Y := a(z) ) a(g(Z))  Z (x := g(Z)), Y := Z ) a – “präziseste Abstraktion” 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 x y -> n = x y x y x = y Coarsening xy

Slicing 1 read(n); 2 i := 1; 3 sum := 0; 4 product := 1; 5 while i <= n do sum := sum + 1; product := product * i; i := i + 1; end 9 write(sum); 10 write(product); 1 read(n); 2 i := 1; 4 product := 1; 5 while i <= n do product := product * i; i := i + 1; end 10 write(product);  (product,10)

9.1 Hybride Systeme hybrid = kontinuierliche + diskrete Variablen Hybrider Automat: h>= max h’ [ -0.8,0.9] h’ [ -0.5,0.7] h <= min Auslaufen Einlaufen (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 f gilt für System mit 0 oder 1 Komponente  Model Checking 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

Verfeinerung Abstraktion Model Checker Formalisierung kompositionale Verifikation parametrisierte Systeme Induktion Assume/Guarantee Small Model Props symbolische Beschreibungen SAT-basiertes MC, Abstraktionsverfeinerung allgemein (Bismulation) gegenbeispielgesteuert (dead end/bad states) Verfeinerung Gegenbeispiel Hardware Protokolle Real-Time Hybrid Software Security Simulation Bisimulation Abstract Interpretation Existential Abstraction Predicate Abstraction Polyhedral Abstraction (Zonen) Regionen Symmetrie Slicing Shapes Fairness explizites MC: Tiefensuche CTL-Algorithmus LTL-Algorithmus (Büchi-Automat) Symmetrie Partial Order Reduction Fairness guarded commands nextstate Transitionssystem Abstraktion Modell System - verteilt enabled Model Checker zeno Timed Automata Hybrid Automata symbolisches MC: BDD-basiert Fixpunktoperationen Widening/Narrowing Fairness SAT-basiert SAT-Checker Formalisierung log. Formel CTL* LTL CTL ACTL Spezifikation Sicherheit Lebendigkeit Pfad, , Computation Tree

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 Automatentheorie (Komposition, Minimierung, Expressivität) Prozeßalgebra (Simulation, Bisimulation, Partial Order Reduction, Fairness, Systembeschreibungssprachen) Komplexitätstheorie (Rechtfertigung “unsauberer” Verfahren) Graphtheorie (SZK, Automorphismen) Theorembeweisen (Software-Verifikation, Predicate Abstraction, Entscheidungsprobleme - SAT - Bitvektor - Pressburger, .... ) Model Checking Schaltkreisentwurf (BDD) Lineare Optimierung/Constraint Programming (Lösung von Constraint-Problemen) Static Analysis (Abstract Interpretation, Alias-Analyse, Shape-Analysis, Slicing) Logik (Syntax, Semantik, Expressivität, Entscheidbarkeit) usw usf

Letzte Folie Erfolg = solide theoretische Basis + Interdisziplinäres Herangehen + gesunder Prgmatismus

The End