E zientes Model-Checking f ur CTL - thi.uni- · PDF fileE zientes Model-Checking f ur CTL Diplomarbeit im Studiengang Mathematik mit Studienrichtung Informatik Julia Gerock Mtr.-Nr

Effizientes Model-Checking fur CTL

Diplomarbeitim Studiengang Mathematik mit Studienrichtung Informatik

Julia GerockMtr.-Nr. 2294990

Institut fur Theoretische InformatikFakultat fur Elektrotechnik und Informatik

Leibniz Universitat Hannover

Prufer: Prof. Dr. Heribert VollmerZweitprufer: Prof. Dr. Rainer Parchmann

Betreuer: M. Sc. Arne Meier

26. Oktober 2009

Danksagung

Ich bedanke mich ganz herzlich bei Herrn Arne Meier fur die hervorragende Betreuungund Unterstutzung meiner Diplomarbeit.

Inhaltsverzeichnis

1 Einfuhrung 11.1 Motivation und Aufgabenstellung . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Gliederung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2 Theoretische Grundlagen 32.1 Model-Checking-Prozess . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32.2 Kripke-Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42.3 CTL als eine von temporalen Logiken . . . . . . . . . . . . . . . . . . . . . . 52.4 Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.5 Komplexitatstheorie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

3 Model-Checking fur CTL 133.1 Formulierung des Problems . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133.2 Komplexitat des Model-Checking-Problems fur CTL . . . . . . . . . . . . . 143.3 Model-Checking fur CTL und CTLpos . . . . . . . . . . . . . . . . . . . . . 15

3.3.1 CTL-MC(ALL) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153.3.2 CTLpos-MC(EX, EG, EU, ER) . . . . . . . . . . . . . . . . . . . . 17

4 Design und Implementierung 214.1 Basisprogramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214.2 Neue Klassenstruktur und die Implementierungsaspekte . . . . . . . . . . 224.3 Bedienungsanleitung zum Programm . . . . . . . . . . . . . . . . . . . . . . 30

5 Auswertung von Algorithmen 365.1 Allgemeine Beschreibung der Experimente . . . . . . . . . . . . . . . . . . . 36

5.1.1 Testsystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365.1.2 Testdaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375.1.3 Ablauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

5.2 Zwei Implementierungen des CTLpos-Algorithmus . . . . . . . . . . . . . . 385.3 Auswertung von CTLpos- und CTL-Algorithmen . . . . . . . . . . . . . . . 405.4 Laufzeit des CTL-Algorithmus fur Kripke-Strukturen mit bis zu 300 Zu-

standen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

6 Zusammenfassung und Ausblick 48

Literaturverzeichnis 54

1 Einfuhrung

1.1 Motivation und Aufgabenstellung

Heutzutage werden Software- und Hardware-Systeme so gut wie in jedem Gebiet ein-gesetzt und haben sich in unserem Leben fest etabliert. Somit wird die Abhangigkeitvon der Zuverlassigkeit dieser Systeme immer großer. Andererseits wird es schwieriger,die Funktionsweise fehlerfrei zu gewahrleisten, da sich der Umfang und die Komplexitatder Systeme auch standig steigern. Mithilfe der Standardmittel wie Testen oder Simu-lation werden Fehlerfalle oft unvollstandig abgedeckt. Und sogar bei einer vollstandigenAbdeckung kann das System weitere Fehler enthalten, die nicht entdeckt wurden.

Deswegen ist die Notwendigkeit entstanden, neue, moglichst effiziente Methoden zuentwickeln, um mit deren Hilfe die Korrektheit und somit die Qualitat eines Systemszu sichern und beweisen zu konnen. Dies kann ermoglicht werden, indem ein zu entwi-ckelndes System sowie dessen relevante Eigenschaften formalisiert werden, und es durchVerifikation uberpruft wird, ob die gewunschten Eigenschaften im System erfullt sind.

Model-Checking als eine dieser Methoden basiert auf diesem Prinzip. Dabei werdenein Modell M , als eine Beschreibung des Systems, und eine logische Formel ϕ, als eineSpezifikation des Systems, verifiziert (M ⊧ ϕ).

Je nach der Art der Formeln1 werden diverse Klassen von Model-Checking-Problemenunterschieden. Diese Arbeit befasst sich mit dem Model-Checking-Problem fur CTL(Computation Tree Logic).

Ziel der Arbeit besteht darin, dieses Problem in Bezug auf seine Effizienz auszuarbei-ten. Als Basis werden die im Institut fur Theoretische Informatik der Leibniz UniversitatHannover entstandenen Ergebnisse der Forschung des Model-Checking-Problems ver-wendet, die weiter unten dargestellt sind. Das Model-Checking-Problem fur CTL ist alsP-vollstandig bekannt. Zugehorigkeit eines Problems zu einer Komplexitatsklasse kanndurch Angeben eines Algorithmus bewiesen werden, der dieses Problem entscheidet undselbst in dieser Komplexitatsklasse liegt. Ein weiteres Ziel der Arbeit ist es, diverse Al-gorithmen des Model-Checking-Problems fur CTL vorzustellen, zu implementieren undihre Effizienz zu vergleichen.

1In Abhangigkeit davon, welche Operatoren erlaubt bzw. welche Constraints festgelegt sind (z. B. CTL,CTL*, LTL).

1

1 Einfuhrung

1.2 Gliederung

In der vorliegenden Arbeit wird nach der Einleitung in Kapitel 2 auf theoretischeGrundlagen eingegangen. Hier werden wichtige Grundbegriffe definiert, die fur diese Ar-beit benotigt werden. Danach wird ein Beispiel prasentiert, um ein intuitives Verstandniszu schaffen.

Kapitel 3 bildet den Hauptteil dieser Arbeit. Hier wird das Model-Checking-Problemfur CTL konkretisiert. Dabei wird untersucht, mit welcher Effizienz dieses Problem gelostwerden kann und welche Schwierigkeiten sich dabei ergeben. In Abschnitt 3.3.1 wirddas Model-Checking-Problem auf die gesamte Klasse CTL verallgemeinert und ein Al-gorithmus aus [CGP99] prasentiert, der in Polynomialzeit arbeitet. In Abschnitt 3.3.2wird ein speziell definiertes Fragment CTLpos betrachtet. Fur dieses wird hier ein weitererEntscheidungsalgorithmus aus [BMT+] vorgestellt.

In Kapitel 4 wird behandelt, wie die in Kapitel 3 geschilderten Algorithmen im-plementiert werden konnen. Diese werden als eine Erweiterung eines existierenden Pro-gramms ([Sol09]) realisiert. Das Programm wird hier auch kurz erlautert.

In Kapitel 5 wird die Laufzeit der Algorithmen fur CTL und CTLpos untersucht undverglichen. Experimente und deren Ergebnisse werden hier veranschaulicht.

Kapitel 6 enthalt eine Zusammenfassung und einen Ausblick der Diplomarbeit.

2

2 Theoretische Grundlagen

In diesem Kapitel werden die fur diese Arbeit relevanten Begriffe wie Model-Checking,Kripke-Struktur, temporale Logik und insbesondere CTL eingefuhrt und in Anlehnungan [CGP99] definiert. Diese werden anschließend mittels eines Beispiels verdeutlicht.Um die Effizienz des Model-Checking-Problems untersuchen zu konnen, werden auchdie fur dieses Thema wichtigsten Resultate der Komplexitatstheorie in diesem Kapitelzusammengefasst.

2.1 Model-Checking-Prozess

Model-Checking ist als eine Verifikationsmethode von endlichen zustandsbasierten Sys-temen bekannt, die die Korrektheit eines Systems bezuglich seiner Spezifikation beweistoder widerlegt und dabei automatisch ablauft. Diese zwei vorteilhaften Aspekte unter-scheiden Model-Checking von den anderen Verifikationsverfahren (z. B. deduktive Verifi-kation) sowie von dem Testen und der Simulation erheblich (vgl. [Sch]). Der Begriff wurdein den 80 Jahren gepragt. Diese Methode ist bereits fur den Korrektheitsnachweis beimEntwurf von komplexen sequentiellen Schaltungen und von Kommunikationsprotokollenerfolgreich praktisch eingesetzt worden (vgl. [CGP99]). Mit Hilfe des Model-Checkingskonnen zur Zeit sowohl Hardware- als auch Software-Systeme untersucht werden.

Im Allgemeinen gliedert sich das Model-Checking in drei Schritte:

1. Modellierung

2. Spezifizierung

3. Verifikation

Im ersten Schritt muss ein zu analysierendes System S in eine vereinbarte Form ge-bracht werden. Somit wird ein Modell M des Systems S erzeugt. Hier ist es wichtig,relevante von nicht relevanten Eigenschaften des Systems zu trennen und nur die signifi-kanten, diese aber alle, abzubilden. Außerdem ist es zu entscheiden, ob das System zumAnwenden des Model-Checkings tauglich, d. h. zustandsbasiert und endlich (mit einemendlich reprasentierbaren Zustandsraum) ist. Dabei kann eine Zustandsexplosion ent-stehen. In den letzten zehn Jahren wurden aber erhebliche Fortschritte zur Behandlungdieses Problems erreicht (siehe [CGP99]).

Es gibt mehrere Methoden, um ein System in ein Modell zu uberfuhren. In dieserArbeit erfolgt dies mittels Konstruierens einer Kripke-Struktur, die in Abschnitt 2.2erlautert wird.

3


In der Spezifikationsphase werden geforderte Eigenschaften des Systems S formal er-fasst. Somit entsteht eine Spezifikation als eine Menge von Regeln, die das System erfullenmuss. Bei der Erstellung der Spezifikation spielt ihre Vollstandigkeit eine zentrale Rolle,da nur diejenigen Eigenschaften mit dem Modell verifiziert werden, die in der Spezifika-tion vorkommen. Wenn nicht alle relevanten Systemanforderungen in der Spezifikationabgebildet sind, werden sie bei der Verifikation nicht beachtet. Dies kann allerdings zueiner falschen Entscheidung fuhren, dass das Modell die Systemanforderungen erfullt,obwohl das nicht vollstandig gepruft wurde.

Meistens wird temporale Logik als Spezifikationssprache von den Software- und Hard-ware-Systemen benutzt. Temporale Logik ermoglicht es, zeitliche Ablaufe des Systems zubeschreiben. In diesem Fall wird die Spezifikation als eine Menge von temporal-logischenFormeln ϕ formuliert. Jede Formel druckt das nachzuweisende Verhalten des Systemsuber die Zeit aus. In Abschnitt 2.3 wird auf die temporale Logik genauer eingegangen.

Im letzten Schritt werden spezielle Model-Checking-Algorithmen angewendet, umnachzuweisen oder zu widerlegen, dass das Modell M die Spezifikation ϕ erfullt. DieserSchritt erfolgt großtenteils automatisch, menschliche Teilnahme wird in der Praxis nurbei der Analyse der Verifikationsergebnisse gefordert.

Das Model-Checking-Problem kann folgendermaßen formuliert werden. Sei S ein zuanalysierendes System.

Eingabe: ein Modell M des Systems S

eine nachzuweisende Eigenschaft ϕ, die das System S haben muss

Frage:”Erfullt das Modell M die Spezifikation ϕ?“

(M ⊧ ϕ?)

Eine genauere Definition fur das fur die vorliegende Arbeit auszuarbeitende Model-Checking-Problem fur CTL wird in Abschnitt 3.1 gegeben, nachdem die Begriffe

”Kripke-

Struktur“ und”CTL“ in den nachsten Abschnitten eingefuhrt werden.

2.2 Kripke-Struktur

Zum Modellieren von endlichen zustandsbasierten Systemen werden beim Model-Che-cking Kripke-Strukturen verwendet. Diese ermoglichen, Eigenschaften eines Systems inverschiedenen Zustanden zu beschreiben, indem bestimmte Aussagen uber das Systemden Zustanden zugeordnet werden. Beispielsweise ist eine Ampel (ein System) in einemZustand

”rot“, und dabei wird ein

”Tonsignal“ abgegeben. In diesem Fall wird dieser

Zustand beim Modellieren der Ampel mit den beiden Aussagen”rot“ und

”Tonsignal“

markiert.Eine Kripke-Struktur ist wie folgt definiert (vgl. [CGP99], [BMT+]).

4


Definition 2.2.1 (Kripke-Struktur) Sei AP eine Menge der atomaren Aussagen(atomic propositions). Eine Kripke-Struktur K uber AP ist ein 4-Tupel K = (W, W0, R,η), wobei

1. W eine endliche Menge der Zustande ist;

2. W0 ⊆W die Menge der Start-Zustande ist;

3. R ⊆W ×W eine totale Transitionsrelation ist, d. h. fur jeden Zustand w ∈ W gibtes einen Zustand w’ ∈ W mit (w, w’) ∈ R;

4. η ∶ W → P(AP ) eine Beschriftungsfunktion (labelling function) ist, die jedemZustand die Menge der atomaren Aussagen zuordnet, die in diesem Zustand erfulltsind.

Bemerkung:

• Manchmal wird die Menge der Start-Zustande nicht explizit angegeben. In diesenFallen wird W0 aus der Definition ausgelassen.

• Ublicherweise wird die Menge der atomaren Aussagen AP im Hinblick auf diegewunschte Spezifikation konstruiert. (vgl. [Sch])

In Abschnitt 2.4 ist ein Beispiel zu finden, wie sich ein System als eine Kripke-Strukturgestalten lasst.

2.3 CTL als eine von temporalen Logiken

Temporale Logik wurde als eine Erweiterung der Aussagenlogik mit dem Ziel definiert,zeitliche Anderungen beschreiben zu konnen. Die Zeit wird hier als Folge (oder spater alsPfad) von Zustanden betrachtet. In diversen Zustanden konnen Aussagen verschiedeneWahrheitswerte annehmen. Temporale Logik ermoglicht es, fur eine logische Aussage ϕsolche Beziehungen zu modellieren, wie z. B.

”ϕ gilt immer“,

”ϕ wird nie wahr“,

”ϕ wird

zum nachsten Zeitpunkt gelten“ usw. Dies erfolgt mittels der sogenannten temporalenOperatoren. Um auszudrucken, dass eine Eigenschaft des Systems gelten muss bzw.kann, werden die Pfad-Quantoren A bzw. E verwendet. Temporale Operatoren undPfad-Quantoren sind in den Tabellen 2.1 und 2.2 aufgelistet und erlautert.

