scholarly journals Performing fully parallel constraint logic programming on a quantum annealer

2018 ◽  
Vol 18 (5-6) ◽  
pp. 928-949 ◽  
Author(s):  
SCOTT PAKIN
Keyword(s):  
Logic Programming ◽  
Constraint Logic Programming ◽  
Logic Programs ◽  
Machine Model ◽  
Computing Systems ◽  
Model Hamiltonian ◽  
Constraint Logic Programs ◽  
Classical Computing ◽  
Specialized Hardware ◽  
High Level

AbstractAquantum annealerexploits quantum effects to solve a particular type of optimization problem. The advantage of this specialized hardware is that it effectively considers all possible solutions in parallel, thereby potentially outperforming classical computing systems. However, despite quantum annealers having recently become commercially available, there are relatively few high-level programming models that target these devices. In this article, we show how to compile a subset of Prolog enhanced with support for constraint logic programming into a two-local Ising-model Hamiltonian suitable for execution on a quantum annealer. In particular, we describe the series of transformations one can apply to convert constraint logic programs expressed in Prolog into an executable form that bears virtually no resemblance to a classical machine model yet that evaluates the specified constraints in a fully parallel manner. We evaluate our efforts on a 1,095-qubit D-Wave 2X quantum annealer and describe the approach's associated capabilities and shortcomings.

Failure tabled constraint logic programming by interpolation

2013 ◽  
Vol 13 (4-5) ◽  
pp. 593-607 ◽  
Author(s):  
GRAEME GANGE ◽  
JORGE A. NAVAS ◽  
PETER SCHACHTE ◽  
HARALD SØNDERGAARD ◽  
PETER J. STUCKEY
Keyword(s):  
Logic Programming ◽  
Constraint Logic Programming ◽  
Logic Programs ◽  
Execution Strategy ◽  
Speed Up ◽  
Constraint Logic Programs

AbstractWe present a new execution strategy for constraint logic programs calledFailure Tabled CLP. Similarly toTabled CLPour strategy records certain derivations in order to prune further derivations. However, our method only learns fromfailed derivations. This allows us to computeinterpolantsrather thanconstraint projectionfor generation ofreuse conditions. As a result, our technique can be used where projection is too expensive or does not exist. Our experiments indicate that Failure Tabling can speed up the execution of programs with many redundant failed derivations as well as achieve termination in the presence of infinite executions.

scholarly journals Using parametric set constraints for locating errors in CLP programs

2002 ◽  
Vol 2 (4-5) ◽  
pp. 549-610 ◽  
Author(s):  
WŁODZIMIERZ DRABENT ◽  
JAN MAŁUSZYŃSKI ◽  
PAWEŁ PIETRZAK
Keyword(s):  
Logic Programming ◽  
Constraint Logic Programming ◽  
Logic Programs ◽  
Set Constraints ◽  
Verification Conditions ◽  
Main Technique ◽  
Polymorphic Type ◽  
Correctness Of Programs

This paper introduces a framework of parametric descriptive directional types for Constraint Logic Programming (CLP). It proposes a method for locating type errors in CLP programs, and presents a prototype debugging tool. The main technique used is checking correctness of programs w.r.t. type specifications. The approach is based on a generalization of known methods for proving the correctness of logic programs to the case of parametric specifications. Set constraint techniques are used for formulating and checking verification conditions for (parametric) polymorphic type specifications. The specifications are expressed in a parametric extension of the formalism of term grammars. The soundness of the method is proved, and the prototype debugging tool supporting the proposed approach is illustrated on examples. The paper is a substantial extension of the previous work by the same authors concerning monomorphic directional types.

scholarly journals Design and implementation of a tracer driver: Easy and efficient dynamic analyses of constraint logic programs

2008 ◽  
Vol 8 (5-6) ◽  
pp. 581-609
Author(s):  
LUDOVIC LANGEVINE ◽  
MIREILLE DUCASSÉ
Keyword(s):  
Dynamic Analysis ◽  
Low Cost ◽  
Logic Programs ◽  
Design And Implementation ◽  
On Demand ◽  
Front End ◽  
Analysis Tools ◽  
Dynamic Analyses ◽  
Constraint Logic Programs ◽  
High Level

AbstractTracers provide users with useful information about program executions. In this article, we propose a “tracer driver”. From a single tracer, it provides a powerful front-end enabling multiple dynamic analysis tools to be easily implemented, while limiting the overhead of the trace generation. The relevant execution events are specified by flexible event patterns and a large variety of trace data can be given either systematically or “on demand”. The proposed tracer driver has been designed in the context of constraint logic programming (CLP); experiments have been made within GNU-Prolog. Execution views provided by existing tools have been easily emulated with a negligible overhead. Experimental measures show that the flexibility and power of the described architecture lead to good performance. The tracer driver overhead is inversely proportional to the average time between two traced events. Whereas the principles of the tracer driver are independent of the traced programming language, it is best suited for high-level languages, such as CLP, where each traced execution event encompasses numerous low-level execution steps. Furthermore, CLP is especially hard to debug. The current environments do not provide all the useful dynamic analysis tools. They can significantly benefit from our tracer driver which enables dynamic analyses to be integrated at a very low cost.

scholarly journals Stable-unstable semantics: Beyond NP with normal logic programs

2016 ◽  
Vol 16 (5-6) ◽  
pp. 570-586 ◽  
Author(s):  
BART BOGAERTS ◽  
TOMI JANHUNEN ◽  
SHAHAB TASHARROFI
Keyword(s):  
Logic Programming ◽  
Logic Programs ◽  
New Paradigm ◽  
Search Problems ◽  
Quantified Boolean Formulas ◽  
Disjunctive Logic Programs ◽  
Boolean Formulas ◽  
Normal Logic ◽  
The Rich ◽  
High Level

