Integrity constraints in deductive databases

A deductive database is a logic program that generalises the concept of a relational database. Integrity constraints are properties that the data of a database are required to satisfy and in the context of logic programming, they are expressed as closed formulae. It is desirable to check the integrity of a database at the end of each transaction which changes the database. The simplest approach to checking integrity in a database involves the evaluation of each constraint whenever the database is updated. However, such an approach is too inefficient, especially for large databases, and does not make use of the fact that the database satisfies the constraints prior to the update. A method, called the path finding method, is proposed for checking integrity in definite deductive databases by considering constraints as closed first order formulae. A comparative evaluation is made among previously described methods and the proposed one. Closed general formulae is used to express aggregate constraints and Lloyd et al. 's simplification method is generalised to cope with these constraints. A new definition of constraint satisfiability is introduced in the case of indefinite deductive databases and the path finding method is generalised to check integrity in the presence of static constraints only. To evaluate a constraint in an indefinite deductive database to take full advantage of the query evaluation mechanism underlying the database, a query evaluator is proposed which is based on a definition of semantics, called negation as possible failure, for inferring negative information from an indefinite deductive database. Transitional constraints are expressed using action relations and it is shown that transitional constraints can be handled in definite deductive databases in the same way as static constraints if the underlying database is suitably extended. The concept of irnplicit update is introduced and the path finding method is extended to compute facts which are present in action relations. The extended method is capable of checking integrity in definite deductive databases in the presence of transitional constraints. Combining different generalisations of the path finding method to check integrity in deductive databases in the presence of arbitrary constraints is discussed. An extension of the data manipulation language of SQL is proposed to express a wider range of integrity constraints. This class of constraints can be maintained in a database with the tools provided in this thesis

The CIFF Proof Procedure for Abductive Logic Programming with Constraints: Definition, Implementation and a Web Application

Abduction has found broad application as a powerful tool for hypothetical reasoning with incomplete knowledge, which can be handled by labeling some pieces of information as abducibles, i.e. as possible hypotheses that can be assumed to hold, provided that they are consistent with the given knowledge base. Attempts to make the abductive reasoning an effective computational tool gave rise to Abductive Logic Programming (ALP) which combines abduction with standard logic programming. A number of so-called proof procedures for ALP have been proposed in the literature, e.g. the IFF procedure, the Kakas and Mancarella procedure and the SLDNFA procedure, which rely upon extensions of different semantics for logic programming. ALP has also been integrated with Constraint Logic Programming (CLP), in order to combine abductive reasoning with an arithmetic tool for constraint solving. In recent years, many proof procedures for abductive logic programming with constraints have been proposed, including ACLP and the A-System which have been applied to many fields, e.g. multi-agent systems, scheduling, integration of information. This dissertation describes the development of a new abductive proof procedure with constraints, namely the CIFF proof procedure. The description is both at the theoretical level, giving a formal definition and a soundness result with respect to the three-valued completion semantics, and at the implementative level with the implemented CIFF System 4.0 as a Prolog meta-interpreter. The main contributions of the CIFF proof procedure are the advances in the expressiveness of the framework with respect to other frameworks for abductive logic programming with constraints, and the overall computational performances of the implemented system. The second part of the dissertation presents a novel application of the CIFF proof procedure as the computational engine of a tool, the CIFFWEB system, for checking and (possibly) repairing faulty web sites. Indeed, the exponential growth of the WWW raises the question of maintaining and automatically repairing web sites, in particular when the designers of these sites require them to exhibit certain properties at both structural and data level. The capability of maintaining and repairing web sites is also important to ensure the success of the Semantic Web vision. As the Semantic Web relies upon the definition and the maintenance of consistent data schemas (XML/XMLSchema, RDF/RDFSchema, OWL and so on), tools for reasoning over such schemas (and possibly extending the reasoning to multiple web pages) show great promise. The CIFFWEB system is such a tool which allows to verify and to repair XML web sites instances, against sets of requirements which have to be fulfilled, through abductive reasoning. We define an expressive characterization of rules for checking and repairing web sites' errors and we do a formal mapping of a fragment of a well known XML query language, namely Xcerpt, to abductive logic programs suitable to fed as input to the CIFF proof procedure. Finally, the CIFF proof procedure detects the errors and possibly suggests modifications to the XML instances to repair them. The soundness of this process is directly inherited from the soundness of CIFF