Temporale Logik wurde im Jahr 1977 in der Arbeit von A. Pnueli”The Temporal Lo-

gic of Programs“ als eine Formalisierungssprache fur Spezifikation und Verifikation vonvergleichbaren Programmen zum ersten Mal vorgestellt und hat sich als eine Spezifika-tionsmethode zur Erfassung von Systemanforderungen beim Model-Checking etabliert.

5


Operator Syntax Bedeutung Semantik Beispielpfad

F F ϕ”in the

future“ oder

”eventually“

ϕ gilt irgendwannauf dem nachfol-genden Pfad

G G ϕ”globally“

oder”al-

ways“

ϕ gilt in jedem Zu-stand auf dem Pfad

X X ϕ”next time“ ϕ gilt im nachsten

Zustand

U ϕ U ψ”until“ ϕ gilt in jedem Zu-

stand, bis der Zu-stand erreicht wird,in dem ψ wahr ist

R ϕ R ψ”release“ ψ gilt bis zu einem

Zustand, in dem ϕgilt oder fur im-mer, wenn ϕ immerfalsch ist

Tabelle 2.1: Temporale Operatoren. ϕ,ψ sind temporal-logische Formeln

Quantor Syntax Name Semantik

A A ϕ Allquantor Fur alle Pfade gilt ϕE E ϕ Existenzquantor Es existiert ein Pfad, fur den ϕ gilt

Tabelle 2.2: Pfad-Quantoren

In Abhangigkeit von verwendeten Operatoren und von deren Semantik werden folgen-de Klassen von temporalen Logiken unterschieden:

LTL: Linear Temporal Logic betrachtet die Zeit als eine lineare Abfolge von Zeitpunktenbzw. Zustanden

CTL: Computational Tree Logic charakterisiert die Zeit als ein verzweigender Ablauf vonZustanden

CTL*: Extended Computation Tree Logic. CTL* ⊃ LTL ∪ CTL. Ausdruckskraft von CTL*,CTL und LTL ist nicht vergleichbar, da sich nicht jede in einer Logik formulierte

6


Aussage in eine aquivalente Aussage in der anderen Logik transformieren lasst.Beispiele dazu sind in [CGP99], [Sol09] zu finden.

Da das Model-Checking-Problem fur diese Arbeit auf CTL eingeschrankt ist, wird dieseLogik hier genauer betrachtet. CTL wurde von Emerson und Clarke eingefuhrt. Wie dieanderen temporalen Logiken beinhaltet sie folgende Bausteine:

• atomare Aussagen

• boolesche Operatoren ¬(NOT), ∧(AND) und ∨(OR)

• temporale Operatoren F,G,X,U,R

• Pfad-Quantoren A,E

Die Sprache, die aus diesen Operatoren und Quantoren besteht, heißt CTL*. Ausdiesen Komponenten werden CTL*-Formeln gestaltet. CTL* ist in [CGP99] und [Sol09]ausfuhrlich beschrieben.

Eine CTL-Formel ist eine CTL*-Formel mit einer Einschrankung auf die Verwendungvon temporalen Operatoren und Pfad-Quantoren. Jeder temporale Operator darf nurnach einem Pfad-Quantor auftreten, und jeder Pfad-Quantor darf nur gefolgt von einemtemporalen Operator in den CTL-Formeln vorkommen. Die Operatoren AF, AG, AX,AU, AR werden universale Operatoren genannt, EF, EG, EX, EU, ER heißen exis-tenzielle Operatoren. Universale und existenzielle Operatoren bilden die Menge ALLvon allen CTL-Operatoren.

Weiter wird eine CTL-Formel induktiv definiert.

Definition 2.3.1 (CTL-Formel) Sei AP eine Menge von atomaren Aussagen, Q ∈{A,E}. Die Symbole ⊺ und � reprasentieren die Wahrheitswerte

”wahr“ und

”falsch“.

• ⊺, � sind CTL-Formeln.

• Ist p ∈ AP , so ist p eine CTL-Formel.

• Sind ϕ,ψ CTL-Formeln, dann sind (ϕ), ¬ϕ, ϕ ∧ ψ, ϕ ∨ ψ, QF ϕ, QG ϕ, QX ϕ,Q(ϕ U ψ), Q(ϕ R ψ) auch CTL-Formeln.

Man unterscheidet zwei Arten von Formeln: Zustand- und Pfad-Formeln. Zustand-Formeln beschreiben Eigenschaften, die in einem Zustand gelten, und Pfad-Formelncharakterisieren Eigenschaften entlang eines Pfades.

Definition 2.3.2 (Zustand-Formel)

• ⊺, � sind Zustand-Formeln.

• Ist p ∈ AP , so ist p eine Zustand-Formel.

• Sind ϕ,ψ Zustand-Formeln, dann sind (ϕ), ¬ϕ, ϕ ∧ ψ, ϕ ∨ ψ Zustand-Formeln.

• Ist χ eine Pfad-Formel, so ist Aχ eine Zustand-Formel.

7


Definition 2.3.3 (Pfad-Formel)

• Ist ϕ eine Zustand-Formel, so ist ϕ auch eine Pfad-Formel.

• Sind χ,π Pfad-Formeln, dann sind (χ), ¬χ, χ ∧ π, χ ∨ π, Xχ und χ U π Pfad-Formeln.

Weiterhin ist {EX, EU, EG} eine minimale Menge der CTL-Operatoren, da jedeCTL-Formel in eine aquivalente Formel konvertiert werden kann, in der nur die CTL-Operatoren EX, EU, EG sowie die booleschen Operatoren ¬ und ∨ verwendet werden.In der Tabelle 2.3 sind die entsprechenden Regeln aufgelistet.

Regel № Allgemeine Form Konvertierte Form

1 E ϕ ¬A¬ϕ2 ϕ ∧ ψ ¬(¬ϕ ∨ ¬ψ)3 EF ϕ E(⊺ U ϕ)4 E(ϕ R ψ) EG ψ∨ E (ψ U ¬(¬ϕ ∨ ¬ψ))5 AF ϕ ¬ EG(¬ϕ)6 AX ϕ ¬ EX(¬ϕ)7 AG ϕ ¬ EF(¬ϕ)8 A(ϕ U ψ) ¬ (EG (¬ψ)∨ E (¬ψ U ¬(ϕ ∨ ψ)))9 A(ϕ R ψ) ¬ E (¬ϕ U ¬ψ)

Tabelle 2.3: Darstellung der CTL-Formeln durch die Operatoren EX, EU, EG, ¬, ∨

CTL, als eine CTL*-Logik, basiert auf der Kripke-Struktur. Um Systemanforderungenmittels CTL-Formeln zu spezifizieren, mussen diverse Eigenschaften des Systems in ver-schiedenen Zeitpunkten beschrieben werden. Die Zeitskala wird als Pfad von Zustandenin der das System reprasentierenden Kripke-Struktur interpretiert. Weiter wird ein Pfaddefiniert.

Definition 2.3.4 (Pfad) Sei K = (W, W0, R, η) eine Kripke-Struktur. Ein Pfad x inder Kripke-Struktur K ist eine unendliche Sequenz von Zustanden x = (x1, x2, ...) ∈W ω,so dass (xi, xi+1) ∈ R ∀i ≥ 1.

In Abschnitt 2.4 wird mittels eines Beispiels gezeigt, wie Systemanforderungen alsCTL-Formeln erfasst werden konnen.

2.4 Beispiel

Ein Model-Checking-Prozess kann in folgenden Schritten kurz gefasst werden. Sei S einzu analysierendes System.

1. Modellierung: im ersten Schritt wird ein Modell M vom System S erstellt. M isteine formale Beschreibung des Systems und spiegelt relevante Eigenschaften von Swider. Als Modellierungsmechanismus wird hier Kripke-Struktur eingesetzt.

8


2. Spezifizierung: hier werden Systemanforderungen Φ = {φj ∣ j = 0,1, ...} erfasst. Furdiese Arbeit sind solche Eigenschaften von Systemen relevant, die uber verzweigen-de Zeit festgelegt werden sollen. Diese werden mittels CTL-Formeln formalisiert.

3. Verifikation: anschließend wird durch das Anwenden eines Algorithmus das Model-Checking-Problem entschieden, das folgendermaßen formuliert werden kann:

”Erfullt das Modell M die Spezifikation Φ?“

An dieser Stelle wird ein Beispiel vorgestellt, mit dem gezeigt wird, wie Model-Checkingangewendet werden kann.

Es handelt sich um das bekannte”Speisende Philosophen“-Problem (siehe Abbildung

2.1). 5 Philosophen A, B, C, D und E sitzen um einen Tisch. Es gibt funf Teller mitdem Essen fur jeden Philosophen, und zwischen je zwei Tellern liegt eine Gabel. Jederdenkt nach und isst abwechselnd. Zum Essen benotigen sie jeweils die beiden Gabelnneben sich. Es konnen somit maximal zwei Personen, die nicht nebeneinander sitzen,gleichzeitig speisen (vgl. [Har02]).

Abbildung 2.1: Speisende Philosophen (vgl. [Sch])

Dieses Problem kann als ein zu analysierendes System S betrachtet werden. S kann mitHilfe eines Graphen G (Abbildung 2.2) oder als eine entsprechende Kripke-Struktur K(Abbildung 2.3) modelliert und durch bestimmte Regeln (Systemanforderungen) ρj,j=0,1,...,die mittels temporal-logischer Formeln (hier CTL-Formeln) ϕj beschrieben werden, spe-zifiziert werden.

Die Bezeichnungen der Zustande sind so gewahlt, dass man erkennen kann, welchePhilosophen in diesem Moment essen (bis auf den Ausnahmezustand S). Das heißt, imZustand A isst der Philosoph A, im Zustand AC speisen die Philosophen A und C, im Zu-stand S in der Mitte denken alle Philosophen nach. Die Ubergange zwischen den Zustan-den stellen die Aktionen der Philosophen dar. Wenn ein Philosoph I ∈ {A,B,C,D,E}eine Gabel vom Tisch aufnimmt (pick up) bzw. zuruckgibt (return), wird der entspre-chende Ubergang mit Ip bzw. Ir beschriftet.

Wenn man das System S in eine Kripke-Struktur K uber AP uberfuhrt, ist sie wiefolgt definiert und in Abbildung 2.3 dargestellt.

9


Abbildung 2.2: Speisende Philosophen als ein Modell([Har02])

K = (W, {S}, R, η), wobei

• AP = {a, b, c, d, e} die Menge der atomaren Aussagen ist, die den Namen derspeisenden Philosophen entsprechen;

• W = {S, A, B, C, D, E, AC, DA, DB, EB, EC} die Menge der Zustande ist;

• R = {(S, A), (S, B), (S, C), (S, D), (S, E), (A, S), (B, S), (C, S), (D, S),(E, S), (A, AC), (A, DA), (B, EB), (B, DB), (C, AC), (C, EC), (D, DB),(D, DA), (E, EC), (E, EB), (EB, B), (EB, E), (AC, A), (AC, C), (DB, B),(DB, D), (EC, C), (EC, E), (DA, A), (DA, D)} die Transitionsrelation ist;

• η ∶ W → P(AP ), fur p ∈ AP,w ∈ W gilt: p ∈ η(w), falls der Philosoph mit demNamen P (

”groß p“) in dem Zustand w isst. Z. B. wenn der Philosoph A in dem

Zustand w speist, dann ist a ∈ η(w).

Das System S muss unter anderen z. B. folgende Eigenschaften erfullen:

• ρ0 =”Die Philosophen A und B durfen nie gleichzeitig essen.“

• ρ1 =”Philosoph A isst als erster.“

• ρ2 =”Wenn Philosoph D nichts gegessen hat, kann er irgendwann zusammen mit

B etwas essen.“

10


Abbildung 2.3: Speisende Philosophen als eine Kripke-Struktur

• ρ3 =”Immer, wenn Philosoph D fertig gegessen hat, muss er solange nachdenken

oder warten, bis Philosoph E auch etwas gegessen hat.“

Die entsprechenden CTL-Formeln sehen wie folgt aus:

• ϕ0 = AG ¬(a ∧ b);

• ϕ1 = A (¬(b ∨ c ∨ d ∨ e) U a);

• ϕ2 = ¬d→ EF(d ∧ b) = d ∨ EF(d ∧ b);

• ϕ3 = AG(¬d→ A(¬d U e)) = AG(d ∨ A(¬d U e));

Somit ist K ein Modell des Systems S und Φ = {ϕi ∣ i = 0, ...,3} ist eine Spezifikation.Die Frage, ob das Modell K die Spezifikation Φ erfullt, kann beantwortet werden, in-

dem K und jede φ ∈ Φ verifiziert werden. Dies erfolgt mittels spezieller Model-Checking-Algorithmen, die in Kapitel 3 vorgestellt und erlautert werden.

11


2.5 Komplexitatstheorie

Da der Verifikationsschritt beim Model-Checking großtenteils automatisch verlauft, istdie Frage der Berechnungskomplexitat dieses Entscheidungsproblems hoch interessant.Die Komplexitat von Model-Checking fur diverse temporale Logiken wurde in [CES86],[Sch02], [EL87] untersucht. Das Model-Checking ist fur CTL* PSPACE-vollstandig undfur CTL P-vollstandig. Theoretische Hintergrunde dafur werden in diesem Abschnitteinbezogen.

Die Komplexitatsklasse P (PTIME), die Klasse der Probleme mit effizienten Algorith-men, wird oft als die Klasse der

”effizient losbaren“ Probleme bezeichnet. Sie besteht

aus allen Sprachen L, die einen Polynomialzeit-Entscheidungsalgorithmus haben. EinProblem A heißt P-vollstandig, falls A ∈ P und jedes andere Problem in P auf A re-duzierbar ist. P-vollstandige Probleme werden manchmal als inharent sequentiell (in-herently sequential) bezeichnet, da sie (wenn P ≠ NC) keine NC-Algorithmen haben.NC-Algorithmen laufen polylogarithmisch (in O(logc n), c konstant) an einem Paral-lelcomputer mit einer polynomiellen Anzahl von Prozessoren. Die KomplexitatsklasseNC beinhaltet die parallel effizient losbaren Entscheidungsprobleme. Daher lassen sichP-vollstandige Probleme nicht parallelisieren (wenn P ≠ NC).

