Alan Bundy. Automated Reasoning LTL Model Checking

Size: px

Start display at page:

Download "Alan Bundy. Automated Reasoning LTL Model Checking"

Hugo Hardy
5 years ago
Views:

1 Automated Reasoning LTL Model Checking Alan Bundy Lecture 9, page 1

2 Introduction So far we have looked at theorem proving Powerful, especially where good sets of rewrite rules or decision procedures have been defined But often requires interactive guidance or specialised domain knowledge to automate Another approach to formal reasoning is model checking Used to decide whether certain properties hold of some formally specified model of a domain Automatic technique which searches through the states of the model for a solution Lecture 9, page 2

3 Motivation Model checking can be applied to verify formally the correctness of systems used in critical situations Successfully used in hardware and protocol verification Now being applied to verify software systems software commonly tested through trial and error at unit level and systems level (simulation) major errors can and do slip through classic testing modes were never meant to be applied to multithreaded systems Lecture 9, page 3

4 Systems Design Finding errors earlier means cost savings later and more reliable product. requirements systems engineering systems design high level architecture detailed design code structure Ideally we should build models to analyse potential violations of a systems requirements and not progress until our models are provably correct. coding testing We should only be testing minor issues here. operation Lecture 9, page 4

5 Formal Verification To ensure correct behaviour of a system, the basic engineering approach could be: requirements logic prototype logic model analysis formal verification Theorem Proving or Model Checking Lecture 9, page 5

6 Model Checking We build a formal model A for a given problem or system (e.g. a bank ATM machine) Let L(A) denote the possible behaviours Let L(P) denote the set of valid or desired behaviours (i.e. those where some property P is satisfied) To show that the model A always satisfies P, it is sufficient to show that: L(A) L(P) Or, equivalently: L(A) L( P) = Model checkers will try to prove this. If the intersection is non-empty, they will find some behaviour which corresponds to a counterexample. Lecture 9, page 6

7 Temporal Model Checking In most systems the truth of certain formulae is dynamic So model checking is based on temporal logic Various temporal logics exist: computation tree logic (CTL): time represented as a tree, rooted at the present moment and branching out into the future linear-time temporal logic (LTL): time is a set of paths, where a path is a sequence of time instances we will be looking at a model checker called Spin which is based on LTL LTL is closely linked with the theory of finite state automata, which we can use to model systems Lecture 9, page 7

8 Finite State Automata A finite state automaton is a tuple (S, s 0, L, T, F) where: S is a finite set of states s 0 is a distinguished initial state, s 0 S L is a finite set of labels (sometimes called the alphabet) T is a set of transitions, T (S x L x S) F is a set of final states, F S In dot notation, given an automaton A A.S is the set of states of A A.s 0 is the initial state of A etc Lecture 9, page 8

9 Example of FSA 4 S 0 0 S 1 S S 5 3 S 2 S 5 A = (S, s 0, L, F, T) A.S = {s 0, s 1, s 2, s 3, s 4, s 5 } A.L = { 0, 1, 2, 3, 4, 5, 6 } A.F = {s 4, s 5 } A.T = {(s 0, 0, s 1 ), (s 1, 1, s 2 ),... } An interpretation of the above automaton could be a simplified example of a bank ATM machine: Welcome Try again card inserted wrong ack Enter PIN correct Amount? cancel - card out problem - card out Thanks, Goodbye sufficient funds - cash and card out Sorry Lecture 9, page 9

10 Determinism A finite state automaton A=(S, s 0, L, F, T) is deterministic iff s, I, s',s''. (s, I, s') A.T (s, I,s'') A.T s' s'' the destination state is uniquely determined by the source state and the transition label an automaton is called non-deterministic if it does not have this property so the bank machine example is deterministic Lecture 9, page 10

11 Automaton Runs A run σ of a finite state automaton (S,s 0,T,L,F) is an ordered set (possibly infinite) of transitions from T starting at s 0 (σ 0 =s 0 ): σ = {(σ 0,l 0,σ 1 ), (σ 1,l 1,σ 2 ), (σ 2,l 2,σ 3 ),...} σ uniquely specifies a sequence of states σ i in S and a sequence of labels l i in L (called words or strings). We will write σ i σ if σ i is contained in any transition in σ (and likewise for l i ). Welcome Try again card inserted wrong ack Enter PIN correct Amount? cancel - card out problem - card out Thanks, Goodbye sufficient funds - cash and card out Sorry (infinite) state sequence from a run: { Welcome, { Enter PIN, Try again }* } corresponding word in L is: { card inserted, { wrong, ack }* } Note: {X}* represents zero or more repetitions of X Lecture 9, page 11

12 Acceptance An accepting run of a finite state automaton A is a finite run σ for which the final transition (σ n-1,i n-1,σ n ) satisfies σ n A.F (i.e. the run ends in a final state) Welcome card inserted Enter PIN cancel - card out Thanks, Goodbye state sequence of an accepting run: wrong ack correct sufficient funds - cash and card out { Welcome, Enter PIN, Amount?, Sorry } Try again Amount? problem - card out Sorry corresponding word in L is: { card inserted, correct, problem-card out } Lecture 9, page 12

13 Accepted Language The language of an automaton A, L(A), is formally defined as the set of words in A.L that correspond to the set of accepting runs of automaton A. Welcome Try again card inserted wrong ack Enter PIN correct Amount? cancel - card out problem - card out Thanks, Goodbye sufficient funds - cash and card out Sorry + represents a choice * represents zero or more repetitions The complete language for this automaton can be characterised as follows: {card inserted, {wrong, ack}*, {cancel... + {correct, {sufficient funds... + problem... }}}} Lecture 9, page 13

