Horn Clauses Research Articles

Parallel Tractability of Ontology Materialization: Technique and Practice

Materialization is an important reasoning service for many ontology-based applications, but the rapid growth of semantic data poses the challenge to efficiently perform materialization on largescale ontologies. Parallel materialization algorithms work well for some ontologies, although the reasoning problem for the used ontology language is not in NC, i.e., the theoretical complexity class for parallel tractability. This motivates us to study the problem of parallel tractability of ontology materialization from a theoretical perspective. We focus on the datalog rewritable ontology languages DL-Lite and Description Horn Logic (DHL) and propose algorithms, called NC algorithms, to identify classes of ontologies for which materialization is tractable in parallel. To verify the practical usability of the above results, we analyze different benchmarks and realworld datasets, including LUBM and the YAGO ontology, and show that for many ontologies expressed in DHL materialization is tractable in parallel. The implementation of our optimized parallel algorithm shows performance improvements over the highly optimized state-of-the-art reasoner RDFox on ontologies for which materialization is tractable in parallel.

Parallel tractability of ontology materialization: Technique and practice

Materialization is an important reasoning service for many ontology-based applications, but the rapid growth of semantic data poses the challenge to efficiently perform materialization on large-scale ontologies. Parallel materialization algorithms work well for some ontologies, although the reasoning problem for the used ontology language is not in NC, i.e., the theoretical complexity class for parallel tractability. This motivates us to study the problem of parallel tractability of ontology materialization from a theoretical perspective. We focus on the datalog rewritable ontology languages DL-Lite and Description Horn Logic (DHL) and propose algorithms, called NC algorithms, to identify classes of ontologies for which materialization is tractable in parallel. To verify the practical usability of the above results, we analyze different benchmarks and real-world datasets, including LUBM and the YAGO ontology, and show that for many ontologies expressed in DHL materialization is tractable in parallel. The implementation of our optimized parallel algorithm shows performance improvements over the highly optimized state-of-the-art reasoner RDFox on ontologies for which materialization is tractable in parallel.

Backdoors for Linear Temporal Logic

In the present paper, we introduce the backdoor set approach into the field of temporal logic for the global fragment of linear temporal logic. We study the parameterized complexity of the satisfiability problem parameterized by the size of the backdoor. We distinguish between backdoor detection and evaluation of backdoors into the fragments of Horn and Krom formulas. Here we classify the operator fragments of globally-operators for past/future/always, and the combination of them. Detection is shown to be fixed-parameter tractable whereas the complexity of evaluation behaves differently. We show that for Krom formulas the problem is paraNP-complete. For Horn formulas, the complexity is shown to be either fixed parameter tractable or paraNP-complete depending on the considered operator fragment.

Towards Coinductive Theory Exploration in Horn Clause Logic: Position Paper

Coinduction occurs in two guises in Horn clause logic: in proofs of self-referencing properties and relations, and in proofs involving construction of (possibly irregular) infinite data. Both instances of coinductive reasoning appeared in the literature before, but a systematic analysis of these two kinds of proofs and of their relation was lacking. We propose a general proof-theoretic framework for handling both kinds of coinduction arising in Horn clause logic. To this aim, we propose a coinductive extension of Miller et al's framework of uniform proofs and prove its soundness relative to coinductive models of Horn clause logic.

Proceedings 5th Workshop on Horn Clauses for Verification and Synthesis

Proceedings 5th Workshop on Horn Clauses for Verification and Synthesis

Proceedings 5th Workshop on Horn Clauses for Verification and Synthesis

Proceedings 5th Workshop on Horn Clauses for Verification and Synthesis

Solving Constrained Horn Clauses Using Dependence-Disjoint Expansions

