Introduction à l'informatique :Approche algorithmique de la programmation

Année Académique 1996-97MATH305info:eu-repo/semantics/publishe

Temporal Databases: Beyond Finite Extensions (position paper)

We argue that temporal databases should not be restricted to relations with finite extensions. many temporal events are periodic and have no natural bounds. Moreover, such events have a more compact representation when allowed to be unbounded. We present two formalisms for representing and querying possibly infinite periodic data and discuss some of their properties, including expressiveness and query evaluation complexity. Finally, we turn to implementation issues and argue that significant extensions to existing database systems are necessary in order to implement the frameworks we describe

On the Expressiveness of Temporal Logic Programming

In this paper, we address expressiveness issues for temporal logic programming, and in particular for the language TEMPLOG. We focus on the temporal component of the expressiveness by considering the propositional fragment of the language, which we call PTEMPLOG. We prove that PTEMPLOG is able to express positive least-fixpoint temporal properties, which (up to a convention concerning atomic formulas) corresponds to finitely regular ω-languages. Finally, we consider the extension of PTEMPLOG With stratified negation and we show that it is able to express all ω-regular languages. © 1995 Academic Press. All rights reserved.SCOPUS: ar.jinfo:eu-repo/semantics/publishe

Logic Programming Semantics: Techniques and Applications

The following are citations selected by title and abstract as being related to computational linguistics or knowledge representation, resulting from a computer search, using the BRS Information Technologies retrieval service, of the Dissertation Abstracts International (DAI) database produced by University Microfilms International. Included are the UM order number and year-month of entry into the database; author; university, degree, and, i

Tree Pattern Matching for ML (Extended Abstract)

This paper addresses the problem of compiling such sequences of patterns into efficient pattern-matching code. The goal is to minimize the number of tests or discriminations that have to be applied to any given argument to determine the first pattern it matches. Our approach is to transform a sequence of patterns into a decision tree, i.e. a tree which encodes the patterns and defines the order in which subterms of any given value term have to be tested at run-time to determine which pattern matches the value. Each internal node of a decision tree corresponds to a matching test and each branch is labeled with one of the possible results of the matching test and with a list of the patterns which remain potential candidates in that case. It is then straightforward to translate the decision tree into code for pattern matching. During the construction of a decision tree it is also easy to determine whether the pattern set is "exhaustive", meaning every possible argument value matches at least one pattern, and whether there are any "redundant" patterns (i.e. patterns that are matched only by values that are already matched by an earlier pattern). Nonexhaustive definitions and redundant patterns are anomalies that can be - 2 - usefully reported by the compiler. Our goal in constructing the decision tree is simply to minimize the total number of testnodes. This minimizes the size of the generated code and also generally minimizes the number of tests performed on value terms. However, we have discovered that finding the decision tree with the minimum number of nodes is an NP-complete problem. This result is established by reduction from one of the trie index construction problems (pruned O-trie space minimization), which was proved to be NP-complete in [Co76, CS77]. Therefore..

Constraint-Generating Dependencies

peer reviewe

On the Representation of Infinite Temporal Data and Queries

Time is unbounded by nature. A temporal predicate (one that varies with time) will thus often have an infinite extension. To store such a predicate in a database, one can either artificially restrict its extension to a finite set or, more desirably, use a formalism that allows the finite representation of at least some infinite temporal extensions. Several such formalisms have been proposed in the past few years. The formalism that extends traditional relational databases most directly is the generalized databases described in [KSW90]. There, database tuples are extended with an arbitrary number of additional columns carrying linear repeating points. These represent periodic sets of time points possibly constrained by linear inequalities. The query language proposed in [KSW90] is a multi-sorted first-order logic in which predicates have..

Temporal Deductive Databases

We survey a number of approaches to the problem of finite representation of infinite temporal extensions. Two of them, Datalog 1S and Templog, are syntactical extensions of Datalog; the third is based on repetition and arithmetic constraints. We provide precise characterizations of the expressiveness and the computational complexity of these languages. We also describe query evaluation methods

Constraint-generating dependencies

Traditionally, dependency theory has been developed for uninterpreted data. Specifically, the only assumption that is made about the data domains is that data values can be compared for equality. However, data is often interpreted and there can be advantages in considering data as such, for instance, obtaining more compact representations as is done in constraint databases. This paper considers dependency theory in the context of interpreted data. Specifically, it studies constraint-generating dependencies. These are a generalization of equality-generating dependencies where equality requirements are replaced by constraints on an interpreted domain. The main technical results in the paper are a general decision procedure for the implication and consistency problems for constraint-generating dependencies and complexity results for specific classes of such dependencies over given domains. The decision procedure proceeds by reducing the dependency problem to a decision problem for the constraint theory of interest and is applicable as soon as the underlying constraint theory is decidable. The complexity results are, in some cases, directly lifted from the constraint theory; in other cases, optimal complexity bounds are obtained by taking into account the specific form of the constraint decision problem obtained by reducing the dependency implication problem. (C) 1999 Academic Press