Es gibt einen NC-Algorithmus zum Parsen von kontextfreien Sprachen (CFL), d. h.CFL ⊆ NC. Deswegen ist die Klasse LOGCFL bei der Untersuchung der Komplexitat desModel-Checkings fur CTL von großem Interesse. Diese Klasse enthalt alle mit logarith-mischem Speicheraufwand auf CFL reduzierbaren Probleme. Daher gilt LOGCFL⊆NC.Andererseits konnen Sprachen in LOGCFL von nichtdeterministischen Turing Maschi-nen in Polynomialzeit entschieden werden, die ein Arbeitsband logarithmischer Großeund zusatzlich einen Stack unendlicher Große haben (siehe [BMT+]). Diese Eigenschaftvon LOGCFL wird bei der Analyse der Komplexitat vom Model-Checking-Problem furCTL erzielt.

Im Rahmen dieser Arbeit werden aber nur die Algorithmen aus P ausgearbeitet.

12

3 Model-Checking fur CTL

Im vorherigen Kapitel wurde der allgemeine Model-Checking-Prozess aufgefuhrt. Zieldieses Kapitels ist es, diesen Prozess auf CTL zu prazisieren. Nachdem das Model-Checking-Problem fur CTL definiert wird, wird seine Komplexitat in Betracht gezogen.Dabei werden die in [BMT+] (eine vorlaufige, unveroffentlichte Version von [BMT+09])prasentierten Hauptresultate sowie zwei Model-Checking-Algorithmen CTLpos-MC(EX,EG, EU, ER) und CTL-MC(ALL) vorgestellt, die in Polynomialzeit arbeiten. Die prak-tische Aufgabe der vorliegenden Arbeit besteht darin, diese Algorithmen zu implemen-tieren und ihre Effizienz zu vergleichen.

3.1 Formulierung des Problems

In Abschnitt 2.3 wurde die Menge ALL von allen CTL-Operatoren erwahnt. MitCTL(ALL) wird dann die Menge von CTL-Formeln bezeichnet. Bei Aufklarung der Kom-plexitatsfragen ist es hilfreich, nicht nur die gesamte Menge ALL, sondern auch kleinereTeilmengen davon zu betrachten.

Definition 3.1.1 (CTL(T)) Sei T ⊆ ALL eine Menge von CTL-Operatoren. MitCTL(T) wird die Menge von CTL-Formeln bezeichnet, in denen nur die booleschen Ope-ratoren {¬,∧,∨} und die CTL-Operatoren aus T erlaubt sind.

Ferner konnen beliebige eingeschrankte Fragmente von CTL(T ) definiert werden. Furdie vorliegende Arbeit wird das Fragment CTLpos (T ) benotigt, in dem CTL-Operatorenim Bereich einer Negation nicht auftreten durfen: fur a, b ∈ AP gilt

• ¬EX a ∉ CTLpos (T )

• ¬(a ∧ ¬b) ∨ EX a ∈ CTLpos (T )

In Abschnitt 2.1 wurde das Model-Checking-Problem in der Frage formuliert, ob einModell eine Spezifikation erfullt. Weiterhin muss das auf eine Kripke-Struktur (Modell)und eine CTL-Formel (Spezifikation) ubertragen werden. Anschließend wird die Erfull-barkeit einer CTL-Formel in Bezug auf eine Kripke-Struktur definiert.

13


Definition 3.1.2 (Model-Checking-Problem) Sei L ∈ {CTL, CTLpos }.

Problem: L-MC(T)

Eingabe: ⟨K, w, ϕ⟩, wobei fur die einzelnen Komponenten gilt:

K = (W, R, η) ist eine Kripke-Struktur,

w ∈W ist ein Zustand,

ϕ ist eine L(T)-Formel.

Frage: Erfullt K im Zustand w die Formel ϕ, also K, w ⊧ ϕ?

Definition 3.1.3 (Semantik) Seien K, w wie in der Definition 3.1.2 und x = (x1,x2, ...) ∈W ω ein Pfad. Ferner seien ϕ,ψ Zustand- und χ,π Pfad-Formeln. Die Evaluie-rung einer Formel zu wahr wird folgendermaßen induktiv definiert.

K,w ⊧ ⊺ immer,K,w ⊧ � nie,K,w ⊧ p falls p ∈ AP und p ∈ η(w),K,w ⊧ ¬ϕ falls K,w ⊧/ ϕ,K,w ⊧ (ϕ ∧ ψ) falls K,w ⊧ ϕ und K,w ⊧ ψ,K,w ⊧ (ϕ ∨ ψ) falls K,w ⊧ ϕ oder K,w ⊧ ψ,K,w ⊧ Aχ falls K,x ⊧ χ ∀x = (x1, x2, ...) mit x1 = w,K,w ⊧ χ falls K,x1 ⊧ χ,K,w ⊧ Xχ falls K,x2 ⊧ χ,K,w ⊧ [χUπ] falls ∃k ∈ IN, so dass K,xk ⊧ π und K,xi ⊧ χ∀1 ≤ i < k.

Die Erfullbarkeit der Formeln, in denen die ubrigen CTL-Operatoren verwendet wer-den, kann mittels der in Tabelle 2.3 aufgelisteten Umwandlungsregeln uberpruft werden.

Außerdem sagt man, eine Zustand-Formel ϕ wird von einer Kripke-Struktur K erfullt,wenn es einen Zustand w ∈ W gibt, so dass K,w ⊧ ϕ. Und analog, eine Pfad-Formel χwird von einer Kripke-Struktur K erfullt, wenn es einen Pfad x = (x1, x2, ...) gibt, sodass K,x ⊧ χ. Geschrieben:

• K ⊧ ϕ⇐⇒ ∃w ∈W ∶K,w ⊧ ϕ

• K ⊧ χ⇐⇒ ∃x = (x1, x2, ...) ∶K,x ⊧ χ

3.2 Komplexitat des Model-Checking-Problems fur CTL

Im Allgemeinen gilt Model-Checking fur CTL als P-vollstandig. Obwohl es in Polynomi-alzeit losbar ist, lasst das Problem sich nicht parallelisieren (falls P ≠ NC). Daher werdenFragmente von CTL betrachtet, um leichtere Teilprobleme zu finden, die effizienter zulosen sind.

Die in [BMT+], [BMT+09] erhaltenen Resultate konnen folgendermaßen zusammenge-fasst werden.

14


1. Nicht-parallelisierbare Falle: P-Vollstandigkeit liegt fur alle CTL-Fragmente vor, indenen mindestens ein CTL-Operator benutzt wird.

2. Trivialfall: Fur Fragmente ohne temporale Operatoren stimmt das Model-Che-cking-Problem mit der Auswertung einer aussagenlogischen Formel uberein, unddieses Problem ist NC1-vollstandig, d. h. parallelisierbar. NC1 ist eine NC-Klasseder Sprachen, die in O(log1 n)-arbeitende Entscheidungsalgorithmen haben (siehe[BMT+09]).

3. Parallelisierbare und nicht-triviale Falle: Model-Checking-Problem CTLpos-MC(T )ist LOGCFL-vollstandig, falls ∅ ⊊ T ⊆ {EX, EF} oder ∅ ⊊ T ⊆ {AX, AG} (vgl.[BMT+09]).

Fur diese Arbeit ist der erste Fall relevant. Auf diesen wird in Abschnitt 3.3 genauereingegangen.

3.3 Model-Checking fur CTL und CTLpos

Dieser Abschnitt enthalt wichtigste Ergebnisse zur Komplexitat von Model-Checking furCTL und fur das in Abschnitt 3.1 definierte negationsbeschrankte Fragment CTLpos . Dieentsprechenden Entscheidungsalgorithmen werden hier vorgestellt und erortert.

3.3.1 CTL-MC(ALL)

Satz 3.3.1 CTL-MC(ALL) ∈ P

In [CGP99] wurde ein Algorithmus vorgestellt, der das Problem CTL-MC(ALL) inPolynomialzeit entscheidet. Dieser wird im Weiteren beschrieben. Seien K = (W, R,η) eine Kripke-Struktur und ϕ eine CTL-Formel. Der Algorithmus bestimmt, in welchenZustanden aus W die Formel ϕ erfullt wird. Die Formel ϕ wird in die Teilformeln zerlegt.Unter einer Teilformel wird hier eine Formel verstanden, aus der mit Hilfe der Operatorendie betrachtete Formel konstruiert wird. Z. B. fur ϕ = γ ∧ λ oder fur ϕ = EXγ sind γ, λdie Teilformeln von ϕ. Jeder Zustand w wird mittels einer Menge label(w) markiert, zuder alle Teilformeln hinzugefugt werden, die in w erfullt sind. Anfangs gilt: label(w) =η(w). Der Algorithmus lauft mehrere Stufen durch. Die Anzahl der Stufen entspricht demVerschachtelungsgrad1 (Anzahl der vorkommenden Operatoren) der Formel ϕ. In der i-enStufe sind Teilformeln des Verschachtelungsgrades i-1 bereits abgearbeitet. Nachdem eineTeilformel γ behandelt wurde, wird sie zu der Menge label(w) von denjenigen Zustandenw hinzugefugt, in denen γ wahr ist. Sobald der Algorithmus terminiert, gilt K,w0 ⊧ ϕ,falls ϕ ∈ label(w0).

In Abschnitt 2.3 wurde beschrieben, dass jede CTL-Formel durch atomare Aussagenund die Operatoren ¬, ∨, EX, EU und EG konstruiert werden kann. Deswegen mussenin jeder Stufe sechs Falle behandelt werden. Seien φ eine CTL-Formel und w ein Zustand,die auf der i-en Stufe betrachtet werden.

1Verschachtelungsgrad ist 0, falls f ∈AP

15


1. φ ∈ AP: φ wird akzeptiert, falls φ ∈ label(w).In diesem Fall wird keine Markierung vorgenommen, da label(w) mit η(w) initia-lisiert wird;

2. φ = ¬γ: markiert werden die Zustande, die mit γ nicht markiert sind.∀v ∈W,γ ∉ label(v): label(v) = label(v) ∪ φ.

3. φ = γ ∨λ: betroffen sind diejenigen Zustande, die mit γ oder mit λ markiert sind.∀v, u ∈W,γ ∈ label(v), λ ∈ label(u): label(v) = label(v)∪φ, label(u) = label(u)∪φ.

4. φ = EXγ: markiert werden direkte Vorfahren der mit γ markierten Zustande.∀v, u ∈W,γ ∈ label(v), (u, v) ∈ R: label(u) = label(u) ∪ φ

5. φ = E(γUλ): markiert werden die Zustande, von denen aus ein Pfad existiert,der aus den mit γ markierten Zustanden besteht und mit dem mit λ markiertenZustand endet. Die Pfade werden ruckwarts von den mit λ markierten Zustandenkonstruiert. Dieser Fall wird in Algorithmus 1 behandelt.

Algorithmus 1 Procedure CheckEU K,w0 ⊧ ϕ

Eingabe: eine Kripke-Struktur K = (W,R, η), w0 ∈W , ϕ = E(αUβ)1: T ← {s ∣ β ∈ label(s)}2: for all s ∈ T do3: label(s)← label(s) ∪ {E(αUβ)}4: end for5: while T is not empty do6: choose s ∈ T7: T ← T /{s}8: for all t such that (t, s) ∈ R do9: if ϕ ∉ label(t) and α ∈ label(t) then

10: label(t)← label(t) ∪ {E(αUβ)}11: T ← T ∪ {t}12: end if13: end for14: end while

6. φ = EGγ: hier werden diejenigen Zustande markiert, von denen aus ein Pfadexistiert, entlang dessen nur die mit γ markierten Zustande vorkommen. Um sol-che Pfade zu finden, wird aus der Kripke-Struktur eine reduzierte Kripke-StrukturK ′ = (W ′,R′, η′) konstruiert, in die nur die mit γ markierten Zustande aus W undzugehorige Relationen aufgenommen werden. Formal: W ′ = {w ∈W,γ ∈ label(w)},R′ = R∣W ′×W ′ und η′ = η∣W ′ . K ′ wird mit Hilfe des Algorithmus von Tarjan[AHU74] in nicht triviale Zusammenhangskomponenten zerlegt. Eine Zusammen-hangskomponente (strong connected component) C ist ein maximaler Teilgraph,in dem jeder Knoten in C von jedem anderen Knoten aus C uber einen gerichteten

16


komplett in C verlaufenden Pfad erreichbar ist. C ist nicht trivial, falls sie entwe-der aus mehr als einem Knoten oder aus nur einem Knoten mit einer Selbstschleifebesteht (C = {v ∈ W ′}, (v, v) ∈ R′). Nachdem K ′ partitioniert wurde, wird nachden Zustanden gesucht, die zu nicht trivialen Zusammenhangskomponenten geho-ren. Dabei wird ruckwarts uber R′ abgearbeitet, und die erforderlichen Zustandewerden markiert. Diesen Fall stellt Algorithmus 2 dar.

Algorithmus 2 Procedure CheckEG K,w0 ⊧ ϕ

Eingabe: eine Kripke-Struktur K = (W,R, η), w0 ∈W , ϕ = EGα1: S′ ← {s ∣ α ∈ label(s)}2: SCC ← {C ∣ C is a nontrivial SCC of S′}3: T ← ⋃C∈SCC{s ∣ s ∈ C}4: for all s ∈ T do5: label(s)← label(s) ∪ {EGα}6: end for7: while T is not empty do8: choose s ∈ T9: T ← T /{s}

10: for all t such that t ∈ S′ and (t, s) ∈ R do11: if ϕ ∉ label(t) then12: label(t)← label(t) ∪ {EGα}13: T ← T ∪ {t}14: end if15: end for16: end while

Das Abarbeiten jeder der Teilformeln von ϕ benotigt O(∣W ∣ + ∣R∣)-Zeit2. Die Kom-plexitat des gesamten Algorithmus betragt somit O(∣ϕ∣ ⋅ (∣W ∣ + ∣R∣)) (Polynomialzeit),wobei ∣ϕ∣ die Anzahl der verschiedenen Teilformeln von ϕ ist.

3.3.2 CTLpos -MC(EX, EG, EU, ER)

