Declarative Logic Programming Research Articles

Finding Cross-Rule Optimization Bugs in Datalog Engines

Datalog is a popular and widely-used declarative logic programming language. Datalog engines apply many cross-rule optimizations; bugs in them can cause incorrect results. To detect such optimization bugs, we propose an automated testing approach called Incremental Rule Evaluation (IRE), which synergistically tackles the test oracle and test case generation problem. The core idea behind the test oracle is to compare the results of an optimized program and a program without cross-rule optimization; any difference indicates a bug in the Datalog engine. Our core insight is that, for an optimized, incrementally-generated Datalog program, we can evaluate all rules individually by constructing a reference program to disable the optimizations that are performed among multiple rules. Incrementally generating test cases not only allows us to apply the test oracle for every new rule generated—we also can ensure that every newly added rule generates a non-empty result with a given probability and eschew recomputing already-known facts. We implemented IRE as a tool named Deopt, and evaluated Deopt on four mature Datalog engines, namely Soufflé, CozoDB, μZ, and DDlog, and discovered a total of 30 bugs. Of these, 13 were logic bugs, while the remaining were crash and error bugs. Deopt can detect all bugs found by queryFuzz, a state-of-the-art approach. Out of the bugs identified by Deopt, queryFuzz might be unable to detect 5. Our incremental test case generation approach is efficient; for example, for test cases containing 60 rules, our incremental approach can produce 1.17× (for DDlog) to 31.02× (for Soufflé) as many valid test cases with non-empty results as the naive random method. We believe that the simplicity and the generality of the approach will lead to its wide adoption in practice.

System Predictor: Grounding Size Estimator for Logic Programs under Answer Set Semantics

AbstractAnswer set programming is a declarative logic programming paradigm geared towards solving difficult combinatorial search problems. While different logic programs can encode the same problem, their performance may vary significantly. It is not always easy to identify which version of the program performs the best. We present the system predictor (and its algorithmic backend) for estimating the grounding size of programs, a metric that can influence a performance of a system processing a program. We evaluate the impact of predictor when used as a guide for rewritings produced by the answer set programming rewriting tools projector and lpopt. The results demonstrate potential to this approach.

Scallop: A Language for Neurosymbolic Programming

We present Scallop, a language which combines the benefits of deep learning and logical reasoning. Scallop enables users to write a wide range of neurosymbolic applications and train them in a data- and compute-efficient manner. It achieves these goals through three key features: 1) a flexible symbolic representation that is based on the relational data model; 2) a declarative logic programming language that is based on Datalog and supports recursion, aggregation, and negation; and 3) a framework for automatic and efficient differentiable reasoning that is based on the theory of provenance semirings. We evaluate Scallop on a suite of eight neurosymbolic applications from the literature. Our evaluation demonstrates that Scallop is capable of expressing algorithmic reasoning in diverse and challenging AI tasks, provides a succinct interface for machine learning programmers to integrate logical domain knowledge, and yields solutions that are comparable or superior to state-of-the-art models in terms of accuracy. Furthermore, Scallop's solutions outperform these models in aspects such as runtime and data efficiency, interpretability, and generalizability.

Synthesizing Formal Network Specifications From Input-Output Examples

We propose, a tool that synthesizes network specifications in a declarative logic programming language from input-output examples. aims to accelerate the adoption of formal verification in networking practice, by reducing the effort and expertise required to specify network models or properties. aims to be i) highly expressive, capable of synthesizing network specifications with complex semantics; ii) scalable, by virtue of using a novel best-first search algorithm to efficiently explore an unbounded solution space, and iii) robust, avoiding the need for exhaustive input-output examples by actively generating new examples. Our experiments demonstrate that can synthesize a wide range of specifications used in network verification, analysis, and implementations. Furthermore, improves upon existing approaches in terms of expressiveness, robustness to examples, and the quality of synthesized programs.

Benchmarking Answer Set Programming systems for resource allocation in business processes

