Linear and Branching Time Safety, Liveness, and Fairness

Slides:



Advertisements
Similar presentations
1 Verification by Model Checking. 2 Part 1 : Motivation.
Advertisements

Model Checking Lecture 1.
Automatic Verification Book: Chapter 6. How can we check the model? The model is a graph. The specification should refer the the graph representation.
Modeling issues Book: chapters 4.12, 5.4, 8.4, 10.1.
Tintu David Joy. Agenda Motivation Better Verification Through Symmetry-basic idea Structural Symmetry and Multiprocessor Systems Mur ϕ verification system.
Mutual Exclusion – SW & HW By Oded Regev. Outline: Short review on the Bakery algorithm Short review on the Bakery algorithm Black & White Algorithm Black.
Uninformed search strategies
Techniques to analyze workflows (design-time)
Algorithmic Software Verification VII. Computation tree logic and bisimulations.
Part 3: Safety and liveness
1 Model checking. 2 And now... the system How do we model a reactive system with an automaton ? It is convenient to model systems with Transition systems.
Planning based on Model Checking Dept. of Information Systems and Applied CS Bamberg University Seminar Paper Svetlana Balinova.
Automatic Verification Book: Chapter 6. What is verification? Traditionally, verification means proof of correctness automatic: model checking deductive:
An Introduction to the Model Verifier verds Wenhui Zhang September 15 th, 2010.
Based on: Petri Nets and Industrial Applications: A Tutorial
PROTOCOL VERIFICATION & PROTOCOL VALIDATION. Protocol Verification Communication Protocols should be checked for correctness, robustness and performance,
Temporal Logic and the NuSMV Model Checker CS 680 Formal Methods Jeremy Johnson.
CS6133 Software Specification and Verification
1 Partial Order Reduction. 2 Basic idea P1P1 P2P2 P3P3 a1a1 a2a2 a3a3 a1a1 a1a1 a2a2 a2a2 a2a2 a2a2 a3a3 a3a3 a3a3 a3a3 a1a1 a1a1 3 independent processes.
Rigorous Software Development CSCI-GA Instructor: Thomas Wies Spring 2012 Lecture 13.
Merged Processes of Petri nets Victor Khomenko Joint work with Alex Kondratyev, Maciej Koutny and Walter Vogler.
1 Temporal Claims A temporal claim is defined in Promela by the syntax: never { … body … } never is a keyword, like proctype. The body is the same as for.
1 Concurrency Specification. 2 Outline 4 Issues in concurrent systems 4 Programming language support for concurrency 4 Concurrency analysis - A specification.
CIS 540 Principles of Embedded Computation Spring Instructor: Rajeev Alur
Digitaalsüsteemide verifitseerimise kursus1 Formal verification: Property checking Property checking.
Process Analysis Toolkit PAT is A SPIN-like self-contained environment for system specification, visualized simulation and automated verification. PAT.
Spin Tutorial (some verification options). Assertion is always executable and has no other effect on the state of the system than to change the local.
Synthesis of Embedded Software Using Free-Choice Petri Nets.
1 Formal Methods in SE Qaisar Javaid Assistant Professor Lecture # 11.
© Katz, 2007CS Formal SpecificationsLecture - Temporal logic 1 Temporal Logic Formal Specifications CS Shmuel Katz The Technion.
Ordering and Consistent Cuts Presented By Biswanath Panda.
Model Checking. Used in studying behaviors of reactive systems Typically involves three steps: Create a finite state model (FSM) of the system design.
Lecture 4&5: Model Checking: A quick introduction Professor Aditya Ghose Director, Decision Systems Lab School of IT and Computer Science University of.
A Schedulability-Preserving Transformation of BDF to Petri Nets Cong Liu EECS 290n Class Project December 10, 2004.
Modeling Software Systems Lecture 2 Book: Chapter 4.
On-the-fly Model Checking from Interval Logic Specifications Manuel I. Capel & Miguel J. Hornos Dept. Lenguajes y Sistemas Informáticos Universidad de.
Behaviour-Preserving Transition Insertions in Unfolding Prefixes
Review of the automata-theoretic approach to model-checking.
Embedded Systems Laboratory Department of Computer and Information Science Linköping University Sweden Formal Verification and Model Checking Traian Pop.
ESE601: Hybrid Systems Introduction to verification Spring 2006.
*Department of Computing Science University of Newcastle upon Tyne **Institut für Informatik, Universität Augsburg Canonical Prefixes of Petri Net Unfoldings.
1 Formal Engineering of Reliable Software LASER 2004 school Tutorial, Lecture1 Natasha Sharygina Carnegie Mellon University.
Petri Nets An Overview IE 680 Presentation April 30, 2007 Renata Kopach- Konrad.
Maria-Cristina Marinescu Martin Rinard Laboratory for Computer Science Massachusetts Institute of Technology A Synthesis Algorithm for Modular Design of.
Cheng/Dillon-Software Engineering: Formal Methods Model Checking.
Review: Search problem formulation Initial state Actions Transition model Goal state (or goal test) Path cost What is the optimal solution? What is the.
Yang Liu, Jun Sun and Jin Song Dong School of Computing National University of Singapore.
CS6133 Software Specification and Verification
Specifying and Verifying Event-based Fairness Enhanced Systems 1 ICFEM 2008 Specifying and Verifying Event-based Fairness Enhanced Systems Jun SUN, Yang.
Defining Programs, Specifications, fault-tolerance, etc.
CIS 540 Principles of Embedded Computation Spring Instructor: Rajeev Alur
Distributed Systems Fall 2010 Logical time, global states, and debugging.
Recognizing safety and liveness Presented by Qian Huang.
Defining Liveness by Bowen Alpern and Fred B. Schneider Presented by Joe Melnyk.
1 CSEP590 – Model Checking and Automated Verification Lecture outline for July 9, 2003.
Model Checking Lecture 1. Model checking, narrowly interpreted: Decision procedures for checking if a given Kripke structure is a model for a given formula.
Presented by: Belgi Amir Seminar in Distributed Algorithms Designing correct concurrent algorithms Spring 2013.
1 Chapter 11 Global Properties (Distributed Termination)
Today’s Agenda  Quiz 4  Temporal Logic Formal Methods in Software Engineering1.
Model Checking Lecture 1: Specification Tom Henzinger.
Introduction to distributed systems description relation to practice variables and communication primitives instructions states, actions and programs synchrony.
Diagnostic Information for Control-Flow Analysis of Workflow Graphs (aka Free-Choice Workflow Nets) Cédric Favre(1,2), Hagen Völzer(1), Peter Müller(2)
Fundamentals of Fault-Tolerant Distributed Computing In Asynchronous Environments Paper by Felix C. Gartner Graeme Coakley COEN 317 November 23, 2003.
Distributed Systems Lecture 6 Global states and snapshots 1.
Model Checking Lecture 2 Tom Henzinger. Model-Checking Problem I |= S System modelSystem property.
Complexity of Compositional Model Checking of Computation Tree Logic on Simple Structures Krishnendu Chatterjee Pallab Dasgupta P.P. Chakrabarti IWDC 2004,
Automatic Verification
Abstraction.
Linear Time Properties
Introduction to verification
Presentation transcript:

Linear and Branching Time Safety, Liveness, and Fairness Lam Quoc Dang FAdCo T-79.5306 Reactive Systems

Contents Linear and Branching Time Safety, Liveness, and Fairness General Overview Linear Time Branching Time Safety, Liveness, and Fairness Safety Property Liveness Property Fairness Assumption

General Overview An abstraction mechanism consisting of π and Ɛπ, Σ and ƐΣ, or both is used. Properties of individual states, transitions, and their relations over time are specified.

Linear Time Looking at each complete execution separately ”K ||− φ” is defined as Ɛπ(K) ||− φ, or ƐΣ(K) ||− φ, or Ɛπ+Σ(K) ||− φ. Property φ belongs to a system iff K ||− φ for every K ∈ CEx. Such property is a linear-time property. Eg: Reachability of a deadlock, 4-boundedness of a Petri net place p are linear-time property.

Linear Time Checking: including a proposition is_deadlock in π, checking whether is_deadlock holds in any abstracted states in sequences of Ɛπ(CEx). A structural transition t ∈ T is Petri-net-live iff ”t is enabled”. Petri-net-liveness of t is not a linear-time property.

Branching Time Petri-net-liveness is determined with t_enab ∈ π and all execution trees shown. An execution tree represents all executions starting with s1 ∈ S1, and records all positions where two executions separate. Execution tree of state space (S, T, Δ, S1) with s1 ∈ S1 is formally defined as rooted edge-labelled graph (V, E, S1).

Branching Time Each node in execution tree contains only information provided by Ɛπ. Edges of execution tree are defined in two different ways if structural transitions are abstracted with Σ or away totally. Property whose validity is defined on Ɛ- abstracted execution trees is branching-time property. Branching-time property is proper if it is not linear-time property, eg: Petri-net-liveness.

Safety Property Safety in concurrent systems corresponds to partial correctness in sequential programs. Linear-time safety is property of Ɛ-abstracted executions having finite counterexamples. A safety property belongs to a system iff all its executions have such property. No property is simultaneously a safety and liveness property.

Safety Property Eg: ”the program will not terminate” is safety property, so as ”prefix” property of fifo queue and 4-boundedness of Petri net place. Safety property can be defined in branching- time by replacing ”execution trees” for ”executions”. Verification for safety is easier than for liveness properties (existing algorithms and not depending on fairness).

Liveness Property Liveness (progress) in concurrent systems corresponds to termination in sequential programs. Liveness is system-specific and more difficult to formulate than termination. Linear-time liveness is property whose counterexamples are Ɛ-abstractions of ony complete executions.

Liveness Property Eg: ”the program will eventually terminate” is liveness property, so as the ”length” property of fifo queues. Counterexamples of linear-time liveness are infinite executions (finite ”prefix” + repeating finite cycle). Counterexamples for proper branching-time properties are more complicated.

Fairness Assumption Fairness is assumption often needed for ensuring liveness. Two well-known notions: weak fairness (justice) and strong fairness (compassion). If a structural transition t is enbled in every state from some point on (but never occurs), weak-fairness will eventually occur.

Fairness Assumption Fairness is used to modelling process schedule to ensure each process gets processor time. Fairness is used to ensure a serve serves its clients equally. In strong fairness, if t is enabled infinitely many times, it should occur infinitely many times.

THANKS FOR YOUR ATTENTION!