Es ist bemerkenswert, dass sich jede obere Grenze fur CTL-MC(T ) auch aufCTLpos -MC(T ) (fur alle T ) ubertragen lasst. Dennoch lasst sich die Komplexitat vonCTLpos-MC(T ) verbessern, wenn in T nur bestimmte Operatoren verwendet werden (vgl.[BMT+09]). Dies ist eine zentrale Idee bei der Untersuchung des CTLpos-Fragmentes. Au-ßerdem steht im Hintergrund die Eigenschaft von LOGCFL-Sprachen, dass sie sich miteiner nichtdeterministischen Turing Maschine in Polynomialzeit entscheiden lassen, dieein Arbeitsband logarithmischer Große und einen unendlichen Stack besitzt. In diesem

2Im ersten Fall wird O(∣W ∣+ ∣AP ∣)-Zeit beansprucht, aber es wird angenommen, dass das zu analysie-rende System in Bezug auf das Zusammenspiel zwischen den Komponenten(|R|) im Vergleich zu derAnzahl der Eigenschaften des Systems (|AP |) genugend komplex ist. Deswegen wird die Komplexitatauf O(∣W ∣ + ∣R∣) verallgemeinert.

17


Abschnitt wird aber ein in Exponentialzeit arbeitender Algorithmus CTLpos-MC(T ) vor-gestellt, der dem in Abschnitt 3.3.1 aufgefuhrten Algorithmus CTL-MC(T ) in Bezug aufihre Effizienz weiter unten gegenubergestellt wird.

Satz 3.3.2 Sei T eine Menge von CTL-Operatoren, so dass alle Operatoren in T exis-tenziell oder alle Operatoren in T universal sind. Dann ist CTLpos-MC(T) ∈ P.

Als Erstes wird der Fall betrachtet, dass in T nur existenzielle Operatoren erhaltlichsind. O. B. d. A. sei T ∈ {EX, EG, EU, ER}. Es wird behauptet, dass Algorithmus 3entscheidet, ob die Kripke-Struktur K = (W,R, η) die CTLpos(T )-Formel ϕ im Zustandw0 ∈ W erfullt. S sei ein Stack zum Speichern von Paaren (ϕ,w) ∈ CTLpos(T ) × W .

Jede Formel wird ahnlich wie im CTL-MC(ALL)-Algorithmus abgearbeitet. Sie wirdje nach dem verwendeten Operator in die Teilformeln zerlegt und entsprechend behan-delt. Ein deutlicher Unterschied liegt in dem Fall vor, wenn eine Pfad-Formel uberpruftwerden muss, z. B. ϕ = EGα oder ϕ = E(αUβ). Hier muss ein Pfad aus allen moglichenaus dem betrachteten Zustand ausgehenden Pfaden nichtdeterministisch gefunden wer-den. α wird dann in jedem Zustand entlang dieses Pfades gepruft. Im CTL-MC(ALL)-Algorithmus werden fur solche Formeln erst die Zustande gefunden, in denen α erfulltwird. Danach werden aus diesen Zustanden starke Zusammenhangskomponenten undaus diesen Ergebnispfade konstruiert.

Die Konstruktion des Algorithmus macht die oben erwahnte Eigenschaft der LOGCFL-Sprachen erkennbar. Der Algorithmus lasst sich mit einer Turing Maschine mit einemStack und einem Arbeitsband logarithmischer Große entscheiden. Wenn der Algorithmusin Polynomialzeit arbeiten wurde, dann konnte man das ProblemCTLpos -MC(EX, EG, EU, ER) zu LOGCFL-Sprachen einordnen. Das ist aber fur denFall ϕ = EGα oder ϕ = E(αUβ) unmoglich. Das Problem liegt fur die Formeln vor, dienach dem folgenden Schema geschachtelt sind. Sei ϕ = EGα0, wobei α0 eine Formel ist,die als Teilformel EGα1 enthalt usw. Z. B. ϕ = EG(x0∨EG(x1∧EG(x2...))). Fur jedeTeilformel αi,i=0,... wird ein neuer Pfad geraten und jeweils |W|-mal auf den Stack gelegt.Analog gilt dies auch fur die EU-Formeln. Dies fuhrt zum exponentiellen Bedarf in derStackgroße. Der Algorithmus benotigt exponentielle und nicht mehr polynomielle Zeit,wie es bei LOGCFL gefordert wird. ER-Formeln stellen eine Kombination von EG- undEU-Formeln dar. EX-Formeln konnen polynomiell mit der Turing Maschine abgearbei-tet werden. Die ubrigen Formeln reprasentieren Trivialfalle. Fur die EG-, EU-Formelnbesitzt der Algorithmus folgende Komplexitat. Um alle Pfade abzuarbeiten, brauchtman O(2n) Zeit. Bei geschickter Implementierung mit dem direkten Zugriff auf Teilfor-meln im Stack ergibt sich O(2log(n)) = O(nO(1)) Bedarf. Folglich ist der Algorithmus furCTLpos-MC(EX, EG, EU, ER) theoretisch polynomiell.

Die Tatsache, dass der Algorithmus immer terminiert, folgt daraus, dass jede Teil-formel von ϕ nicht mehr als |W |-mal im Stack S gespeichert wird. Außerdem zeigt dieInduktivitat der Struktur von Formeln, dass der Algorithmus genau dann false zuruck-gibt, wenn fur alle aus dem Stack S geladenen Paare (φ,w) K,w ⊭ φ gilt. Folglichterminiert der Algorithmus mit true, genau dann wenn K,w ⊧ ϕ.

18


Algorithmus 3 Entscheide, ob K,w ⊧ ϕ

Eingabe: eine Kripke-Struktur K = (W,R, η), w0 ∈W , ϕ ∈ CTLpos (T)Ausgabe: true (falls K,w ⊧ ϕ) oder false (sonst)1: push(S, (ϕ,w0))2: while S is not empty do3: (ϕ,w)← pop(S)4: if ϕ is a propositional formula then5: if ϕ evaluates to false in w under η then6: return false7: end if8: else if ϕ = α ∧ β then9: push(S, (β,w))

10: push(S, (α,w))11: else if ϕ = α ∨ β then12: nondet. push(S, (α,w)) or push(S, (β,w))13: else if ϕ = EXα then14: nondet. choose w′ ∈ {w′ ∣ (w,w′) ∈ R}15: push(S, (α,w′))16: else if ϕ = EGα then17: guess a path (wi)1≤i≤∣W ∣ such that w1 = w18: for all 1 ≤ i ≤ ∣W ∣ do19: push(S, (α,wi))20: end for21: else if ϕ = E(αUβ) then22: guess k ≤ ∣W ∣ and a path (wi)1≤i≤k such that w1 = w23: for all 1 ≤ i < k do24: push(S, (α,wi))25: end for26: push(S, (β,wk))27: else if ϕ = E (αRβ) then28: guess γ ∈ {EGβ, E(βU(α ∧ β))}29: push(S, (γ,w))30: end if31: end while32: return true

19


Bei der Implementierung dieses Algorithmus kollidiert man mit den Problemen, diesich durch den in den Zeilen 12, 14, 17, 22, 28 vorkommenden Nichtdeterminismus be-kunden. Außerdem, um bessere Effizienz zu erreichen, mussen die Pfade in den Zeilen15, 19, 24 auf dem Stack knotenweise und nicht als Ganzes gespeichert und bearbeitetwerden. Diese sowie weitere Besonderheiten bezuglich der Implementierung werden inKapitel 4 besprochen.

Der Fall, wenn alle Operatoren in T universal sind, folgt aus Abgeschlossenheit von Punter dem Komplement und kann analog gelost werden (Eϕ ≡ ¬A¬ϕ).

20

4 Design und Implementierung

Im vorigen Kapitel wurden die Model-Checking-Algorithmen fur CTL-MC(ALL) undCTLpos-MC(EX, EG, EU, ER) prasentiert. Diese werden im Rahmen dieser Diplomar-beit in Java implementiert. In diesem Kapitel werden Implementierungsaspekte erlautert.Dabei wird ein existierendes Programm um weitere Funktionalitaten erweitert. DiesesProgramm wird in Abschnitt 4.1 vorgestellt. Die ausfuhrliche Beschreibung findet manin [Sol09]. Die geanderte Klassenstruktur und die neuen Moglichkeiten des Programmswerden auch in diesem Kapitel veranschaulicht.

4.1 Basisprogramm

Als Basis wurde ein Programm verwendet, das im Rahmen einer anderen Diplomarbeitam Institut fur theoretische Informatik der Leibniz Universitat Hannover entstanden ist.Dieses Programm wurde mit dem Ziel entwickelt, einige Model-Checking-Algorithmenfur LTL zu realisieren. Die Benutzeroberflache des Hauptfensters ist in Abbildungen 4.1zu sehen.

Das Hauptfenster besteht aus drei Bereichen, die sich auf Kripke-Struktur, Formelund Algorithmen beziehen. In jedem Bereich gibt es Buttons zum Aufrufen diverserAufgaben und ein Textfeld, in dem eine Kripke-Struktur, eine Formel oder Ergebnisse derAlgorithmen veranschaulicht werden. Folgende Funktionalitaten sind bereits vorhanden:

• Erstellung einer neuen Kripke-Struktur bzw. einer neuen Formel;

• Speicherung einer Kripke-Struktur bzw. einer Formel in einer Datei;

• Laden einer Kripke-Struktur bzw. einer Formel aus einer Datei;

• Zeichnen einer Kripke-Struktur;

• Starten der Model-Checking-Algorithmen fur LTL angewendet auf die erstellte/ge-ladene Kripke-Struktur und die erstellte/geladene Formel.

Die implementierte Datenstruktur, die eine Kripke-Struktur reprasentiert, und alle zuge-horigen Funktionalitaten werden ubernommen. Die Visualisierung der Kripke-Strukturwird uberarbeitet und um einige Funktionen erganzt. Da das Basisprogramm speziellfur das Model-Checking fur LTL entwickelt wurde, mussen die Operationen zur Bearbei-tung der Formeln angepasst und erweitert werden, um CTL-Formeln zu erfassen, um diein dieser Arbeit auszuarbeitenden Model-Checking-Algorithmen verwenden zu konnen.Weiter unten werden diese und andere Erweiterungen des Basisprogramms erortert.

21


Abbildung 4.1: Das Hauptfenster des Basisprogramms (Bild aus [Sol09])

4.2 Neue Klassenstruktur und dieImplementierungsaspekte

In diesem Abschnitt wird die erweiterte Klassenstruktur des Programms erlautert. Abbil-dung 4.2 stellt die Programmlogik dar, und Abbildung 4.3 zeigt die Klassenstruktur derBenutzerschnittstelle. Die fur diese Arbeit relevanten Klassen des Basisprogramms wer-den ohne Attribute bzw. Operationen abgebildet. Die komplett ubernommenen Klassensind in schwarz und die erweiterten Klassen sind in grun dargestellt. Die neuen Klassensind in blau hervorgehoben. Die get- und set-Methoden werden ubersichtshalber nichtdargestellt.

22


ModelCheckingCTL

-formulaCTL: FormulaCTL

-kripke: Kripke

-labeledStates: HashMap<Number, State>

+modelCheckingCTL(FormulaCTL): HashMap<Number,

State>

-checkPropositions(Proposition): HashMap<Number,

State>

-checkNot(HashMap<Number, State>): HashMap<Number,

State>

-checkOr(HashMap<Number, State>,HashMap<Number,

State>): HashMap<Number, State>

-checkEX(HashMap<Number, State>): HashMap<Number,

State>

-checkEU(HashMap<Number, State>,HashMap<Number,

State>): HashMap<Number, State>

-checkEG(HashMap<Number, State>): HashMap<Number,

State>

-getSCC(HashMap<Number, State>): ArrayList<ArrayList<State>>

ModelCheckingCTLpos

-formulaCTLpos: FormulaCTLpos

-kripke: Kripke

-state: State

-paths: ArrayList<ArrayList<State>>

-result: boolean

+modelCheckingCTLposArrayList(Kripke,FormulaCTLpos,

State): boolean

+modelCheckingCTLposTree(Kripke,FormulaCTLpos,

State): boolean

FormulaCTLpos

#not: boolean

#and: boolean

#or: boolean

#EX: boolean

#EG: boolean

#EU: boolean

#ER: boolean

+isProposition(): boolean

+stringToFormula(String): FormulaCTLpos

+stringInPrefixToFormula(String): FormulaCTLpos

+formulaToString(): String

+formulaToStringInPrefix(): String

#getIndexOfMainOperator(String): int

-modifyAccordingDeMorgan()

-getToken(String): String

FormulaCTL

-EF: boolean

-AF: boolean

-AX: boolean

-AG: boolean

-AU: boolean

-AR: boolean

+isProposition(): boolean

+stringToFormula(String): FormulaCTL

+stringInPrefixToFormula(String): FormulaCTL

+formulaToString(): String

+formulaToStringInPrefix(): String

+convert()

-getToken(String)

Proposition

State

-key: int

-name: String

-initial: boolean

-propositions: String[]

-transitions: ArrayList<Transition>

-computaionTree : TreeNode<State>

-paths: ArrayList<ArrayList<State>>

-index: int

-lowLink: int

...()

+evaluatePropositionalFormula(FormulaCTLPos): booelan

+getPredecessorStates(Kripke): HashMap<Number, State>

+getSuccStates(Kripke): int[]

+formPaths(int,Kripke)

+createComputationTree(Kripke): TreeNode<State>

Kripke

-...

-allTransVector: ArrayList<HashMap<Number, Transition>>

...()

+edit()

+createRandomKripke(int,int,int)

-getRandomPropositions(int): String[]

Transition

1..*

0..1

0..2

TreeNode<T>

-value: T

-parent: TreeNode<T>

-leftChild: TreeNode<T>

-rightSibling: TreeNode<T>

-depth: int

+addChild(T): TreeNode<T>

+addRightSibling(T): TreeNode<T>

+getChildren(): ArrayList<TreeNode<T>>

0..2

0..1

11..*

2

1

Abbildung 4.2: Klassendiagramm fur Programmlogik

23


ModelCheckerCTL

-formulaCTL: FormulaCTL

-formulaCTLpos: FormulaCTLpos

-kripke: Kripke

-result: boolean

-selectedStates: ArrayList<State>

+labelTrueStatesInGraph()

-getStatesList(): ArrayList<State>

-setClickedStatesInGraph(ArrayList<State>)

ModelChecker

State

Kripke

Formula

