No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
Logic programming with temporal constraints
Abstract
Combines logic programming and temporal constraint processing techniques in a language called TCLP (Temporal Constraint Logic Programming), which augments logic programs with temporal constraints. Known algorithms for processing disjunctions in temporal constraint networks are applied. We identify a decidable fragment called Simple TCLP, which can be viewed as extending Datalog with limited functions to accommodate intervals of occurrence and temporal constraints between them. Some of the restrictions introduced by Simple TCLP are overcome by a syntactic structure which provides it with the benefits of reification. The latter allows quantification on temporal occurrences and relation symbols
... Extending PROLOG to deal with uncertain events [10] or mixing logic programming and temporal constraints [17,18] is not a new topic. However, PROLogic is the first language that includes all the possibilities of the FTCN model. ...
... The combination of logic-based and constraint-based temporal reasoning is also investigated within the Constraint Logic Programming (CLP) paradigm. For example, the TCLP framework proposed by Schwalb and Vilain [70] augments logic programs with temporal constraints. Indeed Schwalb and Vilain investigate a decidable fragment called Simple TCLP accommodating intervals of event occurrences and temporal constraints between them. ...
In this paper we present a new framework for modelling switching tasks and adaptive, flexible behaviours for cognitive robots. The framework is constructed on a suitable extension of the Situation Calculus, the Temporal Flexible Situation Calculus (TFSC), accommodating Allen temporal intervals, multiple timelines and concurrent situations. We introduce a constructive method to define pattern rules for temporal constraint, in a language of macros. The language of macros intermediates between Situation Calculus formulae and temporal constraint Networks. The programming language for the TFSC is TFGolog, a new Golog interpreter in the Golog family languages, that models concurrent plans with flexible and adaptive behaviours with switching modes. Finally, we show an implementation of a cognitive robot performing different tasks while attentively exploring a rescue environment.
... Constraint Logic Programming (CLP) looks like the natural formalism to integrate temporal constraints in logic programming. Temporal CLP have been studied in a number of works 25,9,17,41]. The temporal CLP language proposed by Schwalb, Vila and Dechter 41] has several similarities with our proposal here. ...
Despite the ubiquity of time and temporal references in legal texts, their formalization has often been either disregarded or addressed in an ad hoc manner. In this paper we address this issue from the standpoint of the research done on temporal representation and reasoning in AI. We identify the temporal requirements of legal domains and propose a temporal representation framework for legal reasoning which is independent of (i) the underlying representation language and (ii) the specific legal reasoning application. The approach is currently being used in a rule-based language for an application in commercial law. 1 Introduction Automated legal reasoning systems require a proper formalization of time and temporal information [40, 29]. Quoting L. Thorne McCarty [29]: ". . . time and action are both ubiquitous in legal domains. . . . " Notions related to time are found in major legal areas such as labor law (e.g. the time conditions to compute benefit periods), commercial law...
The volume of alarm messages could be very large in modern large-scale power systems. Many intelligent methods have been developed for alarm processing in order to provide summarized and synthesized information instead of a flood of raw alarm data. The timestamps of alarms represent the temporal relationship among event occurrences. However, the temporal information has not yet been appropriately utilized in traditional intelligent methods. A temporal constraint network (TCN) is a kind of directed acyclic graph (DAG) which is of promise for the representation of temporal logics. Based on TCN, an on-line intelligent alarm analyzer with the temporal information of alarms taken into account is proposed for on-line operational environment. The advanced intelligent alarm analyzer is able to infer what events cause the reported alarms and to estimate when these events occurred, as well as to identify the abnormal or missing alarms. Finally, a case study is served for demonstrating the feasibility and efficiency of the proposed method.
Qualitative models are abstractions of ordinary differential equation models. Their value comes from the ability to represent natural states of incomplete knowledge, and to draw useful inferences from those states of knowledge. QSIM is a representation for qualitative differential equation (QDE) models and an algorithm for qualitative simulation, producing a transition graph of qualitative states rooted in a given initial qualitative state [Kuipers, 1994a]. QSIM provides the guarantee that the predicted transition graph of qualitative states describes all possible real solutions to all possible ordinary differential equation (ODE) models and initial states described by the given QDE and initial qualitative state [Kuipers, 1986]. Furthermore, as the imprecision of the state of knowledge decreases to zero, the resulting model and its predictions converge to an ordinary differential equation and its real-valued solution [Berleant and Kuipers, 1997]. Qualitative models are therefore useful whenever an agent, human or robotic, needs to reason about continuous change in spite of incomplete knowledge. Knowledge is often incomplete, of course, but especially so in common-sense reasoning about the everyday continuous world, diagnosis of broken systems, design of new systems, and scientific discovery about unknown systems. The treatment of time in qualitative simulation attempts to bridges the gap between continuous and discrete symbolic models of time, making it possible to apply a variety of other discrete symbolic calculi for temporal inference to problems that arise in the continuous domain.
Time is fundamental in representing and reasoning about a chang-ing world. A proper temporal representation requires characterizing two notions: (1) time itself, and (2) temporal incidence, i.e. the domain-independent properties for the truth-value of uents and events through-out time. Their formal deenition involves some controversial issues such as (i) the expression of instantaneous events and uents that hold instan-taneously, (ii) the dividing instant problem and (iii) the formalization of the properties for non-instantaneous holding of uents. This paper discusses how previous attempts fail to address all these issues and presents simple yet satisfactory theories of time and temporal incidence. The theory of time, called IP, is based on having instants and periods at the same ontological level. The theory of temporal incidence is deened upon IP and its key insight is the distinction between continuous and discrete uents.
The alarm-processing problem is to interpret a large number of alarms under stress conditions, such as faults or disturbances, by providing summarized and synthesized information instead of a flood of raw alarm data. Alarm timestamps represent the temporal relationship among event occurrences and consist of rich and useful information for alarm processing. However, the temporal information has not been well utilized in existing alarm-processing methods. The temporal constraint network (TCN) is a type of directed acyclic graph suitable for representing temporal logics. Based on TCN, a new analytic model is developed for alarm processing with temporal information taken into account. Three major modules are included in the developed approach or alarm processor (i.e., alarm selection, event analysis, and result evaluation). In the alarm selection module, reported alarms are divided into related groups. The function of the event analysis module is to find out what events cause the reported alarms and to estimate when these events happen. The result evaluation module is used to identify abnormal or missing alarms. Finally, two alarm-processing scenarios of an actual power system are served for demonstrating the feasibility and efficiency of the developed approach.
Time representation is important in many applications, such as temporal databases, planning, and multi-agents. Since Allen's work on binary interval relations (called interval algebra), many researchers have further investigated temporal information processing based on interval calculus. However, there are still some limitations such as constraint satisfaction is a NP-hard problem in interval calculus. For this reason, we propose a new interpretation for interval relationships and their calculus in this paper. That is to establish a new method to transform interval calculus into matrix calculus. Our experiments show that it is faster to propagate temporal relations than interval algebra.
We outline an approach for reasoning about events and time within a logic programming framework. The notion of event is taken
to be more primitive than that of time and both are represented explicitly by means of Horn clauses augmented with negation
by failure.
The main intended applications are the updating of databases and narrative understanding. In contrast with conventional databases
which assume that updates are made in the same order as the corresponding events occur in the real world, the explicit treatment
of events allows us to deal with updates which provide new information about the past.
Default reasoning on the basis of incomplete information is obtained as a consequence of using negation by failure. Default
conclusions are automatically withdrawn if the addition of new information renders them inconsistent.
Because events are differentiated from times, we can represent events with unknown times, as well as events which are partially
ordered and concurrent.
We describe two temporal reasoning systems called Timegraph I and II, which can efficiently manage large sets of relations in the Point Algebra as well as metric information. Our representation is based on timegraphs, graphs partitioned into a set of chains on which the search is supported by a metagraph data structure. Timegraph I was originally developed by Taugher, Schubert and Miller in the context of story comprehension. Timegraph II provides useful extensions which makes the system more expressive in the representation of qualitative information and suitable for a larger class of applications. Experimental results show that our approach is very efficient, especially when the given relations admit representation as a collection of chains connected by relatively few cross-chain links.
An important requirement of advanced temporal applications is the ability to deal with definite, indefinite, finite and infinite temporal information. There is currently no database model which offers this functionality in a single unified framework. We argue that the combination of relational databases and temporal constraints offers a powerful framework which addresses these needs. In this thesis we develop the foundations of a theory of temporal constraint databases and indefinite temporal constraint databases. At first, we study a hierarchy of parameterized database models: ML -relational databases, L-constraint databases and indefinite L-constraint databases. The language L, the parameter, defines the constraint vocabulary and ML is the structure over which L-constraints will be interpreted. The models of temporal constraint databases and indefinite temporal constraint databases can then be studied as instances of the last two of the above parameterized models. In the course of...
this paper we demonstrate how metric and Allen-style constraint networks be integrated in a constraint-based reasoning system. The highlights of the work include a simple but powerful logical language for expressing both quantitative and qualitative information; translations algorithms between the metric and Allen sublanguages that entail a minimal loss of information; and a constraint-propagation procedure for problems expressed in a combination of metric and Allen constraints.
Constraint Logic Programming (CLP) is a merger of two declarative paradigms: constraint solving and logic programming. Although a relatively new field, CLP has progressed in several quite different directions. In particular, the early fundamental concepts have been adapted to better serve in different areas of applications. In this survey of CLP, a primary goal is to give a systematic description of the major trends in terms of common fundamental concepts. The three main parts cover the theory, implementation issues, and programming for applications.
Temporal reasoning is a central component of research in artificial intelligence as well as of our everyday reasoning. This dissertation investigates some problems that arise when one wishes to make temporal inferences that are both rigorous and efficient. The particular task of concern is that of predicting the future. In this context, two problems are identified, named the qualification problem and the extended prediction problem which subsume the infamous frame problem. The solution offered to those problems is counched in a logical framework. First introduced are two related logics of time intervals; next, a somewhat new, and very simple,approach to nonmonotonic logs. A nonmonotonic modal logic is then constructed, which combines elements of the interval logic and the modal logic of knowledge. It is shown that this logic, called the logic of chronological ignorance, solves the two problems mentioned above. Furthermore, while in general the logic of chronological ignorance is badly undecidable, a class of theories is identified, called causal theories, about which reasoning can be carried out very efficiently. This in turn suggests a new theory of causation and of its central role in common-sense reasoning.
An interval-based temporal logic is introduced together with a computationally effective reasoning algorithm based on constraint propagation. This system is notable in offering a delicate balance between expressive power and the efficiency of its deductive engine. A notion of reference intervals is introduced which captures the temporal hierarchy implicit in many domains, and which can be used to precisely control the amount of deduction performed automatically by the system. Examples are provided for a database containing historical data, a database used for modeling processes and process interaction, and a database for an interactive system where the present moment is continually being updated.
This paper extends network-based methods of constraint satisfaction to include continuous variables, thus providing a framework for processing temporal constraints. In this framework, called temporal constraint satisfaction problem (TCSP), variables represent time points and temporal information is represented by a set of unary and binary constraints, each specifying a set of permitted intervals. The unique feature of this framework lies in permitting the processing of metric information, namely, assessments of time differences between events. We present algorithms for performing the following reasoning tasks: finding all feasible times that a given event can occur, finding all possible relationships between two given events, and generating one or more scenarios consistent with the information provided.
We distinguish between simple temporal problems (STPs) and general temporal problems, the former admitting at most one interval constraint on any pair of time points. We show that the STP, which subsumes the major part of Vilain and Kautz's point algebra, can be solved in polynomial time. For general TCSPs, we present a decomposition scheme that performs the three reasoning tasks considered, and introduce a variety of techniques for improving its efficiency. We also study the applicability of path consistency algorithms as preprocessing of temporal problems, demonstrate their termination and bound their complexities.
Representing and reasoning about incomplete and indefinite qualitative temporal information is an essential part of many artificial intelligence tasks. An interval-based framework and a point-based framework have been proposed for representing such temporal information. In this paper, we address two fundamental reasoning tasks that arise in applications of these frameworks: Given possibly indefinite and incomplete knowledge of the relationships between some intervals or points, (i) find a scenario that is consistent with the information provided, and (ii) find the feasible relations between all pairs of intervals or points.For the point-based framework and a restricted version of the interval-based framework, we give computationally efficient procedures for finding a consistent scenario and for finding the feasible relations. Our algorithms are marked improvements over the previously known algorithms. In particular, we develop an O(n2)-time algorithm for finding one consistent scenario that is an O(n) improvement over the previously known algorithm, where n is the number of intervals or points, and we develop an algorithm for finding all the feasible relations that is of far more practical use than the previously known algorithm. For the unrestricted version of the interval-based framework, finding a consistent scenario and finding the feasible relations have been shown to be NP-complete. We show how the results for the point algebra aid in the design of a backtracking algorithm for finding one consistent scenario that is shown to be useful in practice for planning problems.
This paper presents a general model for temporal reasoning that is capable of handling both qualitative and quantitative information. This model allows the representation and processing of many types of constraints discussed in the literature to date, including metric constraints (restricting the distance between time points) and qualitative, disjunctive constraints (specifying the relative position of temporal objects). Reasoning tasks in this unified framework are formulated as constraint satisfaction problems and are solved by traditional constraint satisfaction techniques, such as backtracking and path consistency. New classes of tractable problems are characterized, involving qualitative networks augmented by quantitative domain constraints, some of which can be solved in polynomial time using arc and path consistency.
Temporal constraint satisfaction problems (TCSPs) provide a formal framework for representing and processing temporal knowledge. Deciding the consistency of TCSPs is known to be intractable. We demonstrate that even local consistency algorithms like path-consistency (PC) can be exponential on TCSPs due to the fragmentation problem. We present two new polynomial approximation algorithms, Upper-Lower Tightening (ULT) and Loose Path-Consistency (LPC), which are efficient yet effective in detecting inconsistencies and reducing fragmentation. Our experiments on hard problems in the transition region show that LPC has the best effectiveness-efficiency tradeoff for processing TCSPs. When incorporated within backtrack search, LPC is capable of improving search performance by orders of magnitude.
We present here a depth-bounded bottom-up evaluation algorithm for logic programs. We show that it is sound, complete, and terminating for finite-answer queries if the programs are syntactically restricted to DatalognS, a class of logic programs with limited function symbols. DatalognS is an extension of Datalog capable of representing infinite phenomena. Predicates in DatalognS can have arbitrary unary and limited n-ary function symbols in one distinguished argument. We precisely characterize the computational complexity of depth-bounded evaluation for DatalognS and compare depth-bounded evaluation with other evaluation methods, top-down and Magic Sets among others. We also show that universal safety (finiteness of query answers for any database) is decidable for DatalognS.
Much previous work in artificial intelligence has neglected representing time in all its complexity. In particular, it has neglected continuous change and the indeterminacy of the future. To rectify this, I have developed a first-order temporal logic, in which it is possible to name and prove things about facts, events, plans, and world histories. In particular, the logic provides analyses of causality, continuous change in quantities, the persistence of facts (the frame problem), and the relationship between tasks and actions. It may be possible to implement a temporal-inference machine based on this logic, which keeps track of several “maps” of a time line, one per possible history.
J.F. Allen's theory of time and action is examined and found to be unsuitable for representing facts about continuous change. A series of revisions to Allen's theory is proposed in order to accommodate this possibility. The principal revision is a diversification of the temporal ontology to include instants on the same footing as intervals; a distinction is also made between two kinds of property, called states of position and states of motion, with respect to the logic of their temporal incidence. As a consequence of these revisions, it is also found necessary to diversify the range of predicates specifying temporal location. Finally, it is argued that Allen's category of processes is superfluous, since it can be assimilated with the category of properties. The implications of this assimilation for the representation of sentences containing verbs in the progressive aspect are discussed.
A temporal logic is presented for reasoning about propositions whose truth values might change as a function of time. The temporal propositions consist of formulae in a sorted first-order logic, with each atomic predicate taking some set of temporal arguments as well as a set of non-temporal arguments. The temporal arguments serve to specify the predicate's dependence on time. By partitioning the terms of the language into two sorts, temporal and non-temporal, time is given a special syntactic and semantic status without having to resort to reification. The benefits of this logic are that it has a clear semantics and a well-studied proof theory. Unlike the first-order logic presented by Shoham, propositions can be expressed and interpreted with respect to any number of temporal arguments, not just with respect to a pair of time points (an interval). We demonstrate the advantages of this flexibility. In addition, nothing is lost by this added flexibility and more standard and usable syntax. To prove this assertion we show that the logic completely subsumes Shoham's temporal logic [19].
The approach to temporal reasoning which has proven most popular in AI is the reified approach. In this approach, one introduces names for events and states and uses special predicates to assert that an event or state occurs or holds at a particular time. However, recently the reified approach has come under attack, both on technical and on ontological grounds. Thus, it has been claimed that at least some reified temporal logics do not give one more expressive power than provided by alternative approaches. Moreover, it has been argued that the reification of event and state types in reified temporal logics, rather than event and state tokens, makes the ontology more complicated than necessary.In this paper, we present a new reified temporal logic, called TRL, which we believe avoids most of these objections. It is based on the idea of reifying event tokens instead of event types. However, unlike other such attempts, our logic contains “meaningful” names for event tokens, thus allowing us to quantify over all event tokens that meet a certain criterion. The resulting logic is more expressive than alternative approaches. Moreover, it avoids the ontologically objectionable reification of event types, while staying within classical first-order predicate logic.
We define here a formal notion of finite representation of infinite query answers in logic programs. We apply this notion to Datalog nS programs may be infinite and consequently queries may have infinite answers.
We present a method to finitely represent infinite least Herbrand models of Datalog nS program (and its underlying computational engine) can be forgotten. Given a query to be evaluated, it is easy to obtain from the relational specification finitely many answer substitutions that represent infinitely many answer substitutions to the query. The method involved is a combination of a simple, unificationless, computational mechanism (graph traversal, congruence closure, or term rewriting) and standard relational query evaluation methods. Second, a relational specification is effectively computable and its computation is no harder, in the sense of the complexity class, than answering yes-no queries.
Our method is applicable to every range-restricted Datalog nS program. We also show that for some very simple non-Datalog nS logic programs, finite representations of query answers do not exist.
Reification of propositions expressing states, events, and properties has been widely advocated as a means of handling temporal reasoning in AI. The author proposes that such reification is both philosophically suspect and technically unneces sary. The reified theories of Allen and Shoham are examined and it is shown how they can be unreified. The resulting loss of expressive power can be recti fied by adopting Davidson's theory in which event tokens, rather than event types, are reified. This pro cedure is illustrated by means of Kowalski and Ser- got's Event Calculus, the additional type-reification of the latter system being excised by means of a gen eral procedure proposed by the author for convert ing type-reification into token-reification. Some examples are given to demonstrate the expressive power of the resulting theory.
The problem of representing temporal knowledge arises in many areas of computer science. In applications in which such knowledge is imprecise or relative, current representations based on date lines or time instants are inadequate. An interval-based temporal logic is introduced, together with a computationally effective reasoning algorithm based on constraint propagation. This system is notable in offering a delicate balance between expressive power and the efficiency of its deductive engine. A notion of reference intervals is introduced which captures the temporal hierarchy implicit in many domains, and which can be used to precisely control the amount of deduction performed automatically by the system. Examples are provided for a data base containing historical data, a data base used for modeling processes and process interaction, and a data base for an interactive system where the present moment is continually being updated.