Computation tree logic

Syntax of CTL

The language of well formed formulas for CTL is generated by the following grammar:

ϕ ::= ⊥ ∣ ⊤ ∣ p ∣ ( ¬ ϕ ) ∣ ( ϕ ∧ ϕ ) ∣ ( ϕ ∨ ϕ ) ∣ ( ϕ ⇒ ϕ ) ∣ ( ϕ ⇔ ϕ ) ∣ AX  ϕ ∣ EX  ϕ ∣ AF  ϕ ∣ EF  ϕ ∣ AG  ϕ ∣ EG  ϕ ∣ A  [ ϕ  U  ϕ ] ∣ E  [ ϕ  U  ϕ ]

where p ranges over a set of atomic formulas. It is not necessary to use all connectives  – for example, { ¬ , ∧ , AX , AU , EU } comprises a complete set of connectives, and the others can be defined using them.

A means 'along All paths' (Inevitably)

E means 'along at least (there Exists) one path' (possibly)

For example, the following is a well-formed CTL formula:

EF  ( EG  p ⇒ AF  r )

The following is not a well-formed CTL formula:

EF  ( r  U  q )

The problem with this string is that U can occur only when paired with an A or an E . It uses atomic propositions as its building blocks to make statements about the states of a system. CTL then combines these propositions into formulas using logical operators and temporal logics.

Logical operators

The logical operators are the usual ones: ¬ , ∨ , ∧ , ⇒ and ⇔ . Along with these operators CTL formulas can also make use of the boolean constants true and false.

Temporal operators

The temporal operators are the following:

Quantifiers over paths

A ϕ  – All: ϕ has to hold on all paths starting from the current state.

E ϕ  – Exists: there exists at least one path starting from the current state where ϕ holds.

Path-specific quantifiers

X ϕ  – Next: ϕ has to hold at the next state (this operator is sometimes noted N instead of X).

G ϕ  – Globally: ϕ has to hold on the entire subsequent path.

F ϕ  – Finally: ϕ eventually has to hold (somewhere on the subsequent path).

ϕ U ψ  – Until: ϕ has to hold at least until at some position ψ holds. This implies that ψ will be verified in the future.

ϕ W ψ  – Weak until: ϕ has to hold until ψ holds. The difference with U is that there is no guarantee that ψ will ever be verified. The W operator is sometimes called "unless".

In CTL*, the temporal operators can be freely mixed. In CTL, the operator must always be grouped in two: one path operator followed by a state operator. See the examples below. CTL* is strictly more expressive than CTL.

Minimal set of operators

In CTL there is a minimal set of operators. All CTL formulas can be transformed to use only those operators. This is useful in model checking. One minimal set of operators is: {true, ∨ , ¬ , EG, EU, EX}.

Some of the transformation used for temporal operator are:

EF ϕ == E[trueU( ϕ )] ( because F ϕ == [trueU( ϕ )] )

AX ϕ == ¬ EX( ¬ ϕ )

AG ϕ == ¬ EF( ¬ ϕ ) == ¬ E[trueU( ¬ ϕ )]

AF ϕ == A[trueU ϕ ] == ¬ EG( ¬ ϕ )

A[ ϕ U ψ ] == ¬ ( E[( ¬ ψ )U ¬ ( ϕ ∨ ψ )] ∨ EG( ¬ ψ ) )

Definition

CTL formulae are interpreted over Transition Systems. A transition system is a triple M = ( S , → , L ) , where S is a set of states, →⊆ S × S is a transition relation, assumed to be serial, i.e. every state has at least one successor, and L is a labelling function, assigning propositional letters to states. Let M = ( S , → , L ) be such a transition model

with s ∈ S , ϕ ∈ F where F is the set of wffs over the Language of M .

Then the relation of semantic entailment ( M , s ⊨ ϕ ) is defined by structural induction on ϕ :

