
- •CONTENTS
- •PREFACE
- •LIST OF FIGURES
- •INTRODUCTION
- •1.1 WHAT IS TIME?
- •1.2 SIMULATION
- •1.3 TESTING
- •1.4 VERIFICATION
- •1.6 USEFUL RESOURCES
- •2.1 SYMBOLIC LOGIC
- •2.1.1 Propositional Logic
- •2.1.2 Predicate Logic
- •2.2 AUTOMATA AND LANGUAGES
- •2.2.1 Languages and Their Representations
- •2.2.2 Finite Automata
- •2.3 HISTORICAL PERSPECTIVE AND RELATED WORK
- •2.4 SUMMARY
- •EXERCISES
- •3.1 DETERMINING COMPUTATION TIME
- •3.2 UNIPROCESSOR SCHEDULING
- •3.2.1 Scheduling Preemptable and Independent Tasks
- •3.2.2 Scheduling Nonpreemptable Tasks
- •3.2.3 Nonpreemptable Tasks with Precedence Constraints
- •3.2.5 Periodic Tasks with Critical Sections: Kernelized Monitor Model
- •3.3 MULTIPROCESSOR SCHEDULING
- •3.3.1 Schedule Representations
- •3.3.3 Scheduling Periodic Tasks
- •3.4 AVAILABLE SCHEDULING TOOLS
- •3.4.2 PerfoRMAx
- •3.4.3 TimeWiz
- •3.6 HISTORICAL PERSPECTIVE AND RELATED WORK
- •3.7 SUMMARY
- •EXERCISES
- •4.1 SYSTEM SPECIFICATION
- •4.2.1 Analysis Complexity
- •4.3 EXTENSIONS TO CTL
- •4.4 APPLICATIONS
- •4.4.1 Analysis Example
- •4.5 COMPLETE CTL MODEL CHECKER IN C
- •4.6 SYMBOLIC MODEL CHECKING
- •4.6.1 Binary Decision Diagrams
- •4.6.2 Symbolic Model Checker
- •4.7.1 Minimum and Maximum Delays
- •4.7.2 Minimum and Maximum Number of Condition Occurrences
- •4.8 AVAILABLE TOOLS
- •4.9 HISTORICAL PERSPECTIVE AND RELATED WORK
- •4.10 SUMMARY
- •EXERCISES
- •VISUAL FORMALISM, STATECHARTS, AND STATEMATE
- •5.1 STATECHARTS
- •5.1.1 Basic Statecharts Features
- •5.1.2 Semantics
- •5.4 STATEMATE
- •5.4.1 Forms Language
- •5.4.2 Information Retrieval and Documentation
- •5.4.3 Code Executions and Analysis
- •5.5 AVAILABLE TOOLS
- •5.6 HISTORICAL PERSPECTIVE AND RELATED WORK
- •5.7 SUMMARY
- •EXERCISES
- •6.1 SPECIFICATION AND SAFETY ASSERTIONS
- •6.4 RESTRICTED RTL FORMULAS
- •6.4.1 Graph Construction
- •6.5 CHECKING FOR UNSATISFIABILITY
- •6.6 EFFICIENT UNSATISFIABILITY CHECK
- •6.6.1 Analysis Complexity and Optimization
- •6.7.2 Timing Properties
- •6.7.3 Timing and Safety Analysis Using RTL
- •6.7.5 RTL Representation Converted to Presburger Arithmetic
- •6.7.6 Constraint Graph Analysis
- •6.8 MODECHART SPECIFICATION LANGUAGE
- •6.8.1 Modes
- •6.8.2 Transitions
- •6.9.1 System Computations
- •6.9.2 Computation Graph
- •6.9.3 Timing Properties
- •6.9.4 Minimum and Maximum Distance Between Endpoints
- •6.9.5 Exclusion and Inclusion of Endpoint and Interval
- •6.10 AVAILABLE TOOLS
- •6.11 HISTORICAL PERSPECTIVE AND RELATED WORK
- •6.12 SUMMARY
- •EXERCISES
- •7.1.1 Timed Executions
- •7.1.2 Timed Traces
- •7.1.3 Composition of Timed Automata
- •7.1.4 MMT Automata
- •7.1.6 Proving Time Bounds with Simulations
- •7.2.1 Untimed Traces
- •7.2.2 Timed Traces
- •7.3.1 Clock Regions
- •7.3.2 Region Automaton
- •7.4 AVAILABLE TOOLS
- •7.5 HISTORICAL PERSPECTIVE AND RELATED WORK
- •7.6 SUMMARY
- •EXERCISES
- •TIMED PETRI NETS
- •8.1 UNTIMED PETRI NETS
- •8.2 PETRI NETS WITH TIME EXTENSIONS
- •8.2.1 Timed Petri Nets
- •8.2.2 Time Petri Nets
- •8.3 TIME ER NETS
- •8.3.1 Strong and Weak Time Models
- •8.5.1 Determining Fireability of Transitions from Classes
- •8.5.2 Deriving Reachable Classes
- •8.6 MILANO GROUP’S APPROACH TO HLTPN ANALYSIS
- •8.6.1 Facilitating Analysis with TRIO
- •8.7 PRACTICALITY: AVAILABLE TOOLS
- •8.8 HISTORICAL PERSPECTIVE AND RELATED WORK
- •8.9 SUMMARY
- •EXERCISES
- •PROCESS ALGEBRA
- •9.1 UNTIMED PROCESS ALGEBRAS
- •9.2 MILNER’S CALCULUS OF COMMUNICATING SYSTEMS
- •9.2.1 Direct Equivalence of Behavior Programs
- •9.2.2 Congruence of Behavior Programs
- •9.2.3 Equivalence Relations: Bisimulation
- •9.3 TIMED PROCESS ALGEBRAS
- •9.4 ALGEBRA OF COMMUNICATING SHARED RESOURCES
- •9.4.1 Syntax of ACSR
- •9.4.2 Semantics of ACSR: Operational Rules
- •9.4.3 Example Airport Radar System
- •9.5 ANALYSIS AND VERIFICATION
- •9.5.1 Analysis Example
- •9.5.2 Using VERSA
- •9.5.3 Practicality
- •9.6 RELATIONSHIPS TO OTHER APPROACHES
- •9.7 AVAILABLE TOOLS
- •9.8 HISTORICAL PERSPECTIVE AND RELATED WORK
- •9.9 SUMMARY
- •EXERCISES
- •10.3.1 The Declaration Section
- •10.3.2 The CONST Declaration
- •10.3.3 The VAR Declaration
- •10.3.4 The INPUTVAR Declaration
- •10.3.5 The Initialization Section INIT and INPUT
- •10.3.6 The RULES Section
- •10.3.7 The Output Section
- •10.5.1 Analysis Example
- •10.6 THE ANALYSIS PROBLEM
- •10.6.1 Finite Domains
- •10.6.2 Special Form: Compatible Assignment to Constants,
- •10.6.3 The General Analysis Strategy
- •10.8 THE SYNTHESIS PROBLEM
- •10.8.1 Time Complexity of Scheduling Equational
- •10.8.2 The Method of Lagrange Multipliers for Solving the
- •10.9 SPECIFYING TERMINATION CONDITIONS IN ESTELLA
- •10.9.1 Overview of the Analysis Methodology
- •10.9.2 Facility for Specifying Behavioral Constraint Assertions
- •10.10 TWO INDUSTRIAL EXAMPLES
- •10.10.2 Specifying Assertions for Analyzing the FCE Expert System
- •Meta Rules of the Fuel Cell Expert System
- •10.11.1 General Analysis Algorithm
- •10.11.2 Selecting Independent Rule Sets
- •10.11.3 Checking Compatibility Conditions
- •10.12 QUANTITATIVE TIMING ANALYSIS ALGORITHMS
- •10.12.1 Overview
- •10.12.2 The Equational Logic Language
- •10.12.3 Mutual Exclusiveness and Compatibility
- •10.12.5 Program Execution and Response Time
- •10.12.8 Special Form A and Algorithm A
- •10.12.9 Special Form A
- •10.12.10 Special Form D and Algorithm D
- •10.12.11 The General Analysis Algorithm
- •10.12.12 Proofs
- •10.13 HISTORICAL PERSPECTIVE AND RELATED WORK
- •10.14 SUMMARY
- •EXERCISES
- •11.1 THE OPS5 LANGUAGE
- •11.1.1 Overview
- •11.1.2 The Rete Network
- •11.2.1 Static Analysis of Control Paths in OPS5
- •11.2.2 Termination Analysis
- •11.2.3 Timing Analysis
- •11.2.4 Static Analysis
- •11.2.5 WM Generation
- •11.2.6 Implementation and Experiment
- •11.3.1 Introduction
- •11.3.3 Response Time of OPS5 Systems
- •11.3.4 List of Symbols
- •11.3.5 Experimental Results
- •11.3.6 Removing Cycles with the Help of the Programmer
- •11.4 HISTORICAL PERSPECTIVE AND RELATED WORK
- •11.5 SUMMARY
- •EXERCISES
- •12.1 INTRODUCTION
- •12.2 BACKGROUND
- •12.3 BASIC DEFINITIONS
- •12.3.1 EQL Program
- •12.3.4 Derivation of Fixed Points
- •12.4 OPTIMIZATION ALGORITHM
- •12.5 EXPERIMENTAL EVALUATION
- •12.6 COMMENTS ON OPTIMIZATION METHODS
- •12.6.1 Qualitative Comparison of Optimization Methods
- •12.7 HISTORICAL PERSPECTIVE AND RELATED WORK
- •12.8 SUMMARY
- •EXERCISES
- •BIBLIOGRAPHY
- •INDEX
ALUR–DILL REGION AUTOMATON AND VERIFICATION |
201 |
The motivation for using a DTA is that it can be easily complemented since at most one run exists over a given timed word. Complementation is needed when we verify that the implementation AI meets the specification AS by checking for the emptiness of L(AI ) ∩ L(AS )C , that is, the intersection of the languages accepted by the implementation and the languages accepted by the complement of the specification (negation of the specification) is empty.
7.3 ALUR–DILL REGION AUTOMATON AND VERIFICATION
To prove that the language accepted by an automaton is nonempty, we need to show that there is an infinite accepting path in the automaton’s transition table. For a timed automaton, the timing constraints disallow certain paths in the transition table. Alur and Dill [Alur, 1991; Alur and Dill, 1994] show that given a timed automaton, a Buchi automaton can be constructed such that the set of untimed words accepted by the Buchi automaton is the same as the one obtained by the Untime operation on the timed words accepted by the timed automaton. They provide an algorithm for checking emptiness for timed automata with clock constraints containing only integer constants.
Clock constraints containing rational numbers can be converted into integers by multiplying each constant by the least common multiple (LCM) of the denominators of all the constants in the clock constraints of an automaton. Note that this does not change the untimed language.
7.3.1 Clock Regions
Since the number of clock interpretations is infinite, the number of extended states is infinite and uncountable. This makes it impossible to construct an automaton with extended states given an automaton with no clock interpretations. However, to verify that two automata are equivalent, for example, that an implementation of a system (represented by an automaton) satisfies the specification of the system (represented by another automaton), we have to find a way to build the corresponding finite automata.
One approach used in other analysis and verification techniques is to aggregate an infinite set of extended states into one state or a finite set of states. Here, this is achieved by grouping infinite sets of states into a finite number of clock regions, and then by showing that runs (or execution paths) from the same states in both automata are similar if their clock values agree.
Suppose the non-clock components of two extended states from these two automata are the same. If these states agree on the integral parts of their clock values as well as on the ordering of the fractional parts of their clock values, then the runs beginning from these extended states are similar. Note that the values of the integral parts of clocks can be unbounded. However, we are only interested in those values that are less than or equal to the largest integer c appearing in clock constraints since these bounded values satisfy these clock constraints and determine allowed execution paths. We now formalize these ideas.
202 VERIFICATION USING TIMED AUTOMATA
A positive real number t can be expressed as t + fract(t) and hence has two parts: the integral part t and the fractional part fract(t). Suppose for each i C, ci is the largest integer that i is compared to in some clock constraint. We first define an equivalence relation called time-abstract bisimulation.
Time-Abstract Bisimulation: The equivalence relation “ ,” also known as the time-abstract bisimulation, over the set of clock interpretations for C is defined as follows. v v iff all three of these conditions hold:
1.For all i C, either v(i) = v (i) or v(i) > ci and v (i) > ci .
2.For all i, j C where v(i) ≤ ci and v( j) ≤ c j , fract(v(i)) ≤ fract(v( j)) iff fract(v (i)) ≤ fract(v ( j)).
3.For all i C where v(i) ≤ ci , fract(v(i)) = 0 iff fract(v (i)) = 0.
Clock Region: A clock region for automaton α is an equivalence class of clock interpretations induced by .
We can define each clock region by specifying:
1. |
a clock constraint from the set for every clock i: {i = c|c = 0, . . . , ci } |
|
{c − 1 < i < c|c = 1, . . . , ci } {i > ci }, and |
2. |
whether fract(i) is <, =, or > fract( j) for every pair of clocks i and j where |
|
c − 1 < i < c and d − 1 < j < d appear in the clock constraint in (1) for |
|
some c and d. |
The number of these clock regions as specified above is bounded but is exponential in the encoding of the clock constraints. A clock region R is said to satisfy a clock constraint δ iff every clock interpretation v in R satisfies δ.
Recall that v is a clock interpretation for a finite set C of clocks. The notation [v] indicates the clock region containing v; that is, v belongs to the clock region [v]. Furthermore, we uniquely characterize each clock region by specifying a finite set of clock constraints that the region satisfies.
Example. A clock region: Suppose there are two clocks (i and j) in a timed transition table, ci = 1 and c j = 2. There are 8 clock regions, as shown in Figure 7.3.
The notion of region equivalence is very important in grouping related clock interpretations together into a single clock region, thus making analysis manageable, as we will see later. The following time-abstract transition relation over the (time) extended states helps illustrate the usefulness of the concept of region equivalence.
Time-Abstract Transition Relation over Extended States: Given |
an alphabet |
||||
|
|
a |
iff there is |
||
symbol a, for two extended states s, v and s , v , s, v → s , v |
|||||
|
|
and a time increment t (a positive real number) such that v |
+ |
t |
|
an edge s, s , a, λ, δ |
|
|
satisfies δ and v = [λ → 0](v + t).

