Printer Friendly

Temporal Logics for Real-Time System Specification.

1. INTRODUCTION

During the last few years, several techniques, tools, and models for the formal specification of real-time systems have been proposed. Typical applications can be found in avionics, robotics, process control, and healthcare. For real-time applications, the meeting of temporal constraints are mandatory. A system specification must formalize system behavior (including temporal constraints), and thus the model must be supported by mechanisms that verify conformity with requirements. Behavior is typically expressed by giving a set of relationships enumerating the temporal constraints among events and actions, such as invariants, precedence among events, periodicity, liveness and safety conditions, etc., see Bucci et al. [1995]; Stoyenko [1992]; Stankovic [1988]; and Stankovic and Ramamritham [1990]. The specification techniques must be formal enough to verify and validate the specification with respect to system requirements by using theorem provers or model-checking techniques.

To this end, many researchers have proposed logical languages integrating temporal logics, e.g., Pnueli [1977]; Jahanian and Mok [1986]; Schwartz et al. [1983]; Gotzhein [1992]; Vila [1994]; and Orgun and Ma [1994]. These languages, together with several algebraic languages augmented with time (Z++, VDM++, Object Z, etc.), e g., Zave [1982]; Lano [1991]; Lano and Haughton [1994]; Carrington et al. [1990]; andDurr and vanKatwijk [1992], provide the most abstract approaches to requirement specification and real-time system analysis [Ostroff 1992; Bucci et al. 1995]. Only in a few cases may logic specifications be used for real implementations of the system.

The temporal logics proposed in the literature differ from each other with regard to expressiveness, availability of support tools for executability, verifiability, etc. In most cases, these temporal logics have been defined to satisfy specific needs. In recent years the structure and capabilities of temporal logics has grown. In some cases, simple temporal logics are preferable to more complex and powerful ones, since the former are more satisfactorily adopted in certain applications. In order to clarify the differences among the several temporal logics, we reviewed a selection of the most representative temporal logics. Our review was based on building a taxonomy that classifies temporal logics in terms of order, time structure, decidability, executability, and expressiveness.

This paper reviews a number of well-known temporal logics designed for the specification of both reactive and/or real-time systems, taking into account their evolution and their expressiveness. The main features of temporal logics are discussed with consideration of their adaptibility for the specification of real-time systems. The features chosen for discussion include aspects of logic theory and applicability as specification languages. The above and other aspects are discussed together with several examples. Where possible, the same example has been used with several formalisms.

Classification is one of the major concerns of this paper. The world of temporal logics is surely far from stable, and we may have overlooked some relevant issues. Thus, we do not claim that this paper is an exhaustive review of temporal logics for the specification of real-time systems; rather it presents a useful taxonomy for classifying and identifying the capabilities of temporal logics, and can be used to classify even those temporal logics that may be proposed in the future.

This paper is organized as follows. Section 2 discusses classical logics in order to highlight their limitations in expressing temporal properties. Section 3 highlights the most important features that characterize temporal logics and presents some examples. Section 4 briefly describes the temporal logics selected and their suitability for the specification of real-time systems. Section 5 reports on the main features of the temporal logics considered. Conclusions are drawn in Section 6.

2. FROM CLASSICAL TO TEMPORAL LOGICS

The primary feature of a logic theory is its order, which defines the domain of all formulas described by the logic: (i) propositional, (ii) first order, (iii) higher order.

Formulas in propositional logic are built on the basis of a set of elementary facts (i.e., atomic formulas) by using a set of logic operators (??, [conjunction], [disjunction], ??, ??). Their semantics can be defined in terms of truth tables or by inductive rules on the structure of the formula itself. Each formula can assume a logical value true (??) or false ([perpendicular to]).

First order logic, FOL, adds several extensions to propositional logic:

-- There exists a domain of elements D on the basis of which the logical formulas are built;

-- n-ary [R.sub.i] relationships on D can be defined as subsets of [D.sup.n];

-- an n-ary predicate [p.sub.i] is associated with each n-ary [R.sub.i] relationship. A predicate is a function that for each element of [D.sup.n] gives a value ?? if it belongs to an n-ary [R.sub.i] relationship, otherwise the value [perpendicular to] is assumed;

-- the operators of FOL are those of propositional logic plus the universal quantifier [inverted] A (for all), and the existential quantifier [exists] (exists).

In FOL, quantified variables must be elements of D and not full predicates. The presence of quantification increases the expressiveness of the logic, allowing the description of existential and generalization relationships.

Higher order logic, HOL, extends the domain modeled by FOL by allowing the adoption of predicates as quantification variables. For example, the following HOL formula:

[inverted] AP. [exists] x.P(x),

cannot be written in FOL since it contains a quantifier varying over a predicate P. The higher expressiveness of HOL makes it suitable for formally describing lower order logics.

2.1 Deductive Systems

Classical logics can formalize the deductive process: given a set of true propositions, it is possible to verify if other propositions are a logical consequence of the early set.

Proving theorems by using formal logic is a process quite different from the human deductive process. Deductive systems are based on a formalized theory by means of a set of axioms and deduction rules. This makes it possible to define a purely syntax-deductive system without adopting the concepts of validity and satisfiability, which are typical of the human deductive process.

In order to adopt a deductive system for proving theorems, it is mandatory to demonstrate that it is complete (i.e., it is possible to construct a demonstration for all theorems of the theory) and sound (i.e., each theorem that can be demonstrable with the logic is a theorem of the logic) [Davis et al. 1989; Abramsky et al. 1992; Ben-Ari 1993; Andrews 1986].

Deductive systems tend to be minimal, as the set of axioms and deductive laws selected are usually just those strictly needed to describe the logic. So the process required to prove other theorems can be complex and long. On the other hand, it is often possible to use the deductive system to demonstrate new deduction laws and theorems that, in turn, can be used in other proof processes as the minimum initial set. Thus a system of the laws of deduction that makes the proof process easier can be built in this way

2.2 Classical Logic and Time

In general, assertions can be classified as either static or dynamic. Static assertions have a fixed and time-independent truth value, while the truth value of dynamic assertions is in some way time-dependent. For example, the proposition 1 [is less than] 2 is always true, whereas the logical value of the proposition:

"it is raining"

is time-varying: it may sometimes be true, while at others it may be false. Since the state of a real system changes over time, logic predicates describing behavior must provide propositions whose values vary over time. Classical logic can express only atemporal (nontime-dependent) formulas whose validity and satisfiability do not depend on the instant in which they are evaluated. In other words, time has no role in classical logic; when a proposition presents a value that changes over time, the time must be modeled as an explicit variable. For example, if a proposition P has to be true in interval [t + 5, t + 20], we have to write the formula as

[inverted] Ax [element of] [t + 5, t + 20].P(x).

This approach makes the writing of time-dependent propositions quite complex. In order to model the behavior of domains in which the logical value of propositions may vary, modal and temporal logics were introduced as extensions of classical logic. These approaches facilitate the specification of temporal relationships.

2.3 Modal Logic

In modal logic, the concepts of truth and falsity are not static and immutable, but are, on the contrary, relative and variable [Hughes and Cresswell 1968]. In modal logic, the classical concept of interpretation of a formula is extended in the sense that every modal logic theory has associated with it, not just a single interpretation, but a set of interpretations called worlds. In each world, a truth value is assigned to a formula, similar to the interpretation of a formula in classical logic.

A modal logic system is defined by <W, R, V> where: W is the set of worlds; R [subset of equal to] W x W is the reachability relationship between worlds; and V is the evaluation function for formulas:

V : F X W [right arrow] {??, [perpendicular to]},

where F is the set of formulas of the modal theory. V assigns a truth value to every formula in F in every world in W.

The forms of W and V depend on other characteristics of the logic; for example, whether it is propositional or a FOL. Besides the operators and symbols of classical logic, modal logic introduces operators L (necessary) and M (possibly). These express the concept of the necessity and possibility of formulas in the set of worlds reachable from the world in which the main formula is evaluated.

The semantics of a modal logic can be formally given on the basis of an evaluation function V, which is inductively defined over the structure of the formula to be evaluated. Omitting the definition of the part about classical logic, V is defined over the modal operators L and M, as follows:

-- V(Mf, w) = ?? iff [exists] v [element of] W. wRv ?? V(f, v);

-- V(Lf, w) = ?? iff [inverted] Av [element of] W.wRv ?? V(f, v).

In other words, formula Mf is true in a world w if and only if there exists a world v reachable from w, where subformula f is true; formula Lf is true in w if and only if in all worlds reachable from w subformula f is true. Modal operators L and M have a simple interpretation as quantifiers defined over the set of reachable worlds from the current world, namely, M is an existential quantifier, while L is a universal quantifier. It is easy to see that the following relation holds between operators L and M:

Lf = ??M ??f.

The features of a modal logic <W, R, V> are strictly connected to the relationship that determines the structure of the set of worlds. The interpretations of relationship R may be several: R can represent how a set of classical theories are correlated; for example, in a nonmonotonic logic the elementary truth and the deducible facts can change dynamically. In the context of temporal logics, the most interesting interpretation for relationship R is the relation next instant. In this way, the worlds are the set of configurations that the system modeled may assume in successive time instants. In this case the modal logic can be used quite profitably to study the temporal properties of systems, and for this reason is called temporal logic.

2.4 Temporal Logic

Temporal logics are particular modal logics where the set of worlds W is interpreted as the set of all possible instants T of a temporal domain.

Temporal logics are usually built as extensions of classical logic by adding a set of new operators that hide quantification over the temporal domain. Temporal logic in the literature are principally obtained by extending propositional or FOL; rarely has the extension started with HOL.

As in modal logic, where the world in which the formula is evaluated is referenced, in temporal logic the evaluation instant of a formula is used. The value of a formula is a dynamic concept. Therefore, the concept of formula satisfiability must be modified to consider both the interpretation of a formula and the instant of evaluation.

Generally, temporal logics add four new operators with respect to classical logics [Prior 1967]:

-- G, always in the future;

-- F, eventually in the future;

-- H, always in the past;

-- P, eventually in the past.

These can be formally defined as:

-- V(Gf, t) = ?? iff [inverted] As [element of] T.t [is less than] s ?? V(f, s);

-- V(Hf, t) = ?? iff [inverted] As [element of] T.s [is less than] t ?? V(f, s);

-- Ff [equivalent] ??G ??f;

-- Pf [equivalent] ??H ??f;

These operators can express the concepts of necessity (G, H) and possibility (F, P) in the future and in the past, respectively. In temporal logics these operators are often represented by other symbols: [] (always) denotes G and [diamond] (eventually) denotes F. For past operators (if they are present), symbol [solid square] denotes H and [solid diamond] denotes P.

If relation [is less than] is transitive and nonreflexive, it is possible to introduce two other binary operators:

-- until (in some cases represented by U), with [[Phi].sub.1] until [[Phi].sub.2] that is true if [[Phi].sub.2] will be true in the future and until that instant [[Phi].sub.1] will always be true;

-- since (in some cases represented by S), with [[Phi].sub.1] since [[Phi].sub.2] that is true if [[Phi].sub.2] was true in the past and since that instant [[Phi].sub.1] has been true;

The semantics of these operators can be formally defined as follows:

-- V([f.sub.1] until [f.sub.2], t) = ?? iff [exists] s [element of] T.t [is less than] s [conjunction] V([f.sub.2], s) [conjunction] [inverted] Au [element of] T.t [is less than] u [is less than] s ?? V([f.sub.1], u);

-- V([f.sub.1] since [f.sub.2], t) = ?? iff [exists] s [element of] T.s [is less than] t [conjunction] V([f.sub.2], s) [conjunction] [inverted] Au [element of] T.s [is less than] u [is less than] t ?? V([f.sub.1], u).

Note that operator until (since) does not include the present instant in the future (past). The introduction of operators until and since is relevant because these operators can express concepts that cannot be expressed with the operators G, H, F and P. On the contrary, these last operators can be defined in terms of until and since:

-- F[Phi] [equivalence] ?? until [Phi];

-- P[Phi] [equivalence] ?? since [Phi];

and

-- G[Phi] [equivalence] ??F ??[Phi];

-- H[Phi] [equivalence] ??P ??[Phi].