Recursion-free Constrained Horn Clauses (CHCs) are logic-programming problems that can model safety properties of programs with bounded iteration and recursion. In addition, many CHC solvers reduce recursive systems to a series of recursion-free CHC systems that can each be solved efficiently. In this paper, we define a novel class of recursion-free systems, named Clause-Dependence Disjoint (CDD), that generalizes classes defined in previous work. The advantage of this class is that many CDD systems are smaller than systems which express the same constraints but are part of a different class. This advantage in size allows CDD systems to be solved more efficiently than their counterparts in other classes. We implemented a CHC solver named Shara. Shara solves arbitrary CHC systems by reducing the input to a series of CDD systems. Our evaluation indicates that Shara outperforms state-of-the-art implementations in many practical cases.

Proceedings 5th Workshop on Horn Clauses for Verification and Synthesis

Proceedings 5th Workshop on Horn Clauses for Verification and Synthesis

General Belief Revision

In artificial intelligence, a key question concerns how an agent may rationally revise its beliefs in light of new information. The standard (AGM) approach to belief revision assumes that the underlying logic contains classical propositional logic. This is a significant limitation, since many representation schemes in AI don’t subsume propositional logic. In this article, we consider the question of what the minimal requirements are on a logic, such that the AGM approach to revision may be formulated. We show that AGM-style revision can be obtained even when extremely little is assumed of the underlying language and its semantics; in fact, one requires little more than a language with sentences that are satisfied at models, or possible worlds. The classical AGM postulates are expressed in this framework and a representation result is established between the postulate set and certain preorders on possible worlds. To obtain the representation result, we add a new postulate to the AGM postulates, and we add a constraint to preorders on worlds. Crucially, both of these additions are redundant in the original AGM framework, and so we extend , rather than modify , the AGM approach. As well, iterated revision is addressed and the Darwiche/Pearl postulates are shown to be compatible with our approach. Various examples are given to illustrate the approach, including Horn clause revision, revision in extended logic programs, and belief revision in a very basic logic called literal revision .

Scaling-up reasoning and advanced analytics on BigData

AbstractBigDatalog is an extension of Datalog that achieves performance and scalability on both Apache Spark and multicore systems to the point that its graph analytics outperform those written in GraphX. Looking back, we see how this realizes the ambitious goal pursued by deductive database researchers beginning 40 years ago: this is the goal of combining the rigor and power of logic in expressing queries and reasoning with the performance and scalability by which relational databases managed BigData. This goal led to Datalog which is based on Horn Clauses like Prolog but employs implementation techniques, such as semi-naïve fixpoint and magic sets, that extend the bottom-up computation model of relational systems, and thus obtain the performance and scalability that relational systems had achieved, as far back as the 80s, using data-parallelization on shared-nothing architectures. But this goal proved difficult to achieve because of major issues at (i) the language level and (ii) at the system level. The paper describes how (i) was addressed by simple rules under which the fixpoint semantics extends to programs using count, sum and extrema in recursion, and (ii) was tamed by parallel compilation techniques that achieve scalability on multicore systems and Apache Spark. This paper is under consideration for acceptance in Theory and Practice of Logic Programming.

Optimal directed hypergraph traversal with ant-colony optimisation

Directed hypergraphs are an extension of directed graphs in which edges connect a set of source nodes to a set of target nodes. Unlike graphs, they can capture complex relations in network structures that go beyond the union of pairwise associations. They are widely applied in a variety of different domains, such as finding pathways in chemical reaction networks or minimising propositional Horn formulas. Calculating optimal paths in hypergraphs in the general case is an NP-hard problem, which can be solved in polynomial time only when utility functions hold specific properties. We present in this paper an approach to search for optimal hypergraph paths in the general case based on ant colony optimisation. Ant colony optimisation is an evolutionary meta-heuristic that is particularly suitable to combinatorial problems, such as optimal graph traversal. We present an experimental evaluation using artificially-generated hypergraphs and discuss innovative applications of the proposed approach in the domains of industrial engineering and chemical informatics.

Proof-relevant Horn Clauses for Dependent Type Inference and Term Synthesis