FormulaCTL

FormulaCTLpos

SettingsFrame

-formulaFile: File

-kripkeFile: File

+loadProperties()

+saveProperties()

GraphVisualization

+draw(Kripke)

+saveImage(Kripke)

ModelCheck

ModelCheckingCTL

ModelCheckingCTLpos

Abbildung 4.3: Klassendiagramm der Benutzerschnittstelle

Kripke-Struktur

Die Klasse Kripke stellt eine Kripke-Struktur als eine Liste von Zustanden dar, diemittels der Klasse State realisiert werden. Jeder Zustand hat eine eindeutige Identi-fikationsnummer, einen Namen und eine Liste der atomaren Aussagen, die in diesemZustand gelten. Das Attribut initial gibt an, ob ein Zustand der Startzustand in derKripke-Struktur ist. Ubergange zwischen den Zustanden in der Kripke-Struktur werdenmittels der Klasse Transition gespeichert. Neben den ubernommenen Funktionalitaten,die Kripke-Struktur zu erstellen/speichern/laden, kann sie jetzt auch geandert werden(edit()). Außerdem wird ermoglicht, eine zufallige Kripke-Struktur generieren zu lassen(createRandomKripke(int , int , int)). Als Argumente werden die Anzahl von ZustandenS, die Anzahl von Ubergangen T , die aus jedem Zustand ausgehen, sowie die maximaleAnzahl von atomaren Aussagen P , die jedem Zustand zugeordnet werden. Die Generie-rung geschieht folgendermaßen.

1. Es wird eine Menge der Große S von Zustanden erzeugt. Als Namen werden dienaturliche Zahlen vergeben.

2. Jedem Zustand werden Ubergange hinzugefugt. Die Anzahl der Ubergange T istfur jeden Zustand fest. Die Endzustande von Ubergangen werden mittels einerZufallsfunktion ermittelt.

24


3. Jeder Zustand wird mit einer Menge von atomaren Aussagen beschriftet. Diesewerden auch zufallig mittels getRandomPropositions(int) generiert. Als atomareAussagen werden hier die Buchstaben des lateinischen Alphabets verwendet. Dasheißt, dass jeder Zustand maximal 26 atomare Aussagen haben kann. Fur jedenBuchstaben wird eine Zufallszahl generiert. Wenn diese Zahl großer als 0,5 ist,wird dieser Buchstabe dem aktuellen Zustand zugeordnet. Der letzte moglicheBuchstabe entspricht dem ubergebenen Parameter P . Mit anderen Worten: jederZustand wird mit keinen oder mit maximal S ersten Buchstaben des lateinischenAlphabets beschriftet.

Die Klasse State wurde um die Attribute index und lowLink erweitert, die den Aufbauvon den fur Algorithmus 2 notwendigen Zusammenhangskomponenten ermoglichen. Eineweitere relevante Methode getPredecessorStates(Kripke), die zu einem Zustand samtlichedirekten Vorfahren findet, wird auch in dieser Klasse implementiert. Mittels der MethodeevaluatePropositionalFormula(FormulaCTLpos) wird uberpruft, ob eine CTLpos-Formel,in der keine CTL-Operatoren, sondern nur die booleschen Operatoren {¬,∧,∨} vorhandensind, in dem aktuellen Zustand erfullt wird.

Algorithmus 3 benotigt bei der Analyse von EG-, EU-Formeln aus einem Zustandausgehende Pfade. Diese konnen mittels der vom Basisprogramm ubernommenen Metho-den getSuccStates(Kripke) und formPaths(int ,Kripke) ermittelt werden. formPaths(...)konstruiert solche Pfade. Jeder Pfad ist eine Liste von Zustanden. Alle aus einem Zustandausgehenden Pfade werden als eine Liste von solchen Listen gespeichert. In Abschnitt3.3.2 wurde erwahnt, dass man eine bessere Effizienz erreichen kann, wenn Zustande aufden Pfaden knotenweise gespeichert werden. Um dies zu ermoglichen, wurde die KlasseTreeNode<T> entwickelt, die einen Baum als Datenstruktur realisiert und alle notigenMethoden bereitstellt. Jeder Zustand ist ein Knoten im Baum. Die von ihm erreichbarenZustande sind seine Kinderknoten usw. Die Methode createComputationTree(Kripke)erzeugt einen Berechnungsbaum, in dem alle ausgehenden Pfade durch Tiefendurchlaufrekonstruiert werden konnen. In der Instanzvariable computaionTree wird der Wurzel-knoten des Berechnungsbaumes gepeichert. Algorithmus 3 wird zweimal implementiert,um die beiden Moglichkeiten zu vergleichen, Pfade als Liste von Listen und als einenBaum abzuarbeiten.

CTL-Formel

CTL-Formeln werden im Hinblick auf Definition 2.3.1 mit Hilfe der Klassen Proposition,FormulaCTLpos und FormulaCTL implementiert. Jede CTL-Formel ist eine Instanzder Klasse FormulaCTLpos bzw. FormulaCTL und besteht aus CTL-Teilformeln, diein einer Liste gespeichert werden. Der verwendete Operator wird registriert, indem dasentsprechende Attribut der Klasse FormulaCTLpos bzw. FormulaCTL auf

”wahr“

gesetzt wird. Dabei gelten die ublichen Prioritatsregeln, und alle binaren Operatorensind linksassoziativ. Jede Formel mit einem binaren Operator (z. B. OR, AND, EU,AR) wird somit als eine Liste mit zwei Elementen und jede Formel mit einem unarenOperator (z. B. NOT, EX, AG) mit einem Element dargestellt.

25


Die einfachste Form einer CTL-Formel ist eine atomare Aussage. Solche Formel wirdals eine Liste mit einem Element, einer Instanz der Klasse Proposition, erzeugt. AlleAttribute werden in diesem Fall mit

”falsch“ initialisiert. Formeln dieser Art konnen mit

Hilfe der Methode isProposition() identifiziert werden.Jede FormulaCTLpos- oder FormulaCTL-Formel besteht folglich entweder aus

einem Objekt der Klasse Proposition oder aus einer Liste mit einem oder zwei Objektender Klasse FormulaCTLpos bzw. FormulaCTL.

Durch die Klasse FormulaCTLpos konnen CTLpos -Formeln erzeugt werden, in de-nen CTL-Operatoren nicht negiert werden durfen. Außerdem ist die Menge der CTL-Operatoren auf die Menge {EX, EG, EU, ER} eingeschrankt, da nur diese fur den Algo-rithmus 3 benotigt werden. Die Klasse FormulaCTL enthalt sowohl die vonFormulaCTLpos geerbten Attribute als auch weitere Attribute, die es zusammenermoglichen, beliebige CTL-Formeln zu bilden. Die Formeln konnen uber eine Benut-zerschnittstelle in textueller Form in der Infix- oder Prafix-Notation eingegeben wer-den. Das Erstellen der Formeln aus dem Eingabetext geschieht mittels der MethodenStringToFormula(String) und StringInPrefixToFormula(String). Dies erfolgt, indem dieEingabe analysiert wird und ein Operator der Formel mittels dergetIndexOfMainOperator(String) und getToken(String) gefunden wird. Folglich werdendie Teilformeln der Formel ermittelt, die weiterhin analog in

”die Tiefe“ geparst wer-

den. Die Konvertierung in die andere Richtung passiert mittels FormulaToString() bzw.FormulaToStringInPrefix().

Die Methode modifyAccordingDeMorgan() bringt eine CTLpos -Formel nach den DeMorganschen Gesetzen in so eine Form, dass die Negationen nur direkt von den ato-maren Aussagen stehen. Diese Umwandlung vereinfacht die Auswertung der Formel inAlgorithmus 3: K,w0 ⊧ ¬p, wenn p ∈ AP und p ∉ η(w0). Dies ermoglicht die MethodeevaluatePropositionalFormula(FormulaCTLpos) in der Klasse State.

Die Methode convert() in der Klasse FormulaCTL wandelt eine CTL-Formel in ei-ne aquivalente um, die aus atomaren Aussagen und den Operatoren ¬, ∨, EX, EU undEG besteht. Diese Methode ist fur CTL-MC(ALL) von großer Bedeutung, da diese Ope-ratoren eine minimale Menge der Operatoren bilden, um alle moglichen CTL-Formelnkonstruieren zu konnen. Die Konvertierung erfolgt mittels der in der Tabelle 2.3 aufge-fuhrten Regeln.

Algorithmen

Die Klassen ModelCheckingCTLpos und ModelCheckingCTL bilden den Kern desProgramms. Sie enthalten namlich die Model-Checking-Algorithmen CTLpos -MC(EX,EG, EU, ER) bzw. CTL-MC(ALL).

Um den CTLpos-Algorithmus ausfuhren zu konnen, mussen eine Kripke-Struktur, einZustand in der Kripke-Struktur und eine zu prufende CTLpos-Formel bekannt sein. Die-se Argumente werden in den entsprechenden Instanzvariablen gespeichert. Die MethodenmodelCheckingCTLposArrayList(Kripke,FormulaCTLpos ,State) und modelChecking-CTLposTree(Kripke,FormulaCTLpos ,State) stellen die zwei oben vorgestellten Imple-mentierungsmoglichkeiten des Algorithmus 3 dar. Die Ergebnisse des Model-Checkings

26


werden in den Variablen result und paths gespeichert. result wird auf”wahr“ gesetzt,

falls die Kripke-Struktur kripke die Formel formulaCTLpos im Zustand state erfullt. InAbhangigkeit davon, ob es um eine Zustands- oder Pfad-Formel handelt, werden in pathsZustande bzw. Pfade verfasst, in denen die Erfullbarkeit vorliegt.

In Abschnitt 3.3.2 wurden die Implementierungsschwierigkeiten des Algorithmus 3erwahnt. Hier liegt das Problem vor, dass man nichtdeterministisch mehrere Teilfor-meln oder Zustande abarbeiten (

”nondet. choose“) oder aus mehreren einen Pfad oder

einen Zustand aussuchen (”guess“) muss, in denen eine bestimmte Eigenschaft – d. h.

eine Formel – erfullt wird. Dieser Nichtdeterminismus wird durch die Uberprufung je-der Teilformel, jedes Zustandes und jedes Pfades der Reihe nach ersetzt, die in Fragekommen. Da es sich um die existentiellen Formeln handelt, kann man die Abarbeitungabbrechen, sobald eine Forderung (ein Zustand fur die EX- oder ein Pfad fur die EG-bzw. EU-Formeln) erfullt wurde. Im schlimmsten Fall mussen aber alle Kandidatenuberpruft werden.

Betrachten wir den Fall ϕ = EGα. Wenn man alle aus einem Zustand w0 ausgehen-den Pfade betrachtet, hat man die exponentielle Anzahl von Moglichkeiten: ∣T ∣∣T ∣, wobei∣T ∣ die Anzahl aus einem Zustand ausgehender Ubergange ist. Die Laufzeit der Abarbei-tung der Pfade ist entsprechend groß. Wenn die Pfade als ArrayList<ArrayList<State>>gespeichert sind, wird jeder Pfad vom ersten bis zum letzten Zustand auf die Erfullbar-keit der Formel α gepruft. Die Situation andert sich, wenn die Pfade in einem Baumgefasst sind. Abbildung 4.4 zeigt diese zwei Abarbeitunsmoglichkeiten. Oben ist eineKripke-Struktur dargestellt. Die Zustande sind mit den atomaren Aussagen versehen.Sei ϕ = EGa. Unten links ist die Liste mit den Pfaden, rechts davon ist der entspre-chende Berechnungsbaum. Die Pfade sowie der Berechnugsbaum sind unendlich, werdenaber auf die Anzahl von Zustanden in der Kripke beschrankt, da die Pfade sonst einenZyklus enthalten. Der gestrichelte Pfeil zeigt die Reihenfolge, in der die Zustande uber-pruft werden, ob die Formel α = a in diesen gilt. Bei der zweiten Implementierung wirdnach einem

”falschen“ Zustand, in dem die Teilformel α nicht gilt, zu seinem rechten

Geschwister ubergegangen. Das wird solange durchgefuhrt, bis es noch solche vorhandensind und noch kein Pfad gefunden wurde. Dies wird mittels des iterativen Tiefendurch-laufs (siehe [AUH82]) realisiert, bei dem zu jedem Knoten seine rechten Geschwister ineinem Stack gespeichert werden. Im Gegensatz zu der ersten Implementierung wird so-mit die Uberprufung in allen vorherigen Zustanden gespart. Eine weitere Moglichkeit ander Laufzeit zu gewinnen, ist die Speicherung von Ergebnissen des Model-Checkings inden gepruften Zustanden. Das bedeutet, dass nachdem die Zustande

”a“,

”a,b“ und

”b“

gepruft wurden, wird fur die Formel α = a gespeichert, dass sie in den Zustanden”a“

und”a,b“ erfullt wird. Wenn der zweite Pfad im Baum analysiert wird, muss der Model-

Checking-Algorithmus im nachsten potenziellen Zustand nicht mehr ausgefuhrt werden.Die schon ermittelten Ergebnisse mussen nur gelesen werden. Dieser Ansatz beanspruchteinen zusatzlichen Speicher, vermindert aber die Laufzeit.

Weiterhin setzt der Algorithmus einen Stack ein. Um den Nichtdeterminismus zu lo-sen, mussen alle moglichen Zustande bzw. Pfade sowie entsprechende Formeln im Stackgespeichert werden. Zusatzlich muss der Typ der Formeln bei der Speicherung ihrer Teil-formeln mit angegeben werden, was jedoch fur die Formeln ohne temporale Operatoren

27


a

a

b a,b

Kripke-Struktur

a,b a,b

a a

aa

ArrayList<ArrayList<State>

aaa

a

a

a

a

a,b a,b

a,b

b b

TreeNode<State>

Abbildung 4.4: Zwei Abarbeitungsmoglichkeiten bei der Untersuchung von Pfad-Formeln