ALUR–DILL REGION AUTOMATON AND VERIFICATION |
203 |
j |
|
|
|
|
R1 |
R2 |
|
2 |
R3 |
|
|
|
R5 |
|
|
1 |
R4 |
|
|
R6 |
|
|
|
|
R8 |
|
|
|
R7 |
|
|
|
|
|
|
0 |
1 |
2 |
i |
|
Figure 7.3 Clock regions for two clocks, ci = 1 and c j = 2.
Property |
of Time-Abstract Bisimulation (Equivalence Relation |
|
): If |
v |
i |
|
v |
j |
|||||||
a |
|
|
|
|
|
|
|
|
|||||||
|
a |
→ |
, vi |
|
exists such that |
vi |
v j |
and |
|||||||
and |
s, vi |
|
s |
, then a clock interpretation v j |
|
|
s, v j →s , v j .
Given an automaton with a clock constraint δ, if two clock interpretations are equivalent (v v ), then v satisfies δ iff v satisfies δ.
7.3.2 Region Automaton
Having defined a clock region as an equivalence class of potentially infinite clock interpretations, we now aggregate every group of equivalent (time) extended states into a single region-state. This leads to the definition of a region automaton R(A) where A is the original timed automaton. Each state s, p in the region automaton consists of the state s S of the corresponding timed automaton and the clock region p, which is the equivalence class of the current clock values.
The region automaton simulates the corresponding timed automaton by following these rules. If the extended state of A is s, v , then the corresponding state of R(A) is s, [v]. A transition exists in R(A) from state s, p to state s , p labeled with a iff in A a transition exists from state s, v with v p to state s , v labeled with a for some v p .
Projection: The projection [r] = (s, [v]) of a run r = (s, v) of automaton A of the form
ρ1,τ1 |
ρ2,τ2 |
|
ρ3,τ3 |
r : s0, v0 → s1 |
, v1 → s2 |
, v2 → · · · |
|
is the sequence |
|
|
|
ρ1 |
ρ2 |
|
ρ3 |
[r] : s0, [v0] →s1, [v1] →s2 |
, [v2] → · · · . |
Progressive Run: Given a region automaton R(A), a run r = (s, p) is progressive iff there is an infinite number of is (i ≥ 0) for each clock j C such that pi satisfies
[( j = 0) ( j > c j )].