If the temporal logic has the begin property (e.g., stating that the temporal domain is bounded in the past, as discussed in the sequel), the operator until is enough to complete the logic's expressiveness: when the past is limited, the operator since is not necessary. Relationships among events in the past can be expressed by using until, starting from the beginning of time (from a fixed reference time instant).

Other common operators are next and prev, represented by [circle] and ??, respectively. These operators are unary and can be defined in terms of the until and since operators:

-- [circle] [Phi] [equivalent] [perpendicular to] until [Phi]

-- ?? [Phi] [equivalent] [perpendicular to] since [Phi]

These two operators assume different meanings depending on the time structure, for example, discrete or continuous, or whether the logic is event-based.

The presence of distinct operators for the past and future simplifies the specification model, since with their use formulas can be written easily--for instance, evaluating the past and describing the future. On the other hand, this distinction is only a convention, since in most temporal logics formulas can easily be shifted to the past or to the future.

3. MAIN CHARACTERISTICS OF TEMPORAL LOGICS

This section presents the evaluation criteria used to compare the temporal logics discussed in the following sections. We provide a taxonomy to classify and evaluate the suitability of temporal logics for specifying real-time systems. Temporal logics are typically used in phases of requirements analysis, advanced analysis, specification, and more recently, even for execution. They focus on modeling system behavior rather than functional or structural aspects [Bucci et al. 1995]. The structural aspect refers to system decomposition into subsystems (modular-temporal logics). The functional aspect deals with the data transformation of the system. Behavior refers to the system's reaction to external stimuli and internal events, a critical aspect of reactive and real-time systems.

To use temporal logics for real-time system specification, it is necessary to evaluate their expressiveness in modeling the typical requirements of such systems and the constraints needed to express the specification. Typical temporal constraints can be divided in two main categories: (i) events and event orderings; and (ii) quantitative temporal constraints.

The following discusses the most important features of temporal logics and the criteria used to identify their general characteristics and properties.

3.1 Order of Temporal Logic

The order of a temporal logic is the order of classical logic on which the temporal logics is constructed. This characteristic dictates the set of formulas that the temporal logic can express. A higher order implies greater expressiveness but more complex formulas, and frequently the logic itself is less complete and decidable. For instance, propositional temporal logics are less expressive than higher order logics, but often propositional temporal logics are decidable and their decision procedures have a tractable complexity; whereas higher order logics are more expressive but much more complex. First order temporal logics usually permit one to write quite expressive formulas without overly increasing the complexity of the logic.

3.2 Temporal Domain Structure

As stated in Section 2.3, the main properties of a modal logic, and hence of a temporal logic, are related to the properties of relation R; the next section shows the structure of temporal domains derived from properties of relationship R. For temporal logics, relation R is called a precedence relation and is denoted by [is less than]. Properties that bear on the temporal domain structure are as follows:

transitivity

[inverted] Axyz.x [is less than] y [conjunction] y [is less than] z ?? x [is less than] z

nonreflexivity

[inverted] Ax.??x [is less than] x

linearity

[inverted] Axy.x [is less than] y [disjunction] x = y [disjunction] y [is less than] x

left linearity

[inverted] Axyz.y [is less than] x [conjunction] z [is less than] x ?? y [is less than] z [disjunction] y = z [disjunction] z [is less than] y

right linearity

[inverted] Axyz.x [is less than] y [conjunction] x [is less than] z ?? y [is less than] z [disjunction] y = z [disjunction] z [is less than] y

begin

[exists] x.?? [exists] y.y [is less than] x

end

[exists] x.?? [exists] y.x [is less than] y

predecessor

[inverted] Ax. [exists] y.y [is less than] x

successor

[inverted] Ax. [exists] y.x [is less than] y

density

[inverted] Axy.x [is less than] y ?? [exists] z.x [is less than] z [is less than] y

discreteness

([inverted] Axy.x [is less than] y ?? [exists] z.x [is less than] z [conjunction] ?? [exists] u.x [is less than] u ??) [conjunction]

([inverted] Axy.x [is less than] y ?? [exists] z.z [is less than] y [conjunction] ?? [exists] u.z [is less than] u [is less than] y)

Usually, [is less than] is a transitive and nonreflexive relationship; hence it is a partial ordering on time instants.

The property begin (end) states that the temporal domain is bounded in the past (future) [Halpern et al. 1983; Melliar-Smith 1987], whereas the property predecessor (successor) shows that the temporal domain is unlimited in the past (future). In fact, the following equivalencies hold:

([exists] x.?? [exists] y.y [is less than] x) ?? ?? ([inverted] Ax. [exists] y.y [is less than] x)

([exists] x.?? [exists] y.x [is less than] y) ?? ?? ([inverted] Ax. [exists] y.x [is less than] y)

A temporal domain is dense with respect to relationship [is less than] if between two instants there is always a third. But the temporal domain is discrete if there exist two instants between which a third cannot be determined.

If the precedence relation is linear, then we have a linear temporal structure that corresponds to the intuitive notion of time. This is the simplest type of temporal structure. In this case, the precedence relation is a total order on time instants. Figure 1 shows the temporal domain for a linear temporal structure with a unlimited past and future, with only a unlimited future and with only an unlimited past. If the time structure is linear and discrete, a state of the system can be associated with each time instant. If the time is dense, the logic must be event-based to support a state-based semantics.

[Figure 1 ILLUSTRATION OMITTED]

When the precedence relation [is less than] is only linear on the left, the temporal structure is more complex: branches can exist in the future (in other words, more than one future can exist for each instant), but there exists only one past (see Figure 2). If the time is discrete and its structure is branched a next state exists, but cannot be determined unequivocally.

[Figure 2 ILLUSTRATION OMITTED]

Temporal structures with branches in the past are also possible. If no hypotheses are made about linearity, branches in the future and in the past are possible.

The order relation of the structure is usually transitive and nonreflexive. The temporal domain may be limited in the past and/or in the future or be unlimited, and it may be dense or discrete. Thus, the temporal structure may be linear or branched in the past and/or in the future. These properties have implications for the decidability of the logic, its executability, and the style used to write formulas.

3.3 Fundamental Entity of the Logic

A basic way to characterize temporal logics in whether points or intervals are used to model time. This also influences the expressiveness of the logic.

Point-based temporal logics express relationships among events in terms of points. Point-based logics define intervals as a connected set of points. In point-based logics it is more difficult to express relationships between intervals in which certain events are verified. Time durations are expressed by using quantifications over time. Logics based on time points [Manna and Pnueli 1983; Rosner and Pnueli 1986] specify system behavior with respect to certain reference points in time; points are determined by a specific state of the system and by the occurrence of events marking state transition. In order to describe temporal relationships, the operators [] (henceforth) and [diamond] (eventually) are usually adopted to specify necessity and possibility, respectively.