und fur die AND-Formeln nicht erforderlich ist, da fur diese kein Nichtdeterminismusvorkommt. Dadurch entsteht ein hoherer Speicherbedarf. Andererseits, sobald der ers-te passende Zustand bzw. Pfad gefunden wurde, mussen alle ubrigen Elemente, die zuder aktuellen Teilformel und ihrer Formel gehoren, aus dem Stack entfernt werden. Dieskostet eine zusatzliche Zeit. In diesem Zusammenhang wird eine rekursive Prozedurdem Stack bevorzugt. Dabei mussen nach dem Finden eines passenden Zustandes bzw.Pfades die ubrigen Zustande bzw. Pfade nicht mehr gespeichert und anschließend ent-fernt werden. Besonders vorteilhaft zeigt sich die rekursive Variante, wenn die wenigverschachtelte Formeln auf die Kripke-Strukturen mit einer großen Anzahl von Zustan-den und Ubergangen angewendet werden. In diesem Fall ist der Speicherbedarf fur denStack deutlich hoher als fur die Zwischenspeicherung der bei den rekursiven Aufrufenentstandenen Daten.

In der Klasse ModelCheckingCTL sind formulaCTL und kripke die fur denCTL-MC(ALL)-Algorithmus benotigten Attribute. Der Algorithmus wird in der Metho-de modelCheckingCTL(FormulaCTL) implementiert. Nach der Abarbeitung werden dieZustande markiert, in denen die zu uberprufende Formel erfullt wird. Diese werden in derInstanzvariable labeledStates gespeichert. Beim Aufruf dieser Methode wird die ubergebe-ne Formel in die Teilformeln zerlegt, die wiederum vonmodelCheckingCTL(FormulaCTL) rekursiv abgearbeitet werden. Folglich hat man dieMengen der von diesen Teilformeln markierten Zustanden. Weiter werden diese Men-gen entsprechend dem in der ubergebenen Formel verwendeten Operator behandelt, undzwar mittels einer der Methoden:

• checkPropositions(Proposition) markiert alle Zustande, in denen die ubergebeneatomare Aussage vorkommt.

• checkNot(HashMap < Number ,State >) hat als Argument eine Menge von Zustan-den, die mit der Teilformel markiert wurden und selektiert diejenigen Zustandeder Kripke-Struktur, die nicht in der Menge sind.

28


• checkOr(HashMap < Number ,State >,HashMap < Number ,State >) gibt eine Ver-einigung der beiden Argumente zuruck.

• checkEX (HashMap < Number ,State >) markiert alle direkten Vorfahren von den inder Argument-Menge enthaltenen Zustanden. Diese werden mit Hilfe der MethodegetPredecessorStates(Kripke) der Klasse State gefunden.

• checkEU (HashMap < Number ,State >,HashMap < Number ,State >) hat als Argu-mente zwei Mengen der Zustande, in denen die erste bzw. die zweite Teilformelgilt und implementiert den Algorithmus 1.

• checkEG(HashMap < Number ,State >) realisiert den Algorithmus 2. Als Erstesmussen hier alle nicht trivialen Zusammenhangskomponenten von den Zustan-den aus der Argument-Menge gefunden werden. Dies erfolgt mittels der MethodegetSCC (HashMap < Number ,State >).

Parallel zur Implementierung werden die entwickelten Datenstrukturen und Algorith-men mit Hilfe von JUnit standig getestet.

Benutzerschnittstelle

Im Basisprogramm wird eine Benutzerschnittstelle uber die Klasse ModelChecker rea-lisiert, die das Hauptfenster des Programms darstellt. Auf dieses werden neue Bedien-Elemente hinzugefugt, um die neuen Funktionalitaten ansprechen zu konnen. Außerdemwird das Fenster benutzerfreundlicher gestaltet, indem ein anderes Swing-Layout, nam-lich das GridBag-Layout, verwendet wird. Alle geanderten bzw. neuen Benutzeroberfla-chen werden in Abschnitt 4.3 veranschaulicht.

Die neue Klasse SettingsFrame verwaltet die Benutzereinstellungen. Hierbei kannman jeweils eine Datei mit einer Kripke-Struktur und einer Formel angeben, die beijedem Start des Programms geladen werden.

Im Basisprogramm gab es die Moglichkeit, die Kripke-Struktur mit Hilfe des Frame-works JUNG1 in Form eines Graphen zeichnen zu lassen. Die Moglichkeit wird beibe-halten, wird aber mit einer neueren Version (2.0) des Frameworks umgesetzt und umdie neuen Funktionalitaten wie die Skalierung des Graphen und die Verschiebung derKnoten erweitert. Fur diese Funktionalitat ist die Methode draw(Kripke) in der KlasseGraphVisualization verantwortlich. Außerdem werden zu den Knoten entsprechendeatomare Aussagen angezeigt. Die Speicherung des Graphen (saveImage(Kripke)) wirdbeibehalten, als Format wird aber PNG statt JPEG benutzt, um die JPEG-Artifakte zuvermeiden.

Die Klasse ModelCheckerCTL stellt die notwendigen Bedienelemente zum Vorbe-reiten der zu analysierenden Daten und zum Ausfuhren der beiden Model-Checking-Algorithmen CTL-MC(ALL) und CTLpos-MC(EX, EG, EU, ER) bereit. Die eingegebe-ne Formel wird in den Instanzvariablen formulaCTL und formulaCTLpos gespeichert, fallssie den Einschrankungen von CTLpos genugt. Die Kripke-Struktur kripke wird hier auch

1http://jung.sourceforge.net/

29

http://jung.sourceforge.net/


visualisiert, und es besteht die Moglichkeit, die Zustande im Graphen oder in einer Listeauszuwahlen. Diese werden in selectedStates gespeichert. In diesen Zustanden wird dieFormel mittels der Algorithmen uberpruft. Nach dem Ablauf der Algorithmen wird dasErgebnis result

”wahr“, falls die uberprufte Formel in mindestens einem Zustand erfullt

wird. Die Zustande werden im Graphen mit Hilfe von labelTrueStatesInGraph() farblichhervorgehoben.

4.3 Bedienungsanleitung zum Programm

In diesem Abschnitt wird eine kurze Anleitung zur Verfugung gestellt, wie das neueProgramm bedient werden kann. Anhand eines Beispiels wird die graphische Benut-zeroberflache des Programms veranschaulicht. Dabei werden die geanderten und dieneuen Bestandteile akzentuiert. Die vom Basisprogramm ubernommenen Komponentenwurden in Abschnitt 4.1 vorgestellt.

Das geanderte Hauptfenster wird in Abbildung 4.5 dargestellt.

Abbildung 4.5: Das geanderte Hauptfenster des Programms

Die Grundstruktur des Programms wurde in Abschnitt 4.1 beschrieben. Es hat sichdas Layout geandert. Die drei Bereiche fur Kripke-Struktur, Formel und Algorithmenwurden durch die Rahmen hervorgehoben. Der Einheitlichkeit halber haben alle Buttonsdie gleiche Große und einen gleichmaßigen Abstand zueinander erhalten.

30


Die Einstellungen des Programms sind uber das Menu Datei→Einstellungen abruf-bar. In Abbildung 4.6 ist veranschaulicht, dass man die Kripke-Struktur- und Formel-enthaltenen Dateien auswahlen kann, die beim Starten des Programms automatisch ge-laden werden. Diese Funktionalitat kann nutzlich sein, wenn man z. B. diverse Formelnauf einer bestimmten Kripke-Struktur ofters prufen will oder umgekehrt. Nach dem Be-tatigen des OK-Buttons werden die Datei-Namen, falls sie selektiert wurden, in einerINI-Datei gespeichert und beim nachsten Start des Programms geladen. Die INI-Dateibefindet sich im selben Verzeichnis wie das Programm oder wird erzeugt.

Mittels des Buttons Kripke-Struktur generieren wird ein neuer Dialog geoffnet, indem die Anzahl von Zustanden, Ubergangen und atomaren Aussagen eingegeben werdenkann. Mit diesen Parametern wird eine zufallige Kripke-Struktur erzeugt.

Abbildung 4.7 zeigt die neue Graph-Visualisierung einer Kripke-Struktur, die sichuber den Button Kripke-Struktur zeichnen im Hauptfenster erscheinen lasst. JederZustand wird mit seinem Namen sowie mit den atomaren Aussagen beschriftet, die indiesem Zustand gelten. Es besteht die Moglichkeit, den Kripke-Graphen zu manipulieren.Durch

”Drag and Drop“ konnen einzelne sowie mehrere ausgewahlte Knoten verschoben

werden. Selektion der Knoten erfolgt durch das An- bzw. Abwahlen der Knoten mit demlinken Mausklick oder durch das Ziehen eines Rechtecks uber die interessierenden Zu-stande. Mehrfachauswahl geschieht, wenn dazu gleichzeitig eine SHIFT-Taste gedrucktwird. Skalierung erfolgt mit Hilfe vom Scrollrad. Diese Funktionalitaten sind behilflich,wenn man mit einer komplexen Kripke-Struktur arbeitet, deren automatische Visua-lisierung unubersichtlich vorkommen kann. Die Speicherung des Bildes erfolgt wie imBasisprogramm uber das Menu Datei→Bild speichern.

Abbildung 4.6: Das Fenster mit den Einstellungen des Programms

31


Abbildung 4.7: Graphische Darstellung einer Kripke-Struktur

Bei der Erstellung einer neuen CTL-Formel ist Folgendes zu beachten. Die temporalenOperatoren mussen groß und ohne Leerzeichen geschrieben werden (z. B. EX fur EXusw.). Eine AU-Formel muss in der Form A(α U β) eingegeben werden. Die gleiche Re-gel gilt auch fur die AR-, EU- und ER-Formeln. Die booleschen Operatoren ¬, ∧ und ∨sind als

”∼“,

”AND“ bzw.

”OR“ einzugeben. Alle ubrigen Zeichenketten werden als ato-

mare Aussagen interpretiert. Wenn man mit LTL-Formeln arbeitet, sind die dazu spezifi-schen Eingaberegeln zu berucksichtigen, die in [Sol09] aufgefuhrt sind. Allerdings findetdie Eingabe samtlicher Formeln im selben Fenster statt, das durch das Betatigen desButtons neue Formel erstellen abrufbar ist. Danach wird intern entschieden, ob dieeingegebene Formel die CTL-, insbesondere CTLpos- und/oder LTL-Kriterien erfullt. AufLTL-Formeln sind die Algorithmen anwendbar, die durch die Buttons ModelCheckVund ModelCheckL aus dem Basisprogramm ausgelost werden konnen. Fur CTL- undCTLpos -Formeln ist ein neu hinzugekommener Button ModelCheckCTL vorgesehen.Folglich wird Benutzer beim Versuch, einen unzulassigen Algorithmus auszufuhren, ent-sprechend benachrichtigt.

Im Formel-Bereich sind zwei Textfelder zu sehen. Im ersten wird die eingegebene bzw.geladene Formel angezeigt. Wenn eine CTL-Formel vorliegt, wird sie im zweiten Textfeldin der konvertierten Form dargestellt, in der nur die Operatoren aus der minimalenMenge {¬, ∨, EX, EU, EG} vorkommen.

32


Das Anklicken des ModelCheckCTL-Buttons lost das Offnen eines neuen Fenstersaus, in dem das Model-Checking fur CTL und insbesondere fur CTLpos gesteuert werdenkann. Abbildung 4.8 reprasentiert dieses Fenster.

Abbildung 4.8: Model-Checking-Fenster fur CTL vor dem Ausfuhren des CTL-MC(ALL)-Algorithmus

Hier wird die Kripke-Struktur graphisch dargestellt und kann wie im oben erlautertenVisualisierungsfenster manipuliert werden. Außerdem werden alle ihre Zustande in einerListe aufgezahlt. Dies dient dazu, die zu prufenden Zustande bequem auszuwahlen. Inder Liste werden sie mit dem linken Mausklick selektiert und mit einem wiederholtendeselektiert. Wenn die Liste den Fokus besitzt, konnen alle Zustande durch die Tasten-kombination STRG+A hervorgehoben werden. In Graph-Darstellung werden Zustandemit einem Doppelklick und bei Mehrfachauswahl mit gedruckter SHIFT-Taste selektiert.Beim (De-)Selektieren der Zustande in der Liste werden diese auch im Graphen farblichhervorgehoben und umgekehrt.

Unter der Liste sind zwei Buttons fur die CTLpos-MC(EX, EG, EU, ER)- und CTL-MC(ALL)-Algorithmen zu sehen. Wenn im Hauptfenster eine CTL-Formel erstellt/gela-den wurde, die den CTLpos -Einschrankungen nicht genugt, wird der Button Model-CheckingCTLpos nicht aktiv sein.

33


Um den CTLpos-Algorithmus starten zu konnen, muss man mindestens einen zu pru-fenden Zustand auswahlen. Fur CTL-MC(ALL)-Algorithmus wird das nicht verlangt.Wenn kein Zustand ausgewahlt und der Button ModelCheckingCTLall betatigt wur-den, wird das Programm es so interpretieren, dass der Algorithmus die Formel uberpruftund als Ergebnis alle Zustande aufzahlt, in denen die Formel zu

”wahr“ evaluiert. Dieses

unterschiedliche Verhalten liegt an der Besonderheiten der Funktionsweise von Algorith-men.

Wenn die Algorithmen ausgefuhrt sind, werden Ergebnisse im Ergebnisfeld ausgege-ben. Außerdem werden die untersuchten Zustande im Graphen grun oder rot markiert,um die Zustande zu betonen, in denen die Formel erfullt bzw. nicht erfullt wird. Daswird in Abbildung 4.9 veranschaulicht.

Abbildung 4.9: Model-Checking-Fenster fur CTL nach dem Ausfuhren des CTL-MC(ALL)-Algorithmus

Der CTLpos -Algorithmus liefert nicht nur eine positive und/oder negative Antwortzu jedem Zustand, sondern auch Zustande fur Zustand-Formeln oder Pfade fur Pfad-Formeln, in denen sie erfullt werden. Die Abbildungen 4.10 und 4.11 reprasentieren diesezwei Falle. In der ersten Zeile in Abbildung 4.11 ist das Ergebnis des CTL-MC(ALL)-Algorithmus zu sehen, der vor dem CTLpos-Algorithmus ausgefuhrt wurde.

34


Das Andern der zu analysierenden Daten findet im Hauptfenster des Programms statt,in das man durch Schließen des CTL-Model-Checking-Fensters zuruckkehrt.

Abbildung 4.10: Model-Checking-Fenster fur CTL nach dem Ausfuhren des CTLpos -MC(EX, EG, EU, ER)-Algorithmus fur eine EX-Formel