Declarative logic programming formalisms are well-suited to model various optimization and configuration problems. In particular, Answer Set Programming (ASP) systems have gained popularity, for example, to deal with scheduling problems present in several domains. The main goal of this paper is to devise a benchmark for ASP systems to assess their performance when dealing with complex and realistic resource allocation with objective optimization. To this end, we provide (i) a declarative and compact encoding of the resource allocation problem in ASP (compliant with the ASP Core-2 standard), (ii) a configurable ASP systems benchmark named BRANCH that is equipped with resource allocation instance generators that produce problem instances of different sizes with adjustable parameters (e.g., in terms of process complexity, organizational and temporal constraints), and (iii) an evaluation of four state-of-the-art ASP systems using BRANCH. This solid application-oriented benchmark serves the ASP community with a tool that leads to potential optimizations and improvements in encodings and further drives the development of ASP solvers. On the other hand, resource allocation is an important problem that still lacks adequate automated tool support in the context of Business Process Management (BPM). The ASP problem encoding, ready-to-use ASP systems and problem instance generators benefit the BPM community to tackle the problem at scale and mitigate the lack of openly available problem instance data.

Logic Programming with Post-Quantum Cryptographic Primitives for Smart Contract on Quantum-Secured Blockchain.

This paper investigates the usage of logic and logic programming in the design of smart contracts. Our starting point is the logic-based programming language for smart contracts used in a recently proposed framework of quantum-secured blockchain, called Logicontract (LC). We then extend the logic used in LC by answer set programming (ASP), a modern approach to declarative logic programming. Using ASP enables us to write various interesting smart contracts, such as conditional payment, commitment, multi-party lottery and legal service. A striking feature of our ASP implementation proposal is that it involves post-quantum cryptographic primitives, such as the lattice-based public key encryption and signature. The adoption of the post-quantum cryptographic signature overcomes a specific limitation of LC in which the unconditionally secure signature, despite its strength, offers limited protection for users of the same node.

Analysis of the methods for competing recursion in recursive riles in the logic programming language Prolog

One of the developing trends in programming is the logic programming associated with the implementation of tools for creating artificial intelligence. One of such programming languages is the nonprocedural declarative logic programming language Prolog. This article is dedicated to the use of recursive rules in Prolog software. The goal of this work lies in analysis of the methods for completing recursive calls in recursive rules, as well as in explication of the use of such methods on the examples of programs with recursion. The author explores the specialized literature on the topic, generalized and systematizes the data, as well as tested the programs and the progress of their implementation. Recursive rule in the Prolog software sets an infinite cycle of repetition of predicates. For completing the recursive cycle, it is necessary to set a condition within the program that would end the cycle. The article examines the variants of organizing recursions with the completion of infinite cycle. The examples used in the article allows using them as the basis for programming in language Prolog for solving similar tasks. The acquired results are valuable for further development of the use of recursive predicates in logic programming languages.

Data Sensitivity and Classification Management: A Declarative Approach

Data protection according to sensitivity and classification has become a mandatory security mechanism for safety- and security-critical organizations. There is however no consensus on how to implement data sensitivity and classification in existing big-data systems. An approach is proposed to express and compute data sensitivity and multidimensional data classification in fine granularity. The approach is based on a declarative logic programming language, which is able to separate security requirement definitions and deduction from implementation details. Expressing and validating the security rules can be done transparently, ignoring underlying technical migrations and infrastructure differences. It is therefore possible to use the same set of security rules among various big data systems. Compared to other logic-programming-based approach, the declarative nature also makes it preferable for modular development and system maintenance. Sensitivity specification is shown and security analysis including conflict detection and resolution is performed on the same platform. Several typical types of data classification have also been illustrated and analyzed. The approach is capable of expressing complex classification methods, including classification with multiple parameters, classification according to graph computation, and classification based on relations among multiple data objects. The logic programming-based method is shown to have more expressive power and better complexity performance than conventional methods.

