1,783 research outputs found
Constraint Handling Rules with Binders, Patterns and Generic Quantification
Constraint Handling Rules provide descriptions for constraint solvers.
However, they fall short when those constraints specify some binding structure,
like higher-rank types in a constraint-based type inference algorithm. In this
paper, the term syntax of constraints is replaced by -tree syntax, in
which binding is explicit; and a new generic quantifier is introduced,
which is used to create new fresh constants.Comment: Paper presented at the 33nd International Conference on Logic
Programming (ICLP 2017), Melbourne, Australia, August 28 to September 1, 2017
16 pages, LaTeX, no PDF figure
Scavenger 0.1: A Theorem Prover Based on Conflict Resolution
This paper introduces Scavenger, the first theorem prover for pure
first-order logic without equality based on the new conflict resolution
calculus. Conflict resolution has a restricted resolution inference rule that
resembles (a first-order generalization of) unit propagation as well as a rule
for assuming decision literals and a rule for deriving new clauses by (a
first-order generalization of) conflict-driven clause learning.Comment: Published at CADE 201
Nominal Unification from a Higher-Order Perspective
Nominal Logic is a version of first-order logic with equality, name-binding,
renaming via name-swapping and freshness of names. Contrarily to higher-order
logic, bindable names, called atoms, and instantiable variables are considered
as distinct entities. Moreover, atoms are capturable by instantiations,
breaking a fundamental principle of lambda-calculus. Despite these differences,
nominal unification can be seen from a higher-order perspective. From this
view, we show that nominal unification can be reduced to a particular fragment
of higher-order unification problems: Higher-Order Pattern Unification. This
reduction proves that nominal unification can be decided in quadratic
deterministic time, using the linear algorithm for Higher-Order Pattern
Unification. We also prove that the translation preserves most generality of
unifiers
Memoization for Unary Logic Programming: Characterizing PTIME
We give a characterization of deterministic polynomial time computation based
on an algebraic structure called the resolution semiring, whose elements can be
understood as logic programs or sets of rewriting rules over first-order terms.
More precisely, we study the restriction of this framework to terms (and logic
programs, rewriting rules) using only unary symbols. We prove it is complete
for polynomial time computation, using an encoding of pushdown automata. We
then introduce an algebraic counterpart of the memoization technique in order
to show its PTIME soundness. We finally relate our approach and complexity
results to complexity of logic programming. As an application of our
techniques, we show a PTIME-completeness result for a class of logic
programming queries which use only unary function symbols.Comment: Soumis {\`a} LICS 201
Processing underspecified semantic representations in the constraint language for lambda structures
The constraint language for lambda structures (CLLS) is an expressive language of tree descriptions which combines dominance constraints with powerful parallelism and binding constraints. CLLS was introduced as a uniform framework for defining underspecified semantics representations of natural language sentences, covering scope, ellipsis, and anaphora. This article presents saturation-based algorithms for processing the complete language of CLLS. It also gives an overview of previous results on questions of processing and complexity.Liegt nicht vor
Boxy Types: Inference for Higher-Rank Types and Impredicativity
Languages with rich type systems are beginning to employ a blend of type inference and type checking, so that the type inference engine is guided by programmer-supplied type annotations. In this paper we show, for the first time, how to combine the virtues of two well-established ideas: unification-based inference, and bidirectional propagation of type annotations. The result is a type system that conservatively extends Hindley-Milner, and yet supports both higher-rank types and impredicativity
The generation of concurrent code for declarative languages
PhD ThesisThis thesis presents an approach to the implementation of declarative languages
on a simple, general purpose concurrent architecture. The safe exploitation of
the available concurrency is managed by relatively sophisticated code generation
techniques to transform programs into an intermediate concurrent machine
code. Compilation techniques are discussed for 1'-HYBRID, a strongly typed
applicative language, and for 'c-HYBRID, a concurrent, nondeterministic logic
language.
An approach is presented for 1'- HYBRID whereby the style of programming
influences the concurrency utilised when a program executes. Code transformation
techniques are presented which generalise tail-recursion optimisation,
allowing many recursive functions to be modelled by perpetual processes. A
scheme is also presented to allow parallelism to be increased by the use of local
declarations, and constrained by the use of special forms of identity function.
In order to preserve determinism in the language, a novel fault handling
mechanism is used, whereby exceptions generated at run-time are treated as a
special class of values within the language.
A description is given of ,C-HYBRID, a dialect of the nondeterministic logic
language Concurrent Prolog. The language is embedded within the applicative
language 1'-HYBRID, yielding a combined applicative and logic programming
language. Various cross-calling techniques are described, including the use of
applicative scoping rules to allow local logical assertions.
A description is given of a polymorphic typechecking algorithm for logic
programs, which allows different instances of clauses to unify objects of different
types. The concept of a method is derived to allow unification Information to
be passed as an implicit argument to clauses which require it. In addition,
the typechecking algorithm permits higher-order objects such as functions to be
passed within arguments to clauses.
Using Concurrent Prolog's model of concurrency, techniques are described
which permit compilation of 'c-HYBRID programs to abstract machine code derived
from that used for the applicative language. The use of methods allows
polymorphic logic programs to execute without the need for run-time type information
in data structures.The Science and Engineering Research Council
- …