# logic language, static/dynamic models SAT solvers Verified Software Systems 1 How can we model check of a program or system?

Save this PDF as:

Size: px
Start display at page:

Download "logic language, static/dynamic models SAT solvers Verified Software Systems 1 How can we model check of a program or system?"

## Transcription

1 5. LTL, CTL Last part: Alloy logic language, static/dynamic models SAT solvers Today: Temporal Logic (LTL, CTL) Verified Software Systems 1 Overview How can we model check of a program or system? Modeling Build a model of the program, system??? Specification Describe requirement properties using a form of Temporal Logic Verification Automatically (semi-automatic) Verified Software Systems 2 1

2 Model checking: definition Given a model M and a formula φ, model checking is the problem of verifying whether or not φ is true in M (written M = φ ). Verified Software Systems 3 Objectives Understand why temporal logic can be a useful formalism for specifying properties of concurrent/reactive systems. Understand the intuition behind Computation Tree Logic (CTL) the specification logic used e.g., in the well-known (Nu)SMV model-checker. Be able to confidently apply Linear Temporal Logic (LTL) the specification logic used in e.g., TLA+ and SPIN to specify properties of systems. Understand the formal semantics of LTL. Verified Software Systems 4 2

3 Reasoning about Executions We ve seen specifications that are about individual program states e.g., assertions, invariants, scoped traces Sometimes we want to reason about the relationship between multiple states Must one state always precede another? Does seeing one state preclude the possibility of subsequently seeing another? We need to shift our thinking from states to paths in the state space Verified Software Systems 5 Examples A use of a variable must be preceded by a definition When a file is opened it must subsequently be closed You cannot shift from drive to reverse without passing through neutral The program will eventually terminate Two concurrent processes will each be able to enter its critical sections Will a print request be served in the future by a Printer Manager Verified Software Systems 6 3

4 Why Use Temporal Logic? Requirements of concurrent, distributed, and reactive systems are often phrased as constraints on sequences of events or states or constraints on execution paths. Temporal logic provides a formal, expressive, and compact notation for realizing/modeling such requirements. The temporal logics we consider are also strongly tied to various computational frameworks (e.g., automata theory) which provides a foundation for building verification tools. Verified Software Systems 7 Linear Time Logic we want to understand Restrict path quantification to ALL (no EXISTS ) Reason in terms of branching traces instead of branching trees Verified Software Systems 8 4

5 Overview Temporal Property: A property with time-related operators such as invariant or eventually Invariant(p): is true in a state if property p is true in every state on all execution paths starting at that state The Invariant operator has different names in different temporal logics: G, AG, ( goal or box or forall ) Eventually(p): is true in a state if property p is true at some state on every execution path starting from that state F, AF, ( diamond or future or exists ) Verified Software Systems 9 An example concurrent program A simple concurrent mutual exclusion program Two processes execute asynchronously There is a shared variable turn Two processes use the shared variable to ensure that they are not in the critical section at the same time Can be viewed as a fundamental program: any bigger concurrent one would include this one 10: while True do 11: wait(turn = 0); // critical section 12: turn := 1; 13: end while; // concurrently with 20: while True do 21: wait(turn = 1); // critical section 22: turn := 0; 23: end while Verified Software Systems 10 5

6 Reachable states of the program 10: while True do 11: wait(turn = 0); // critical section 12: turn := 1; 13: end while; // concurrently with 20: while True do 21: wait(turn = 1); // critical section 22: turn := 0; 23: end while Verified Software Systems 11 Properties of the program Example: In all the reachable states (configurations) of the system, the two processes are never in the critical section at the same time Equivalently, we can say that Invariant( (pc1=12 pc2=22)) Also: Eventually the first process enters the critical section Eventually(pc1=12) pc1=12, pc2=22 are atomic properties Verified Software Systems 12 6

7 Transition Systems In model checking the system being analyzed is represented as a labeled transition system T = (S, I, R, L) Also called a Kripke Structure S = Set of states // standard FSM I S = Set of initial states // standard FSM R S S = Transition relation // standard FSM L: S P(AP) = Labeling function // this is new! AP: Set of atomic propositions (e.g., x=5 ) Atomic propositions capture basic properties For software, atomic props depend on variable values The labeling function labels each state with the set of propositions true in that state Verified Software Systems 13 LTL In LTL time is implicit, discrete, has an initial moment with no predecessors, and infinite in the future The model of LTL formula is infinite sequence of states π: s 0, s 1, s 2, Verified Software Systems 14 7

8 LTL (cont d) Elements: Atomic propositions AP Boolean operators Syntax: Temporal operators G F X U R Φ ::= P Φ ϕ ψ ϕ ψ Φ Φ G Φ F Φ X Φ ϕ U ψ ϕ R ψ Verified Software Systems 15 Semantic Intuition G f - always f f f f f f f F f eventually f f f X f next state Xf f f U r until f f f f r f R r releases r r r r,f Verified Software Systems 16 8

