ON THE EXPRESSIVE POWER OF INFINITE TEMPORAL DATABASES

We discuss different techniques for representing infinite temporal data. There are two basic approaches: A procedural description, as used in production systems, and represented, in this paper, by a version of Datalog. The second approach is a more declarative method, using some form of temporal logic programming. We examine several versions of each approach, and compare their expressive power, i.e., what temporal data each formalism can capture.Information Systems Working Papers Serie

An extended interval temporal logic and a framing technique for temporal logic programming

PhD ThesisTemporal logic programming is a paradigm for specification and verification of concurrent programs in which a program can be written, and the properties of the program can be described and verified in a same notation. However, there are many aspects of programming in temporal logics that are not well-understood. One such an aspect is concurrent programming, another is framing and the third is synchronous communication for parallel processes. This thesis extends the original Interval Temporal Logic (ITL) to include infinite models, past operators, and a new projection operator for dealing with concurrent computation, synchronous communication, and framing in the context of temporal logic programming. The thesis generalizes the original ITL to include past operators such as previous and past chop, and extends the model to include infinite intervals. A considerable collection of logic laws regarding both propositional and first order logics is formalized and proved within model theory. After that, a subset of the extended ITL is formalized as a programming language, called extended Tempura. These extensions, as in their logic basis, include infinite models, the previous operator, projection and framing constructs. A normal form for programs within the extended Tempura is demonstrated. Next, a new projection operator is introduced. In the new construct, the sub-processes are autonomous; each process has the right to specify its own interval over which it is executed. The thesis presents a framing technique for temporal logic programming, which includes the definitions of new assignments, the assignment flag and the framing operator, the formalization of algebraic properties of the framing operator, the minimal model semantics of framed programs, as well as an executable framed interpreter. The synchronous communication operator await is based directly on the proposed framing technique. It enables us to deal with concurrent computation. Based on EITL and await operator, a framed concurrent temporal logic programming language, FTLL, is formally defined within EITL. Finally, the thesis describes a framed interpreter for the extended Tempura which has been developed in SICSTUS prolog. In the new interpreter, the implementation of new assignments, the frame operator, the await operator, and the new projection operator are all included

Expressiveness of Temporal Query Languages: On the Modelling of Intervals, Interval Relationships and States

Storing and retrieving time-related information are important, or even critical, tasks on many areas of Computer Science (CS) and in particular for Artificial Intelligence (AI). The expressive power of temporal databases/query languages has been studied from different perspectives, but the kind of temporal information they are able to store and retrieve is not always conveniently addressed. Here we assess a number of temporal query languages with respect to the modelling of time intervals, interval relationships and states, which can be thought of as the building blocks to represent and reason about a large and important class of historic information. To survey the facilities and issues which are particular to certain temporal query languages not only gives an idea about how useful they can be in particular contexts, but also gives an interesting insight in how these issues are, in many cases, ultimately inherent to the database paradigm. While in the area of AI declarative languages are usually the preferred choice, other areas of CS heavily rely on the extended relational paradigm. This paper, then, will be concerned with the representation of historic information in two well known temporal query languages: it Templog in the context of temporal deductive databases, and it TSQL2 in the context of temporal relational databases. We hope the results highlighted here will increase cross-fertilisation between different communities. This article can be related to recent publications drawing the attention towards the different approaches followed by the Databases and AI communities when using time-related concepts

Reasoning about Actions with Temporal Answer Sets

In this paper we combine Answer Set Programming (ASP) with Dynamic Linear Time Temporal Logic (DLTL) to define a temporal logic programming language for reasoning about complex actions and infinite computations. DLTL extends propositional temporal logic of linear time with regular programs of propositional dynamic logic, which are used for indexing temporal modalities. The action language allows general DLTL formulas to be included in domain descriptions to constrain the space of possible extensions. We introduce a notion of Temporal Answer Set for domain descriptions, based on the usual notion of Answer Set. Also, we provide a translation of domain descriptions into standard ASP and we use Bounded Model Checking techniques for the verification of DLTL constraints.Comment: To appear in Theory and Practice of Logic Programmin

Towards a unified theory of intensional logic programming

AbstractIntensional Logic Programming is a new form of logic programming based on intensional logic and possible worlds semantics. Intensional logic allows us to use logic programming to specify nonterminating computations and to capture the dynamic aspects of certain problems in a natural and problem-oriented style. The meanings of formulas of an intensional first-order language are given according to intensional interpretations and to elements of a set of possible worlds. Neighborhood semantics is employed as an abstract formulation of the denotations of intensional operators. Then we investigate general properties of intensional operators such as universality, monotonicity, finitariness and conjunctivity. These properties are used as constraints on intensional logic programming systems. The model-theoretic and fixpoint semantics of intensional logic programs are developed in terms of least (minimum) intensional Herbrand models. We show in particular that our results apply to a number of intensional logic programming languages such as Chronolog proposed by Wadge and Templog by Abadi and Manna. We consider some elementary extensions to the theory and show that intensional logic program clauses can be used to define new intensional operators. Intensional logic programs with intensional operator definitions are regarded as metatheories

TEMPORAL LOGIC AS A SIMULATION LANGUAGE

We advocate the use of temporal logic instead of the first-order logic in rules of knowledge-based simulation systems. We argue that this provides several advantages that will be discussed in the paper. We show how temporal logic is used in simulation by considering language PTL based on temporal logic programming.Information Systems Working Papers Serie

Monotone Logic Programming

We propose a notion of an abstract logic. Based on this notion, we define abstract logic programs to be sets of sentences of an abstract logic. When these abstract logics possess certain logical properties (some properties considered are compactness, finitariness, and monotone consequence relations) we show how to develop a fixed-point, model-state-theoretic and proof theoretic semantics for such programs. The work of Melvin Fitting on developing a generalized semantics for multivalued logic programming is extended here to arbitrary abstract logics. We present examples to show how our semantics is robust enough to be applicable to various non-classical logics like temporal logic and multivalued logics, as well as to extensions of classical logic programming such as disjunctive logic programming. We also show how some aspects of the declarative semantics of distributed logic programming, particularly work of Ramanujam, can be incorporated into our framework

VALIDATING REQUIREMENTS SPECIFICATIONS STATED IN KNOWLEDGE REPRESENTATION LANGUAGE TEMPLAR

Techniques for analysis and validation of software requirements specifications written in the knowledge representation language Templar are presented. Templar specifications are analyzed in terms of ambiguity, non-minimality, contradiction, incompleteness, and redundancy. Since Templar is a powerful knowledge representation language supporting a rich set of modeling primitives, it is difficult to reason directly on Templar specifications. To solve this problem, Templar specifications are mapped into equivalent temporal logic programs which are analyzed in terms the criteria listed above. However, it is hard to reason about Templar specifications because some of the criteria cannot be formally proven, and the verification of other criteria constitute undecidable or intractable problems. To overcome these difficulties, we consider a set of tractable conditions for each criteria, which serve as "alarms" for the user. If a condition is violated then it means that the specification either definitely has or potentially can have a problem. Furthermore, the user is notified about the source and the nature of the problem in certain cases.Information Systems Working Papers Serie