Interval-based temporal logics (interval logics) are more expressive, since they are capable of describing events in time intervals, and a single time instant is represented with a time interval of one. Usually, interval-based logics permit one to write formulas with a greater level of abstraction, and so are more concise and easy to understand than point-based temporal logics. In the case of time intervals [Schwartz and Melliar-Smith 1982; Schwartz et al. 1983; Moszkowski 1986; Halpern et al. 1983; Halpern and Shoham 1986; Ladkin 1987]; Melliar-Smith 1987]; and Razouk and Gorlick 1989] formulas specify the temporal relationships among facts, events, and intervals, thus allowing a higher level of abstraction for system specification. Interval-based logics usually present specific operators to express the relationships between intervals (meet, before, after [Allen 1983]), and/or operators for combining intervals (e.g., the chop operator [Rosner and Pnueli 1986), or operators to specify the interval boundaries on the basis of the truth of predicates [Melliar-Smith 1987].

The qualitative relationships that may hold between intervals as classified by Allen and Ferguson [1994] are represented in Figure 3.

[Figure 3 ILLUSTRATION OMITTED]

The relationships among time points or intervals are typically qualitative, but quantitative temporal logics are preferable for the specification of real-time systems (e.g., RTL [Jahanian and Mok 1986]; MTL [Koymans 1990]; TRIO [Ghezzi et al. 1990]; and TILCO [Mattolini and Nesi 1996]).

3.4 A Metric for Time and Quantitative Temporal Constraints

The presence of a metric for time determines the possibility of expressing temporal constraints in a quantitative form in the logic formulas; without a metric for time, only temporal-order relations can be expressed (qualitative temporal logics).

The temporal operators presented in Section 2.4 are qualitative, since it is not possible to give an exact measure (i.e., duration, timeout) for events and among events. Temporal logics without a metric for time adopt a time model for which the events are those that describe system evolution (event-based temporal logics). Each formula expresses what the system does at each event, events are referred to other events, and so on: this results in specifying relationships of precedence and cause-effect among events.

Temporal logics with a metric for time allow the definition of quantitative temporal relationships--such as distance among events and durations of events in time units. The expression of quantitative temporal constraints is fundamental for real-time systems specification. It is necessary to have a metric for time if the temporal logic has to be used to express the behavior of hard or non-hard real-time systems. A typical way to add a metric for time is to allow the definition of bounded operators--for example:

[[diamond].sub.[4, 7]] A

for stating that A is eventually true from 4 to 7 time instants from the current time, or [[diamond].sub.[is less than or equal to] 5] A, which means that A is eventually true within 5 time units. A different method is based on the explicit adoption of a general system clock in the formulas (see Section 3.6).

A different way to manage time quantitatively is to adopt the freeze quantifier [Alur 1992], which allows only references to times that are associated with states. This means that freeze quantifier "x." differs from the FOL quantification over time. For instance:

[]x. (p [right arrow] [diamond] y. (q [disjunction] y [is less than or equal to] x + 6))

This means that in every state with time x, if p holds, then there is a future state with time y such that q holds and y is at most x + 6. Logics allowing freeze quantification are called half-order logics.

In specifying real-time systems, the general behavior of the system is typically expressed by means of quantitative temporal constraints. The correct behavior of the system depends on the satisfiability of these temporal constrains.

In Koymans [1990], a classification of temporal constraints with respect to event occurrences has been proposed. In particular, we can specify constraints for establishing relationships between the occurrence of

(1) an event and a corresponding reaction (reaction time). Typical cases are

-- maximum distance between event and reaction (e.g., timeout);

-- exact distance between event and reaction (e.g., delay);

(2) the same event (period). Typical cases are

-- minimum distance between two occurrences of an event;

-- exact distance between occurrences of an event.

This classification can be simplified by reducing the types of temporal constraints to only two elementary constraints:

-- universal temporal quantifier [[].sub.i]A means that A is true in all time instants of interval i;

-- existential temporal quantifier [[diamond].sub.i]A means that A is true in at least one time instant in interval i;

where A is a temporal logic formula and i is an interval that can either be a set of points or a fundamental entity whose extremes are expressed quantitatively (see Figure 4). By using these two elementary operators most of the possible temporal requirements of real-time systems can be expressed. For example.

[Figure 4 ILLUSTRATION OMITTED]

-- when A happens, B must happen within t time units: A ?? [[diamond].sub.(0, t)] B

-- when A happens, B must happen after t time units: A ?? [[].sub.[t, t]]B

-- the distance between two occurrences of event A is at least t time units: A ?? [[].sub.(0, t)] ??A

-- the distance between two occurrences of event A is always equal to t time units:

A ?? ([[].sub.(0, t)] ??A) [conjunction] ([[].sub.[t, t]]A)

where intervals are specified using the usual mathematical notation, with round and squared brackets used for excluding and including bounds, respectively. The intervals are defined relative to the instant in which formulas are evaluated, so the time is implicit.

The above two elementary temporal operators are sufficient for expressing safeness or liveness. For example, the classical safety conditions such as [[].sub.i]A (where A is a positive property) must be satisfied by the system specification, where the interval i can be extended to the specification temporal domain as well as to only a part of it. Liveness conditions such as [[].sub.i]A (A will be satisfied within i), or deadlock-free conditions such as [[].sub.j]([[].sub.i] ?? A) can also be specified.

If unbounded intervals are allowed, operators [], [diamond], [solid square], and [solid diamond] can be defined as

-- [] [Phi] [equivalent] [[].sub.(0, +[infinity])] [Phi];

-- [diamond] [Phi] [equivalent] [[diamond].sub.(0, +[infinity])] [Phi];

-- [solid square] [Phi] [equivalent] [[].sub.(-[infinity], 0)] [Phi].

-- [solid diamond] [Phi] [equivalent] [[diamond].sub.(-[infinity], 0)] [Phi].

Certain temporal logics also provide bounded versions of the operators since and until. These versions can be easily obtained from the unbounded operators since and until and the bounded operators henceforth and always.

Some other temporal logics are much more oriented towards presenting the behavior of predicates intended as signals. These logics have frequently been used for modeling digital signals and are typically based on intervals. In order to relate the definition of an interval for bounding predicates with the evolution of other predicates, a special operator for capturing the time instant related to events is needed. This special function from Predicate [right arrow] Time is frequently introduced by using special operators.

3.5 Events and Ordering of Events

Typical relationships of cause-effect can be specified by using the simple operators imply (??) and co-imply (??). Moreover, the simpler operators of temporal logic (i.e., [] and [diamond]) can profitably be used for describing facts and rules. A fact is a predicate that is true at least for a time (e.g., presence of an event), while a rule is a predicate that is true in all time instants. These operators are unsuitable for specifying relationships of ordering among events, such as

(a) A precedes B;

(b) A follows B;

(c) A will be true until B will become true for the next time;

(d) A has been true since the last time that B was true for the last time;

where A and B are temporal logic formulas. In Figure 5, graphical representations of (a) through (d) are shown, where T represents the instant in which formulas are evaluated. Constraints (c) and (d) may be described by using operators until and since, respectively. The precedence relation in the future (past) may be defined with operator until (since), as shown by Manna and Pnueli [1983], defining operators precede and follow:

(2) A precede B [equivalent] ?? ((??A) until B)

A follow B [equivalent] ?? ((??A) since B).

[Figure 5 ILLUSTRATION OMITTED]

Therefore, in order to express the ordering between events, the temporal logic has to provide the operators until and since.

In effect, several versions of until and since operators exist. The typical definition of the until/since operator is the "weak" definition:

-- A [until.sub.w] B -- is true if B will become true and until that instant A will be true, or if B will stay always false and A always true.

-- A [since.sub.w] B -- is true if B has been true since the instant in which A became true, or if B has been always false and A always true.

The strong version of these operators assumes the occurrence of the change of status for B. Therefore, they can be defined in terms of the above operators as follows:

-- A until B [equivalent] [diamond] B [conjunction] A [until.sub.w] B

-- A since B [equivalent] [solid diamond] B [conjunction] A [since.sub.w] B

Different versions can be defined, and the current time can also be included in the evaluation range of the operators. In this case, the so-called 0 version of the weak version of the operators can be defined as follows:

-- A [until.sub.w0] B [equivalent] B [disjunction] (A [conjunction] A [until.sub.w] B)

-- A [since.sub.w0] B [equivalent] B [disjunction] (A [conjunction] A [since.sub.w] B)

Other versions can be defined for combinations of the basic versions stated above.

3.6 Time Implicit, Explicit, Absolute

Time in temporal logics can be defined in an implicit or explicit manner. A time model is implicit when the meaning of formulas depends on the evaluation time, and this is left implicit in the formula. For instance, [] A means that

[inverted] At [element of] [[T.sub.0], [infinity]].A(t)

where [T.sub.0] is the evaluation time (the so-called current time instant). When time is implicit, the formalism is able to represent the temporal ordering of events. Each formula represents what happens in the evaluation time (e.g., in the past or in the future of the evaluation time), which is the implicit current time:

[diamond][[].sub.[3, 5]] A

means that A will be eventually true in the future for an interval of 3 to 5 time units later with respect to the evaluation time. If time is treated implicitly, the possibility of referring the specification to an absolute value of time is usually lost. Temporal logics with time implicit may or may not allow the quantification over time (e.g., TRIO allows quantification over time and adopts a implicit model of time).

But when the time is explicit, the language represents the time through a variable. In this way, it is possible to express any useful property of real-time. The explicit specification of time allows the specification of expressions that have no sense in the time domain--e.g., the activation of a predicate when the time is even.

The reference to time can be absolute or relative. It is considered absolute when the value of the current time is referenced to a general system clock (the clock is idealized in the sense that no drift is supposed). It is frequently represented with T; for example, in the following formula an absolute explicit model of time is used:

[inverted] A t.[] (E [conjunction] T = t) [right arrow] [diamond] (A [conjunction] T - t [is less than] 10ms)

where E is an event. When time is expressed in absolute form, time durations and deadlines are given directly in seconds or milliseconds (i.e., the absolute time on the clock). Therefore, meeting timing constraints depends on the context (machine type, number of processes, workload, etc.).

The formula that follows has a relative explicit model of time:

[inverted] A t.[] (E [conjunction] T = t) [right arrow] [diamond] (A [conjunction] T - t [is less than] 10)

Time is frequently expressed in a relative manner; that is, time durations and deadlines are given in time units. In this case, the relationship between these time units and the absolute measure of time expressed in seconds (or milliseconds) is left until the implementation phase. However, the validation of specifications becomes almost implementation independent. A different definition for absolute and relative time is reported in Koymans [1990].

3.7 Logic Decidability

The decidability of a temporal logic is related to the concepts of validity and satisfiability. A formula is satisfiable if there exists an interpretation for the symbols in the formula for which the formula is true, whereas a formula is valid if for every interpretation the formula is true. This feature is strongly related to the order of the logic. First-order (discrete time) temporal logic is incomplete, and validity and satisfiability problems are undecidable in the general case. This is mainly due to the quantification of time-dependent variables. The prohibition of this kind of quantification has often been shown to be a necessary condition for the existence of feasible automated verification mechanisms such as in TPTL [Alur and Henzinger 1990].

Satisfiability (validity) is a decidable problem for a logic if there exists a decision procedure for the satisfiability (validity) of every formula of the logic. If one of these problems is decidable for the logic, then the proof of theorems may be automatic. This property is highly desirable because it increases the logic's usability, since automatic instruments to verify and validate specifications can be built. This property is much more useful for temporal logics that are based on property proofs for the verification and validation of system properties. The adoption of a theorem prover confers an absolute certainty regarding the behavior of the system.

Other temporal logics have semantics defined in terms of state evolution. This makes their application much more operational than descriptive [Bucci et al. 1995]. For these models, verification and validation activities are typically performed by using model-checking techniques. Unfortunately, for real systems, the verification of system behavior in all its states can be infeasible because it is too complex and time consuming, even using symbolic model-checking algorithms. A semantics based on state is frequently associated with the presence of an event-based temporal logic or of a discrete linear model of time. In both these cases, the definition of an operational semantics for the temporal logic is quite simple.

3.8 Deductive System sound and complete

As expressed in Section 2.1, a deductive system is a formalization of the deduction process that is usually used to make proofs manually. A deductive system permits one to build proofs manually in a simpler way and provides the basis for automating some simple rewriting of formulas. These mechanisms are typically used in automatic and semiautomatic theorem provers. Naturally, it must be proved that this deductive system is sound, so that all proofs built are correct.

Another desirable but less "necessary" property is the completeness of the deductive system; that is, the capacity to build a proof for every theorem true for the logic. It should be noted that it is never possible to build a complete deductive system: for example, the theory of natural numbers on FOL is sound but not complete; that is, there are nonprovable true formulas [Davis 1989].

3.9 Logic Specification Executability

The problem of executability of specifications given by means of temporal logics has often been misunderstood. It mainly depends on the meaning assigned to executability [Fisher and Owens 1995; Moszkowski 1986; Barringer et al. 1996]. There are at least three different definitions of executability, as follows:

(i) Specification models are considered to be executable if they have a semantics defining an effective procedure capable of determining for any formula of the logic theory whether or not that formula is a theorem of the theory [Moszkowski 1986]. In effect, this property corresponds to that of decidability of the validity problem, rather than to that of system specification executability.

(ii) A second meaning refers to the possibility of generating a model for a given specification [Felder and Morzenti 1992]. A detailed version of this concept leads to verifying if an off-line generated temporal evolution of inputs and outputs is compatible with the specification. This operation is usually called history-checking.

(iii) The last meaning for executability consists of using the system specification itself as a prototype or implementation of the real-time system, thus allowing, in each time instant, the on-line generation of system outputs on the basis of present inputs and its internal state and past history. When this is possible, the specification can be executed directly, instead of transforming it in a program.

In the literature, there exists only few executable temporal logics that can be used to build a system prototype according to meaning (iii) of executability. In general, the execution or simulation of logic specifications with the intent of producing system outputs in the correct time order by meeting the temporal constraints is a quite difficult problem. The difficulty mainly depends on the computational complexity of the algorithms proposed.

Moreover, while executing propositional temporal logics is a complex task, executing first-order temporal logics is undecidable and highly complex [Fisher and Owens 1995; Merz 1993]. A solution for executing propositional temporal logics could be (a) to restrict the logic and provide an execution algorithm for the remaining part, or (b) to execute the complete logic by using specific inferential rules and/or backtracking techniques. For first-order temporal logic, the solution can be to apply the same approaches used for propositional temporal logics or to try to build a model for the formula as in (i) and (ii), above.

If a temporal logic is executable, the system can be simulated and/or executed. Thus, it is possible to validate system behavior through simulation and to use the system specification as a prototype, or as an implementation if the execution speed is high enough to satisfy temporal constraints of the system.

4. A SELECTION OF TEMPORAL LOGICS

This section presents a selection of the most interesting types of temporal logics for the specification of real-time systems. There are many other temporal logics in the literature, but most of them can be regarded as generalizations or specializations of those discussed herein.

The order in which the logics are presented is quite close to chronological, from the earliest to the latest, from the simplest to its more complex evolutions (if present). Several examples are given in order to make the comparisons among the temporal logics possible. The section concludes with a brief discussion of the logics and a table for comparison purposes.

4.1 PTL: Propositional Temporal Logic

Propositional Temporal Logic (PTL) introduced by Pnueli [Pnueli 1977; 1981; 1986]; (see also Ben-Ari [1993]) extends the propositional logic by introducing temporal operators [], [diamond], [circle], and U. The propositions of PTL describe temporal relationships between states that characterize the temporal evolution of the system. PTL is an event-based logic and does not provide a metric for time.

System requirements are specified by describing a set of constraints on the event sequences that occur in the system, thus modifying its state. Time consists of a sequence of instants corresponding with the sequence of states of the system. In a certain sense, the fundamental entity of the logic is the instant in which the state of the system changes. For these reasons it is particularly suitable for integration in operational models such as state machines [Bucci et al. 1995].

The temporal structure of PTL is linear, bounded in the past (an initial instant exists), unbounded in the future (an infinite sequence of future states exists), and discrete (i.e., the set of instants is modeled with the set of natural numbers). For this reason, only temporal operators in the future are present. The temporal operators [], [diamond], and U correspond to the operators G, F, and until described in Section 2.4. The formula [circle] [Phi] is a valid formula if the formula [Phi] is true in the next state. Operator until in PTL is equivalent to [until.sub.0] in Section 3.5. Since PTL provides the operator until, it is possible to specify real-time system requirements about the order of events in the future. The asymmetry of the logic (due to the boundary in the past) and the absence of the operator since does not permit specification of requirements about the order of events in the past. Moreover, the absence of a metric for time does not allow specification of any type of quantitative temporal constraint. Therefore, PTL is much more suitable for use with reactive and concurrent systems than with real-time systems. Reactive systems are typically event-driven, and do not present quantitative temporal constraints such as timeouts or deadlines.

PTL is decidable (for example, using a decision procedure based on the semantic tables method), and it is possible to build a sound and complete deductive system for the logic. In the literature, methods or instruments for executing PTL formulas have not been presented and, in general, these formulas are not executable.

Manna and Pnueli [1990] proved that for an extension of PTL built adding symmetric operators in the past for [solid square] [solid diamond], [solid circle], and L, it is possible to transform formulas of a particular class in finite state machines, thus permitting the execution of some formulas of this extension of PTL.

Table I shows some examples of the extended version of PTL. The table also shows a set of specifications that cannot be expressed by using this temporal logic. In the next sections, similar tables are provided to allow comparison of the several temporal logics on the basis of a collection of equivalent specifications.
Table I. Some Specifications in PTL

meaning                             PTL

Always A in the Past                [solid circle] [square] A

Always A in the Future              [circle] []A
Always A                            [square] A [conjunction] []A
A Since Weak B                      [solid circle](ALB
                                      [disconjunction] [square] A)
A Until Weak B                      [circle](AUB [disconjunction]
                                      []A)

Last A up to [t.sub.1]              -
Lasted A from [-t.sub.1]            -
A Within [-t.sub.1] in the Past     -
A Within [-t.sub.1] in the Future   -

A Within ([-t.sub.1], [t.sub.2])    -
A Was true in                       -
  ([-t.sub.1], [-t.sub.2])
A will be true in
  ([-t.sub.1], [t.sub.2])
A Could be true in
  ([-t.sub.1], [t.sub.2])

A Since B during                    -
  ([-t.sub.1], [-t.sub.2])
A Until B during                    -
  ([t.sub.1], [t.sub.2])


In Barringer et al. [1990; 1991]; and in Finger et al. [1993], METAMEM is presented. METATEM includes an executable model and algorithm, and can be considered to be based on an extended version of PTL.

4.2 Choppy Logic

Choppy Logic presented by Rosner and Pnueli [1986] is an extension of PTL obtained by adding operator C(chop). This logic has all characteristics of PTL, and enhances its expressiveness with operator C, which permits one to concatenate state sequences. In the first approximation, the Chop operator can be regarded as an operator for dividing time intervals. In particular, a state sequence [Sigma] is a model for formula [Phi] C [Psi] if it can be divided in two sequences [Sigma]' and [Sigma]" such that: [Sigma]' is a model for [Phi], and [Sigma]" is a model for [Psi]. This logic has a greater expressiveness than PTL, but a more complex decision procedure is required. Thus, Choppy logic maintains all the merits and problems of PTL.

4.3 BTTL: Branching Time Temporal Logic

Branching Time Temporal Logic (BTTL), introduced by Ben-Ari et al. [1983] is an extension of PTL. It has a temporal structure with branches in the future, and thus could be used for describing the behavior of nondeterministic systems. PTL operators are enhanced to deal with branches. Four operators have been defined to quantify both on different evolution traces and states that are present on the selected traces:

-- [inverted] A[], for all traces [Pi] and for all states s [element of] [Pi];

-- [exists] [], for at least one trace [Pi] and for all states s [element] [Pi];

-- [inverted] A [diamond], for all traces [Pi] and at least one state s [element of] [Pi];

-- [exists] [diamond], for at least one trace [Pi] and for at least one state s [element of] [Pi].

In several aspects BTTL is practically equivalent to PTL. Moreover, it adopts a temporal structure branched in the future. BTTL also presents a complete axiomatization; it is decidable, and the satisfiability of formulas can be determined by using a method based on semantic tables that also produces models for the BTTL formulas. The models for the formulas are finite, and could be used to build finite state machines corresponding to the formulas. This makes the model operationally executable. Even with this improvement of PTL, it is not possible to specify quantitative temporal constraints. Thus, this logic is also not suitable for real-time systems specification.

4.4 ITL: Interval Temporal Logic

Interval Temporal Logic (ITL) introduced by Halpern et al. [1983] and used and studied further by Moszkowski and Manna [1984]; Moszkowski [1985; 1986] can be considered as an extension of PTL. ITL is a propositional logic with a temporal structure that is bounded in the past, unbounded in the future, discrete, and linear. The fundamental entity of ITL is the interval made of a sequence of states. The length of an interval is defined as the number of states in the sequence. ITL does not provide a metric for time, and can be considered an event-based logic. It has been applied for modeling the evolution of digital signals. ITL extends propositional logic with the operators [circle] (next), [], [diamond], and ";" (chop, analogous to operator C of Choppy logic). The semantics of all these operators is defined in terms of intervals rather then of states, as in PTL. From the above basic operators, a set of derived operators has been defined. The presence of operator chop makes the satisfiability of ITL formulas undecidable; nevertheless, the satisfiability is decidable for a particular subclass of ITL formulas. It is possible to build a sound deductive system for ITL.

Tempura is presented in Moszkowski [1986]. It is a subset of ITL formulas with some syntactic properties, for which the problem of building an execution for formula is tractable, even if unsolvable, in the general case. In ITL, only order properties showing qualitative relationships among the order of events can be specified. This makes this logic less powerful for specifying realtime systems. To specify order properties, the operator chop must be used since ITL does not have operator until. As a surrogate of the metric for time, a special operator Len(n) is used to count the number of states in a sequence. This allows one to specify the exact duration in terms of the number of transitions among events.

4.5 PMLTI: Propositional Modal Logic of Time Intervals

Propositional Modal Logic of Time Intervals (PMLTI) presented by Halpern and Shoham [1986] is a temporal logic that extends propositional logic. The fundamental temporal entity is the interval and the temporal operators can express the possible relationships between intervals, as reported in Figure 3. The temporal structure requires only the total order of the points in the intervals. With this limitation, the time structure can be linear or branched, bounded or unbounded, dense or discrete. PMLTI does not provide an explicit metric for time. The selection of a specific temporal structure leads to implications about the complexity of the decision procedure for demonstrating the validity of formulas. The problem of validity and satisfiability of PMLTI formulas may be decidable or undecidable, depending on the temporal structure chosen.

PMLTI uses a method of translating temporal logic formulas in FOL formulas of a specific deductive system to proof theorems of the logic. This approach enables application of all the techniques available for first-order logic. To date, the problem of formula executability has not been addressed. The presence of operators for the specification of relationships between intervals permits one to easily express event order constraints. However, the absence of a metric for time makes the expression of quantitative temporal constraints impossible.

4.6 CTL: Computational Tree Logic

The Computational Tree Logic (CTL) presented by Clarke et al. [Clarke et al. 1986; Clarke and Grumberg 1987; Stirling 1987] is a propositional branching time temporal logic. The fundamental temporal entity is the point, and presents specific operators for reasoning about the system behavior in terms of several futures, called sequences. It is very similar to BTTL. CTL does not provide an explicit metric for time. For verifying CTL specification a model-checking approach is typically used since the specification can be modeled as a state machine [Clarke et al. 1986]. In Emerson and Halpern [1986] and Emerson et al. [1989], a real-time extension of CTL has been presented, RTCTL, presenting a metric for time. The satisfiability problem for this logic is doubly exponential. The model-checking has a polynomial time algorithm [Ostroff 1992]. In Josko [1987], a modular version of CTL has been presented, MCTL.

4.7 IL: Interval Logic

Interval Logic (IL) presented by Schwartz et al. [1983] and Schwartz and Melliar-Smith [1982] is based on time interval and propositional logic. The temporal structure is linear, bounded in the past and unbounded in the future. IL does not present an explicit metric for time. Time intervals are bounded by events and by the changes of system state described by the formulas. Therefore, IL is an event-based logic. A typical IL formula is in the following form:

[I][Alpha],

where [Alpha] is a formula and I is the interval that is the context in which formula [Alpha] has to be verified. This formula means that the next time the interval can be built, formula [Alpha] will hold in it. The most interesting feature of IL is the set of instruments that can be used for the determination and construction of time intervals. It presents bounded versions of operators [diamond] and []. The bound is defined by means of the interval: [I] [diamond] [Alpha] means that [Alpha] can be true in I. The interval bounds can be defined by the occurrence of events. Given an interval, the initial and final intervals can be extracted. Moreover, the existence of an interval with certain characteristics is an event. Finally, to describe system behavior, operators at, in, and after have been defined; these specify the truth at the start, during, and at the end of the interval, respectively. They may be used as events for constructing intervals. For instance, A ?? as interval means that the interval starts when A starts and ends at the end of the context.

Results for testing the executability of IL do not exist because IL was introduced as a specification language and is verified by means of automatic instruments, without taking into consideration the possibility of simulating or executing the specifications. IL permits one to easily write constraints about the order of events using the instruments for the construction of context intervals, but it cannot be used to specify quantitative temporal constraints, as can the extensions discussed in Sections 4.8 and 4.9.

4.8 EIL: Extended Interval Logic

Extended Interval Logic (EIL) was introduced by Melliar-Smith [1987]. It extends IL by adding the possibility of specifying some types of quantitative temporal constraints. These extensions were introduced to eliminate IL's inability to express the typical requirements of real-time systems. The first extension is the possibility of defining an event from another event at a constant temporal distance (positive or negative): if E is an event, then E + 1sec is also an event. The second extension is the possibility of limiting the length of intervals. For example, formula [is less than] 2sec is true if the interval in which it is evaluated has a duration of less than 2 seconds, while [is greater than] 10min is true if the interval has a duration greater than 10 minutes. The extensions introduced add the capability of expressing some of the quantitative temporal constraints that are needed to specify real-time systems. For instance,

[][E ?? *endA]([is less than] [t.sub.e] [conjunction] *startA)

means that, for each occurrence of event E, predicates startA and endA (marking an interval in which A is true) hold, and this interval is included from the occurrence of the E and [t.sub.e] (see Figure 6, in which [t.sub.0] is the time instant in which E occurs). In the above formula, operator * can be read as exists an occurrence of, while ?? means that the left bound of the interval is defined by the occurrence of event E.

[Figure 6 ILLUSTRATION OMITTED]

4.9 RTIL: Real-Time Interval Logic

Real-Time Interval Logic (RTIL) presented by Razouk and Gorlick [1989] is another extension of IL. In this case the goal is to permit the specification of real-time systems with the specific intention of verifying the consistency between the execution traces and the system specification itself. RTIL extends IL by introducing a metric for time. It can assign a temporal value to the extremes of the intervals and can construct intervals by assigning numerical values at interval bounds, not only by using events and state changes. Moreover, it is possible to measure the interval duration. This characteristic makes RTIL interesting for the specification of realtime systems. For example, the specification in Figure 6 can be written as

[][?? E [right arrow] [t.sub.e])* (?? startA ?? ?? endA)

In this case, operator * has to be read as exists a subinterval. The special operator ?? A extracts the time instant in which A becomes true. endA and startA have the same meanings as in EIL. Instants can be specified absolutely or relative to the beginning of the current context. RTIL also permits quantification over finite domains. This feature does not enhance the expressiveness of the logic, but simplifies the writing of complex and repetitive formulas.

4.10 LTI: Logic of Time Intervals

Logic of Time Intervals (LTI) of Allen and Ferguson [1994] is an interval temporal logic of the second order. It is also called Interval Time Logic (acronym ITL). To avoid confusion with the ITL presented, it is referred to in this paper as LTI. Intervals can be divided into subintervals. Intervals that cannot be further divided into subintervals constitute moments. The logic permits quantification of temporal intervals. The temporal structure is linear, without any further limitations, even the model of time can be either discrete or dense. LTI does not provide an explicit metric for time. Temporal propositions are made by declaring the order relationships between intervals (see Figure 3). In Ladkin [1987], it is shown that LTI theory is incomplete and proposes a way to make it complete. Furthermore, it is shown that both the theories, the new and complete and the early and incomplete versions, are decidable. An axiomatic system is provided for both, although there are no known results about logic executability. LTI does not present problems for ordering constraints regarding the expression of typical temporal constraints of real-time systems. Specification of quantitative temporal constraints is impossible, since the measure of the length of intervals is missing.

4.11 RTTL: Real-Time Temporal Logic

Real-Time Temporal Logic (RTTL) by Ostroff and Wonham [1987], Ostroff [1989], Ostroff and Wonham [1990], and Ostroff [1992] extends PTL with proof rules for real-time properties. The temporal structure is linear and discrete; the fundamental entity is the point. Time is limited in the past and unlimited in the future. Time is defined with both a sequence of state and a sequence of temporal instants. The presence of a state-based model makes RTTL particularly suitable for model-checking techniques; thus it can be used as a model to verify small systems. A natural number is associated with each time instant; thus RTTL is based on an explicit model of time. The clock of the system is periodically incremented and is accessible for writing formulas. State changes can occur: (i) corresponding to changes of time of system, or (ii) between two successive instants. In the case in which more events occur between two successive instants, these events are distinguishable for the order in which they occur only, and not for the temporal instant associated with the occurrences. For this reason the metric for time is only partial: nonsimultaneous events that occur for the same value of the system clock may exist. Operator until of PTL and operator until of RTTL are equivalent to [until.sub.0] in Section 3.5. In RTTL, quantification of rigid variables is allowed. Rigid variables are variable in the set of possible executions, but are constant for each execution. RTTL is a first-order logic. For RTTL, it is essential that the system clock (T) value be referenced in formulas to express some kinds of concepts, such as to establish relationships between different temporal contexts. Table II shows some RTTL specifications; no specifications involving the past are shown since RTTL presents only the future.
Table II. Some Specifications in RRTL

meaning                            RTTL

Always A in the Past               -
Always A in the Future             [circle] []A
Always A                           -
A Since Weak B                     -
A Until Weak B                     [circle] (AUB) [disjunction]
                                     []A

Lasts A up to [t.sub.1]            t = T [right arrow] []((t < T
                                     [conjunction] T < t +
                                     [t.sub.1]) [right arrow] A)
Lasted A from [-t.sub.1]           -
A Within [-t.sub.1] in the Past    -
A Within [t.sub.1] in the Future   t = T [right arrow]
                                     [diamond]((t < T
                                     [conjunction] T < t +
                                     [t.sub.1]) [conjunction] A)

A Within ([-t.sub.1], [t.sub.2])   -
A Was true in                      -
  ([-t.sub.1], [-t.sub.2])
A Will be true in                  t = T [right arrow] []((t +
  ([t.sub.1], [t.sub.2])             [t.sub.1] < T [conjunction]
                                     T < t + [t.sub.2])
                                     [right arrow] A)
A Could be true in                 t = T [right arrow]
  ([t.sub.1], [t.sub.2])             [diamond]((t + [t.sub.1] <
                                     T [conjunction] T < t +
                                     [t.sub.2]) [conjunction] A)

A Since B during                   -
  ([-t.sub.1], [-t.sub.2])
A Until B during                   t = T [right arrow] AU(B
  ([t.sub.1], [t.sub.2])             [conjunction] t + [t.sub.1]
                                     < T [conjunction] T < t +
                                     [t.sub.2]


All global variables (t in Table II) in formulas are assumed to be universally quantified [Ostroff 1991]. The logic also presents the next operator [circle]. "Lasts A up to [t.sub.1]" can also be written in a more concise notation [[diamond].sub.(0, [t.sub/1])]A, while "A Until B during ([t.sub.1], [t.sub.2])" can be specified as [MATHEMATICAL EXPRESSION NOT REPRODUCIBLE IN ASCII]. The situation in Figure 6 can be specified using

[MATHEMATICAL EXPRESSION NOT REPRODUCIBLE IN ASCII]

considering predicates startA and endA as above. Note the adoption of bounded operator [diamond]. The possibility of adopting (i) an explicit reference to the system clock value, and (ii) indirect quantifications on values assumed by the clock leads to the ability to write every type of ordering and quantitative constraints (the above example is implicitly quantified on t). This is extremely interesting for the specification of real-time systems. However, this flexibility leads to the production of formulas that are quite difficult to understand and manipulate with respect to other temporal logics that avoid quantification over time-dependent variables. A sound deductive system has been built for RTTL (extending a deductive system of PTL), but the satisfiability problem is undecidable. The suitability of RTTL for model-checking and the presence of a deductive system makes RTTL a dual model according to the classification reported in Bucci et al. [1995]. No results on the executability of RTTL specifications are available. TTM/RTTL is a dual approach obtained by the integration of a state machine model and RTTL [Ostroff and Wonham 1987; Ostroff 1989; Ostroff and Wonham 1990]. TTM is an operational model based on communicating finite state machines in which variables with arbitrary domains are used. The operations allowed are variable assignment, send, and/or receive. The state machine follows a Mealy model in which conditions on transitions between states are equivalent to logic formulas on state variables, while the output is an assignment to state variables.

4.12 TPTL: Timed Propositional Temporal Logic

Alur and Henzinger [1989] presented Timed Propositional Temporal Logic (TPTL); in 1990 they demonstrated the expressiveness and complexity of this logic. TPTL is an extension of PTL. Like PTL, TPTL is a propositional logic, where the instant is the fundamental temporal entity and the time is linear, discrete, limited in the past, unlimited in the future. An extension with respect to PTL is the presence of a metric for time: every instant corresponds to a natural number and a monotone function associates a temporal value with each state of the system, making timed state sequences possible. The presence of operator until permits one to specify order constraints. The possibility of specifying quantitative temporal constraints is one of the fundamental characteristics of the logic. For these reasons, this logic is suitable for specifying real-time systems requirements. Its theoretic base facilitates requirement verification and validation. Table III shows some specifications in TPTL. No specifications in the past are shown, since TPTL presents only the future. TPTL adopts the freeze operator, thus x and y represent time instants. The specifications are quite similar to RTTL. Adoption of the freeze operator can be very interesting to mode] systems in which more than a real-time clock is present. A typical application is the specification of communicating systems in which distinct specifications have to be synchronized (see APTL in Wang et al. [1993]).
Table III. Some Specifications in TPTL

meaning                            TPTL

Always A in the Past               -
Always A in the Future             [circle] []A
Always A                           -
A Since Weak B                     -
A Until Weak B                     [circle] (UBA [disconjunction]
                                     []A)

Lasts A up to [t.sub.1]            x.[].y.(x < y < x + [t.sub.1])
                                     [right arrow] A
Lasted A from [-t.sub.1]           -
A Within [-t.sub.1] in the Past    -
A Within [t.sub.1] in the Future   x.[diamond]y.(x < y < x +
                                     [t.sub.1]) [conjunction] A

A Within ([-t.sub.1], [t.sub.2])   -
A Was true in                      -
  ([-t.sub.1], [-t.sub.2])
A Will be true in                  x.[]y.(x + [t.sub.1] < y < x +
  ([t.sub.1], [t.sub.2])             [t.sub.2]) [right arrow] A
A Could be true in                 x.[diamond]y.(x + [t.sub.1] < y
  ([t.sub.1], [t.sub.2])             < x + [t.sub.2])
                                     [conjunction] A

A Since B during                   -
  ([-t.sub.1], [t.sub.2])
A Until B during                   x. [circle] Uy.B
  ([t.sub.1], [t.sub.2])             [disconjunction] (x +
                                     [t.sub.1] < y < x +
                                     [t.sub.2])A


The situation described in Figure 6 is specified in TPTL by using:

[]x.E [right arrow] ([diamond] y.endA [conjunction] y [is less than or equal to] x + [t.sub.e]) [conjunction] ??(U endA ?? startA)

considering predicates startA and endA as above. It has been proven [Alur and Henzinger 1990] that the choice of the set of natural numbers for a temporal domain is essential to obtaining a temporal logic for which the satisfiability problem is decidable. In fact, for every temporal domain with a more complex structure than natural numbers, the problem of satisfiability is undecidable. PTL's deductive systems can be extended and transformed for TPTL by retaining the properties of soundness and completeness. Moreover, a decision procedure based on the semantic table algorithm and a model-checking algorithm has been presented. This facilitates the use of this logic for the specification and verification of real-time systems requirements.

4.13 RTL: Real-Time Logic

The Real-Time Logic of Jahanian and Mok [1986] is a logic that extends first-order logic with a set of elements for the specification of real-time systems requirements. RTL proposes a logic approach for the specification of real-time systems, but is not a temporal logic in the classical sense. It presents an absolute clock to measure time progression. The value of this clock can be referenced in the formulas: function "@" permits one to assign a temporal value (execution instant) to an event occurrence. The temporal domain is the set of natural numbers, and is linear, discrete, limited in the past, unlimited in the future, and totally ordered. The fundamental entity is the time instant. In RTL, there are no problems in specifying ordering and quantitative temporal constraints, since it is possible to make explicit reference to time even through quantification. The main problem with RTL is the fact that absolute system time is referenced, with a low level of abstraction, leading to very complex formulas required to describe the system. The example of Figure 6 is specified in RTL by using

[inverted] At. [inverted] A.@([Omega]E, i) = t [right arrow] ([exists] j.(t [is less than or equal to] @([up arrow] A,j)) [conjunction] (@([down arrow] A,j) [is less than or equal to] t + [t.sub.e]))

Operator [Omega]E states the occurrence of external event E; [up arrow] A turning true from false of predicate/signal A; [down arrow] A the becoming false from true of A; i and j are the occurrences of the events marked with operator @; t is the time. Note the need for a quantification over time to specify the example. It is shown in Alur and Henzinger [1990] that RTL is undecidable even when the syntax is restricted. In Jahanian and Mok [1986], a procedure to demonstrate the consistency of safeness assertions relative to real-time system specification is proposed. A deductive system for RTL has not been presented, but it seems to be feasible by extending a system for FOL with laws for the new operators. There are no known results regarding the executability of RTL. In Armstrong and Barroca [1996], an approach based on RTL and Statechart is presented. In that case, formal verification is provided by using a theorem prover.

4.14 TRIO: Tempo Reale ImplicitO

TRIO is a logic language for real-time system specification (Tempo Reale ImplicitO, i.e., Implicit Real Time), presented by Ghezzi et al. [1990] and Felder and Morzenti [1994]. TRIO extends FOL with specific predicates for real-time system specification. The temporal structure is linear and totally ordered: possible temporal domains are the natural numbers, the integers, the real numbers, or an interval of one of these set. The fundamental temporal entity is the point and a metric for time is available. On that basis, it is possible to measure the distance of two points and the length of an interval. Since TRIO is an extension of FOL, which is undecidable, TRIO is also an undecidable logic. TRIO presents only two temporal operators: Futr(A, t) and Past(A, t) for specifying that A occurs at time instant t in the future and past, respectively (more recently it was demonstrated that both operators can be defined in terms of a unique operator). Moreover, based on these operators, several other operators in TRIO can be defined as parametric predicates. This is frequently allowed by many temporal logics, for example, TILCO, MTL. The temporal operators introduced by TRIO, with the possibility of quantification on temporal variables without any restriction, permit the expression of order and quantitative temporal constraints as needed for real-time systems specification. It is necessary to use quantification over the time domain, so formulas are often complex and difficult to read and manipulate. Table IV shows some specifications in TRIO, the table presents three columns. The middle column shows the specification written on the basis of TRIO's elementary operators, while the column on the right shows the version of the specification in a derived form. This derived form can be obtained by defining a new temporal operator (special parameterized predicate) with the specification in the middle column or by using already defined operators. It is possible to define new "temporal operators" by means of special functions: on the one hand, this keeps the size of formulas low, but on the other, makes the language harder to understand. A large number of operators can create confusion during the specification process, especially when these specifications have to be understood by other analysts who do not know the definitions of the same predicates implementing complex temporal operators.
Table IV. Some TRIO Simple Temporal Specifications

meaning         TRIO

Always Past     [inverted] At(t > 0 [right arrow] Past(A, t))

Always Future   [inverted] At(t > 0 [right arrow] Futr(A, t))

Always          [inverted] At(t > 0 [right arrow] Futr(A, t))
                [conjunction] A [conjunction] [inverted] At(t > 0
                [right arrow] Past(A, t))

Since Weak      [inverted] At"(t" > 0 [right arrow] Past(A, t"))
                [disjunction]
                [exists] t(t > 0 [conjunction] Past(B, t)
                [conjunction] [inverted] At' (0 < t' < t
                [right arrow] Past(A, t')))

Until Weak      [inverted] At"(t" > 0 [right arrow] Futr(A, t"))
                [disjunction]
                [exists] t(t > 0 [conjunction] Futr(B, t)
                [conjunction] [inverted] At' (0 < t' < t
                [right arrow] Futr(A, t')))

Lasts           [inverted] At'(0 < t' < t [right arrow]
                Futr(A, t'))

Lasted          [inverted] At'(0 < t' < t [right arrow]
                Past(A, t'))

Within Past     [exists] t'(O < t' < t [conjunction]
                Past(A, t'))

Within Future   [exists] t'(O < t' < t [conjunction] Futr(A, t'))

Within          [exists] t'(0 < t' < [t.sub.1] [conjunction]
                Past(A, t')) [disjunction] A [disjunction]
                [exists] t"(O < t" < [t.sub.2] [conjunction]
                Futr(A, t"))

Was             Past([inverted] At'(0 < t' < [t.sub.1] - [t.sub.2]
                [right arrow] Futr(A, t')), [t.sub.1])

Will be         Futr([inverted] At'(0 < t' < [t.sub.2] - [t.sub.1]
                [right arrow] Futr(A, t')), [t.sub.1])

Could be        Futr(??[inverted] At'(0 < t' <
                [t.sub.2] - [t.sub.1] [right arrow]
                Futr(-,A, t')), [t.sub.1])

A Since B       [exists] t(0 < [t.sub.2] < t < [t.sub.2])
                [conjunction] Past(B, t) [conjunction]

during          [inverted] At'(0 < t' < t [right arrow] Past(A, t'))
(-[t.sub.1],
-[t.sub.2])

A Until B       [exists] t(0 < [t.sub.1] < t < [t.sub.2])
                [conjunction] Futr(B, t) [conjunction]

during          [inverted] At'(0 < t' < t [right arrow]Futr(A, t'))
([t.sub.1],
[t.sub.2])

meaning         TRIO derived

Always Past     AlwP (A)

Always Future   AlwF (A)

Always          Alw (A)

Since Weak      [Since.sub.w](B, A)

Until Weak      [Until.sub.w](B,A)

Lasts           Lasts (A, t)

Lasted          Lasted (A, t)

Within Past     WithinP (A, t)

Within Future   WithinF (A, t)

Within          Within (A, [t.sub.1], [t.sub.2])

Was             Past (Lasts(A, [t.sub.1] - [t.sub.2]), [t.sub.1])

Will be         Futr (Lasts(A, [t.sub.2] - [t.sub.1]), [t.sub.1])

Could be        Futr (??Lasts(??A, [t.sub.2] - [t.sub.1),
                [t.sub.1])

A Since B
during          [Since.sub.B](B, A, [t.sub.1], [t.sub.2])
(-[t.sub.1],
-[t.sub.2])

A Until B
during          [Until.sub.B](B, A, [t.sub.1, [t.sub.2])
([t.sub.1],
[t.sub.2])


For TRIO, the example in Figure 6 is obtained by using

Alw(E [right arrow] [exists] t((0 [is less than] t [is less than] [t.sub.e]) [conjunction] Futr(endA, t) [conjunction] WithinF(startA, t)))

In this case, the specification was obtained by using a user-defined operator WithinF(); its definition is provided in Table IV. Even in this case quantification over time is needed. The same specification could be given by using operator until without the adoption of the quantification over time:

Alw(E [right arrow] WithinF(endA, [t.sub.e]) [conjunction] ??Until (endA, ??startA))

A deductive system for TRIO has been presented. This system was used to prove theorems for TRIO and to build a deductive system for Timed Petri Nets. TRIO has mainly been used for the validation and verification of system requirements through testing activity (history-checking), and not by means of the proof of system properties. TRIO has been described as an executable logic language in the general sense. It can be used to build a model of the system under specification as TRIO formulas. Histories of system variables can be checked against the specification in order to verify whether they satisfy the specification. So TRIO must be considered a specific case of model-checking and not a full execution according to the classification of Fisher and Owens [1995].

4.15 MTL: Metric Temporal Logic

Koymans [1990] presented Metric Temporal Logic (MTL) that extends FOL with temporal operators from modal logic: G, F, H, P. MTL includes a metric for time according to some properties that describe the structure of the temporal domain. One of these properties states that the order of the temporal structure has to be total, leading to a linear temporal structure. The fundamental entity of the logic is the temporal point. The presence of the metric for time permits one to modify the temporal operators making temporal versions of most of the temporal operators above: G, F, H, P. This allows one to reduce the need for quantifications on a temporal domain. The operators until and since can be obtained on the basis of the other operators as depicted in Table V. These provide support for avoiding the adoption of quantification over time. In Table V, some MTL specifications are given. MTL presents both past and future operators. The three columns in Table V have the same meaning as the table presented for TRIO (see Table IV).
Table V. Some Specifications in MTL

meaning                    MTL

Always A in the Past       HA

Always A in the Future     GA

Always A                   HA [conjunction] A [conjunction] GA

A Since Weak B             HA [disjunction] [exists] t(t [much
                           greater than] 0 [conjunction]
                           [P.sub.t]B [conjunction] [H.sub.<t]A)

A Until Weak B             GA [disjunction] (exists]t(t [much
                           greater than] 0 [conjunction]
                           [F.sub.t]B [conjunction] [G.sub.<t]A)

Lasts A up to t            [G.sub.<t] A

Lasted A from - t          [H.sub.<t] A

A Within - t in the Past   [P.sub.<t] A

A Within t in the Future   [F.sub.<t] A

A Within                   [MATHEMATICAL EXPRESSION NOT
(-[t.sub.1], [t.sub.2])    REPRODUCIBLE IN ASCII]

A Was true in              [MATHEMATICAL EXPRESSION NOT
(-[t.sub.1], -[t.sub.2])   REPRODUCIBLE IN ASCII]

A Will be true in          [MATHEMATICAL EXPRESSION NOT
([t.sub.1], [t.sub.2])     REPRODUCIBLE IN ASCII]

A Could be true in         [MATHEMATICAL EXPRESSION NOT
([t.sub.1], [t.sub.2])     REPRODUCIBLE IN ASCII]

A Since B during           [exists] t([t.sub.2] [much less than]
(-[t.sub.1], -[t.sub.2])   t [much less than] [t.sub.1]
                           [conjunction] [P.sub.t]B A [H.sub.<t]A)

A Until B during           [exists] t([t.sub.1] [much less than]
([t.sub.1], [t.sub.2])     t [much less than] [t.sub.2]
                           [conjunction] [F.sub.t]B A [G.sub.<t]A)

meaning                    MTL Derived

Always A in the Past

Always A in the Future

Always A

A Since Weak B             A since B

A Until Weak B             A until B

Lasts A up to t

Lasted A from - t

A Within - t in the Past

A Within t in the Future

A Within
(-[t.sub.1], [t.sub.2])

A Was true in
(-[t.sub.1], -[t.sub.2])

A Will be true in
([t.sub.1], [t.sub.2])

A Could be true in
([t.sub.1], [t.sub.2])

A Since B during           [MATHEMATICAL EXPRESSION NOT
(-[t.sub.1], -[t.sub.2])   REPRODUCIBLE IN ASCII]

A Until B during           [MATHEMATICAL EXPRESSION NOT
([t.sub.1], [t.sub.2])     REPRODUCIBLE IN ASCII]


The example shown in Figure 6 for MTL can be obtained by using

E [right arrow] [exists] t(0 [much less than] t [much less than] [t.sub.e] [conjunction] [F.sub.t] endA [conjunction] [F.sub.[is less than] t] startA)

The same specification could be written without adopting the quantification over time,

E [right arrow] [F.sub.[is less than] te] endA [conjunction] ??(??startA until endA)

As stated in Alur and Henzinger [1990], MTL is undecidable, but a deductive system is available. The MTL operators permit one to specify constraints on event order (until, since) and quantitative temporal constraints (G, F, H, P). The executability of MTL has not been discussed in the literature.

4.16 TILCO: Time interval Logic with Compositional Operators

Mattolini [1996] and Mattolini and Nesi [1996; 1999] presented TILCO (Time Interval Logic with Compositional Operators), a temporal logic for real-time system specification. TILCO extends the FOL and uses the interval as a fundamental temporal entity even if the interval is defined in terms of a couple of time instants. The temporal structure is linear and presents a metric for time that associates an integer number to every temporal instant; no explicit temporal quantification is allowed. In TILCO, the same formalism used for system specification is employed for describing high-level properties that should be satisfied by the system itself. These must be proven on the basis of the specification in the system-validation phase. Since TILCO operators quantify over intervals, instead of using time points, TILCO is more concise in expressing temporal constraints with time bounds, as needed in specifying real-time systems. The basic temporal operators of TILCO are the existential and universal temporal quantifiers (@ and ?, respectively), and operators until and since). These operators permit a concise specification of temporal requirements, relationships of ordering and quantitative distance among events; thus TILCO fully supports the specification of real-time systems. TILCO is also characterized by its compositional operators that work with intervals: comma ",", which corresponds to [conjunction], and semicolon ";", which corresponds to [disjunction] between intervals. Compositional operators "," and" ;" assume different meanings if they are associated with operators "@" or "?":

A@i,j [equivalent] (A@i) [conjunction] (A@j),

A?i,j [equivalent] (A?i) [conjunction] (A?j),

A@i;j [equivalent] (A@i) [disjunction] (A@j),

A?i;j [equivalent] (A?i) [disjunction] (A?j).

Other operators among intervals, such as intersection "[intersection]" and union "[union]" are defined by considering time intervals as sets. Table VI shows some specifications in TILCO. In this case, the table has only two columns; even in TILCO, special functions can easily be written for defining new temporal operators, as in TRIO and MTL. However, in TILCO this is less necessary, since TILCO specifications are quite concise, as can be seen by comparing Tables IV, V, and VI.
Table VI. Some Specifications in TILCO

meaning                            TILCO

Always A in the Past               A@(-[infinity], 0)
Always A in the Future             A@(0, [infinity])
Always A                           A@(-[infinity], [infinity])
A Since Weak B                     since (B, A)
A Until Weak B                     until (B, A)

Lasts A up to t                    A@(0, t)
Lasted A from -t                   A@(-t, 0)
A Within -t in the Past            A?(-t, 0)
A Within t in the Future           A?(0, t)

A Within (-[t.sub.1], [t.sub.2])   A?(-[t.sub.1], [t.sub.2])
A Was true in (-[t.sub.1],
  -[t.sub.2])                      A@(-[t.sub.1], -[t.sub.2])
A Will be true in
  ([t.sub.1], [t.sub.2])           A@([t.sub.1], [t.sub.2])
A Could be true in
  ([t.sub.1], [t.sub.2])           A?([t.sub.1], [t.sub.2])

A Since B during                   B?(-[t.sub.1], -[t.sub.2])
(-[t.sub.1], -[t.sub.2])           [conjunction] since(B, A)
                                   @[-[t.sub.2], -[t.sub.2]]
                                   [conjunction]
                                   A@[-[t.sub.2], 0)

A Until B during                   B?([t.sub.1], [t.sub.2])
([t.sub.1], [t.sub.2])             [conjunction] until(B, A)
                                   @[[t.sub.1], [t.sub.1]]
                                   [conjunction] A@(0,
                                   [t.sub.1]]


For TILCO, the condition depicted in Figure 6 can be specified by using

E [right arrow] endA ?(0, [t.sub.e]) [conjunction] ??until(endA, ??startA)

A sound deductive system for TILCO is presented in Mattolini [1996] and Mattolini and Nesi [2000]. This system is used in the context of the general theorem-prover Isabelle [Paulson 1994] to provide support for proving TILCO formulas. Using this formalization, a set of fundamental theorems was proven and a set of tactics built for supporting the semi-automatic demonstration of properties of TILCO specifications. Causal TILCO specifications are also executable by using a modified version of the tableaux algorithm. Since TILCO has aspects typical of both descriptive and operational semantics, it can be considered a dual approach, following the classification reported in Bucci et al. [1995]. Since TILCO extends FOL, it is undecidable in the general case. However, the subset of formulas that presents only quantifications on finite sets is decidable. Causal TILCO specifications can be executed with a modified version of a tableaux algorithm.

5. DISCUSSION

The main characteristics of the temporal logics reviewed in the previous sections are collected in Table VII. The following discussion considers two main aspects of the logics: the intrinsic power of expressiveness in terms of logic order and quantification over time variables and the readability/understandability of the logics.
Table VII. Comparing Features of Temporal Logics

                                                 Metric for
                                                 time/
                    Fundamental                  Quantitative
         Logic      time          Temporal       temporal
Logic    order(1)   entity(2)     structure(3)   constraints(4)

PTL         P            P             L               N
Choppy      P            P             L               N
BTTL        P            P             B               N
ITL         P            I             L               N
PMLTI       P            I            L/B              N
CTL         P            P             B               N
IL          P            I             L               N
EIL         P            I             L               Y
RTIL        P            I             L               Y
LTI        2nd           I             L               N
RTTL       1st           P             L              (Y)
TPTL        P            P             L               Y
RTL        1st           I             L               Y
TRIO       1st           P             L               Y
MTL        1st           P             L               Y
TILCO      1st           I             L               Y

         Logic             Deductive   Logic
Logic    decidability(4)   system(4)   executability(4)

PTL             Y              Y              Y
Choppy          Y             (Y)            (Y)
BTTL            Y              Y              Y
ITL            (Y)            (Y)            (Y)
PMLTI          (Y)            NA              NA
CTL             Y             NA              NA
IL              Y             NA              NA
EIL             Y             NA              NA
RTIL            Y             NA              NA
LTI             Y              Y              NA
RTTL            N              Y              NA
TPTL            Y              Y              NA
RTL             N             NA              NA
TRIO            N              Y             (Y)
MTL            (N)            (Y)             NA
TILCO          (Y)             Y             (Y)

         Ordering    Implicit,
Logic    events(4)   Explicit(5)

PTL          Y            I
Choppy       Y            I
BTTL         Y            I
ITL          Y            I
PMLTI        Y            I
CTL          Y            I
IL           Y            I
EIL          Y            I
RTIL         Y           (I)
LTI          Y           (I)
RTTL         Y            E
TPTL         Y           (E)
RTL          Y            E
TRIO         Y            I
MTL          Y            I
TILCO        Y            I


(1) P = propositional, 1st = first order, 2nd = second order;

(2) P = point, I = interval;

(3) L = linear, B = branching;

(4) N = no, (N)= no in the general case, Y = yes, (Y)=yes in some specific case, NA = not available;

(5) I = implicit, E = explicit.

The temporal logics discussed can be divided into two main categories: temporal logics without a metric for time and those with a metric for time. PTL, Choppy logic, BTTL, ITL, PMLTI, IL, CTL, and LTI belong to the first category. These logics are less satisfactory for the specification of real-time systems, since quantitative temporal constraints cannot be specified. In the second category, lie the following temporal logics: EIL, RTIL, RTTL, TPTL, RTL, TRIO, MTL, and TILCO. Some of these are characterized by the fact that they permit explicit quantification on the variable time, whereas it is not permitted for the others. In Alur and Henzinger [1989] it was observed that not permitting explicit quantification on time brings about a more natural specification style. Moreover, in Alur and Henzinger [1990], the impossibility of explicit quantification on time was demonstrated to be a necessary condition for the existence of a practically usable verification method, such as techniques based on tableaux. In fact, a logic that allows quantification over time has the expressive power of FOL and is undecidable. For this reason, in many cases logics like EIL, RTIL, TPTL, and TILCO are preferable to RTTL, RTL, TRIO, and MTL that permit quantifications over time. When a temporal logic allows the possibility of quantification on nontemporal variables (even with some limitations), it can be considered a first-order temporal logic. This is a great advantage, since it leads to a more expressive specification language and has a greater power of abstraction. Among the logics examined, only RTIL, RTL, TRIO, MTL, and TILCO permit quantification on nontime-dependent variables. More specifically, only RTIL and TILCO present the most complete collection of interesting characteristics for real-time systems specification (metric for time, expression of quantitative and events-order temporal constraints, no quantification over time). Both these logics do not permit quantification on time, but permit the quantification on nontime-dependent variables with finite domains. RTIL permits one to reference absolute time only, and then only indirectly in a relative manner. Moreover, the order of events is not complete, since events having a relationship of successor or predecessor can occur for the same value of the system clock. TILCO does not have these problems, and has a sound deductive system that supports the assisted proof of theorems and execution of formulas.

From the point of view of readability and understandability of temporal logic, it is highly relevant to evaluate two aspects: the number of elementary operators and the structure of the syntax. The first of these is quite objective, since a lower number of temporal operators is typically preferred. Temporal logics that have a high number of operators are, like programming languages, typically hard to learn and understand. Their expressiveness can be high, since a large collection of operators or temporal predicates can be very useful for specifying complex systems, but ease of learning and readability are low. It was previously shown that all the most useful specifications can be expressed by using a very low number of temporal operators. If these operators support a metric for time, their expressiveness is even higher. As a case limit, all the operators can be defined in terms of a measuring operator or modeled with delay. On the other hand, too low a number of temporal operators can produce the same effects, since complex specifications have to be built by using elementary operators even for very simple specifications. This means that a balance between the power of the temporal logic and the number of its temporal operators is needed. The number of operators also influences the syntax of the temporal logic. In some cases, the verbosity of temporal logic depends on the presence of a neat distinction between past and future, for example, extended PTL, TRIO, MTL. This distinction typically leads to duplication of the number of operators in order to have specific operators for past and future. When this distinction is not made, time can be considered only in the future, for example, RTTL, TPTL, or more general and flexible operators capable of working continuously from past to future are defined, for example, TILCO. In evaluating temporal logics, other interesting features can be the availability of (i) a graphical representation for the visual specification; (ii) support for structuring communicating processes. The visual representation of temporal specifications has frequently been addressed by researchers who have neglected the capabilities of temporal logics. Visual representation may make the readability of the specifications easier, but their real expressiveness is given by the above-mentioned features of temporal logics. An interesting integrated approach can be seen in Dillon et al. [1994] and in Moser et al. [1997]. The second aspect has been only marginally considered in this survey since, for many of the temporal logics presented, several researchers discussed the possibility of specifying process/subsystem communication. These cases should be considered very carefully, since the concept of communication directly implies the definition of a theory for supporting processes/modules. These can be processes (behavioral decomposition) or objects (structure decomposition). In any case, the complexity of these aspects cannot be described in a few pages.

6. CONCLUSIONS

In this article, a series of criteria for assessing the capabilities of temporal logics for the specification, validation, and verification of real-time systems are presented. On the basis of the adopted criteria, most of the temporal logics examined are found not fully satisfactory for the specification of real-time systems. The criteria proposed delineate some essential characteristics that an "ideal" temporal logic should have to be profitably adopted for the specification of real-time systems. This does not mean that temporal logics that do not have these features cannot be used for that purpose, but only that their adoption makes the specification of some temporal constraints hard and sometimes impossible. Frequently, if a temporal constraint cannot be specified as imagined by the analysis, it may be specified in some other way by using different constructs. According to our point of view and the trend in temporal logics in recent years, the following features should be available to build a temporal logic highly suitable for the specification of real-time systems. It should (i) be based on FOL; (ii) prohibit quantification on time variables; (iii) have a metric for time; (iv) use the interval as a fundamental time entity, since the interval can be seen as a generalization of the point; (v) have a model that is a relative time model and not absolute; (vi) have a limited number of basic operators and the possibility of building special functions.

REFERENCES

ABRAMSKY, S. AND MAIBAUM, T. S. E., Eds. 1992. Handbook of Logic in Computer Science (vol. 1): Background: Mathematical Structures. Oxford University Press, Inc., New York, NY.

ALLEN, J. F. 1983. Maintaining knowledge about temporal intervals. Commun. ACM 26, 11 (Nov.), 832-843.

ALLEN, J. F. AND FERGUSON, G. 1994. Actions and events in interval temporal logic. Tech. Rep. TR-URCSD 521. University of Rochester, Rochester, NY.

ALUR, R. 1992. Logics and models of real time: A survey. Tech. Rep. Department of Computer Science, Cornell University, Ithaca, NY.

ALUR, R. AND HENZINGER, T.A. 1989. A really temporal logic. In Proceedings of the 30th IEEE Conference on Foundatiions of Computer Science, IEEE Computer Society Press, Los Alamitos, CA.

ALUR, R. AND HENZINGER, T.A. 1990. Real time logics: Complexity and expressiveness. In Proceedings of the 5th Annual IEEE Symposium on Logic in Computer Science (LICS '90, June), IEEE Press, Piscataway, NJ, 390-401.

ANDREWS, P.B. 1986. An Introduction to Mathematical Logic and Type Theory. Academic Press series in computer science and applied mathematics. Academic Press Prof., Inc., San Diego, CA.

ARMSTRONG, J. AND BARROCA, L. 1996. Specification and verification of reactive system behavior: The railroad crossing example.qjReal-Time Syst. 10, 3, 143-178.

BARRINGER, H., FISHER, M., GABBAY, D., GOUGH, G., AND OWENS, e. 1990. METATEM: A framework for programming in temporal logic. In Proceedings of the REX Workshop on Stepwise Refinement of Distributed Systems: Models, Formalisms, Correctness (Mook, The Netherlands, May 29-June 2), J. W. de Bakker, W. P. de Roever, and G. Rozenberg, Eds. Springer Lecture Notes in Computer Science Springer-Verlag, New York, NY, 94-129.

BARRINGER, H., FISHER, M., GABBAY, D., AND HUNTER, A. 1991. Meta-reasoning in executable temporal logic. In Proceedings of the 2nd International Conference on Principles of Knowledge Representation and Reasoning, Morgan Kaufmann, San Mateo, CA.

BARRINGER, H., FISHER, M., GABBAY, D., OWENS, R., AND REYNOLDS, M., Eds. 1996. The Imperative Future: Principles of Executable Temporal Logic. Wiley Advanced software development series. John Wiley and Sons, Inc., New York, NY.

BEN-ARI, M. 1993. Mathematical Logic for Computer Science. Prentice-Hall International Series in Computer Science. Prentice-Hall, Inc., Upper Saddle River, NJ.

BEN-ARI, M., PNUELI, A., AND MANNA, Z. 1983. The temporal logic of branching time. Acta Inf. 20.

BUCCI, G., CAMPANAI, M., AND NESI, P. 1995. Tools for specifying real-time systems. Real-Time Syst. 8, 2/3 (Mar./May 1995), 117-172.

CARRINGTON, D., DUKE, D., DUKE, R., KING, P., ROSE, G., AND SMITH, G. 1990. Object-Z: An object-oriented extension to Z. In Formal Description Techniques, S. T. Voung, Ed. Elsevier Science Inc., New York, NY.

CLARKE, E. M., EMERSON, E. A., AND SISTLA, A. P. 1986. Automatic verification of finite-state concurrent systems using temporal logic specifications. ACM Trans. Program. Lang. Syst. 8, 2 (Apr. 1986), 244-263.

CLARKE, E. M. AND GRUMBERG, O. 1987. The model checking problem for concurrent systems with many similar processes. In Proceedings of the International Conference on Temporal Logic in Specification (Altrincham, UK, Apr. 8-10), B. Banieqbal, H. Barringer, and A. Pnueli, Eds. Springer Lecture Notes in Computer Science Springer-Verlag, New York, NY, 188-201.

DAVIS, L. S., DEMENTHON, D., BESTUL, T., HARWOOD, D., SRINIVASAN, H. V., AND ZIAVRAS, S. 1989. RAMBO: Vision and planning on the connection machine. In Proceedings of the Sixth Scandanavian Conference on Image and Application (Oulu, Finland, June), 1-14.

DAVIS, R.E. 1989. Truth, Deduction, and Computation: Logic and Semantics for Computer Science. Computer Science Press, Inc., New York, NY.

DILLON, L. K., KUTTY, G., MOSER, L. E., MELLIAR-SMITH, P. M., AND RAMAKRISHNA, Y.S. 1994. A graphical interval logic for specifying concurrent systems. ACM Trans. Softw. Eng. Methodol. 3, 2 (Apr. 1994), 131-165.

DURR, E. AND VAN KATWIJK, J. 1992. VDM++: A formal specification language for object-oriented designs. In Proceedings of the Seventh International Conference on Technology of Object-Oriented Languages and Systems (TOOLS 7, Dortmund, Germany), G. Heeg, B. Magnusson, and B. Meyer, Eds. TOOLS conference series Prentice Hall International (UK) Ltd., Hertfordshire, UK, 63-78.

EMERSON, E. A. AND HALPERN, J. Y. 1986. "Sometimes" and "not never" revisited: On branching versus linear time temporal logic. J. ACM 33, 1 (Jan. 1986), 151-178.

EMERSON, E. A., MOK, A. K., SISTLA, A. P., AND SRINIVASAN, J. 1989. Quantitative temporal reasoning. In Proceedings of the Workshop on Finite-State Concurrency (Grenoble, France).

FELDER, M. AND MORZENTI, A. 1992. Validating real-time systems by history-checking TRIO specifications. In Proceedings of the 14th International Conference on Software Engineering (ICSE '92, Melbourne, Australia, May 11-15), T. Montgomery, Ed. ACM Press, New York, NY, 199-211.

FELDER, M. AND MORZENTI, A. 1994. Validating real-time systems by history-checking TRIO specifications. ACM Trans. Softw. Eng. Methodol. 3, 4 (Oct. 1994), 308-339.

FINGER, M., FISHER, M., AND OWENS, R. 1993. Metamem at work: Modelling reactive systems using executable temporal logic. In Proceedings of the 6th International Conference on Industrial and Engineering Applications of Artificial Intelligence and Expert Systems (Edinburg, UK, June), Gordon and Breach Science Publishers, Inc., Langhorn, PA.

FISHER, M. AND OWENS, R. 1993. An introduction to executable modal and temporal logics. In Proceedings of the Workshop on Executable Modal and Temporal Logics (IJCAI '93, Chamberry, France, Aug.), M. Fisher and R. Owens, Eds. Springer-Verlag, New York.

GHEZZI, C., MANDRIOLI, D., AND MORZENTI, A. 1990. TRIO: A logic language for executable specifications of real-time systems. J. Syst. Softw. 12, 2 (May 1990), 107-123.

GOTZHEIN, R. 1992. Temporal logic and applications: a tutorial. Comput. Netw. ISDN Syst. 24, 3 (May 1, 1992), 203-218.

HALPERN, J., MANNA, Z., AND MOSZKOWSKI, B. 1983. A hardware semantics based on temporal intervals. In Proceedings of the Tenth Colloquium on Automata Languages and Programming (Barcelona, Spain, July), J. Diaz, Ed. Springer-Verlag, New York.

HALPERN, J. Y. AND SHOHAM, Y. 1986. A propositional modal logic of time intervals. In Proceedings of the First IEEE Symposium on Logic in Computer Science, IEEE Press, Piscataway, NJ, 274-292.

HUGHES, G. E. AND CRESSWELL, M.K. 1968. An Introduction to Modal Logic. Muthuen and Co. Ltd., London, UK.

JAHANIAN, F AND MOK, A K 1986. Safety analysis of timing properties in real-time systems. IEEE Trans. Softw. Eng. SE-12, 9 (Sept. 1986), 890-904.

JOSKO, B. 1987. MCTL: An extension of CTL for modular verification of concurrent systems. In Proceedings of the International Conference on Temporal Logic in Specification (Altrincham, UK, Apr. 8-10), B. Banieqbal, H. Barringer, and A. Pnueli, Eds. Springer Lecture Notes in Computer Science Springer-Verlag, New York, NY, 165-187.

KOYMANS, R. 1990. Specifying real-time properties with metric temporal logic. Real-Time Syst. 2, 4 (Nov. 1990), 255-299.

LADKIN, P. 1987. Models of axioms for time intervals. In Proceedings of the Sixth National Conference on Artificial Intelligence (AAAI'87), AAAI Press, Menlo Park, CA, 234-239.

LANO, K. 1991. Z++, an object-oriented extension to z. In Proceedings of the Fourth Annual Meeting on Z User (Oxford, UK), J. E. Nicholls, Ed. Springer-Verlag, Secaucus, NJ, 151-172.

LANO, K. AND HAUGHTON, H., Eds. 1994. Object-Oriented Specification Case Studies. Prentice-Hall Object-Oriented Series. Prentice Hall International (UK) Ltd., Hertfordshire, UK.

MANNA, Z. AND PNUELI, A. 1983. Proving precedence properties: The temporal way. In Proceedings of the Tenth Colloquium on Automata Languages and Programming (Barcelona, Spain, July), J. Diaz, Ed. Springer-Verlag, New York, 491-512.

MANNA, Z. AND PNUELI, A. 1990. A hierarchy of temporal properties (invited paper). In Proceedings of the Ninth Annual ACM Symposium on Principles of Distributed Computing (PODC '90, Quebec City, Canada, Aug. 22-24), C. Dwork, Ed. ACM Press, New York, NY, 377-410.

MATTOLINI, R. 1996. TILCO: A temporal logic for the specification of real-time systems (TILCO: una Logica Temporale per la Specifica di Sistemi di Tempo Reale). Ph.D. Dissertation.

MATTOLINI, R. AND NESI, P. 1996. Using Tilco for specifying real-time systems. In Proceedings of the Second IEEE International Conference on Engineering of Complex Computer Systems (Montreal, Canada), IEEE Computer Society Press, Los Alamitos, CA, 18-25.

MATTOLINI, R. AND NESI, P. 2000. An interval logic for real-time system specification (in press). IEEE Trans. Softw. Eng..

MELLIAR-SMITH, P.M. 1987. Extending interval logic to real time systems. In Proceedings of the Conference on Temporal Logic Specification (UK, Apr.), B. Banieqbal, H. Barringer, and A. Pnueli, Eds. Springer-Verlag, New York, 224-242.

MERZ, S. 1993. Efficiently executable temporal logic programs. In Proceedings of the Workshop on Executable Modal and Temporal Logics (IJCAI '93, Chamberry, France, Aug.), M. Fisher and R. Owens, Eds. Springer-Verlag, New York, 1-20.

MOSER, L. E., RAMAKRISHNA, Y. S., KUTTY, G., MELLIAR-SMITH, P. M., AND DILLON, L. K. 1997. A graphical environment for the design of concurrent real-time systems. ACM Trans. Softw. Eng. Methodol. 6, 1, 31-79.

MOSZKOWSKI, B. 1985. A temporal logic for multilevel reasoning about hardware. IEEE Computer, 10-19.

MOSZKOWSKI, B. AND MANNA, Z. 1984. Reasoning in interval logic. In Proceedings of the ACM/NSF/ONR Workshop on Logics of Programs, Springer-Verlag, Secaucus, NJ, 371-384.

MOSZKOWSKI, B. C. 1986. Executing temporal logic programs. Ph.D. Dissertation. Cambridge University Press, New York, NY.

ORGUN, M. AND MA, W. 1994. An overview of temporal logic programming. In Proceedings of the First International Conference on Temporal Logic (ICTL, Bonn, Germany, July), Springer-Verlag, Secaucus, NJ.

OSTROFF, J. S. 1989. Temporal Logic for Real Time Systems. Wiley Advanced software development series. John Wiley and Sons, Inc., New York, NY.

OSTROFF, J. S. 1991. Verification of safety critical systems using ttm/rttl. In Proceedings of the REX Workshop on Real-Time: Theory in Practice, Springer-Verlag, New York, NY.

OSTROFF, J. S. 1992. Formal methods for the specification and design of real-time safety critical systems. J. Syst. Softw. 18, 1 (Apr. 1992), 33-60.

OSTROFF, J. S. AND WONHAM, W. 1987. Modeling and verifying real-time embedded computer systems. In Proceedings of the 8th IEEE Real-Time Systems Symposium, IEEE Computer Society Press, Los Alamitos, CA, 124-132.

OSTROFF, J. S. AND WONHAM, W. M. 1990. A framework for real-time discrete event control. IEEE Trans. Automat. Contr. 35, 4 (Apr.), 386-397.

PAULSON, L. C. 1994. Isabelle: A Generic Theorem Prover. Lecture Notes in Computer Science, vol. 828. Springer-Verlag, New York, NY.

PNUELI, A. 1977. The temporal logic of programs. In Proceedings of the 18th Annual Symposium on Foundations of Computer Science, IEEE Computer Society Press, Los Alamitos, CA, 46-57.

PNUELI, A. 1981. The temporal semantics of concurrent programs. Theor. Comput. Sci. 13.

PNUELI, A 1986. Applications of temporal logic to the specification and verification of reactive systems: a survey of current trends. In Current Trends in Concurrency. Overviews and Tutorials, J. W. de Bakker, W. P. de Roever, and G. Rozenberg, Eds. Springer Lecture Notes in Computer Science. Springer-Verlag, New York, NY, 510-584.

PRIOR, A. 1967. Past, Present and Future. Oxford University Press, Oxford, UK.

RAZOUK, R. AND GORLICK, M. 1989. Real-time interval logic for reasoning about executions of real-time programs. SIGSOFT Softw. Eng. Notes 14, 8 (Dec. 1989), 10-19.

ROSNER, R. AND PNUELI, A. 1986. A choppy logic. In Proceedings of the First IEEE Symposium on Logic in Computer Science, IEEE Press, Piscataway, NJ, 306-313.

SCHWARTZ, R. L. AND MELLIAR-SMITH, P.M. 1982. From state machines to temporal logic: Specification methods for protocol standards. IEEE Trans. Commun. 30, 12 (Dec.), 2486-2496.

SCHWARTZ, R. L., MELLIAR-SMITH, P. M., AND VOGT, F. H. 1983. An interval logic for higher-level temporal reasoning. In Proceedings of the Second ACM Symposium on Principles of Distributed Computing (Aug.), ACM Press, New York, NY, 173-186.

STANKOVIC, J. A. 1988. Misconceptions about real-time computing: a serious problem for next-generation systems. IEEE Computer 21, 10 (Oct. 1988), 10-19.

STANKOVIC, J. A. AND RAMAMRITHAM, K. 1990. What is predictability for real-time systems. IEEE Real-Time Syst. Newsl., 247-254.

STIRLING, C. 1987. Comparing linear and branching time temporal logics. In Proceedings of the International Conference on Temporal Logic in Specification (Altrincham, UK, Apr. 8-10), B. Banieqbal, H. Barringer, and A. Pnueli, Eds. Springer Lecture Notes in Computer Science Springer-Verlag, New York, NY, 1-20.

STOYENKO, A. D. 1992. The evolution and state-of-the-art of real-time languages. J. Syst. Softw. 18, 1 (Apr. 1992), 61-84.

VILA, L. 1994. A survey on temporal reasoning in artificial intelligence. AI Commun. 7, 1 (Mar. 1994), 4-28.

WANG, F., MOK, A. K., AND EMERSON, E. A. 1993. Distributed real-time system specification and verification in APTL. ACM Trans. Softw. Eng. Methodol. 2, 4 (Oct. 1993), 346-378.

ZAVE, P. 1982. An operational approach to requirements specification for embedded systems. IEEE Trans. Softw. Eng. 8, 3 (May), 250-269.

Received: April 1998; revised: May 1999; accepted: May 1999

P. BELLINI, R. MATTOLINI, and P. NESI University of Florence

Authors' address: Department of Systems and Informatics, University of Florence, Via S. Marta 3, Firenze, 50139, Italy; email: nesi@ingfi1.ing.unifi.it; http://www.dsi.unifi.it/.

Permission to make digital/hard copy of part or all of this work for personal or classroom use is granted without fee provided that the copies are not made or distributed for profit or commercial advantage, the copyright notice, the title of the publication, and its date appear, and notice is given that copying is by permission of the ACM, Inc. To copy otherwise, to republish, to post on servers, or to redistribute to lists, requires prior specific permission and/or a fee.

[C] 2000 ACM 0360-0300/00/0300-0012 $5.00
COPYRIGHT 2000 Association for Computing Machinery, Inc.
No portion of this article can be reproduced without the express written permission from the copyright holder.
Copyright 2000 Gale, Cengage Learning. All rights reserved.

Article Details
Printer friendly Cite/link Email Feedback
Author:BELLINI, P.; MATTOLINI, R.; NESI, P.
Publication:ACM Computing Surveys
Geographic Code:1USA
Date:Mar 1, 2000
Words:17504
Previous Article:Introduction to the Computing Surveys' Electronic Symposium on Object-Oriented Application Frameworks.
Next Article:Programming Languages and Systems for Prototyping Concurrent Applications.
Topics:

Terms of use | Privacy policy | Copyright © 2019 Farlex, Inc. | Feedback | For webmasters