Algorithmic definitions for KLM-style defeasible disjunctive Datalog

Datalog is a declarative logic programming language that uses classical logical reasoning as its basic form of reasoning. Defeasible reasoning is a form of non-classical reasoning that is able to deal with exceptions to general assertions in a formal manner. The KLM approach to defeasible reasoning is an axiomatic approach based on the concept of plausible inference. Since Datalog uses classical reasoning, it is currently not able to handle defeasible implications and exceptions. We aim to extend the expressivity of Datalog by incorporating KLM-style defeasible reasoning into classical Datalog. We present a systematic approach for extending the KLM properties and a well-known form of defeasible entailment: Rational Closure. We conclude by exploring Datalog extensions of less conservative forms of defeasible entailment: Relevant and Lexicographic Closure. We provide algorithmic definitions for these forms of defeasible entailment and prove that the definitions are LM-rational.

Fixpoints for the masses: programming with first-class Datalog constraints

Datalog is a declarative logic programming language that has been used in a variety of applications, including big-data analytics, language processing, networking and distributed systems, and program analysis. In this paper, we propose first-class Datalog constraints as a mechanism to construct, compose, and solve Datalog programs at run time. The benefits are twofold: We gain the full power of a functional programming language to operate on Datalog constraints-as-values, while simultaneously we can use Datalog where it really shines: to declaratively express and solve fixpoint problems. We present an extension of the lambda calculus with first-class Datalog constraints, including its semantics and a type system with row polymorphism based on Hindley-Milner. We prove soundness of the type system and implement it as an extension of the Flix programming language.

Spreadsheets for Legal Reasoning: The Continued Promise of Declarative Logic Programming in Law

The legal services market is one in which there is too much demand, and too little supply. One method of increasing supply in a market is to increase efficiency by automating. Automated legal services require the automation of legal reasoning. Declarative logic programming (DLP) has long been recognized as well-suited to the automation of legal reasoning. This dissertation reviews the legal academic literature surrounding the automation of legal services using DLP, which has been discussed primarily with regard to how it can be used to build “expert systems”. This dissertation argues that most of the criticisms of the use of expert systems for automating legal services can be addressed by using modern DLP technologies, conceiving of the encoding as being representative of an interpretation of the law rather than the law’s correct meaning, and increasing ease-of-use for non-programmers. The dissertation then proposes a set of 7 criteria of suitability for DLP tools developed from a legal services automation perspective. A survey of available tools is performed, comparing the available tools to these criteria. The dissertation advocates for the development of open source DLP tools that have both accessibility features (ease of use and price), and at least one of the five technical features. The dissertation concludes with the description of an opensource tool developed by the author as an ABA Innovation Fellowship project, which is open-source, free, aims to be easy to use, and implements case-based reasoning to allow users to automate reasoning around open-textured legal concepts.

Effective interactive resolution of static analysis alarms

We propose an interactive approach to resolve static analysis alarms. Our approach synergistically combines a sound but imprecise analysis with precise but unsound heuristics, through user interaction. In each iteration, it solves an optimization problem to find a set of questions for the user such that the expected payoff is maximized. We have implemented our approach in a tool, Ursa, that enables interactive alarm resolution for any analysis specified in the declarative logic programming language Datalog. We demonstrate the effectiveness of Ursa on a state-of-the-art static datarace analysis using a suite of 8 Java programs comprising 41-194 KLOC each. Ursa is able to eliminate 74% of the false alarms per benchmark with an average payoff of 12× per question. Moreover, Ursa prioritizes user effort effectively by posing questions that yield high payoffs earlier.

Radial Restraint: A Semantically Clean Approach to Bounded Rationality for Logic Programs

