Abstract: This article describes a graphical interval logic that is the foundation of a tool set supporting formal specification and verification of concurrent software systems Experience has shown that most software engineers find standard temporal logics difficult to understand and use The objective of this article is to enable software engineers to specify and reason about temporal properties of concurrent systems more easily by providing them with a logic that has an intuitive graphical representation and with tools that support its use To illustrate the use of the graphical logic, the article provides some specifications for an elevator system and proves several properties of the specifications The article also describes the tool set and the implementation

Abstract: This paper presents an overview of the development of the field of temporal and modal logic programming. We review temporal and modal logic programming languages under three headings: (1) languages based on interval logic, (2) languages based on temporal logic, and (3) languages based on (multi)modal logics. The overview includes most of the major results developed, and points out some of the similarities, and the differences, between languages and systems based on diverse temporal and modal logics. The paper concludes with a brief summary and discussion.

Abstract: In this paper, we present an overview on the use of interval arithmetic to process numerical constraints in Constraint Logic Programming. The main principle is to approximate n-ary relations over IR with Cartesian products of intervals whose bounds are taken in a finite subset of IR. Variables represent real values whose domains are intervals defined in the same manner. Narrowing operators are defined from approximations. These operators compute, from an interval and a relation, a set included in the initial interval. Sets of constraints are then processed thanks to a local consistency algorithm pruning at each step values from initial intervals. This algorithm is shown to be correct and to terminate, on the basis of a certain number of properties of narrowing operators. We focus here on the description of the general framework based on approximations, on its application to interval constraint solving over continuous and discrete quantities, we establish a strong ling between approximations and local consistency notions and show that arc-consistency is an instance of the approximation framework. We finally describe recent work on different variants of the initial algorithm proposed by John Cleary and developped by W. Older and A. Vellino which have been proposed in this context. These variants address four particular points: generalization of the constraint language, improvement of domain reductions, efficiency of the computation and finally, cooperation with other solvers. Some open questions are also identified.

Abstract: Verifying that test executions are correct is a crucial step in the testing process. Unfortunately, it can be a very arduous and error-prone step, especially when testing a concurrent system. System developers can therefore benefit from oracles automating the verification of test executions.This paper examines the use of Graphical Interval Logic (GIL) for specifying temporal properties of concurrent systems and describes a method for constructing oracles from GIL specifications. The visually intuitive representation of GIL specifications makes them easier to develop and to understand than specifications written in more traditional temporal logics.Additionally, when a test execution violates a GIL specification, the associated oracle provides information about a fault. This information can be displayed visually, together with the execution, to help the system developer see where in the execution a fault was detected and the nature of the fault.

Abstract: We outline a methodology for the modular speciication of telephone services within rst-order linear-time temporal logic. Typically, the services ooered by a telephone system consist of a basic service and several optional additional services, such as automatic callback, redirection, etc. We argue informally that temporal logic provides a exible formalism for the speciication of individual services, and for the composition of diierent services. We present a style of speciication, in which the expected behavior of each additional service can be speciied independently of other services. In this style, it is straightforward to compose noninteracting services. We outline, by means of examples, how certain interactions between services that prescribe connicting behavior can manifest themselves as inconsistencies when the services are composed. We then outline how the resolution of such interactions can be described in the formalism.

Abstract: We define a projection operator in the framework of the temporal logic programming. Its syntax and semantics are presented and illustrated with examples. We also discuss the implementation details of the projection construct.

Abstract: In this paper we describe a general way of formalizing reasoning behaviour. Such a behaviour may be described by all the patterns which are valid for the behaviour. A pattern can be seen as a seque...