9 Semantic Semantic is given with respect to path π = s 0 s 1 s 2 Suffix of trace starting at s i π i = s i s i+1 s i+2 A system satisfies an LTL formula f if each possible path through the system satisfy f. Verified Software Systems 17 Semantic (cont d) π = a iff a s 0 [a L(s 0 )] π = ϕ iff π = ϕ π = ϕ ψ iff π = ϕ and π = ψ π = ϕ ψ iff π = ϕ or π = ψ π = X ϕ iff π 1 = ϕ π = F ϕ iff exists i 0 π i = ϕ π = G ϕ iff for all i 0 π i = ϕ π = ϕ U ψ iff exists i 0 π i = ψ and for all 0 j < n. π j = ϕ π = ϕ R ψ iff for all j 0, if for every i < j not π i = ϕ then π j = ψ Verified Software Systems 18 9

10 LTL Identities G ϕ = F ϕ F ϕ = (true U ϕ) ϕ R ψ = ( ϕ U ψ) Every LTL formula f can be rewritten using only operators X U This is important for implementing tools for verification. Verified Software Systems 19 LTL Satisfiability Examples Verified Software Systems 20 10

11 Practical patterns of specifications It is impossible to get to a state where started holds, but ready does not hold G (started ready) For any state, if a request (of some resource) occurs, then it will eventually be acknowledged G(requested F acknowledged). A certain process is enabled infinitely often on every computation path GF enabled Verified Software Systems 21 Practical patterns of... Whatever happens, a certain process will eventually be permanently deadlocked FG deadlock If the process is enabled infinitely often, then it runs infinitely often GF enabled GF running. An upwards travelling lift at the second floor does not change its direction when it has passengers wishing to go to the fifth floor G(floor2 directionup ButtonPressed5 (directionup U floor5)) Verified Software Systems 22 11

12 Practical patterns of... From any state it is possible to get to a restart state (i.e., there is a path from all states to a state satisfying restart). Not expressible! Why?? Verified Software Systems 23 LTL Verification Verified Software Systems 24 12

13 State Sequences as Words Let AP be the finite set of atomic propositions of the formula f. Let Σ = 2 AP be the alphabet over AP. Every sequence of states is an ω word in Σ ω α = P 0, P 1, P 2, where P i = L(s i ). A word a is a model of formula f iff α = f Example: for f = p ( q U q) {p},{},{q},{p,q} ω Let Mod(f) denote the set of models of f. Automata theory: automata are computational devices to determine whether a word belongs to language. Verified Software Systems 25 Automata Theory Automaton A = (Q,Σ,δ,I,F) Q set of states Σ finite alphabet δ transition relation I set of initial states F set of acceptance states A runρof A on ω word α ρ = q 0,q 1,q 2,, s.t. q 0 I and (q i,α i,q i+1 ) δ The runρis accepting if Inf(ρ) I F a a q 1 q 2 b b Verified Software Systems 26 13

14 An Example An automaton for a Modula 3 counter with operations inc, dec? inc 0 1 dec inc dec inc dec 2 Verified Software Systems 27 Observation We can use automata to model services like Counter, Printer Manager, When we deal with real-life systems, these are often broken up into components. We first model the components. Then, the global automaton is obtained from the component automata by having them to cooperate. Verified Software Systems 28 14

15 An Example without synchronisation A system composed of a modulo 2, modulo 3 and modulo 4 counter. Means composing the three automata Possible states are: Verified Software Systems 29 A few transition of the product Verified Software Systems 30 15

16 An example with synchronization We forbid them to evolve independently. Sync={(inc,inc,inc), (dec,dec,dec)} and we can build the reachability automaton. Verified Software Systems 31 Coming back to LTL verification LTL are path formulas. The viewpoint adopted will be language theory. Consider the formula p: GFP An execution q0, q1, satisfying p must contain infinitely many positions qx at which p holds. The execution is of the form (( P) *.P) ω An execution not satisfying p must, from a certain point on, only contain states satisfying P. ( P + P) *.( P) ω Verified Software Systems 32 16

17 Basic Strategy Checking relies on the possibility to associate with each LTL formula p an ω-regular expression describing the form imposed on an execution by its satisfaction of p. The does A = p? question then reduces to a are all the executions of A of the form described by the regular expression. Build B p. Strongly synchronize A and B p. Build the product automaton A B p. does A = p? reduces to is the language of A B p empty? Verified Software Systems 33 Example Create an automata for B Φ where Φ is G(P XFQ). The negation of Φ means that there exists an occurrence of P after which we will never encounter Q. Verified Software Systems 34 17

18 The Automata A The model to be checked Verified Software Systems 35 The product automaton Model Property Observations: t u1 if t leaves a state sat. P t u2 if t leaves a state sat. Q We can observe behaviors of A that are in A B p. If the language is not empty the property is not satisfied. Product Automaton Verified Software Systems 36 18

19 Automata for LTL Formula and GBA Generalized Büchi Automaton (GBA) A is A = (Q,Σ,δ,I,FT), where FT is FT = < F 1, F 2,, F k > A run ρ is accepting if Inf(ρ) for every 1 i k F i A set of models Mod(f) of formula f is ω-regular and we can construct a GBA A for the formula s.t. Mod(f) = L(A(f)), where L(A(f)) is a language accepted by Automata A I Verified Software Systems 37 Process of Model Checking LTL Target Program Requirement Properties (Φ Ω) Model Checker Verified Software Systems 38 19