Declarative logic programs (LP) based on the well-founded semantics (WFS) are widely used for knowledge representation (KR). Logical functions are desirable expressively in KR, but when present make LP inferencing become undecidable. In this paper, we present radial restraint: a novel approach to bounded rationality in LP. Radial restraint is parameterized by a norm that measures the syntactic complexity of a term, along with an abstraction function based on that norm. When a term exceeds a bound for the norm, the term is assigned the WFS's third truth-value of undefined. If the norm is finitary, radial restraint guarantees finiteness of models and decidability of inferencing, even when logical functions are present. It further guarantees soundness, even when non-monotonicity is present. We give a fixed-point semantics for radially restrained well-founded models which soundly approximate well-founded models. We also show how to perform correct inferencing relative to such models, via SLG_ABS, an extension of tabled SLG resolution that uses norm-based abstraction functions. Finally we discuss how SLG_ABS is implemented in the engine of XSB Prolog, and scales to knowledge bases with more than 10^8 rules and facts.

Towards a Calendar Agent Society with Intelligent Agents in ASP-Updates

We present the analysis and some preliminary specifications to describe a multi-agent society to represent dynamic appointments under in Answer-Sets Programming, by means of knowledge-base updates. This is a case study to represent a group of intelligent BDI agents with a common goal of scheduling a meeting, and we use an example to show how to distribute and change their specifications under unforeseen circumstances, as well as a simple protocol to realise a consensual meeting. We claim that the proposed framework is appropriate to have the benefits from a strong foundation like Answer-Sets Programming, simplicity for its declarative logic programming, as well as practicality for existent implemented solvers, which can be used to implement a more-complete and useful system of agent societies.

Modelling autonomic dataspaces using answer sets

This paper presents an approach for managing an autonomic data space, able to automatically define views that fulfill the requirements of a set of users, and adjust them as the data space evolves. An autonomic data space deals with incomplete knowledge to manage itself because of the heterogeneity and the lack of metadata related to the resources it integrates. Our approach exploits the expressiveness of stable models and the K action language for expressing the data space management functions. It is based on a model for specifying an autonomic dataspace expressed using answer set programming (ASP). ASP is a type of declarative logic programming particularly useful in knowledge-intensive applications. It is based on the stable semantics (answer sets), which allows negation as failure and applies the ideas of auto-epistemic logic to distinguish between what is true and what is believed.

The Space Package: Tight Integration between Space and Semantics

Interpretation of spatial features often requires combined reasoning over geometry and semantics. We introduce the Space package, an open source SWI-Prolog extension that provides spatial indexing capabilities. Together with the existing semantic web reasoning capabilities of SWI-Prolog, this allows efficient integration of spatial and semantic queries and provides an infrastructure for declarative programming with space and semantics. There are few systems that provide indexing and reasoning facilities for both spatial and semantic data. A common solution is to combine separate semantic reasoning and geospatial services. Such loose coupling has the disadvantage that each service cannot make use of the statistics of the other. This makes optimization of such a service-oriented architecture hard. The SWI-Prolog Space and Semantic web packages provide a native Prolog interface to both spatial and semantic indexing and reasoning, which makes it easy to write combined query optimizers. Another advantage of the Space package is that it allows declarative logic programming, which means in practice that you say what you want to compute instead of how to compute it. The actual indexing machinery is encapsulated inside Prolog predicates. In this article we describe the interface of the Space package, compare its functionality to alternative software libraries, and show how to work with it using three example applications. These example illustrations include reasoning over movement patterns, dynamically loading geospatial linked data off the semantic web, and setting up a simple KML server.

On a decision procedure for quantified linear programs