AbstractStandard answer set programming (ASP) targets at solving search problems from the first level of the polynomial time hierarchy (PH). Tackling search problems beyond NP using ASP is less straightforward. The class of disjunctive logic programs offers the most prominent way of reaching the second level of the PH, but encoding respective hard problems as disjunctive programs typically requires sophisticated techniques such as saturation or meta-interpretation. The application of such techniques easily leads to encodings that are inaccessible to non-experts. Furthermore, while disjunctive ASP solvers often rely on calls to a (co-)NP oracle, it may be difficult to detect from the input program where the oracle is being accessed. In other formalisms, such as Quantified Boolean Formulas (QBFs), the interface to the underlying oracle is more transparent as it is explicitly recorded in the quantifier prefix of a formula. On the other hand, ASP has advantages over QBFs from the modeling perspective. The rich high-level languages such as ASP-Core-2 offer a wide variety of primitives that enable concise and natural encodings of search problems. In this paper, we present a novel logic programming–based modeling paradigm that combines the best features of ASP and QBFs. We develop so-calledcombined logic programsin which oracles are directly cast as (normal) logic programs themselves. Recursive incarnations of this construction enable logic programming on arbitrarily high levels of the PH. We develop a proof-of-concept implementation for our new paradigm.

scholarly journals Evaluation of the Implementation of an Abstract Interpretation Algorithm using Tabled CLP

2019 ◽  
Vol 19 (5-6) ◽  
pp. 1107-1123
Author(s):  
JOAQUÍN ARIAS ◽  
MANUEL CARRO
Keyword(s):  
Logic Programming ◽  
Abstract Interpretation ◽  
Constraint Logic Programming ◽  
Additional Cost ◽  
Logic Programs ◽  
Semantic Equivalence ◽  
Constraint Solver ◽  
Abstract Domains ◽  
Interpretation Algorithm ◽  
Branch Switching

AbstractCiaoPP is an analyzer and optimizer for logic programs, part of the Ciao Prolog system. It includes PLAI, a fixpoint algorithm for the abstract interpretation of logic programs which we adapt to use tabled constraint logic programming. In this adaptation, the tabling engine drives the fixpoint computation, while the constraint solver handles the LUB of the abstract substitutions of different clauses. That simplifies the code and improves performance, since termination, dependencies, and some crucial operations (e.g., branch switching and resumption) are directly handled by the tabling engine. Determining whether the fixpoint has been reached uses semantic equivalence, which can decide that two syntactically different abstract substitutions represent the same element in the abstract domain. Therefore, the tabling analyzer can reuse answers in more cases than an analyzer using syntactical equality. This helps achieve better performance, even taking into account the additional cost associated to these checks. Our implementation is based on the TCLP framework available in Ciao Prolog and is one-third the size of the initial fixpoint implementation in CiaoPP. Its performance has been evaluated by analyzing several programs using different abstract domains.

scholarly journals A design and implementation of the Extended Andorra Model

2011 ◽  
Vol 12 (3) ◽  
pp. 319-360 ◽  
Author(s):  
RICARDO LOPES ◽  
VÍTOR SANTOS COSTA ◽  
FERNANDO SILVA
Keyword(s):  
Logic Programming ◽  
Computational Models ◽  
Search Space ◽  
Basic Design ◽  
Logic Programs ◽  
Performance Study ◽  
Control Rules ◽  
Advanced Search ◽  
High Level ◽  
And Control

AbstractLogic programming provides a high-level view of programming, giving implementers a vast latitude into what techniques to explore to achieve the best performance for logic programs. Towards obtaining maximum performance, one of the holy grails of logic programming has been to design computational models that could be executed efficiently and that would allow both for a reduction of the search space and for exploiting all the available parallelism in the application. These goals have motivated the design of the Extended Andorra Model (EAM), a model where goals that do not constrain nondeterministic goals can execute first. In this work, we present and evaluate the Basic design for EAM, a system that builds upon David H. D. Warren's original EAM with Implicit Control. We provide a complete description and implementation of the Basic design for EAM System as a set of rewrite and control rules. We present the major data structures and execution algorithms that are required for efficient execution, and evaluate system performance. A detailed performance study of our system is included. Our results show that the system achieves acceptable base performance and that a number of applications benefit from the advanced search inherent to the EAM.

scholarly journals A non-termination criterion for binary constraint logic programs

2009 ◽  
Vol 9 (02) ◽  
pp. 145-164 ◽  
Author(s):  
ÉTIENNE PAYET ◽  
FRED MESNARD
Keyword(s):  
Logic Programming ◽  
Logical Form ◽  
Operational Definition ◽  
Research Topic ◽  
Logic Programs ◽  
Termination Analysis ◽  
Binary Constraint ◽  
Termination Criterion ◽  
Constraint Logic Programs ◽  
The One

AbstractOn the one hand, termination analysis of logic programs is now a fairly established research topic within the logic programming community. On the other hand, non-termination analysis seems to remain a much less attractive subject. If we divide this line of research into two kinds of approaches, dynamic versus static analysis, this paper belongs to the latter. It proposes a criterion for detecting non-terminating atomic queries with respect to binary constraint logic programming (CLP) rules, which strictly generalizes our previous works on this subject. We give a generic operational definition and an implemented logical form of this criterion. Then we show that the logical form is correct and complete with respect to the operational definition.

Sign in / Sign up

Export Citation Format

Share Document