Abbildung 4.11: Model-Checking-Fenster fur CTL nach dem Ausfuhren des CTLpos -MC(EX, EG, EU, ER)-Algorithmus fur eine EG-Formel

35

5 Auswertung von Algorithmen

Ziel dieses Kapitels ist es, Laufzeit der vorgestellten Algorithmen anhand der Experimen-te zu analysieren und zu vergleichen. Nachdem das Testsystem, Ablauf der Experimentesowie verwendete Testdaten beschrieben werden, werden die Ergebnisse der Experimentemit bestimmten Laufzeiten vorgestellt. Die Experimente werden in drei Gruppen einge-teilt, die den folgenden Zielsetzungen entsprechen:

• Auswertung der Laufzeiten von zwei Implementierungsarten des CTLpos-MC(EX,EG, EU, ER)-Algorithmus1: modelCheckingCTLposArrayList(...) und model -CheckingCTLposTree(...).

• Vergleich der Laufzeiten von CTL-MC(ALL)-Algorithmus2 und von der effizien-teren Implementierung des CTLpos -Algorithmus angewendet auf die Formeln desFragmentes CTLpos(EX, EG, EU, ER) und

”kleine“ Kripke-Strukturen.

• Auswertung des CTL-Algorithmus fur diverse Formeln und”großere“ Kripke-Struk-

turen.

5.1 Allgemeine Beschreibung der Experimente

5.1.1 Testsystem

Algorithmen werden auf dem folgenden System getestet:

• CPU: Intel Core Duo T5500 1,66 GHz

• RAM: 1 GB (DDR2 SDRAM)

• Mainboard: ASUSTek Computer Inc. F3JC

• OS: Microsoft Windows XP

• Java: J2SE Version 1.6

1weiter als ”CTLpos-Algorithmus“ genannt2weiter als ”CTL-Algorithmus“ genannt

36


5.1.2 Testdaten

Zum Testen der Algorithmen werden verschiedene Kripke-Strukturen und Formeln be-notigt. Um allgemeine Auswertung zu ermoglichen, werden zufallig erzeugte Kripke-Strukturen verwendet. Das Prinzip der Generierung wurde in Abschnitt 4.2 erlautert,da diese Funktion (createRandomKripke(int , int , int)) zu den Funktionalitaten des Pro-gramms gehort. Fur die Experimente werden die Kripke-Strukturen mit unterschiedli-cher Anzahl von Zustanden, Ubergangen aus jedem Zustand und atomaren Aussagenautomatisch erzeugt. Alle diese Kennzahlen werden fur jedes Experiment aufgezeich-net und mit den Ergebnissen aufgelistet. In den Experimenten, in denen der CTLpos

-Algorithmus analysiert wird, werden”kleine“ Kripke-Strukturen generiert, die aus bis zu

9 Zustanden bestehen. Diese Grenze wurde experimentell herausgefunden und ist ge-nugend, um festzustellen, ob sich die Vermutung bestatigen lasst, dass die Laufzeit desCTLpos-Algorithmus mit der Anzahl von Zustanden und Ubergangen beim Untersuchender Pfad-Formeln exponentiell wachst. Bei der Analyse des CTL-Algorithmus werdenauch

”großere“ Kripke-Strukturen mit bis zu 300 Zustanden untersucht, da dieser Algo-

rithmus in Polynomialzeit arbeitet.Die zu testenden Formeln werden nicht zufallig erzeugt, sondern explizit definiert. Das

ist wichtig, um die Algorithmen in Abhangigkeit von der Art der Formel (Pfad- oderZustand-Formel), vom verwendeten Operator und vom Verschachtelungsgrad der Formelbeurteilen zu konnen.

5.1.3 Ablauf

Jedes Experiment basiert auf folgenden Schritten.

1. Erzeuge eine Kripke-Struktur mit W Zustanden, T Ubergangen und maximal Patomaren Aussagen in jedem Zustand. Je nach Experiment werden verschiedeneWerte fur W und T eingesetzt. Fur alle Experimente wird P = 5 verwendet, da dieEvaluierung einer aussagenlogischen Formel NC1-vollstandig ist. Deswegen kann dieLaufzeit der Algorithmen durch einen großeren Wert von P nicht beeintrachtigtwerden.

2. Wahle eine Formel ϕ aus den Testformeln (siehe Tabelle 5.1).

3. Fur jede Kripke-Struktur und jede Formel ϕ rufe CTLpos- und/oder CTL-Algorithmusin jedem Zustand auf.

4. Messe die Laufzeit der Algorithmen. Dabei wird die Methode currentTimeMillis()aus der Standardklasse java.lang.System benutzt, die die Laufzeit in Millisekundenmisst.

5. Speichere Ergebnisse: charakteristische Kennzahlen der Testdaten W , T , P , dieanalysierte Formel ϕ sowie die Laufzeiten von Algorithmen und die Anzahl der zu

”wahr“ evaluierten Zustande. Diese werden in einer .csv-Datei gespeichert, um die

Auswertung zu erleichtern.

37


In manchen Experimenten werden Kripke-Strukturen mit bestimmten Vorgaben (W , T )mehrmals erzeugt und auf dieselbe Formel angewendet. Das ermoglicht, Ergebnisse mitverschiedener Anzahl von

”wahr“-Zustanden und mit unterschiedlichen Laufzeiten fur

gleich-große Kripke-Strukturen zu beobachten. Die Kennzahlen von Testdaten sowie dieAnzahl der Durchlaufe, in denen solche Kripke-Strukturen erzeugt werden, werden furjedes Experiment tabellarisch aufgefuhrt. Die getesteten Formeln, die Anzahl der

”wahr“-

Zustande sowie die Laufzeiten werden graphisch veranschaulicht. In allen folgenden Ab-bildungen stehen auf der Y-Achse Laufzeiten in Millisekunden. In den Abbildungen, indenen jeweils nur eine Formel dargestellt ist, sind auf der X-Achse drei Reihen von Wer-ten zu sehen. Die untere bzw. die mittlere Reihe reprasentiert die Anzahl von Zustandenbzw. Ubergangen von generierten Kripke-Strukturen. Die obere Reihe gibt die Anzahlvon

”wahr“-Zustanden an. Diese entfallt fur die Abbildungen, in denen mehrere Formeln

erfasst sind.

a AND b (EX a) OR (a AND b)EX a AX aEG b AG bE(c U d) A(c U d)E(c R d) A(c R d)EF c AF cEG(e AND EX a) AG(e AND AX a)EG(EG b) AG(AG b)∼AG(∼e AND AX a) EG (b OR ∼b)EX ∼a EX(a AND ∼a)

Tabelle 5.1: Test-Formeln

5.2 Zwei Implementierungen des CTLpos -Algorithmus

In diesem Abschnitt werden zwei Implementierungen (ArrayList<ArrayList<State>>und TreeNode<State>) des CTLpos-Algorithmus unter der Anwendung der Pfad-Formelngegenubergestellt. Hier werden zwei Experimente durchgefuhrt. In Tabelle 5.2 sind dieTestsparameter sowie die uberpruften Formeln aufgelistet. Die Ergebnisse sind in Abbil-dungen 5.1, 5.2, 5.3 und 5.4 zu sehen.

Im ersten Experiment wird die Laufzeit in Abhangigkeit von der Anzahl der Zustandegemessen. Im zweiten werden Kripke-Strukturen mit jeweils 9 Zustanden erzeugt. DieAnzahl der Ubergange wird variiert. Abbildung 5.1 ist ein Ausschnitt aus Abbildung 5.2.Das Verhalten von beiden Implementierungen ist fur die Kripke-Strukturen mit bis zu7 Zustanden ahnlich. Danach wachst die Laufzeit der

”List“-Implementierung exponen-

tiell. Fur großere Kripke-Strukturen steigt die”Tree“-Implementierung langsamer, aber

auch exponentiell an. Dies ist in den Abbildungen 5.3 und 5.4 ersichtlich, in denen dieLaufzeiten in Abhangigkeit von der Anzahl der Ubergange dargestellt sind. In diesen

38


Abbildungen besteht die Moglichkeit, das Verhalten des Algorithmus in Bezug auf dieAnzahl der zu

”wahr“ evaluierten Zustande zu analysieren, die in der obersten Zeile auf

der X-Achse dargestellt sind.Wegen der exponentiellen Laufzeit und des Mangels an Ressourcen konnen

”große-

re“ Kripke-Strukturen nicht getestet werden. Wenn eine Pfad-Formel auf einer Kripke-Struktur mit 9 Zustanden und 9 Ubergangen mittels der modelCheckingCTLpos-ArrayList(...) gepruft wird, tritt ein

”java.lang.OutOfMemoryError“ Fehler auf. Beim Ver-

wenden der Methode modelCheckingCTLposTree(...) tritt dieses Problem fur Kripke-Strukturen mit 15 Zustanden und 6 Ubergangen aus jedem Zustand auf. In Abbildung5.3 ist zu sehen, dass die Laufzeit von der Tree-Implementierung langsamer, aber auchexponentiell wachst.

Experiment I Experiment II

Anzahl der Zustande W 2..8 9

Anzahl der Ubergange ⌊W2⌋ 2..4

Anzahl der Durchlaufe 5 3Getestete Formeln EG b, E(c U d) EG bAbbildungen 5.1, 5.2 5.3, 5.4

Tabelle 5.2: Experimentendaten fur zwei Implementierungen des CTLpos-Algorithmus

Abbildung 5.1: Zwei Implementierungen des CTLpos -Algorithmus: EG- und EU-Formeln, Zustande 2..7

39


Abbildung 5.2: Zwei Implementierungen des CTLpos -Algorithmus: EG- und EU-Formeln, Zustande 2..8

Abbildung 5.3: Zwei Implementierungen des CTLpos -Algorithmus: EG-Formel, 9Zustande

5.3 Auswertung von CTLpos - und CTL-Algorithmen

Hier werden die CTLpos- und CTL-Algorithmen verglichen. Wir fuhren zwei Experimentedurch, in denen, wie im vorigen Abschnitt, die Abhangigkeit von der Anzahl der Zustan-de und der Ubergange anhand den Abbildungen herausgestellt wird. Um Algorithmenvergleichen zu konnen, werden Formeln betrachtet, die die CTLpos-Bedingungen erfullen.

40


Abbildung 5.4: Tree-Implementierung des CTLpos-Algorithmus: EG-Formel, 9 Zustande

Die Tabelle 5.3 enthalt die Testsdaten von diesen Experimenten.


Anzahl der Zu-stande W

2..8 5

Anzahl derUbergange

⌊W2⌋ 2..5

Anzahl derDurchlaufe

5 5

Getestete For-meln

a AND b, EG b, (EX a) OR (a AND b),EG(e AND EX a), EG(EG b)

EX a, EG b

Abbildungen 5.5, 5.6, 5.7 5.9, 5.8

Tabelle 5.3: Experimentendaten fur CTLpos- und CTL-Algorithmen

In Abbildung 5.5 werden die Laufzeiten von Zustand-Formeln prasentiert. Die Laufzeit-Kurven der beiden Algorithmen verlaufen ahnlich. Die herausragenden spitzigen Buckelstellen die Laufzeiten fur diejenigen Kripke-Strukturen und Formeln dar, die in jedemZustand erfullt werden. Die Laufzeiten der beiden Algorithmen nehmen fur diese For-meln auf diesem Intervall zu und tendieren zur linearen Laufzeit. Eine andere Situationist in Abbildung 5.6 zu beobachten. Die Laufzeit des CTLpos-Algorithmus ist nicht mehr

”linear“. Der CTL-Algorithmus ist fur die EG-, EU-Formeln deutlich schneller als der

CTLpos-Algorithmus. Die Kurven des CTL-Algorithmus sind kaum zu erkennen, da seineLaufzeit fur diese Formeln zwischen 0 und 0,8 Millisekunden schwankt (siehe Abbildung5.7).

41


Die Abbildungen 5.9, 5.8 zeigen das Verhalten der Algorithmen fur Kripke-Strukturenmit jeweils 5 Zustanden und mit variierter Anzahl von Ubergangen. Das exponentielleWachstum des CTLpos-Algorithmus lasst sich noch nicht erkennen.

Abbildung 5.5: Vergleich der CTLpos - und CTL-Algorithmen: Zustand-Formeln, 2..8Zustande

Abbildung 5.6: Vergleich der CTLpos- und CTL-Algorithmen: EG- und EU-Formeln, 2..8Zustande

42


Abbildung 5.7: Vergleich der CTLpos- und CTL-Algorithmen: Ausschnitt aus 5.6 mit denLaufzeiten des CTL-Algorithmus, 2..8 Zustande

Abbildung 5.8: Vergleich der CTLpos - und CTL-Algorithmen: EG-Formel, 5 Zustande,2..5 Ubergange

5.4 Laufzeit des CTL-Algorithmus fur Kripke-Strukturenmit bis zu 300 Zustanden

Ziel dieses Abschnitts ist die Analyse des CTL-Algorithmus fur”große“ Kripke-Struktu-

ren. Im ersten Experiment beschranken wir uns auf die Kripke-Strukturen mit bis zu100 Zustanden. Abbildungen 5.10, 5.11, 5.12 zeigen die Laufzeiten je nach der Art der

43


Abbildung 5.9: Vergleich der CTLpos - und CTL-Algorithmen: EX-Formel, 5 Zustande,2..5 Ubergange

Operatoren (existenzielle oder universelle) bzw. in Abhangigkeit vom Verschachtellungs-grad der Formeln. Da jede Formel immer mittels der Operatoren der minimalen Menge{¬, ∨, EX, EU, EG} umgewandelt wird, bevor der CTL-Algorithmus gestartet wird,dienen die Abbildungen 5.11 und 5.12 nur zum Uberblick und stellen die Laufzeiten furdie Formeln großeres Verschachtellungsgrades im Vergleich zu den Formeln aus Abbil-dung 5.10 dar. Das zweite Experiment (Abbildung 5.13) visualisiert das polynomielleVerhalten des CTL-Algorithmus abhangig von der Anzahl der Zustande. Hier werdendie Formeln betrachtet, die erzwingen, dass die entweder in keinem oder in allen Zu-standen erfullt werden. Die Laufzeit fur die Formel EX ∼ a ist kleiner als fur die FormelEG(b OR ∼ b), da die letzte mehr Zeit fur den Aufbau der Zusammenhangkomponentenbeansprucht. Die Laufzeiten fur die Formeln, die nie erfullt werden, betragen maximalfunf Millisekunden. Allerdings demonstrieren alle Abbildungen polynomielle Laufzeit desCTL-Algorithmus.