AbstractFirst-order resolution has been used for type inference for many years, including in Hindley-Milner type inference, type-classes, and constrained data types. Dependent types are a new trend in functional languages. In this paper, we show that proof-relevant first-order resolution can play an important role in automating type inference and term synthesis for dependently typed languages. We propose a calculus that translates type inference and term synthesis problems in a dependently typed language to a logic program and a goal in the proof-relevant first-order Horn clause logic. The computed answer substitution and proof term then provide a solution to the given type inference and term synthesis problem. We prove the decidability and soundness of our method.

Solving Horn Clauses on Inductive Data Types Without Induction

AbstractWe address the problem of verifying the satisfiability of Constrained Horn Clauses (CHCs) based on theories of inductively defined data structures, such as lists and trees. We propose a transformation technique whose objective is the removal of these data structures from CHCs, hence reducing their satisfiability to a satisfiability problem for CHCs on integers and booleans. We propose a transformation algorithm and identify a class of clauses where it always succeeds. We also consider an extension of that algorithm, which combines clause transformation with reasoning on integer constraints. Via an experimental evaluation we show that our technique greatly improves the effectiveness of applying the Z3 solver to CHCs. We also show that our verification technique based on CHC transformation followed by CHC solving, is competitive with respect to CHC solvers extended with induction.

An iterative approach to precondition inference using constrained Horn clauses

AbstractWe present a method for automatic inference of conditions on the initial states of a program that guarantee that the safety assertions in the program are not violated. Constrained Horn clauses (CHCs) are used to model the program and assertions in a uniform way, and we use standard abstract interpretations to derive an over-approximation of the set ofunsafeinitial states. The precondition then is the constraint corresponding to the complement of that set, under-approximating the set ofsafeinitial states. This idea of complementation is not new, but previous attempts to exploit it have suffered from the loss of precision. Here we develop an iterative specialisation algorithm to give more precise, and in some cases optimal safety conditions. The algorithm combines existing transformations, namely constraint specialisation, partial evaluation and a trace elimination transformation. The last two of these transformations perform polyvariant specialisation, leading to disjunctive constraints which improve precision. The algorithm is implemented and tested on a benchmark suite of programs from the literature in precondition inference and software verification competitions.

Logical composition of qualitative shapes applied to solve spatial reasoning tests

A logical approach to compose qualitative shape descriptors (LogC-QSD) is presented in this paper. Each object shape is described qualitatively by its edges, angles, convexities, and lengths. LogC-QSD describes the shape of composed objects qualitatively adding circuits to describe the connections among the shapes. It also infers new angles and lengths using composition tables. Its main contributions are: (i) describing qualitatively the resulting boundary of connecting N shapes and (ii) its application to solve spatial reasoning tests. LogC-QSD approach has been implemented using Prolog programming language, which is based on Horn clauses and first order logic. The testing framework was SWI-Prolog on the LogC-QSD dataset. The obtained results show that the LogC-QSD approach was able to correctly answer all the questions in the LogC-QSD dataset, which involved compositions up to five shapes. The correct answer for 60% of the questions was obtained in an average time of 2.45·10-4 s by comparing the concavities and right angles of the final QSD composed shape with the possible answers. The rest of the questions required a matching algorithm and they were solved by LogC-QSD in an average time of 19.50·10-4 s. Analysis of the execution times obtained showed that the algorithmic cost of LogC-QSD is lower than O(n2) in the worst case.

A data-driven CHC solver

We present a data-driven technique to solve Constrained Horn Clauses (CHCs) that encode verification conditions of programs containing unconstrained loops and recursions. Our CHC solver neither constrains the search space from which a predicate's components are inferred (e.g., by constraining the number of variables or the values of coefficients used to specify an invariant), nor fixes the shape of the predicate itself (e.g., by bounding the number and kind of logical connectives). Instead, our approach is based on a novel machine learning-inspired tool chain that synthesizes CHC solutions in terms of arbitrary Boolean combinations of unrestricted atomic predicates. A CEGAR-based verification loop inside the solver progressively samples representative positive and negative data from recursive CHCs, which is fed to the machine learning tool chain. Our solver is implemented as an LLVM pass in the SeaHorn verification framework and has been used to successfully verify a large number of nontrivial and challenging C programs from the literature and well-known benchmark suites (e.g., SV-COMP).