20 CTL Computational Tree Logic Verified Software Systems 39 Basic Concepts CTL Verified Software Systems 40 20

21 CTL Syntax Verified Software Systems 41 CTL Syntax Verified Software Systems 42 21

22 CTL Parse trees Verified Software Systems 43 Exercise Verified Software Systems 44 22

23 Answer Verified Software Systems 45 CTL Semantics Verified Software Systems 46 23

24 CTL Semantics Verified Software Systems 47 CTL Semantics: transition system Verified Software Systems 48 24

25 CTL semantics from transition systems to computation paths Verified Software Systems 49 CTL Examples Verified Software Systems 50 25

26 Short Summary Verified Software Systems 51 CTL semantics Verified Software Systems 52 26

27 CTL Semantics (temporal operators) Verified Software Systems 53 CTL Semantics (temporal operators) φ φ Verified Software Systems 54 27

28 Exercise Verified Software Systems 55 Equivalences between CTL formulas Verified Software Systems 56 28

29 Specification patterns Verified Software Systems 57 Practical Patterns of Specifications A certain process is enabled infinitely often on every path AG(AF enabled) An upward traveling lift at the second floor does not change its direction if it has passengers that want to go to the fifth floor. AG(floor2 directionup Button5 -> A[directionup U floor5]) It is possible to get to a state where started holds, but ready does not EF(started ready) Verified Software Systems 58 29

30 Model Checking CTL Verified Software Systems 59 The Labeling algorithm Verified Software Systems 60 30

31 Labeling Informally Verified Software Systems 61 Labeling for EG Verified Software Systems 62 31

32 LTL vs CTL Verified Software Systems 63 CTL vs. LTL If a process is enabled infinitely often, then it runs infinitely often. CTL: - (AGAF enabled -> AGAF running)? From any state it is possible to get to a restart state CTL: AG(EF restart) LTL: - LTL: GF enabled -> GF running The lift can remain idle on the third floor with its doors closed CTL: AG(floor3 idle doorclosed -> EG(floor3 idle doorclosed)) LTL: - Verified Software Systems 64 32

33 Comparison Different views of time branching with linear Incomparable expressive power: FGp is not expressible in CTL AGEFp is not expressible in LTL Performance: CTL run in time O( P x f ) LTL run in time O( P x2 O( f ) ) and space O(( f +log( P )) 2 ) Verified Software Systems 65 Disadvantages of CTL CTL is unintuitive and difficult to use In most important cases complexity is comparable to LTL or even worse (reactive systems, hierarchical systems) Hardly applicable for compositional verification and semiformal verification On formulas which expressible both in LTL and CTL performance is equal or may be made equal Verified Software Systems 66 33

34 Advantages of LTL LTL is more natural for verification Suits well for compositional and semi-formal verification Allow application of different techniques for state-space reduction Uniform approach for model treatment (language containment and automata theory) Bounded model checking Verified Software Systems 67 Disadvantages of LTL For compositional reasoning specification language should be as expressive as modeling language BUT! LTL cannot express finite-state systems Corollary: LTL is too weak We need more expressive temporal specification language Verified Software Systems 68 34

35 Solutions ETL [VW94] extension with temporal connectives representing ω-automata Linear µ-calculus [BB87] extended LTL with fixpoint operators QPTL [SVW87] extension of LTL with quantification over propositional variables FTL by Intel [Armoni02] Verified Software Systems 69 Conclusions LTL suits better for verification of concurrent reactive systems CTL can be used as back-end for linear-time model checkers The linear-time model checking technology is still an open issue Verified Software Systems 70 35

### Model Checking: An Introduction

Announcements Model Checking: An Introduction Meeting 2 Office hours M 1:30pm-2:30pm W 5:30pm-6:30pm (after class) and by appointment ECOT 621 Moodle problems? Fundamentals of Programming Languages CSCI

### Model Checking II Temporal Logic Model Checking

1/32 Model Checking II Temporal Logic Model Checking Edmund M Clarke, Jr School of Computer Science Carnegie Mellon University Pittsburgh, PA 15213 2/32 Temporal Logic Model Checking Specification Language:

### Introduction to Software Verification

Introduction to Software Verification Orna Grumberg Lectures Material winter 2013-14 Lecture 4 5.11.13 Model Checking Automated formal verification: A different approach to formal verification Model Checking

### Algorithmic Software Verification

Algorithmic Software Verification (LTL Model Checking) Azadeh Farzan What is Verification Anyway? Proving (in a formal way) that program satisfies a specification written in a logical language. Formal

### Temporal Logics. Computation Tree Logic

Temporal Logics CTL: definition, relationship between operators, adequate sets, specifying properties, safety/liveness/fairness Modeling: sequential, concurrent systems; maximum parallelism/interleaving

### Software Model Checking: Theory and Practice

Software Model Checking: Theory and Practice Lecture: Secification Checking - Temoral Logic Coyright 2004, Matt Dwyer, John Hatcliff, and Robby. The syllabus and all lectures for this course are coyrighted

### Formal Verification and Linear-time Model Checking

Formal Verification and Linear-time Model Checking Paul Jackson University of Edinburgh Automated Reasoning 21st and 24th October 2013 Why Automated Reasoning? Intellectually stimulating and challenging