Abstract: An extension of the propositional temporal language is introduced with a simple syntactic device, called ”reference pointer” which provides for making references within a formula to ”instants of reference” specified in the formula. The language with reference pointers \(\mathcal{L}_{trp}\) has a great expressive power (e.g. Kamp's and Stavi's operators as well as Prior's clock variables are definable in it), especially compared to its frugal syntax, perspicuous semantics and simple deductive system. The minimal temporal logic K trp of this language is axiomatized and strong completeness theorem is proved for it and extended to an important class of extensions of K trp . The validity in \(\mathcal{L}_{trp}\) is proved undecidable.

Abstract: We present two algorithms: a realizability-checking algorithm and a synthesis algorithm. Given a specification of reactive asynchronous modules expressed in prepositional ETL (Extended Temporal Logic), the realizability-checking algorithm decides whether the specification has an actual implementation, under the assumptions of a random environment and fair execution. It also creates a structure which can then be transformed by the synthesis algorithm into a program, represented as a labeled finite automaton. Unlike previous approaches, the realizability-checking algorithm can handle fairness assumptions. The realizability-checking algorithm is incremental and it directly manipulates formulas in linear temporal logic without having to transform into a branching-time logic or other representations.

Abstract: Duration Calculus was introduced in [ZHR91] as a logic to specify and reason about requirements for real-time systems. It is an extension of Interval Temporal Logic [Mos85] where one can reason about integrated constraints over time-dependent and Boolean valued states without explicit mention of absolute time. Several major case studies, e.g. the gas burner system in [RRH93], have shown that Duration Calculus provides a high level of abstraction for both expressing and reasoning about specifications. Using Timed Automata [A1D92] one can express how real-time systems can be constructed at a level of detail which is close to an actual implementation. We consider in the paper the correctness of Timed Automata with respect to Duration Calculus formulae. For a subset of Duration Calculus, we show that one can automatically verify whether a Timed Automaton ? is correct with respect to a formulaD, abbreviated ? ?D, i.e. one can domodel-checking. The subset we consider is expressive enough to formalize the requirements to the gas burner system given in [RRH93]; but only for a discrete time domain. Model-checking is done by reducing the correctness problem ? ?D to the inclusion problem of regular languages.

Abstract: We present a new temporal logic, GTL, appropriate for specifying properties of hardware at the register transfer level. We argue that this logic represents an improvement over model checking for some natural hardware verification problems. We show that the validity problem for this logic is π 1 1 complete. We then identify a fragment of the logic that is decidable. We show that in this fragment we are still able to encode many interesting problems, including the correctness of pipelined microprocessors.

Abstract: This paper embeds durations in an interval temporal logic proposed by Venema. The resulting logic, DCL, is a conservative extension of the original Duration Calculus with two extra chopping operators. In contrast to the original Duration Calculus, DCL can be used to specify and verify abstract liveness and fairness properties of systems. In fact, it is shown that durations are useful for specifying such properties on a dense time domain.

Abstract: A new type of tableau system is proposed for the complete class (called miniscoped Horn-like) of first-order linear temporal logic. The described system instead of induction-like postulates contains some nonlogical axioms indicating the saturation of a derivation process in this system.

Abstract: A temporal logic model is introduced to the modeling and design of discrete event systems. Within such a model, the relationship between the reachability of states and the validity of formulas is given to provide a basis for the composition and synthesis of discrete event systems in a temporal logic framework. The composition of temporal logic models is accomplished by formulating a temporal logic model as a process algebra and defining projection applications within the temporal logic models. Procedures are developed for reachability synthesis and a controller logic model is designed to ensure that the required behavior of the system is met. An example of a system of read-write processes is demonstrated to illustrate the novelty of this approach. >

Abstract: It is fairly easy, if somewhat tedious, to prove that our rules preserve satisfiability. Completeness, however, is a much tougher question, and the proof is quite involved. This is one of the reasons why the present note is merely a position paper. The other reason is that so far we did not show that the idea of incorporating linear constraints into temporal logic tableaux is in some sense a real improvement over the current state of the art. On the other hand, we would like to point out at least a few advantages that might be gained from it:

Abstract: We introduce a temporal logic TAL and prove that it has several nice features. The formalism is a two-dimensional modal system in the sense that formulas of the language are evaluated at pairs of time points. Many known formalisms with a two-dimensional flavor can be expressed in TAL, which can be seen as the temporal version of square arrow logic.

Abstract: A logic-based foundation of discrete event modeling and simulation is presented by defining (1) its fundamental concepts and terms from a perspective commonly held by logicians, (2) a modal Discrete Event Logic LDE The ways of expressing models using LDE are discussed and compared with the ways of expressing models in simulation languages that support the event scheduling world view The logic-based foundation provides fundamentally new insights It asserts that events are logical propositions and the use of temporal operators is implicit in discrete event modeling and simulation languages However, existing languages utilize only a few temporal operators in a restricted manner The logic-based foundation enhances the ways of expressing models by using the operators implicit in existing languages in more general ways, new operators, and a parallel connective || The logic LDE and notions implicit in it form a new framework for understanding, defining, and studying logical combinations of events, variables, and time, and expressions containing a wide range of temporal operators including next, if, when, whenever, until, while, unless, and at

Abstract: We describe an attempt to formalise the semantics of the Temporal Logic of Actions (TLA) by means of the HOL theorem prover. Special concern has been devoted to trying to formalise the rules that govern refinement mappings and data hiding in the TLA framework.

Abstract: In temporal logic programming, a stream can be specified by a single-valued, time-varying predicate which, at any given moment in time, represents the corresponding element in the stream. However, due to inherent nondeterminism in logic programming, time-varying predicates do not necessarily represent single-valued relations at any given moment in time. Choice predicates are also time-varying predicates, but, in principle, they act like a dataflow node with multiple input lines which nondeterministically selects one of its inputs as output. Therefore they are guaranteed to be single-valued at all moments in time, and they can be regarded as representing “nondeterministic” streams. Users do not define choice predicates, they are supplied automatically for all predicates defined in temporal logic programs. Inputs to choice predicates are supplied by the corresponding predicates. When the connection between choice predicates and the corresponding predicates is established, we obtain non-Horn temporal logic programs as a result. The model-theoretic semantics of such a program is developed in terms of “minimal models”. However, the logical structure of the program dictates which minimal models are constructible from the program. We in particular discuss a characterization of constructible minimal models as limits of chains of models obtained by alternating applications of two new mappings NTP and CP . The paper also outlines a proof procedure for the temporal language Chronolog extended with choice predicates.

Abstract: A simple and elegant formulation of compositional proof systems for concurrent programs results from a refinement of temporal logic semantics. The refined temporal language we propose is closed under W-stuttering and, thus, provides a fully abstract semantics with respect to some chosen observation level w. This avoids incorporating irrelevant detail in the temporal semantics of parallel programs. Besides compositional verification, concurrent program design and implementation of a coarser-grained program by a finer-grained one, turn out to be easily practicable in the setting of the new temporal logic.

Abstract: Existing interval constraint logic programming languages, such as BNR Pro-log, work under the framework of interval narrowing and are deecient in solving linear systems, which constitute an important class of problems in engineering and other applications. In this paper, an interval linear equality solver, which is based on generalized interval arithmetic and Gaussian elimination , is proposed. We show how the solver can be adapted to incremental execution and incorporated into a constraint logic programming language already equipped with a non-linear solver based on interval narrowing. The two solvers interact and cooperate during computation, resulting in a practical interval constraint arithmetic language CIAL. A prototype of CIAL, based on CLP(R), is constructed and compared favourably against several major constraint logic programming languages.

Abstract: We present an algorithm which derives the input conditional formula from a reactive system specification. The input conditional formula explicitly expresses the constraints on the environment behavior which are implicitly involved in an unrealizable specification. The input conditional formula provides useful information in the specification/synthesis process for reactive systems. We use propositional linear-time temporal logic as a specification language, and our derivation algorithm is based on the tableau method for temporal logic.

Abstract: This thesis investigates temporal specification and verification techniques using a linear-time temporal logic with interval constructs. It identifies an expressive elementary logic with interval modalities, called Future Interval Logic (FIL). This logic has a natural graphical representation which, combined with its ability to nest intervals, allows institutive specification of many commonly encountered temporal properties of concurrent systems. We present the first known elementary decision procedure for an interval logic, using the method of automata. The procedure uses a novel concept of syntactic reductions between formulae of the logic. FIL is a purely qualitative logic, allowing the specification and verification of permissible event orderings in a concurrent system. In the second part of the thesis we extend FIL, with a real-time metric, thus allowing the expression of real-time constraints. We provide a decision method for this logic, using the Timed-Automata of Alur and Dill. We investigate the expressive power and complexity of the logics FIL and RTFIL, and some of their extensions. Finally, we turn to the issue of combining temporal logics with decidable quantifier-free non-temporal logics. A very large class of verification problems are covered by such a combination, parameterized by appropriate decidable logics. We give an automata-theoretic account of a method of Plaisted, to decide the satisfiability of such a logic, which uses both rigid and flexible variables. This framework allows us to obtain an exponentially more efficient algorithm than the best algorithm known so far. Our approach also clarifies the metalogical aspects of the method, thus making it applicable in a more general setting. The main contributions of this thesis are that it provides the first known elementary decision method for an interval logic and, more importantly, that it extends the well-understood methods of automata and of tableaux to interval logics. Interval logics (and their real-time extensions) have traditionally been considered as being beyond the domain of these methods. From a less prescriptive and more descriptive standpoint, our algorithms reinforce the general applicability of the automata-theoretic framework for obtaining efficient decision procedures for a variety of temporal logics, as well as for their combinations with decidable non-temporal logics. From a more practical viewpoint, the graphical flavour of the logic and its timing-diagram look-and-feel make it an appropriate candidate for a practical formal methods tool.

Abstract: In earlier work, we have shown that the formalism of abductive logic programs with FOL integrity constraints provides, under a completion semantics, the same declarative expressivity for representing incomplete information as full first order logic. We have shown how the combination of this formalism with a variant of the Event Calculus of Kowalski and Sergot results in a correct and very expressive framework for temporal reasoning and representation. In this paper we demonstrate how this Abductive Event Calculus formalism provides a general frame-work for the representation and use of temporal databases. On the declarative level, it is particularly convenient for the representation of incomplete knowledge. Complementary, on the procedural level, we are able to provide a number of simple algorithms using abduction and deduction to test the consistency of the base, answer queries, update the database, handle complex formulas and resolve inconsistency. Furthermore, the use of the database for general temporal problem solving is possible using the known Event Calculus and Logic Programming methods. In particular we show how planning is possible in this kind of temporal database.

Abstract: Graphical interval logic (GIL) is a visual temporal logic in which formulas resemble the informal timing diagrams familiar to system designers and software engineers It provides an intuitive and natural visual notation in which to express specifications for concurrent systems and retains the benefits of a formal notation A visual editor permits GIL specifications to be easily constructed, and to be stored in and retrieved from files The editor interfaces with a proof checker and model generator, which permit verification of temporal inferences The paper shows how graphical specifications are created and used to reason about temporal properties of systems It shows how pictures that formalize temporal arguments enhance understanding and help motivate successful proof strategies

Abstract: Addresses the problem of comparing and unifying temporal relationships between activities expressed in timing diagrams and natural language narrative (English). This problem often occurs in specifications expressing behavioral requirements and constraints. The approach followed is to translate both diagrams and text into a common knowledge representation (conceptual graphs) employing temporal relations developed for temporal interval logic. In this knowledge representation, the requirements may be integrated, checked for inconsistencies, and subjected to additional temporal reasoning. An algorithm of polynomial complexity for generating a compact representation of temporal relationships from timing diagrams is presented. Generation of comparable conceptual graphs from English statements is described by using examples. Integrating conceptual graphs from timing diagrams and sentences while checking for inconsistencies is also of polynomial complexity. >

Abstract: This paper presents a structured, annotated bibhography of extensions of logic programming based on temporal and modal logics. Temporal and modal logic programming is a new area of research, which gained momentum in the late 1980'ies. The paper discusses temporal and modal logic programming under three headings: (1) interval logic programming, (2) temporal logic programming, and (3) modal logic programming. It contains up-todate information on the current status of the area, and it is intended for researchers and students alike as a source guide for further study. 1 I n t r o d u c t i o n In logic programming, a program is a set of Horn clauses representing our knowledge and assumptions about some problem. The semantics of logic programs as developed by van Emden and Kowalski [12] is based on the notion of the least (minimum) Herbrand model and its elegant fixed-point characterization. As logic programming has been applied to a growing number of problem domains, some of its limitations have also s tar ted to surface, especially in those problem domains requiring the notion of a dynamic change. On the one hand, we would hke to be able to broaden applications of logic programming to, say, temporal reasoning, deductive databases, knowledge representation, and dataflow computation. On the other hand, we would like to remain true to the original goals of logic programming outlined by Kowalski [7]: Logic programs should specify only what is to be computed; not how it is to be computed. In order to overcome some of the limitations of logic programming, many non-logical constructs in the form of annotations, extra system predicates, and infinitary objects are introduced; for instance, see Shapiro [10] for a comprehensive survey on concurrent logic languages. These languages (and other such extensions) are an important contribution to the field of programming languages and their implementations, but the problem with them is that extended "logic" programs are no longer logic. The intended meaning of an extended program cannot be reasoned about from its logical reading; we must know the underlying execution mechanism of a particular extension to figure out what a program really does. A potential solution to this problem lies not in extending logic programming with non-logical tools, but in employing more powerful logical tools such as temporal and modal logics and other forms of intensional logic (or with other nonclassical logics whenever appropriate). In particular, if we want to model t ime-dependent properties in a given application (such as that in temporal reasoning) and the dynamic properties of certain problems such as simulation, why not use temporal logic in the first place? Temporal logics have already been used in program specification and verification, temporal reasoning, and temporal databases. Or if we want to model knowledge and belief, why not use modal and/or epistemic logics? These logics have been extensively studied in philosophy and mathematics and appfied in many problem domains (including those in artificial intelligence) with

Abstract: We address the problem of the specification and the verification of processes with infinite-state spaces. Many relevant properties for such processes involve constraints on numbers of occurrences of events (truth of propositions). These properties are nonregular and hence, they are not expressible neither in the usual logics of processes nor by finite-state ω-automata. We propose a logic called PCTL that allows the description of such properties. PCTL is a combination of the branching-time temporal logic CTL with Presburger arithmetic. Mainly, we study the decidability of the satisfaction relation between context-free processes and PCTL formulas. We show that this relation is decidable for a large fragment of PCTL. Furthermore, we study the satisfiability problem for PCTL. We show that this problem is highly undecidable (Σ 1 1 -complete), even for the fragment where the satisfaction relation is decidable, and exhibit a nontrivial fragment where the satisfiability problem is decidable.