14 Infinite Runs Some FSAs permit infinite runs (e.g. bank machine example) This type of FSA is called an ω-automata. We will be considering a special type called Büchi automata, each of whose infinite runs, σ, can be split into two parts: a set σ + of transitions that are taken finitely many times; a set σ of transitions that repeat infinitely many times. σ σ + σ Lecture 9, page 14

15 Büchi Acceptance Final states do not make sense for infinite runs. So how can we define acceptance for an ω-automata A? Let A.F denote a set of accepting states We say an infinite run σ is ω-accepting if it passes through an accepting state infinitely often: i 0. (σ i,l i,σ i+1 ) σ σ i A.F σ i σ ω This is known as Büchi acceptance Lecture 9, page 15

16 Decidability Issues Model checking is most interested in the following two properties of Büchi automata: language emptiness (are there any accepting runs?) language intersection (are there any runs that are accepted by 2 or more automata?) Both properties are formally decidable Spin's model checking is based on these two checks Spin determines if the intersection of the language of a property automaton and a system automaton is empty Properties that can be stated in linear temporal logic (LTL) can be converted into Büchi automata Lecture 9, page 16

17 Linear Temporal Logic We need a clear, concise and unambiguous notation for stating desired properties of systems Propositional linear temporal logic (LTL) gives us this It provides a direct link with the theory of ω-automata Assumes time is discrete LTL is propositional logic + temporal operators We will work with the operators (temporal connectives): Next X Eventually F Always G Strong Until U U Weak Until W W NB: there are two conventions for notation. LTL notation is in blue (used in lecture and Spin). CTL notation is in red (used in Huth & Ryan). Lecture 9, page 17

18 Syntax Well formed formulae (wff) in temporal logic are defined as: true and false are wffs if p is a propositional symbol representing a property which is true or false for any state in our model, then p is a wff if p and q are wff, so are: p, p q, p q, p q, p, p, p, p U q, p W q if p is a wff, then (p) is a wff nothing else is a wff Lecture 9, page 18

19 Precedence The connectives of temporal logic have the following precedences: not next always eventually weak until strong until and or implies W U precedence Brackets can be dropped if there is no ambiguity, e.g. (( ( p)) ( (q s))) becomes p (q s) ((( p) ( q)) (p W r)) becomes p q p W r Lecture 9, page 19

20 Semantics: Notation The symbol is used to mean that a state sequence (or state) satisfies a temporal well-formed formula (or property): σ[i] p property p holds for state sequence {σ i,σ i+1,...}. σ f a temporal wff f holds for state sequence σ where σ[i] denotes the suffix of σ starting after the i th transition, i.e. {(σ i,l i,σ i+1 ), (σ i+1,l i+1,σ i+2 ),...}, with σ[0]=σ (NB: Huth and Ryan use the alternate notation π i for σ[i]) With this notation, we can give formal definitions for the temporal operators just introduced (,,, W, U). Lecture 9, page 20

21 Always, Eventually and Next Always: σ p i 0. (σ[i] p) p captures the notion that the property p remains invariantly true throughout a state sequence. Eventually: σ p i 0. (σ[i] p) p captures the notion that the property p is guaranteed to eventually become true at least once in a run. Next: σ[i] p σ[i+1] p p states that the property p is true in the immediately following state of the run. Lecture 9, page 21

22 Until There are 2 variations of until: Strong until: σ (p U q) i 0. (σ[i] q) ( k. 0 k<i (σ[k] p)) This definition demands that q does hold in some future state. Weak until: σ (p W q) ( i 0. (σ[i] q) ( k. 0 k<i (σ[k] p))) ( j 0. (σ[j] p)) This definition does not require that q ever become true (in which case p must be true forever once we reach state i). Lecture 9, page 22

23 LTL Formulae Some standard LTL formulae are: Formula Pronounced p always p p eventually p p q p implies eventually q p q U r p implies q until r p always eventually p p eventually always p eventually p implies p q eventually q Type/Template invariance guarantee response precedence recurrence (progress) stability (non-progress) correlation Lecture 9, page 23

24 Behaviour Specifications How do we state: It is always the case that eventually we are either always in the state Thanks Goodbye or always in state Sorry? ( ( ( Thanks Goodbye ) ( Sorry) ) ) Welcome card inserted Enter PIN cancel - card out Thanks, Goodbye Is this true? wrong ack correct sufficient funds - cash and card out Try again Amount? problem - card out Sorry Lecture 9, page 24

25 Behaviour Specifications (II) The previous expression is not true! It is possible that Enter Pin and Try Again loop forever. The following expression is true: It is always the case that if we are eventually always not in Try Again then eventually we are either always in the state Thanks Goodbye or always in the state Sorry. ( ( Try Again ) ( ( Thanks Goodbye Sorry ) ) ) Welcome Try again card inserted wrong ack Enter PIN correct Amount? cancel - card out problem - card out Thanks, Goodbye sufficient funds - cash and card out Sorry Lecture 9, page 25

26 Summary Introduction to model checking Model systems using FSAs Model system behaviour using LTL temporal operators,,, U, W Next time: model checking using Spin Lecture 9, page 26

Logic Model Checking

Logic Model Checking Lecture Notes 10:18 Caltech 101b.2 January-March 2004 Course Text: The Spin Model Checker: Primer and Reference Manual Addison-Wesley 2003, ISBN 0-321-22862-6, 608 pgs. the assignment