### Today s Agenda. Automata and Logic. Quiz 4 Temporal Logic. Introduction Buchi Automata Linear Time Logic Summary

Today s Agenda Quiz 4 Temporal Logic Formal Methods in Software Engineering 1 Automata and Logic Introduction Buchi Automata Linear Time Logic Summary Formal Methods in Software Engineering 2 1 Buchi Automata

### Software Modeling and Verification

Software Modeling and Verification Alessandro Aldini DiSBeF - Sezione STI University of Urbino Carlo Bo Italy 3-4 February 2015 Algorithmic verification Correctness problem Is the software/hardware system

### T-79.186 Reactive Systems: Introduction and Finite State Automata

T-79.186 Reactive Systems: Introduction and Finite State Automata Timo Latvala 14.1.2004 Reactive Systems: Introduction and Finite State Automata 1-1 Reactive Systems Reactive systems are a class of software

### The Model Checker SPIN

The Model Checker SPIN Author: Gerard J. Holzmann Presented By: Maulik Patel Outline Introduction Structure Foundation Algorithms Memory management Example/Demo SPIN-Introduction Introduction SPIN (Simple(

### Testing LTL Formula Translation into Büchi Automata

Testing LTL Formula Translation into Büchi Automata Heikki Tauriainen and Keijo Heljanko Helsinki University of Technology, Laboratory for Theoretical Computer Science, P. O. Box 5400, FIN-02015 HUT, Finland

### On the Modeling and Verification of Security-Aware and Process-Aware Information Systems

On the Modeling and Verification of Security-Aware and Process-Aware Information Systems 29 August 2011 What are workflows to us? Plans or schedules that map users or resources to tasks Such mappings may

### Software Engineering using Formal Methods

Software Engineering using Formal Methods Model Checking with Temporal Logic Wolfgang Ahrendt 24th September 2013 SEFM: Model Checking with Temporal Logic /GU 130924 1 / 33 Model Checking with Spin model

### Formal Verification of Software

Formal Verification of Software Sabine Broda Department of Computer Science/FCUP 12 de Novembro de 2014 Sabine Broda (DCC-FCUP) Formal Verification of Software 12 de Novembro de 2014 1 / 26 Formal Verification

### A Logic Approach for LTL System Modification

A Logic Approach for LTL System Modification Yulin Ding and Yan Zhang School of Computing & Information Technology University of Western Sydney Kingswood, N.S.W. 1797, Australia email: {yding,yan}@cit.uws.edu.au

### Fundamentals of Software Engineering

Fundamentals of Software Engineering Model Checking with Temporal Logic Ina Schaefer Institute for Software Systems Engineering TU Braunschweig, Germany Slides by Wolfgang Ahrendt, Richard Bubel, Reiner

### CISC422/853: Formal Methods

Outline CISC422/853: Formal Methods in Software Engineering: Computer-Aided Verification Topic 7: Specifying, or How to Describe How the System Should (or Should Not) Behave Juergen Dingel Feb, 2009 Readings:

### Formal Verification by Model Checking

Formal Verification by Model Checking Natasha Sharygina Carnegie Mellon University Guest Lectures at the Analysis of Software Artifacts Class, Spring 2005 1 Outline Lecture 1: Overview of Model Checking

### Development of dynamically evolving and self-adaptive software. 1. Background

Development of dynamically evolving and self-adaptive software 1. Background LASER 2013 Isola d Elba, September 2013 Carlo Ghezzi Politecnico di Milano Deep-SE Group @ DEIB 1 Requirements Functional requirements

### http://aejm.ca Journal of Mathematics http://rema.ca Volume 1, Number 1, Summer 2006 pp. 69 86

Atlantic Electronic http://aejm.ca Journal of Mathematics http://rema.ca Volume 1, Number 1, Summer 2006 pp. 69 86 AUTOMATED RECOGNITION OF STUTTER INVARIANCE OF LTL FORMULAS Jeffrey Dallien 1 and Wendy

### tutorial: hardware and software model checking

tutorial: hardware and software model checking gerard holzmann and anuj puri { gerard anuj } @research.bell-labs.com Bell Labs, USA outline introduction (15 mins) theory and algorithms system modeling

### Model checking test models. Author: Kevin de Berk Supervisors: Prof. dr. Wan Fokkink, dr. ir. Machiel van der Bijl

Model checking test models Author: Kevin de Berk Supervisors: Prof. dr. Wan Fokkink, dr. ir. Machiel van der Bijl February 14, 2014 Abstract This thesis is about model checking testing models. These testing

### Validated Templates for Specification of Complex LTL Formulas

Validated Templates for Specification of Complex LTL Formulas Salamah Salamah Department of Electrical, computer, Software, and Systems Engineering Embry Riddle Aeronautical University 600 S. Clyde Morris

### Model Checking LTL Properties over C Programs with Bounded Traces

Noname manuscript No. (will be inserted by the editor) Model Checking LTL Properties over C Programs with Bounded Traces Jeremy Morse 1, Lucas Cordeiro 2, Denis Nicole 1, Bernd Fischer 1,3 1 Electronics

### Software Verification and Testing. Lecture Notes: Temporal Logics

Software Verification and Testing Lecture Notes: Temporal Logics Motivation traditional programs (whether terminating or non-terminating) can be modelled as relations are analysed wrt their input/output

### Model Checking of Software

Model Checking of Software Patrice Godefroid Bell Laboratories, Lucent Technologies SpecNCheck Page 1 August 2001 A Brief History of Model Checking Prehistory: transformational programs and theorem proving

### Formal verification of contracts for synchronous software components using NuSMV

Formal verification of contracts for synchronous software components using NuSMV Tobias Polzer Lehrstuhl für Informatik 8 Bachelorarbeit 13.05.2014 1 / 19 Problem description and goals Problem description

### Using Patterns and Composite Propositions to Automate the Generation of Complex LTL

University of Texas at El Paso DigitalCommons@UTEP Departmental Technical Reports (CS) Department of Computer Science 8-1-2007 Using Patterns and Composite Propositions to Automate the Generation of Complex

### LTL Model Checking with Logic Based Petri Nets

LTL Model Checking with Logic Based Petri Nets Tristan M. Behrens and Jürgen Dix IfI Technical Report Series IfI-07-04 Impressum Publisher: Institut für Informatik, Technische Universität Clausthal Julius-Albert

### Automata-based Verification - I

CS3172: Advanced Algorithms Automata-based Verification - I Howard Barringer Room KB2.20: email: howard.barringer@manchester.ac.uk March 2006 Supporting and Background Material Copies of key slides (already

### Feature Specification and Automated Conflict Detection

Feature Specification and Automated Conflict Detection AMY P. FELTY University of Ottawa and KEDAR S. NAMJOSHI Bell Laboratories Large software systems, especially in the telecommunications field, are

### Software Model Checking: Theory and Practice

Software Model Checking: Theory and Practice Lecture: Specification Checking - LTL Model Checking Copyright 2004, Matt Dwyer, John Hatcliff, and Robby. The syllabus and all lectures for this course are

### A Classification of Model Checking-based Verification Approaches for Software Models

A Classification of Model Checking-based Verification Approaches for Software Models Petra Brosch, Sebastian Gabmeyer, Martina Seidl Sebastian Gabmeyer Business Informatics Group Institute of Software

### Formal Specification and Verification

Formal Specification and Verification Stefan Ratschan Katedra číslicového návrhu Fakulta informačních technologíı České vysoké učení technické v Praze 2. 5. 2011 Stefan Ratschan (FIT ČVUT) PI-PSC 4 2.

### Context-Bounded Model Checking of LTL Properties for ANSI-C Software. Jeremy Morse, Lucas Cordeiro, Bernd Fischer, Denis Nicole

Context-Bounded Model Checking of LTL Properties for ANSI-C Software Jeremy Morse, Lucas Cordeiro, Bernd Fischer, Denis Nicole Model Checking C Model checking: normally applied to formal state transition

### Development of global specification for dynamically adaptive software

Development of global specification for dynamically adaptive software Yongwang Zhao School of Computer Science & Engineering Beihang University zhaoyw@act.buaa.edu.cn 22/02/2013 1 2 About me Assistant

### Static Program Transformations for Efficient Software Model Checking

Static Program Transformations for Efficient Software Model Checking Shobha Vasudevan Jacob Abraham The University of Texas at Austin Dependable Systems Large and complex systems Software faults are major

### Business Process Verification: The Application of Model Checking and Timed Automata

Business Process Verification: The Application of Model Checking and Timed Automata Luis E. Mendoza Morales Processes and Systems Department, Simón Bolívar University, P.O. box 89000, Baruta, Venezuela,

### Automata-Based Verification of Temporal Properties on Running Programs Dimitra Giannakopoulou Klaus Havelund

Automata-Based Verification of Temporal Properties on Running Programs Dimitra Giannakopoulou Klaus Havelund RIACS Technical Report 01.21 August 2001 Presented at the 16 th IEEE International Conference

### Fixed-Point Logics and Computation

1 Fixed-Point Logics and Computation Symposium on the Unusual Effectiveness of Logic in Computer Science University of Cambridge 2 Mathematical Logic Mathematical logic seeks to formalise the process of

### Program Synthesis is a Game

Program Synthesis is a Game Barbara Jobstmann CNRS/Verimag, Grenoble, France Outline Synthesis using automata- based game theory. MoBvaBon, comparison with MC and LTL. Basics Terminology Reachability/Safety

### Path Querying on Graph Databases

Path Querying on Graph Databases Jelle Hellings Hasselt University and transnational University of Limburg 1/38 Overview Graph Databases Motivation Walk Logic Relations with FO and MSO Relations with CTL

### Introduction to SPIN. Acknowledgments. Parts of the slides are based on an earlier lecture by Radu Iosif, Verimag. Ralf Huuck. Features PROMELA/SPIN

Acknowledgments Introduction to SPIN Parts of the slides are based on an earlier lecture by Radu Iosif, Verimag. Ralf Huuck Ralf Huuck COMP 4152 1 Ralf Huuck COMP 4152 2 PROMELA/SPIN PROMELA (PROcess MEta

### Model Checking based Software Verification

Model Checking based Software Verification 18.5-2006 Keijo Heljanko Keijo.Heljanko@tkk.fi Department of Computer Science and Engineering Helsinki University of Technology http://www.tcs.tkk.fi/~kepa/ 1/24

### Modular Verification of Dynamically Adaptive Systems

Modular Verification of Dynamically Adaptive Systems Ji Zhang, Heather J. Goldsby, and Betty H.C. Cheng Department of Computer Science and Engineering, Michigan State University East Lansing, Michigan,

### Software Reliability: Runtime Verification

Software Reliability: Runtime Verification Martin Leucker and the whole ISP team Institute for Software Engineering Universität zu Lübeck Riga, 21.07. 04.08.14 Martin Leucker Basoti, 2014 1/117 Runtime

### Runtime Verification - Monitor-oriented Programming - Monitor-based Runtime Reflection

Runtime Verification - Monitor-oriented Programming - Monitor-based Runtime Reflection Martin Leucker Technische Universität München (joint work with Andreas Bauer, Christian Schallhart et. al) FLACOS

### MODEL CHECKING CONCURRENT AND REAL-TIME SYSTEMS: THE PAT APPROACH. LIU YANG (B.Sc. (Hons.), NUS)

MODEL CHECKING CONCURRENT AND REAL-TIME SYSTEMS: THE PAT APPROACH LIU YANG (B.Sc. (Hons.), NUS) A THESIS SUBMITTED FOR THE DEGREE OF DOCTOR OF PHILOSOPHY DEPARTMENT OF COMPUTER SCIENCE NATIONAL UNIVERSITY

### Formal Verification of Computer Systems - (INFO-F-412)

Formal Verification of Computer Systems - (INFO-F-412) Thierry Massart Université Libre de Bruxelles Département d Informatique February 2013 Acknowledgment I want to thank Edmund Clarke, Keijo Heljanko,

### 2 Temporal Logic Model Checking

Bounded Model Checking Using Satisfiability Solving Edmund Clarke 1, Armin Biere 2, Richard Raimi 3, and Yunshan Zhu 4 1 Computer Science Department, CMU, 5000 Forbes Avenue Pittsburgh, PA 15213, USA,

### Informatique Fondamentale IMA S8

Informatique Fondamentale IMA S8 Cours 1 - Intro + schedule + finite state machines Laure Gonnord http://laure.gonnord.org/pro/teaching/ Laure.Gonnord@polytech-lille.fr Université Lille 1 - Polytech Lille

### Formal Verification Coverage: Computing the Coverage Gap between Temporal Specifications

Formal Verification Coverage: Computing the Coverage Gap between Temporal Specifications Sayantan Das Prasenjit Basu Ansuman Banerjee Pallab Dasgupta P.P. Chakrabarti Department of Computer Science & Engineering

### Access Control Based on Dynamic Monitoring for Detecting Software Malicious Behaviours

Access Control Based on Dynamic Monitoring for Detecting Software Malicious Behaviours K. Adi, L. Sullivan & A. El Kabbal Computer Security Research Laboratory http://w3.uqo.ca/lrsi NCAC'05 1 Motivation

### An Automata-Theoretic Approach to Linear Temporal Logic

An Automata-Theoretic Approach to Linear Temporal Logic Moshe Y. Vardi? Rice University Department of Computer Science P.O. Box 1892 Houston, TX 77251-1892, U.S.A. Email: vardi@cs.rice.edu URL: http://www.cs.rice.edu/

### The Course. http://www.cse.unsw.edu.au/~cs3153/

The Course http://www.cse.unsw.edu.au/~cs3153/ Lecturers Dr Peter Höfner NICTA L5 building Prof Rob van Glabbeek NICTA L5 building Dr Ralf Huuck NICTA ATP building 2 Plan/Schedule (1) Where and When Tuesday,

### An Approach for Generating Concrete Test Cases Utilizing Formal Specifications of Web Applications

An Approach for Generating Concrete Test Cases Utilizing Formal Specifications of Web Applications Khusbu Bubna RC Junit concrete test cases suitable for execution on the implementation. The remainder

### Monitoring Metric First-order Temporal Properties

Monitoring Metric First-order Temporal Properties DAVID BASIN, FELIX KLAEDTKE, SAMUEL MÜLLER, and EUGEN ZĂLINESCU, ETH Zurich Runtime monitoring is a general approach to verifying system properties at

### VeriTech - A Framework for Translating among Model Description Notations

Software Tools for Technology Transfer manuscript No. (will be inserted by the editor) VeriTech - A Framework for Translating among Model Description Notations Orna Grumberg and Shmuel Katz Computer Science

### Automata-Based Verification of Temporal Properties on Running Programs

Automata-Based Verification of Temporal Properties on Running Programs Dimitra Giannakopoulou (RIACS) and Klaus Havelund (Kestrel Technologies) Automated Software Engineering Group NASA Ames Research Center,

### HECTOR a software model checker with cooperating analysis plugins. Nathaniel Charlton and Michael Huth Imperial College London

HECTOR a software model checker with cooperating analysis plugins Nathaniel Charlton and Michael Huth Imperial College London Introduction HECTOR targets imperative heap-manipulating programs uses abstraction

### introduction to program monitoring

introduction to program monitoring CS 119 part II beyond assert and print course website http://www.runtime-verification.org/course09 action standing order: sell when price drops more than 2% within 1

### Fabio Patrizi DIS Sapienza - University of Rome

Fabio Patrizi DIS Sapienza - University of Rome Overview Introduction to Services The Composition Problem Two frameworks for composition: Non data-aware services Data-aware services Conclusion & Research

### Quick Start Guide. June 3, 2012

The ERIGONE Model Checker Quick Start Guide Mordechai (Moti) Ben-Ari Department of Science Teaching Weizmann Institute of Science Rehovot 76100 Israel http://stwww.weizmann.ac.il/g-cs/benari/ June 3, 2012

### System modeling. Budapest University of Technology and Economics Department of Measurement and Information Systems

System modeling Business process modeling how to do it right Partially based on Process Anti-Patterns: How to Avoid the Common Traps of Business Process Modeling, J Koehler, J Vanhatalo, IBM Zürich, 2007.

### MetaGame: An Animation Tool for Model-Checking Games

MetaGame: An Animation Tool for Model-Checking Games Markus Müller-Olm 1 and Haiseung Yoo 2 1 FernUniversität in Hagen, Fachbereich Informatik, LG PI 5 Universitätsstr. 1, 58097 Hagen, Germany mmo@ls5.informatik.uni-dortmund.de

### A CTL-Based Logic for Program Abstractions

A CTL-Based Logic for Program Abstractions Martin Lange 1 and Markus Latte 2 1 Dept. of Computer Science, University of Kassel, Germany 2 Dept. of Computer Science, Ludwig-Maximilians-University Munich,

### Bounded LTL Model Checking with Stable Models

Under consideration for publication in Theory and Practice of Logic Programming 1 Bounded LTL Model Checking with Stable Models KEIJO HELJANKO and ILKKA NIEMELÄ Helsinki University of Technology Department

### Verifying Real-Time Embedded Software by Means of Automated State-based Online Testing and the SPIN Model Checker Application to RTEdge Models

Verifying Real-Time Embedded Software by Means of Automated State-based Online Testing and the SPIN Model Checker Application to RTEdge Models A thesis submitted to the Faculty of Graduate and Postdoctoral

### Institut für Parallele und Verteilte Systeme. Abteilung Anwendersoftware. Universität Stuttgart Universitätsstraße 38 D-70569 Stuttgart

Institut für Parallele und Verteilte Systeme Abteilung Anwendersoftware Universität Stuttgart Universitätsstraße 38 D-70569 Stuttgart Diplomarbeit Nr. 3243 Development and Evaluation of a Framework for

### From Workflow Design Patterns to Logical Specifications

AUTOMATYKA/ AUTOMATICS 2013 Vol. 17 No. 1 http://dx.doi.org/10.7494/automat.2013.17.1.59 Rados³aw Klimek* From Workflow Design Patterns to Logical Specifications 1. Introduction Formal methods in software

### Lecture 9 verifying temporal logic

Basics of advanced software systems Lecture 9 verifying temporal logic formulae with SPIN 21/01/2013 1 Outline for today 1. Introduction: motivations for formal methods, use in industry 2. Developing models

### Rigorous Software Development CSCI-GA 3033-009

Rigorous Software Development CSCI-GA 3033-009 Instructor: Thomas Wies Spring 2013 Lecture 11 Semantics of Programming Languages Denotational Semantics Meaning of a program is defined as the mathematical

### Mechanizing the Powerset Construction for Restricted Classes of ω-automata

Mechanizing the Powerset Construction for Restricted Classes of ω-automata Christian Dax 1, Jochen Eisinger 2, Felix Klaedtke 1 1 ETH Zurich 2 Albert-Ludwigs-University of Freiburg ATVA 2007 Motivation

### Research Article Towards Support for Software Model Checking: Improving the Efficiency of Formal Specifications

Advances in Software Engineering Volume 2011, Article ID 869182, 13 pages doi:10.1155/2011/869182 Research Article Towards Support for Software Model Checking: Improving the Efficiency of Formal Specifications

### Verification of multiagent systems via ordered binary decision diagrams: an algorithm and its implementation

Verification of multiagent systems via ordered binary decision diagrams: an algorithm and its implementation Franco Raimondi Alessio Lomuscio Department of Computer Science King s College London London

Verication by Finitary Abstraction Weizmann Institute of Sciences and Universite Joseph Fourier, Grenoble Fourth International Spin Workshop (SPIN'98) Paris 2.11.98 Joint work with: Y. Kesten Ben Gurion

### Software Active Online Monitoring Under. Anticipatory Semantics

Software Active Online Monitoring Under Anticipatory Semantics Changzhi Zhao, Wei Dong, Ji Wang, Zhichang Qi National Laboratory for Parallel and Distributed Processing P.R.China 7/21/2009 Overview Software

### Software Verification: Infinite-State Model Checking and Static Program

Software Verification: Infinite-State Model Checking and Static Program Analysis Dagstuhl Seminar 06081 February 19 24, 2006 Parosh Abdulla 1, Ahmed Bouajjani 2, and Markus Müller-Olm 3 1 Uppsala Universitet,

### A First Investigation of Sturmian Trees

A First Investigation of Sturmian Trees Jean Berstel 2, Luc Boasson 1 Olivier Carton 1, Isabelle Fagnot 2 1 LIAFA, CNRS Université Paris 7 2 IGM, CNRS Université de Marne-la-Vallée Atelier de Combinatoire,

### INF5140: Specification and Verification of Parallel Systems

INF5140: Specification and Verification of Parallel Systems Lecture 7 LTL into Automata and Introduction to Promela Gerardo Schneider Department of Informatics University of Oslo INF5140, Spring 2007 Gerardo

### Introduction to Promela and SPIN. LACL, Université Paris 12

Introduction to Promela and SPIN LACL, Université Paris 12 Promela = Process Meta Language A specification language! No programming language! Used for system description : Specify an abstraction of the

### The Common Fragment of ACTL and LTL

The Common Fragment of ACTL and LTL Miko laj Bojańczyk Warsaw University Abstract. The paper explores the relationship between tree languages definable in LTL, CTL, and ACTL, the fragment of CTL where

### Analysis of Boolean Programs

Analysis of Boolean Programs Patrice Godefroid 1 Mihalis Yannakakis 2 1 Microsoft Research, pg@microsoft.com 2 Columbia University, mihalis@cs.columbia.edu Abstract. Boolean programs are a popular abstract

### Introducing Formal Methods. Software Engineering and Formal Methods

Introducing Formal Methods Formal Methods for Software Specification and Analysis: An Overview 1 Software Engineering and Formal Methods Every Software engineering methodology is based on a recommended

### ω-automata Automata that accept (or reject) words of infinite length. Languages of infinite words appear:

ω-automata ω-automata Automata that accept (or reject) words of infinite length. Languages of infinite words appear: in verification, as encodings of non-terminating executions of a program. in arithmetic,

### An Approach to Dependable Embedded Software Development

University of West Bohemia in Pilsen Department of Computer Science and Engineering Univerzitni 8 30614 Pilsen Czech Republic An Approach to Dependable Embedded Software Development State of The Art and

Test Case Generation for Ultimately Periodic Paths Joint work with Saddek Bensalem Hongyang Qu Stavros Tripakis Lenore Zuck Accepted to HVC 2007 How to find the condition to execute a path? (weakest precondition

### Munich University of Technology Department of Informatics. Diploma Thesis. in Informatics

Munich University of Technology Department of Informatics Diploma Thesis in Informatics Development of a programming-language-like temporal logic specification language Jonathan Streit Date: April 12th,

### Runtime Verification for Real-Time Automotive Embedded Software

Runtime Verification for Real-Time Automotive Embedded Software S. Cotard, S. Faucou, J.-L. Béchennec, A. Queudet, Y. Trinquet 10th school of Modelling and Verifying Parallel processes (MOVEP) Runtime

### Specification and Analysis of Contracts Lecture 1 Introduction

Specification and Analysis of Contracts Lecture 1 Introduction Gerardo Schneider gerardo@ifi.uio.no http://folk.uio.no/gerardo/ Department of Informatics, University of Oslo SEFM School, Oct. 27 - Nov.

### Enhancing ABC for LTL Stabilization Verification of SystemVerilog/VHDL Models

1 Enhancing ABC for LTL Stabilization Verification of SystemVerilog/VHDL Models Jiang Long, Sayak Ray, Baruch Sterin, Alan Mishchenko, Robert Brayton Berkeley Verification and Synthesis Research Center

### Combining Software and Hardware Verification Techniques

Formal Methods in System Design, 21, 251 280, 2002 c 2002 Kluwer Academic Publishers. Manufactured in The Netherlands. Combining Software and Hardware Verification Techniques ROBERT P. KURSHAN VLADIMIR

### A Framework for the Semantics of Behavioral Contracts

A Framework for the Semantics of Behavioral Contracts Ashley McNeile Metamaxim Ltd, 48 Brunswick Gardens, London W8 4AN, UK ashley.mcneile@metamaxim.com Abstract. Contracts have proved a powerful concept

### Constructing Automata from Temporal Logic Formulas : A Tutorial

Constructing Automata from Temporal Logic Formulas : A Tutorial Pierre Wolper Université de Liège, Institut Montefiore, B28, 4000 Liège, Belgium pw@montefiore.ulg.ac.be, http://www.montefiore.ulg.ac.be/~pw/

### Software Model Checking. Equivalence Hierarchy

Software Equivalence Hierarchy Moonzoo Kim CS Dept. KAIST CS750B Software Korea Advanced Institute of Science and Technology Equivalence semantics and SW design Preliminary Hierarchy Diagram Trace-based

### Slides based in part on previous lectures by Mahesh Vishwanathan, and by Gul Agha January 21, 2014 1

Contact Information CS477 Formal Software Development Methods Elsa L Gunter 2112 SC, UIUC egunter@illinois.edu http://courses.engr.illinois.edu/cs477 Office: 2112 SC Office Hours: Wednesdays 11:00am -

### Formal Verification Toolkit for Requirements and Early Design Stages

Formal Verification Toolkit for Requirements and Early Design Stages Julia M. Badger 1 and Sheena Judson Miller 2 1 NASA Johnson Space Center, Houston, TX 77058, USA 2 Barrios Technology, Houston, TX 77058,