Disentangling two distinct notions of NEG raising

In this paper we consider two analyses of NEG raising phenomena: a syntactic approach based on raising NEG, as recently advocated in Collins & Postal 2014, and a semantic/pragmatic approach based on the Excluded Middle Assumption; see Bartsch 1973. We show that neither approach alone is sufficient to account for all the relevant phenomena. Although the syntactic approach is needed to explain the distribution of strict NPIs and Horn clauses, the semantic/pragmatic approach is needed to explain certain inferences where syntactic NEG raising is blocked. EARLY ACCESS

Characterization of the Convex Łukasiewicz Fragment for Learning From Constraints

This paper provides a theoretical insight for the integration of logical constraints into a learning process. In particular it is proved that a fragment of the Łukasiewicz logic yields a set of convex constraints. The fragment is enough expressive to include many formulas of interest such as Horn clauses. Using the isomorphism of Łukasiewicz formulas and McNaughton functions, logical constraints are mapped to a set of linear constraints once the predicates are grounded on a given sample set. In this framework, it is shown how a collective classification scheme can be formulated as a quadratic programming problem, but the presented theory can be exploited in general to embed logical constraints into a learning process. The proposed approach is evaluated on a classification task to show how the use of the logical rules can be effective to improve the accuracy of a trained classifier.

Therapeutic effect of Guijiajiao (Colla Carapacis et Plastri) on bone regeneration in rats and zebrafish

OBJECTIVETo investigate the effect of Guijiajiao (Colla Carapacis et Plastri, CCP), the glue of tortoise shell, on bone regeneration in zebrafish and male Wistar rats. METHODSIn this study, we applied in vitro and in vivo models, tissue section analysis, and quantitative polymerase chain reaction to assess the effects of CCP on bone repair. MG-63 cells were used in alkaline phosphatase (ALP) activity and mineralization assays. Zebrafish and male Wistar rats were used to evaluate the effects of CCP on bone repair in vivo. RESULTSA simple preparation of CCP promoted osteogenesis in vivo and in vitro, and promoted MG-63 cell proliferation as well as ALP activity and mineralization. In addition, CCP activated Akt and extracellular signaling-regulated kinase pathways and significantly increased the expression of ossification-related genes and proteins such as runt-related transcription factor-2, osteocalcin, and osteopontin. The in vivo results revealed promotion of osteogenesis by immersing zebrafish in CCP for 72 h. An oral dose of 1.25 g/kg CCP significantly improved skull defects in rats, which was accompanied by an increase in serum ALP levels. CONCLUSIONOne of the ingredients of Guilu Erxianjiao (tortoise shell and deer horn formula) provides a practical alternative therapy for bone regeneration.

Interval-based resource usage verification by translation into Horn clauses and an application to energy consumption

AbstractMany applications require conformance with specifications that constrain the use of resources, such as execution time, energy, bandwidth, etc. We present a configurable framework for static resource usage verification where specifications can include data size-dependent resource usage functions, expressing both lower and upper bounds. Ensuring conformance with respect to such specifications is an undecidable problem. Therefore, to statically check such specifications, our framework infers the same type of resource usage functions, which safely approximate the actual resource usage of the program, and compares them against the specification. We review how this framework supports several languages and compilation output formats by translating them to an intermediate representation based on Horn clauses and using the configurability of the framework to describe the resource semantics of the input language. We provide a detailed formalization and extend the framework so that both resource usage specification and analysis/verification output can include preconditions expressing intervals for the input data sizes for which assertions are intended to hold, proved, or disproved. Most importantly, we also extend the classes of functions that can be checked. We also report on and provide results from an implementation within the Ciao/CiaoPP framework, as well as on a practical tool built by instantiating this framework for the verification of energy consumption specifications for imperative/embedded programs. Finally, we show as an example how embedded software developers can use this tool, in particular, for determining values for program parameters that ensure meeting a given energy budget while minimizing the loss in quality of service.