Zum Inhalt springen

„Computation Tree Logic“ – Versionsunterschied

aus Wikipedia, der freien Enzyklopädie
[gesichtete Version][gesichtete Version]
Inhalt gelöscht Inhalt hinzugefügt
Temporaloperatoren: daß --> dass
 
(37 dazwischenliegende Versionen von 25 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
[[Datei:Computational Tree Logic Example.png|mini|hochkant=1.25|CTL-Formeln visualisiert]]
Die '''Computation Tree Logic''' (kurz CTL) ist eine [[Temporale Logik]], die speziell zur [[Spezifikation]] und [[Verifikation]] von [[Computersystem]]en dient. Meist wird sie auch mit CTL* bezeichnet. CTL bezeichnet dann eine spezielle Teilmenge der CTL*-Formeln. Eine weitere wichtige spezielle Teilmenge von CTL* ist die [[Lineare_temporale_Logik | ''Linear Time Temporal Logic'']] (kurz LTL).


Die '''Computation Tree Logic''' (kurz CTL) ist eine [[Temporale Logik]], deren Modell der Zeit eine baumartige Struktur hat. Die zeitliche Änderung von Zuständen und deren Eigenschaften wird durch Pfade innerhalb dieser Baumstruktur modelliert. Hierbei hat die Zukunft mehrere Pfade, wobei nicht festgelegt ist, welche letztendlich realisiert werden. Demnach können Aussagen über die mögliche Entwicklungen getroffen werden.
Wie allgemein bei temporalen Logiken geht es nicht um die Beschreibung von zeitlichen Abläufen (dies wäre die [[Real Time Logik]]), sondern um die Eigenschaften von Zuständen und deren Änderung in Systemabläufen. CTL* ist dabei eine Erweiterung der [[Aussagenlogik]].


Die CTL wird zur [[Verifizierung|Verifikation]] von Hard- und Software verwendet, üblicherweise von [[Model Checking|Model Checkern]].
== Syntax und Semantik ==


Zu der Familie der temporalen Logiken gehört auch die [[Lineare temporale Logik|Linear temporale Logik]] (LTL), wobei hier nur eine Zukunft möglich ist. Eine Verallgemeinerung der beiden Logiken wird als CTL* bezeichnet.
=== Atomare Aussagen ===
''(siehe auch den Abschnitt "Umgangssprachliche Einleitung" im Artikel [[Aussagenlogik#Umgangssprachliche Einleitung|Aussagenlogik]])''


== Syntax ==
Ausgangspunkt sind Eigenschaften von Zuständen. Ist ''AP'' eine Menge von atomaren Aussagen (Behauptungen), so ist jedes Element ''p'' von ''AP'' eine Zustandsformel. Jedes ''p'' von ''AP'' ist eine Abbildung von der Zustandsmenge in die Menge der [[Wahrheitswert|Wahrheitswerte]] {''W''ahr,''F''alsch}. Man sagt ein Zustand ''s'' erfüllt ein ''p'' aus ''AP'' genau dann, wenn ''p''(''s'')=''W''.
=== Minimale Grammatik ===
Sei <math>AP</math> eine Menge von [[Aussage (Logik)#Einfach – zusammengesetzt|atomaren Aussagen]] (Behauptungen), dann ist jedes Element <math>p \in AP</math> eine CTL-Formel. Sind <math>\phi</math> und <math>\psi</math> Formeln, dann auch <math>\neg\phi</math>, <math>\phi \lor \psi</math>, <math>\text{EX}\phi</math>, <math>\text{EG} \phi</math> und <math>\phi \text{EU} \psi</math>. Dies definiert die minimale [[Formale Grammatik|Grammatik]] von CTL. In der Regel wird diese allerdings um die gängigen [[Boolescher Operator|booleschen Operatoren]] <math>\land</math>, <math>\implies</math>und <math>\Lrarr</math>, sowie einigen weiteren temporalen Operatoren erweitert.


=== Boolesche Operatoren ===
=== Temporale Operatoren ===
Die Erweiterung der minimalen Grammatik um folgende Operatoren erhöht nicht die Mächtigkeit der [[Formale Sprache|Sprache]], da alle Operatoren durch Umformungen zurückgeführt werden können.
Aus den atomaren Formeln können nun aussagenlogische Formeln konstruiert werden. Durch den einstelligen Operator <math>\neg</math> und die zweistelligen Operatoren <math>\wedge,\vee,\Rightarrow,\iff</math>, können wie bei der [[Aussagenlogik]] üblich neue Formeln im Sinne von NICHT, UND, ODER, IMPLIKATION und ÄQUIVALENZ gebildet werden.


* Pfadoperatoren:
=== Temporaloperatoren ===
** <math>A\phi</math> – ''auf allen Pfaden folgt <math>\phi</math>'' (englisch: ''All'')
Statt einzelner Zustände kann man nun unendliche Folgen solcher Zustände betrachten und darauf eine [[Semantik]] definieren. Die bisher definierten Formeln werden von einem Pfad erfüllt, wenn der erste Zustand des Pfades sie erfüllt. Diese Formeln werden nun durch die einstelligen Operationen '''X''' für den ''unmittelbar folgenden Zustand'' (englisch: ''neXt state''), '''F''' für einen ''irgendwann folgenden Zustand'' (englisch: ''some Future state''), '''G''' für ''alle folgenden Zustände'' (englisch: ''Globally'') sowie die beiden zweistelligen Operator '''U''' für ''bis zum Erreichen des Zustands'' (englisch: ''Until'') und '''R''' (englisch: ''Release'') erweitert. Selten definiert man zusätzlich noch die Vergangenheitsformen '''P''' für ''vorheriger'', (englisch: ''previous''), '''O''' für ''war einmal'' (englisch: ''once''), '''B''' für ''war immer'' (englisch: ''always been'') und '''S''' für ''seit'' (englisch: ''since'').
** <math>E\phi</math> – ''auf mindestens einem Pfad folgt <math>\phi</math>'' (englisch: ''Exists'')
* Pfad-spezifische Operatoren:
** <math>X\phi</math> – ''unmittelbar folgt <math>\phi</math>'' (englisch: ''neXt state'')
** <math>F\phi</math> – ''irgendwann folgt <math>\phi</math>'' (englisch: ''some Future state'' oder ''Finally'')
** <math>G\phi</math> – ''auf dem folgenden Pfad folgt in jedem Zustand <math>\phi</math>'' (englisch: ''Globally'')
** <math>\phi U \psi</math> ''<math>\phi</math> folgt bis zum Erreichen des Zustands <math>\psi</math>'' (englisch: ''Until'')
** <math>\phi W \psi</math> – ''<math>\phi</math> folgt immer oder bis zum Erreichen des Zustands <math>\psi</math>'' (englisch: ''Weak Until'')


Pfad und pfad-spezifische Operatoren können miteinander kombiniert werden, sodass sich beispielsweise folgende Formeln ergeben:
Pfade erfüllen diese Formeln nun genau dann, wenn (umgangssprachlich)
# ihr nächster Zustand <math>\phi</math> erfüllt ('''X''' <math>\phi</math>),
# irgendein Folgezustand <math>\phi</math> erfüllt ('''F''' <math>\phi</math>),
# alle Zustände <math>\phi</math> erfüllen ('''G''' <math>\phi</math>),
# <math>\phi</math> gilt, bis ein Folgezustand erreicht wird, an dem <math>\psi</math> erfüllt ist (<math>\phi</math> '''U''' <math>\psi</math>),
# <math>\psi</math> gilt bis (einschließlich) zu dem Zustand, an dem <math>\phi</math> erfüllt ist (<math>\phi</math> '''R''' <math>\psi</math>).


* <math>EX\phi</math> – ''in (mind.) einem nächsten Zustand gilt'' <math>\phi</math>
Formal sind die Operatoren wie folgt definiert:
* <math>EF\phi</math> – ''in (mind.) einem der folgenden Zustände gilt'' <math>\phi</math>
* <math>EG\phi</math> – ''es gibt (mind.) einen Pfad, so dass <math>\phi</math> entlang des ganzen Pfades gilt''
* <math>E[\phi U \psi ]</math> – ''es gibt einen Pfad, für den gilt: bis zum ersten Auftreten von <math>\psi</math> gilt'' <math>\phi</math>
* <math>AX \phi</math> ''in jedem nächsten Zustand gilt'' <math>\phi</math>
* <math>AF \phi</math> – ''man erreicht immer einen Zustand, in dem <math>\phi</math> gilt''
* <math>AG \phi</math> – ''auf allen Pfaden gilt in jedem Zustand'' <math>\phi</math>
* <math>A [ \phi U \psi ]</math> – ''es gilt immer <math>\phi</math> bis zum ersten Auftreten von'' <math>\psi</math>


== Semantik ==
# '''X''' <math>\phi</math> : = Der hinter dem Startzustand liegende Zustand (<math>x_1</math>) erfüllt die Formel <math>\phi</math>,
# '''F''' <math>\phi</math> : = Es gibt einen Zustand <math>x_i</math> mit i<math>\geq</math>0, so dass die Formel <math>\phi</math> für den Zustand <math>x_i</math> erfüllt ist,
CTL Formeln werden über [[Transitionssystem]]e definiert. Für eine gegebene Folge von Zuständen des Systems <math>T(s_0) = s_0, s_1, \ldots</math> (beginnend in Zustand <math>s_0</math>) sind die Operatoren formal wie folgt definiert, dabei steht <math>T(s_0) \models \phi</math> für <math>T(s_0)</math> erfüllt <math>\phi</math>:
# '''G''' <math>\phi</math> : = Für alle Zustände <math>x_i</math> mit i<math>\geq</math>0 auf dem Pfad ist die Formel <math>\phi</math> erfüllt,
# <math>\phi</math> '''U''' <math>\psi</math> : = Es gibt einen Zustand <math>x_i</math>, so dass <math>\phi</math> für <math>x_0, x_1, . . . , x_{i-1}</math> erfüllt ist, und <math>\psi</math> in <math>x_i</math> gilt,
# <math>\phi</math> '''R''' <math>\psi</math> : = Es gibt einen Zustand <math>x_i</math>, so dass <math>\psi</math> für <math>x_0, x_1, . . . , x_i</math> erfüllt ist, und <math>\phi</math> in <math>x_i</math> gilt.


* <math>T(s_0) \models \neg \phi \quad \Lrarr \quad T(s_0) \not\models \phi </math>
Für '''F''', '''G''' und '''U''' gilt die Prämisse "Zukunft schließt Gegenwart mit ein", d.h. wird eine Formel in einem der folgenden Zustände erfüllt, so gilt das auch für den Startzustand.
* <math>T(s_0) \models \phi \lor \psi \quad \Lrarr \quad T(s_0) \models \phi \text{ oder } T(s_0) \models \psi </math>
Die bis hier definierten Formeln bilden die sogenannten Pfadformeln und die schon oben erwähnte ''Linear Time Temporal Logic''.
* <math>T(s_0) \models EX\phi \quad \Lrarr \quad T(s_1) \models \phi </math>
* <math>T(s_0) \models EG\phi \quad \Lrarr \quad \forall i: T(s_i) \models \phi </math>
* <math>T(s_0) \models \phi EU \psi \quad \Lrarr \quad \exists k: T(s_k) \models \psi \land \forall i < k: T(s_i) \models \phi</math>


Die oben genannten Umformungen erlauben es, Formeln ineinander umzuwandeln.
=== Pfadquantoren ===
* <math>\neg A\phi \equiv E \neg \phi </math>
Statt Pfaden können auch Bäume von Zuständen betrachtet werden, die in jedem Zweig unendlich tief sind. Zu einer Pfadformel kann man mit den Quantoren ''E'' für ''entlang (mindestens) eines Pfades'' (englisch: ''exists'') und ''A'' für ''entlang aller Pfade'' (englisch: ''always'') Zustandsformeln gewinnen. Ein Baum erfüllt ''E'' <math>\phi</math> genau dann, wenn es in diesem beginnend bei der Wurzel einen Pfad gibt, der <math>\phi</math> erfüllt. Ein Baum erfüllt ''A'' <math>\phi</math> genau dann, wenn jeder bei der Wurzel beginnende Pfad <math>\phi</math> erfüllt.
* <math>\neg AF\phi \equiv EG\neg\phi</math>

* <math>\neg EF\phi \equiv AG\neg\phi</math>
Die so definierte Logik bildet nun '''CTL*'''.
* <math>\neg AX\phi \equiv EX\neg\phi</math>

* <math>AG\phi \equiv \phi \land AX AG \phi</math>
=== Die Teilmenge CTL ===
* <math>EG\phi \equiv \phi \land EX EG \phi</math>
Zu dieser Logik kann man noch eine Teilmenge definieren, die man wie schon oben erwähnt '''CTL''' nennt. Diese entstehen, wenn jeder Temporaloperator durch genau einen Pfadquantor quantifiziert wird. CTL wird also aus den atomaren Zustandsaussagen, den booleschen Operatoren und Paaren von Pfadquantor und Temporaloperator (in dieser Reihenfolge) gebildet. Die Aussagenlogik wird also um die Operatoren erweitert:
* <math>AF\phi \equiv \phi \lor AX AF \phi</math>

* '''EX''' <math>\phi</math> (in (mind.) einem nächsten Zustand gilt <math>\phi</math>),
* <math>EF\phi \equiv \phi \lor EX EF \phi</math>
* '''EF''' <math>\phi</math> (in (mind.) einem der folgenden Zustände gilt <math>\phi</math>),
* <math>A[\phi U \psi] \equiv \psi \lor (\phi \land AX A [\phi U \psi])</math>
* '''EG''' <math>\phi</math> (es gibt (mind.) einen Pfad, so dass <math>\phi</math> entlang des ganzen Pfades gilt),
* <math>E[\phi U \psi] \equiv \psi \lor (\phi \land EX E [\phi U \psi])</math>
* '''E'''[<math>\phi</math> '''U''' <math>\psi</math>] (es gibt einen Pfad für den gilt: bis zum ersten Auftreten von <math>\psi</math> gilt <math>\phi</math>),
* '''AX''' <math>\phi</math> (in jedem nächsten Zustand gilt <math>\phi</math>),
* '''AF''' <math>\phi</math> (man erreicht immer einen Zustand, der <math>\phi</math> erfüllt),
* '''AG''' <math>\phi</math> (auf allen Pfaden gilt in jedem Zustand <math>\phi</math>) und
* '''A'''[<math>\phi</math> '''U''' <math>\psi</math>] (es gilt immer <math>\phi</math> bis zum ersten Auftreten von <math>\psi</math>).

Sollen diese Operatoren als Ausgangspunkt für eine [[Fixpunkt_(Mathematik)|Fixpunktbestimmung]] genutzt werden, so genügt es die Zahl der Operatoren durch Umformungen auf diese drei zu begrenzen:

* '''<math>EX \phi</math>'''
* '''<math>EG \phi</math>'''
* '''<math> E \phi U \psi</math>'''

Dies ist der Fall, weil folgende Äquivalenzen gelten:

* <math> AX \phi \equiv \neg EX (\neg \phi)</math>
* <math> EF \phi \equiv E ((true) U \phi)</math>
* <math> AG \phi \equiv \neg EF \neg \phi</math>
* <math> AF \phi \equiv \neg EG \neg \phi</math>
* <math> A (\phi U \psi) \equiv \neg E (\neg \psi U (\neg \phi \wedge \neg \psi)) \wedge \neg EG \neg \psi</math>
* <math> A (\phi R \psi) \equiv \neg E (\neg \phi U \neg \psi)</math>
* <math> E (\phi R \psi) \equiv \neg A (\neg \phi U \neg \psi)</math>


== Literatur ==
== Literatur ==
* Clarke, Grumberg, Peled: ''Model Checking''. MIT Press, 2000. ISBN 0-262-03270-8
* Clarke, Grumberg, Peled: ''Model Checking''. MIT Press, 2000, ISBN 0-262-03270-8
* Rohit Kapur: ''CTL for Test Information of Digital ICS'', Springer, 2002, ISBN 1-402-07293-7
* Rohit Kapur: ''CTL for Test Information of Digital ICS''. Springer, 2002, ISBN 978-1-4020-7293-2
* B. Berard, Michel Bidoit, Alain Finkel: ''Systems and Software Verification''. Model-Checking Techniques and Tools.: ''Model-checking Techniques and Tools''. Springer, 2001, ISBN 3-540-41523-8
* B. Berard, Michel Bidoit, Alain Finkel: ''Systems and Software Verification. Model-checking Techniques and Tools.'' Springer, 2001, ISBN 3-540-41523-8
* M. Huth and M. Ryan: ''Logic in Computer Science - Modelling and Reasoning about Systems''. Cambridge, 2004, ISBN 0-521-54310-X
* M. Huth and M. Ryan: ''Logic in Computer Science - Modelling and Reasoning about Systems''. Cambridge, 2004, ISBN 0-521-54310-X


[[Kategorie:Mathematische Logik]]
[[Kategorie:Mathematische Logik]]
[[Kategorie:Temporale Logik]]

[[en:Computation tree logic]]
[[ja:計算木論理]]
[[ko:계산 트리 논리]]

Aktuelle Version vom 29. November 2020, 20:27 Uhr

CTL-Formeln visualisiert

Die Computation Tree Logic (kurz CTL) ist eine Temporale Logik, deren Modell der Zeit eine baumartige Struktur hat. Die zeitliche Änderung von Zuständen und deren Eigenschaften wird durch Pfade innerhalb dieser Baumstruktur modelliert. Hierbei hat die Zukunft mehrere Pfade, wobei nicht festgelegt ist, welche letztendlich realisiert werden. Demnach können Aussagen über die mögliche Entwicklungen getroffen werden.

Die CTL wird zur Verifikation von Hard- und Software verwendet, üblicherweise von Model Checkern.

Zu der Familie der temporalen Logiken gehört auch die Linear temporale Logik (LTL), wobei hier nur eine Zukunft möglich ist. Eine Verallgemeinerung der beiden Logiken wird als CTL* bezeichnet.

Minimale Grammatik

[Bearbeiten | Quelltext bearbeiten]

Sei eine Menge von atomaren Aussagen (Behauptungen), dann ist jedes Element eine CTL-Formel. Sind und Formeln, dann auch , , , und . Dies definiert die minimale Grammatik von CTL. In der Regel wird diese allerdings um die gängigen booleschen Operatoren , und , sowie einigen weiteren temporalen Operatoren erweitert.

Temporale Operatoren

[Bearbeiten | Quelltext bearbeiten]

Die Erweiterung der minimalen Grammatik um folgende Operatoren erhöht nicht die Mächtigkeit der Sprache, da alle Operatoren durch Umformungen zurückgeführt werden können.

  • Pfadoperatoren:
    • auf allen Pfaden folgt (englisch: All)
    • auf mindestens einem Pfad folgt (englisch: Exists)
  • Pfad-spezifische Operatoren:
    • unmittelbar folgt (englisch: neXt state)
    • irgendwann folgt (englisch: some Future state oder Finally)
    • auf dem folgenden Pfad folgt in jedem Zustand (englisch: Globally)
    • folgt bis zum Erreichen des Zustands (englisch: Until)
    • folgt immer oder bis zum Erreichen des Zustands (englisch: Weak Until)

Pfad und pfad-spezifische Operatoren können miteinander kombiniert werden, sodass sich beispielsweise folgende Formeln ergeben:

  • in (mind.) einem nächsten Zustand gilt
  • in (mind.) einem der folgenden Zustände gilt
  • es gibt (mind.) einen Pfad, so dass entlang des ganzen Pfades gilt
  • es gibt einen Pfad, für den gilt: bis zum ersten Auftreten von gilt
  • in jedem nächsten Zustand gilt
  • man erreicht immer einen Zustand, in dem gilt
  • auf allen Pfaden gilt in jedem Zustand
  • es gilt immer bis zum ersten Auftreten von

CTL Formeln werden über Transitionssysteme definiert. Für eine gegebene Folge von Zuständen des Systems (beginnend in Zustand ) sind die Operatoren formal wie folgt definiert, dabei steht für erfüllt :

Die oben genannten Umformungen erlauben es, Formeln ineinander umzuwandeln.

  • Clarke, Grumberg, Peled: Model Checking. MIT Press, 2000, ISBN 0-262-03270-8
  • Rohit Kapur: CTL for Test Information of Digital ICS. Springer, 2002, ISBN 978-1-4020-7293-2
  • B. Berard, Michel Bidoit, Alain Finkel: Systems and Software Verification. Model-checking Techniques and Tools. Springer, 2001, ISBN 3-540-41523-8
  • M. Huth and M. Ryan: Logic in Computer Science - Modelling and Reasoning about Systems. Cambridge, 2004, ISBN 0-521-54310-X