A Tabulation Proof Procedure for First-order Residuated Logic Programs: Soundness, Completeness and Optimizations

2006 ◽  
Author(s):  
C.V. Damasio ◽  
J. Medina ◽  
M. Ojeda-Aciego
Keyword(s):  
Logic Programs ◽  
First Order ◽  
Proof Procedure

scholarly journals An Interpolation-based Compiler and Optimizer for Relational Queries (System design Report)

10.29007/53fk ◽  
2018 ◽  
Author(s):  
David Toman ◽  
Grant Weddell
Keyword(s):  
System Design ◽  
Cost Model ◽  
Interpolation Theorem ◽  
Database Schema ◽  
External Cost ◽  
First Order ◽  
User Query ◽  
Order Constraints ◽  
Proof Procedure ◽  
Distinguished Subset

We outline the implementation of a query compiler for relational queries that generates query plans with respect to a database schema, that is, a set of arbitrary first-order constraints, and a distinguished subset of predicate symbols from the underlying signature that correspond to access paths. The compiler is based on a variant of the Craig interpolation theorem, with reasoning realized via a modified analytic tableau proof procedure. This procedure decouples the generation of candidate plans that are interpolants from the tableau proof procedure, and applies A*-based search with respect to an external cost model to arbitrate among the alternative candidate plans. The tableau procedure itself is implemented as a virtual machine that operates on a compiled and optimized byte-code that faithfully implements reasoning with respect to the database schema constraints and a user query.

scholarly journals Learning Relational Representations with Auto-encoding Logic Programs

2019 ◽  
Author(s):  
Sebastijan Dumancic ◽  
Tias Guns ◽  
Wannes Meert ◽  
Hendrik Blockeel
Keyword(s):  
Deep Learning ◽  
Relational Learning ◽  
Order Logic ◽  
First Order Logic ◽  
Relational Data ◽  
Logic Programs ◽  
Learning Methods ◽  
First Order ◽  
Relational Structures ◽  
Representation Language

Deep learning methods capable of handling relational data have proliferated over the past years. In contrast to traditional relational learning methods that leverage first-order logic for representing such data, these methods aim at re-representing symbolic relational data in Euclidean space. They offer better scalability, but can only approximate rich relational structures and are less flexible in terms of reasoning. This paper introduces a novel framework for relational representation learning that combines the best of both worlds. This framework, inspired by the auto-encoding principle, uses first-order logic as a data representation language, and the mapping between the the original and latent representation is done by means of logic programs instead of neural networks. We show how learning can be cast as a constraint optimisation problem for which existing solvers can be used. The use of logic as a representation language makes the proposed framework more accurate (as the representation is exact, rather than approximate), more flexible, and more interpretable than deep learning methods. We experimentally show that these latent representations are indeed beneficial in relational learning tasks.

A PROOF PROCEDURE FOR TEMPORAL LOGIC PROGRAMMING

2004 ◽  
Vol 15 (02) ◽  
pp. 417-443 ◽  
Author(s):  
MANOLIS GERGATSOULIS ◽  
CHRISTOS NOMIKOS
Keyword(s):  
Logic Programming ◽  
Programming Languages ◽  
Temporal Logic ◽  
Programming Language ◽  
Branching Time ◽  
Logic Programs ◽  
Temporal Logic Programming ◽  
Time Logic ◽  
Proof Procedure ◽  
Resolution Proof

In this paper, we propose a new resolution proof procedure for the branching-time logic programming language Cactus. The particular strength of the new proof procedure, called CSLD-resolution, is that it can handle, in a more general way, open-ended queries, i.e. goal clauses that include atoms which do not refer to specific moments in time, without the need of enumerating all their canonical instances. We also prove soundness, completeness and independence of the computation rule for CSLD-resolution. The new proof procedure overcomes the limitations of a family of proof procedures for temporal logic programming languages, which were based on the notions of canonical program and goal clauses. Moreover, it applies directly to Chronolog programs and it can be easily extended to apply to multi-dimensional logic programs as well as to Chronolog(MC) programs.

Sign in / Sign up

Export Citation Format

Share Document