Quantified linear programming is the problem of checking whether a polyhedron specified by a linear system of inequalities is non-empty, with respect to a specified quantifier string. Quantified linear programming subsumes traditional linear programming, since in traditional linear programming, all the program variables are existentially quantified (implicitly), whereas, in quantified linear programming, a program variable may be existentially quantified or universally quantified over a continuous range. In this paper, the term linear programming is used to describe the problem of checking whether a system of linear inequalities has a feasible solution. On account of the alternation of quantifiers in the specification of a quantified linear program (QLP), this problem is non-trivial. QLPs represent a class of declarative constraint logic programs (CLPs) that are extremely rich in their expressive power. The complexity of quantified linear programming for arbitrary constraint matrices is unknown. In this paper, we show that polynomial time decision procedures exist for the case in which the constraint matrix satisfies certain structural properties. We also provide a taxonomy of quantified linear programs, based on the structure of the quantifier string and discuss the computational complexities of the constituent classes.

Modelling and implementing asynchronous timed multimedia frameworks using coordination principles

This paper combines work done in the areas of Artificial Intelligence, Multimedia Systems and Coordination Programming to derive a framework for Distributed Multimedia Systems based on asynchronous timed computations expressed in a certain coordination formalism. More to the point, we propose the development of multimedia programming frameworks based on the declarative logic programming setting and in particular the framework of object-oriented timed concurrent constraint programming (OO-TCCP). The real-time extensions that have been proposed for the concurrent constraint programming framework are coupled with the object-oriented and inheritance mechanisms that have been developed for logic programs yielding an integrated declarative environment for multimedia objects modelling, composition and synchronisation. Furthermore, we show how the framework can be implemented in the general-purpose coordination language MANIFOLD without the need for using special architectures or real-time languages.

Uniform Lazy Narrowing

Needed narrowing is a complete and optimal operational principle for modern declarative languages which integrate the best features of lazy functional and logic programming. We investigate the formal relation between needed narrowing and another (not so lazy) narrowing strategy which is the basis for popular implementa- tions of lazy functional logic languages. We demonstrate that needed narrowing and lazy narrowing are computationally equivalent over the class of uniform programs introduced in (16,17). We also introduce a complete refinement of lazy narrowing, called uniform lazy narrowing, which is still equivalent to needed narrowing over the aforementioned class. Since actual implementations of functional logic languages are based on the transformation of the original program into a uniform one—which is then executed using a lazy narrowing strategy—our results can be thought of as a formal basis for the correctness of these implementations. Functional logic programming (11) allows us to integrate some of the best features of the classical declarative paradigms, namely functional and logic programming. The operational semantics of the integrated languages is usually based on narrowing, an evaluation mecha- nism which combines the reduction principle of functional languages with the instantiation of unbound variables used in logic programming. Lazy evaluation is a significant feature of functional (logic) programming languages since it avoids unnecessary computations and al- lows programs to deal with infinite data structures. Due to its optimality properties, needed narrowing (5) is currently considered the best lazy narrowing strategy. It generalizes Huet and Levy's (15) call-by-need reduction in order to deal with logical variables and unification. This work investigates and clarifies the formal relation between needed narrowing and another (not so lazy) narrowing strategy which was introduced in (22)—where it is called lazy narrowing—and is the basis for the implementation of several lazy functional logic languages like, e.g., (12,16,22). Our main contributions are the following:

Using methods of declarative logic programming for intelligent information agents

At present, the search for specific information on the World Wide Web is faced with several problems, which arise on the one hand from the vast number of information sources available, and on the other hand, from their intrinsic heterogeneity, since standards are missing. A promising approach for solving the complex problems emerging in this context is the use of multi-agent systems of information agents, which cooperatively solve advanced information-retrieval problems. This requires advanced capabilities to address complex tasks, such as search and assessment of information sources, query planning, information merging and fusion, dealing with incomplete information, and handling of inconsistency. In this paper, our interest lies in the role which some methods from the field of declarative logic programming can play in the realization of reasoning capabilities for information agents. In particular, we are interested to see how they can be used, extended, and further developed for the specific needs of this application domain. We review some existing systems and current projects, which typically address information-integration problems. We then focus on declarative knowledge-representation methods, and review and evaluate approaches and methods from logic programming and nonmonotonic reasoning for information agents. We discuss advantages and drawbacks, and point out the possible extensions and open issues.