1. ( ( M , s ) ⊨ ⊤ ) ⇔ ( ( M , s ) ⊭ ⊥ )
2. ( ( M , s ) ⊨ p ) ⇔ ( p ∈ L ( s ) )
3. ( ( M , s ) ⊨ ¬ ϕ ) ⇔ ( ( M , s ) ⊭ ϕ )
4. ( ( M , s ) ⊨ ϕ 1 ∧ ϕ 2 ) ⇔ ( ( ( M , s ) ⊨ ϕ 1 ) ∧ ( ( M , s ) ⊨ ϕ 2 ) )
5. ( ( M , s ) ⊨ ϕ 1 ∨ ϕ 2 ) ⇔ ( ( ( M , s ) ⊨ ϕ 1 ) ∨ ( ( M , s ) ⊨ ϕ 2 ) )
6. ( ( M , s ) ⊨ ϕ 1 ⇒ ϕ 2 ) ⇔ ( ( ( M , s ) ⊭ ϕ 1 ) ∨ ( ( M , s ) ⊨ ϕ 2 ) )
7. ( ( M , s ) ⊨ ϕ 1 ⇔ ϕ 2 ) ⇔ ( ( ( ( M , s ) ⊨ ϕ 1 ) ∧ ( ( M , s ) ⊨ ϕ 2 ) ) ∨ ( ¬ ( ( M , s ) ⊨ ϕ 1 ) ∧ ¬ ( ( M , s ) ⊨ ϕ 2 ) ) )
8. ( ( M , s ) ⊨ A X ϕ ) ⇔ ( ∀ ⟨ s → s 1 ⟩ ( ( M , s 1 ) ⊨ ϕ ) )
9. ( ( M , s ) ⊨ E X ϕ ) ⇔ ( ∃ ⟨ s → s 1 ⟩ ( ( M , s 1 ) ⊨ ϕ ) )
10. ( ( M , s ) ⊨ A G ϕ ) ⇔ ( ∀ ⟨ s 1 → s 2 → … ⟩ ( s = s 1 ) ∀ i ( ( M , s i ) ⊨ ϕ ) )
11. ( ( M , s ) ⊨ E G ϕ ) ⇔ ( ∃ ⟨ s 1 → s 2 → … ⟩ ( s = s 1 ) ∀ i ( ( M , s i ) ⊨ ϕ ) )
12. ( ( M , s ) ⊨ A F ϕ ) ⇔ ( ∀ ⟨ s 1 → s 2 → … ⟩ ( s = s 1 ) ∃ i ( ( M , s i ) ⊨ ϕ ) )
13. ( ( M , s ) ⊨ E F ϕ ) ⇔ ( ∃ ⟨ s 1 → s 2 → … ⟩ ( s = s 1 ) ∃ i ( ( M , s i ) ⊨ ϕ ) )
14. ( ( M , s ) ⊨ A [ ϕ 1 U ϕ 2 ] ) ⇔ ( ∀ ⟨ s 1 → s 2 → … ⟩ ( s = s 1 ) ∃ i ( ( ( M , s i ) ⊨ ϕ 2 ) ∧ ( ∀ ( j < i ) ( M , s j ) ⊨ ϕ 1 ) ) )
15. ( ( M , s ) ⊨ E [ ϕ 1 U ϕ 2 ] ) ⇔ ( ∃ ⟨ s 1 → s 2 → … ⟩ ( s = s 1 ) ∃ i ( ( ( M , s i ) ⊨ ϕ 2 ) ∧ ( ∀ ( j < i ) ( M , s j ) ⊨ ϕ 1 ) ) )

Characterisation of CTL

Rules 10–15 above refer to computation paths in models and are what ultimately characterise the "Computation Tree"; they are assertions about the nature of the infinitely deep computation tree rooted at the given state s .

Semantic equivalences

The formulae ϕ and ψ are said to be semantically equivalent if any state in any model which satisfies one also satisfies the other. This is denoted ϕ ≡ ψ

It can be seen that A and E are duals, being universal and existential computation path quantifiers respectively: ¬ A ϕ ≡ E ¬ ϕ .

Furthermore, so are G and F.

Hence an instance of De Morgan's Laws can be formulated in CTL:

¬ A F ϕ ≡ E G ¬ ϕ ¬ E F ϕ ≡ A G ¬ ϕ ¬ A X ϕ ≡ E X ¬ ϕ

It can be shown using such identities that a subset of the CTL temporal connectives is adequate if it contains E U , at least one of { A X , E X } and at least one of { E G , A F , A U } and the boolean connectives.

The important equivalences below are called the expansion laws; they allow to unfold the verification of a CTL connective towards its successors in time.

A G ϕ ≡ ϕ ∧ A X A G ϕ E G ϕ ≡ ϕ ∧ E X E G ϕ A F ϕ ≡ ϕ ∨ A X A F ϕ E F ϕ ≡ ϕ ∨ E X E F ϕ A [ ϕ U ψ ] ≡ ψ ∨ ( ϕ ∧ A X A [ ϕ U ψ ] ) E [ ϕ U ψ ] ≡ ψ ∨ ( ϕ ∧ E X E [ ϕ U ψ ] )

Examples

Let "P" mean "I like chocolate" and Q mean "It's warm outside."

AG.P

"I will like chocolate from now on, no matter what happens."

EF.P

"It's possible I may like chocolate some day, at least for one day."

AF.EG.P

"It's always possible (AF) that I will suddenly start liking chocolate for the rest of time." (Note: not just the rest of my life, since my life is finite, while G is infinite).

EG.AF.P

"This is a critical time in my life. Depending on what happens next (E), it's possible that for the rest of time (G), there will always be some time in the future (AF) when I will like chocolate. However, if the wrong thing happens next, then all bets are off and there's no guarantee about whether I'll ever like chocolate."

The two following examples show the difference between CTL and CTL*, as they allow for the until operator to not be qualified with any path operator (A or E):

AG(PUQ)

"From now until it's warm outside, I will like chocolate every single day. Once it's warm outside, all bets are off as to whether I'll like chocolate anymore. Oh, and it's guaranteed to be warm outside eventually, even if only for a single day."

EF((EX.P)U(AG.Q))

"It's possible that: there will eventually come a time when it will be warm forever (AG.Q) and that before that time there will always be some way to get me to like chocolate the next day (EX.P)."

Relations with other logics

Computation tree logic (CTL) is a subset of CTL* as well as of the modal µ calculus. CTL is also a fragment of Alur, Henzinger and Kupferman's Alternating-time Temporal Logic (ATL).

Computation tree logic (CTL) and Linear temporal logic (LTL) are both a subset of CTL*. CTL and LTL are not equivalent and they have a common subset, which is a proper subset of both CTL and LTL.

GF.P exists in LTL but not in CTL.

AG(P ⇒ ((EX.Q) ∧ (EX¬Q))) and AG.EF.P exist in CTL but not in LTL.