204 VERIFICATION USING TIMED AUTOMATA
S0 |
alarm, i := 0 |
S1 |
|
false alarm, (i < 1)? |
|
||||||
|
|
< |
1)? |
|
i:= |
0 |
|
|
(j |
|
|
|
|
||
check, |
|
|
|
< 1)?, |
|
||
|
|
|
(i |
|
|
||
|
alarm, |
|
|
|
|||
|
|
|
|
|
evacuate
(i = 1)?
S3 S2 return, (j < 1)?
Figure 7.4 Automaton α3.
Example. Figure 7.4 shows a timed automaton α3 with the alphabet
{alarm, false alarm, check, evacuate, return}.
The construction of the corresponding region automaton R(α3) is left as an exercise.
7.3.3 Verification Algorithm
Now we are ready to describe the Alur–Dill verification approach. A great deal of theory and definitions have been presented so far, but the main idea is as follows. Untimed automata are extended with clock variables and timing constraints on transitions to yield timed Buchi automata (TBAs), which can represent timed regular processes. Then to allow the analysis of TBAs with an infinite number of extended states, corresponding region automata are introduced.
The verification algorithm to be described can verify the correctness of finitestate real-time systems. TBAs model finite-state real-time systems. The objective is to check that the implementation of a real-time system meets the specification of this system. Both the implementation and the specification are first represented by TBAs. Then we prove that the desired inclusion, that the language accepted by the implementation automaton, is a subset of the language accepted by the specification automaton.
Given a timed process (A, L) where L is a language over the alphabet P(A), if L is a timed regular language, then this is a timed regular process representable by a timed automaton. Usually, an implementation is represented by a TBA AI that is a composition of n components with each component described by a timed regular process Pi = (Ai , L(Ai )). The system specification is represented by a timed regular language S over the alphabet P(A), where A = A1 · · · An . The system is said to be correct iff the following inclusion is satisfied: L(AI ) S. The verification algorithm is shown in Figure 7.5.