44



Anzahl derZustandeW (Schritt)

10..100(10) 50..300(25)

Anzahl derUbergange

⌊W2⌋ ⌊W

2⌋

Anzahl derDurchlaufe

5 1

Getestete For-meln

EG b, (EX a), E(c U d), E(c R d), EF c,AG b, (AX a), A(c U d), A(c R d), AF c,EG(EG b), AG(AG b), AG(e AND AXa), AG( e AND AX a)

EX a, EX ( aAND a), EG (bOR b), EG (aAND a)

Abbildungen 5.10, 5.11, 5.12 5.13

Tabelle 5.4: Experimentendaten fur den CTL-Algorithmus mit”großen“ Kripke-Struk-

turen

Abbildung 5.10: Vergleich der Laufzeiten des CTL-Algorithmus: Formeln mit existenti-ellen Operatoren, 10..100 Zustande

45


Abbildung 5.11: Vergleich der Laufzeiten des CTL-Algorithmus: Formeln mit universalenOperatoren, 10..100 Zustande

Abbildung 5.12: Vergleich der Laufzeiten des CTL-Algorithmus: Formeln verschiedenesVerschachtellungsgrades, 10..100 Zustande

46


Abbildung 5.13: Vergleich der Laufzeiten des CTL-Algorithmus: EX- und EG-Formeln,50..300 Zustande

47

6 Zusammenfassung und Ausblick

Die Aufgabe dieser Diplomarbeit ist es, das Model-Checking-Problem fur CTL auszuar-beiten. Als Erstes wurde der allgemeine Model-Checking-Prozess betrachtet, und dessengrundlegende Begriffe wurden eingefuhrt. Insbesondere wurde die Kripke-Struktur de-finiert, mit deren Hilfe endliche zustandsbasierte Systeme modelliert werden konnen.Anforderungen an die Systeme werden mittels einer Spezifikationssprache formalisiert.Im Rahmen dieser Arbeit wurde auf die temporale Logik CTL (Computation Tree Logic)naher eingegangen, die fur die Spezifikation verwendet wird. Die theoretischen Grund-lagen wurden anhand von Beispielen veranschaulicht.

Ein weiteres Ziel besteht darin, die Komplexitat des Model-Checking-Problems furCTL zu untersuchen. Dieses Problem ist als P-vollstandig bekannt ([CES86], [Sch02]).Es wird versucht, leichtere Teilprobleme zu finden, die effizienter zu losen sind. Dafurwurde CTLpos , ein Fragment von CTL, betrachtet, in dem die Negation nicht auf dietemporalen Operatoren angewendet werden darf. Außerdem werden nur bestimmte tem-porale Operatoren erlaubt.

Weiterhin wurden zwei Model-Checking-Algorithmen vorgestellt, und zwar fur CTLallgemein und fur CTLpos. Als praktischer Teil dieser Arbeit wurden sie in Java implemen-tiert. Dabei wurde ein schon existierendes Programm erweitert, in dem die Datenstrukturfur die Kripke-Struktur vorhanden war. Dieses Programm wurde fur Model-Checking fureine andere temporale Logik entwickelt. Deswegen wurden die Datenstrukturen fur CTL-und CTLpos -Formeln geschaffen. Die beiden Algorithmen haben polynomielle Laufzeit.Im Algorithmus fur CTLpos musste man nichtdeterministisch eine Entscheidung treffen.Dies wurde dadurch ersetzt, dass alle in Frage kommenden Moglichkeiten der Reihenach untersucht wurden, bis eine Losung gefunden wurde. Im schlimmsten Fall mussenaber alle Moglichkeiten uberpruft werden. Dies fuhrt zu der exponentiellen Laufzeit desimplementierten Algorithmus. Als Verbesserung der exponentiellen Laufzeit wurde eineweitere Implementierung vorgenommen, in der Berechnungspfade in einer baumartigenStruktur gespeichert und entsprechend traversiert werden.

Außerdem wurde ein großer Wert auf die Benutzerschnittstelle des Programms gelegt.Insbesondere wurde die graphische Benutzeroberflache uberarbeitet. Es wurden neueFunktionalitaten eingefuhrt, die unter anderem dem Benutzer ermoglichen, Zustande inder Kripke-Struktur per Mausklick zu (de-)selektieren und die Algorithmen fur diver-se Zustande auszufuhren. Die Ergebnisse der Algorithmen werden nicht nur im Text,sondern auch graphisch angezeigt. Weiterhin kann der Benutzer das Programm so ein-zustellen, dass bestimmte Kripke-Struktur und Formel beim Offnen des Programms au-tomatisch geladen werden. Es besteht jetzt auch die Moglichkeit, Kripke-Strukturen mitbestimmter Anzahl der Zustande, der Ubergange und der atomaren Aussagen zufalligzu generieren.

48

6 Zusammenfassung und Ausblick

Anschließend wurden die betrachteten Algorithmen anhand der zufalligen Testdatenuntersucht und ausgewertet. Die Laufzeiten wurden graphisch veranschaulicht.

Die Auswertung der Algorithmen hat das polynomielle Verhalten des CTL- und dasexponentielle Verhalten des implementierten CTLpos -Algorithmus fur das betrachteteFragment der temporalen Operatoren {EX, EG, EU, ER} anhand der Visualisierungender Laufzeiten bestatigt.

Um eine bessere Komplexitat des Model-Checking-Problems fur CTL zu erreichen,konnte man weitere Fragmente von CTL untersuchen. Da sich der CTL-Algorithmus alseffizient erwiesen hat, kann er fur das Model-Checking fur CTL eingesetzt werden.

Das Programm kann weiterentwickelt werden. Dabei konnen die bestehenden Daten-strukturen einerseits fur weitere Model-Checking-Algorithmen verwendet, andererseitsfur andere temporale Logiken modifiziert werden.

Weiterhin konnte man das Erstellen und das Andern der Kripke-Struktur direkt inihrer Visualisierung als Graphen ermoglichen, damit der Benutzer Zustande und Uber-gange per Mausklick hinzufugen und loschen konnte.

49

Abbildungsverzeichnis

2.1 Speisende Philosophen (vgl. [Sch]) . . . . . . . . . . . . . . . . . . . . . . . 92.2 Speisende Philosophen als ein Modell([Har02]) . . . . . . . . . . . . . . . . 102.3 Speisende Philosophen als eine Kripke-Struktur . . . . . . . . . . . . . . . 11

4.1 Das Hauptfenster des Basisprogramms (Bild aus [Sol09]) . . . . . . . . . . 224.2 Klassendiagramm fur Programmlogik . . . . . . . . . . . . . . . . . . . . . . 234.3 Klassendiagramm der Benutzerschnittstelle . . . . . . . . . . . . . . . . . . 244.4 Zwei Abarbeitungsmoglichkeiten bei der Untersuchung von Pfad-Formeln 284.5 Das geanderte Hauptfenster des Programms . . . . . . . . . . . . . . . . . 304.6 Das Fenster mit den Einstellungen des Programms . . . . . . . . . . . . . 314.7 Graphische Darstellung einer Kripke-Struktur . . . . . . . . . . . . . . . . 324.8 Model-Checking-Fenster fur CTL vor dem Ausfuhren des CTL-MC(ALL)-

Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.9 Model-Checking-Fenster fur CTL nach dem Ausfuhren des CTL-MC(ALL)-

Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344.10 Model-Checking-Fenster fur CTL nach dem Ausfuhren des CTLpos-MC(EX,

EG, EU, ER)-Algorithmus fur eine EX-Formel . . . . . . . . . . . . . . . 354.11 Model-Checking-Fenster fur CTL nach dem Ausfuhren des CTLpos-MC(EX,

EG, EU, ER)-Algorithmus fur eine EG-Formel . . . . . . . . . . . . . . . 35

5.1 Zwei Implementierungen des CTLpos-Algorithmus: EG- und EU-Formeln,Zustande 2..7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

5.2 Zwei Implementierungen des CTLpos-Algorithmus: EG- und EU-Formeln,Zustande 2..8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

5.3 Zwei Implementierungen des CTLpos-Algorithmus: EG-Formel, 9 Zustande 405.4 Tree-Implementierung des CTLpos-Algorithmus: EG-Formel, 9 Zustande . 415.5 Vergleich der CTLpos - und CTL-Algorithmen: Zustand-Formeln, 2..8 Zu-

stande . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425.6 Vergleich der CTLpos- und CTL-Algorithmen: EG- und EU-Formeln, 2..8

Zustande . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425.7 Vergleich der CTLpos- und CTL-Algorithmen: Ausschnitt aus 5.6 mit den

Laufzeiten des CTL-Algorithmus, 2..8 Zustande . . . . . . . . . . . . . . . . 435.8 Vergleich der CTLpos- und CTL-Algorithmen: EG-Formel, 5 Zustande, 2..5

Ubergange . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435.9 Vergleich der CTLpos- und CTL-Algorithmen: EX-Formel, 5 Zustande, 2..5

Ubergange . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

50

Abbildungsverzeichnis

5.10 Vergleich der Laufzeiten des CTL-Algorithmus: Formeln mit existentiellenOperatoren, 10..100 Zustande . . . . . . . . . . . . . . . . . . . . . . . . . . 45

5.11 Vergleich der Laufzeiten des CTL-Algorithmus: Formeln mit universalenOperatoren, 10..100 Zustande . . . . . . . . . . . . . . . . . . . . . . . . . . 46

5.12 Vergleich der Laufzeiten des CTL-Algorithmus: Formeln verschiedenes Ver-schachtellungsgrades, 10..100 Zustande . . . . . . . . . . . . . . . . . . . . . 46

5.13 Vergleich der Laufzeiten des CTL-Algorithmus: EX- und EG-Formeln,50..300 Zustande . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

51

Tabellenverzeichnis

2.1 Temporale Operatoren. ϕ,ψ sind temporal-logische Formeln . . . . . . . . 62.2 Pfad-Quantoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.3 Darstellung der CTL-Formeln durch die Operatoren EX, EU, EG, ¬, ∨ . 8

5.1 Test-Formeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385.2 Experimentendaten fur zwei Implementierungen des CTLpos-Algorithmus 395.3 Experimentendaten fur CTLpos- und CTL-Algorithmen . . . . . . . . . . . 415.4 Experimentendaten fur den CTL-Algorithmus mit

”großen“ Kripke-Struk-

turen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

52

Literaturverzeichnis

[AHU74] Aho, A. V., J. E. Hopcroft und J. D. Ullmann: The Design and Analy-sis of Computer Algorithms. Addison-Wesley Publishing Company, London,England, 1974.

[AUH82] Aho, A. V., J. D. Ullman und J. E. Hopcroft: Data Structures andAlgorithms. Addison Wesley Pub Co Inc, 1982.

[BMT+] Beyersdorff, O., A. Meier, M. Thomas, H. Vollmer, M. Mundhenkund T. Schneider: Model Checking for CTL Fragments Made EfficientlyParallel. Unveroffentlichte, vorlaufige Version von [BMT+09].

[BMT+09] Beyersdorff, O., A. Meier, M. Thomas, H. Vollmer, M. Mund-henk und T. Schneider: Model Checking CTL is Almost AlwaysInherently Sequential. Proc. of the 16th International Symposiumon Temporal Representation and Reasoning, IEEE Computer SocietyPress, 2009. http://www.thi.uni-hannover.de/fileadmin/forschung/

publikationen/daten/be-me-mu-sc-th-vo-09.pdf.

[CES86] Clarke, E., A. E. Emerson und A. Systla: Automatic verification offinite-state concurrent systems using temporal logic specifications. ACM Tran-sactions on Programming Languages and Systems, 1986.

[CGP99] Clarke, E. M., O. Grumberg und D. A. Peled: Model Checking. TheMIT Press, Cambridge, Massachusetts, London, England, 1999.

[EL87] Emerson, A. E. und C.-L. Lei: Modalities for model checking: Branchingtime logic strikes back. Science of Computer Programming, 1987.

[Har02] Hartmann, A.: Ein grafisches Werkzeug zur Unterstutzung von Model-Checking-Prozessen. Diplomarbeit, Universitat Rostock, Fachbereich In-formatik, 2002. http://www.cocooncenter.org/index/thesis_hartmann.pdf.

[Sch] Schwoon, S.: Model-Checking. http://www.fmi.uni-stuttgart.de/szs/teaching/ss2004/modelchecking/modelchecking.pdf.

[Sch02] Schnoebelen, P.: The complexity of temporal logic model Checking. Ad-vances in Modal Logic, 2002.

53

http://www.thi.uni-hannover.de/fileadmin/forschung/publikationen/daten/be-me-mu-sc-th-vo-09.pdf

http://www.thi.uni-hannover.de/fileadmin/forschung/publikationen/daten/be-me-mu-sc-th-vo-09.pdf

http://www.cocooncenter.org/index/thesis_hartmann.pdf

http://www.cocooncenter.org/index/thesis_hartmann.pdf

http://www.fmi.uni-stuttgart.de/szs/teaching/ss2004/modelchecking/modelchecking.pdf

http://www.fmi.uni-stuttgart.de/szs/teaching/ss2004/modelchecking/modelchecking.pdf

Literaturverzeichnis

[Sol09] Soldatova, M.: Effizientes Model-Checking fur CTL*. Diplomarbeit, Uni-versitat Hannover, 2009. http://www.thi.uni-hannover.de/fileadmin/

forschung/arbeiten/soldatova-da.pdf.

54

http://www.thi.uni-hannover.de/fileadmin/forschung/arbeiten/soldatova-da.pdf

http://www.thi.uni-hannover.de/fileadmin/forschung/arbeiten/soldatova-da.pdf

Erklarung

Hiermit versichere ich, dass ich die vorliegende Arbeit und die zugehorige Implementie-rung selbstandig verfasst und dabei nur die angegebenen Quellen und Hilfsmittel ver-wendet habe.

Hannover, 26. Oktober 2009

Julia Gerock

Documents

E zientes Model-Checking f ur CTL - thi.uni- · PDF fileE zientes Model-Checking f ur CTL Diplomarbeit im Studiengang Mathematik mit Studienrichtung Informatik Julia Gerock Mtr.-Nr