Negative non-ground queries in well founded semantics

Dissertação apresentada na Faculdade de Ciências e Tecnologia da Universidade Nova de Lisboa para obtenção do grau de Mestre em Computational LogicThe existing implementations of Well Founded Semantics restrict or forbid the use of variables when using negative queries, something which is essential for using logic programming as a programming language. We present a procedure to obtain results under the Well Founded Semantics that removes this constraint by combining two techniques: the transformation presented in [MMNMH08] to obtain from a program its dual and the derivation procedure presented in [PAP+91] to determine if a query belongs or not to the Well Founded Model of a program. Some problems arise during their combination, mainly due to the original environment for which each one was designed: results obtained in the first one obey a variant of Kunen Semantics and non-ground programs are not allowed (or previously grounded) in the second one. Most of these problems were solved by using abductive techniques, which lead us to observe that the existing implementations of abduction in logic programming disallow the use of variables. The reason for that is the impossibility to evaluate non-ground queries, so it seemed interesting to develop an abductive framework making use of our negation system. Both goals are achieved in this thesis: the capability of solving non-ground queries under Well Founded Semantics and the use of variables in abductive logic programming

Logic programming for deliberative robotic task planning

Over the last decade, the use of robots in production and daily life has increased. With increasingly complex tasks and interaction in different environments including humans, robots are required a higher level of autonomy for efficient deliberation. Task planning is a key element of deliberation. It combines elementary operations into a structured plan to satisfy a prescribed goal, given specifications on the robot and the environment. In this manuscript, we present a survey on recent advances in the application of logic programming to the problem of task planning. Logic programming offers several advantages compared to other approaches, including greater expressivity and interpretability which may aid in the development of safe and reliable robots. We analyze different planners and their suitability for specific robotic applications, based on expressivity in domain representation, computational efficiency and software implementation. In this way, we support the robotic designer in choosing the best tool for his application

A Statically Typed Logic Context Query Language With Parametric Polymorphism and Subtyping

The objective of this thesis is programming language support for context-sensitive program adaptations. Driven by the requirements for context-aware adaptation languages, a statically typed Object-oriented logic Context Query Language  (OCQL) was developed, which is suitable for integration with adaptation languages based on the Java type system. The ambient information considered in context-aware applications often originates from several, potentially distributed sources. OCQL employs the Semantic Web-language RDF Schema to structure and combine distributed context information. OCQL offers parametric polymorphism, subtyping, and a fixed set of meta-predicates. Its type system is based on mode analysis and a subset of Java Generics. For this reason a mode-inference approach for normal logic programs that considers variable aliasing and sharing was extended to cover all-solution predicates. OCQL is complemented by a service-oriented context-management infrastructure that supports the integration of OCQL with runtime adaptation approaches. The applicability of the language and its infrastructure were demonstrated with the context-aware aspect language CSLogicAJ. CSLogicAJ aspects encapsulate context-aware behavior and define in which contextual situation and program execution state the behavior is woven into the running program. The thesis concludes with a case study analyzing how runtime adaptation of mobile applications can be supported by pure object-, service- and context-aware aspect-orientation. Our study has shown that CSLogicAJ can improve the modularization of context-aware applications and reduce anticipation of runtime adaptations when compared to other approaches

Hybrid Rules with Well-Founded Semantics

A general framework is proposed for integration of rules and external first order theories. It is based on the well-founded semantics of normal logic programs and inspired by ideas of Constraint Logic Programming (CLP) and constructive negation for logic programs. Hybrid rules are normal clauses extended with constraints in the bodies; constraints are certain formulae in the language of the external theory. A hybrid program is a pair of a set of hybrid rules and an external theory. Instances of the framework are obtained by specifying the class of external theories, and the class of constraints. An example instance is integration of (non-disjunctive) Datalog with ontologies formalized as description logics. The paper defines a declarative semantics of hybrid programs and a goal-driven formal operational semantics. The latter can be seen as a generalization of SLS-resolution. It provides a basis for hybrid implementations combining Prolog with constraint solvers. Soundness of the operational semantics is proven. Sufficient conditions for decidability of the declarative semantics, and for completeness of the operational semantics are given