On solving the equality problem in theories defined by Horn clauses

The abstraction and over-approximation of protocols and web services by a set of Horn clauses is a very successful method in practice. It has however limitations for protocols and web services that are based on databases of keys, contracts, or even access rights, where revocation is possible, so that the set of true facts does not monotonically grow with state transitions. We extend the scope of these over-approximation methods by defining a new way of abstraction that can handle such databases, and we formally prove that the abstraction is sound. We realize a translator from a convenient specification language to standard Horn clauses and use the verifier ProVerif and the theorem prover SPASS to solve them. We show by a number of examples that this approach is practically feasible for wide variety of verification problems of security protocols and web services

We present a method for verifying properties of imperative programs manipulating integer arrays. We assume that we are given a program and a property to be verified. The interpreter that is, the operational semantics of the program is specified as a set of Horn clauses with constraints in the domain of integer arrays, also called constraint logic programs over integer arrays, denoted CLPArray. Then, by specializing the interpreter with respect to the given program and property, we generate a set of verification conditions expressed as a CLPArray program whose satisfiability implies that the program verifies the given property. Our verification method is based on transformations that preserve the least model semantics of CLPArray programs, and hence the satisfiability of the verification conditions. In particular, we apply the usual rules for CLP transformation, such as unfolding, folding, and constraint replacement, tailored to the specific domain of integer arrays. We propose an automatic strategy that guides the application of those rules with the objective of deriving a new set of verification conditions which is either trivially satisfiable because it contains no constrained facts or is trivially unsatisfiable because it contains the fact false. Our approach provides a very rich program verification framework where one can compose together several verification strategies, each of them being implemented by transformations of CLPArray programs.

Computing abductive explanations is an important problem, which has been studied extensively in Artificial Intelligence (AI) and related disciplines. While computing some abductive explanation for a literal χ with respect to a set of abducibles A from a Horn propositional theory Σ is intractable under the traditional representation of Σ by a set of Horn clauses, the problem is polynomial under model-based theory representation, where Σ is represented by its characteristic models. Furthermore, computing all the (possibly exponentially) many explanations is polynomial-time equivalent to the problem of dualizing a positive CNF, which is a well-known problem whose precise complexity in terms of the theory of NP-completeness is not known yet. In this paper, we first review the monotone dualization problem and its connection to computing all abductive explanations for a query literal and some related problems in knowledge discovery. We then investigate possible generalizations of this connection to abductive queries beyond literals. Among other results, we find that the equivalence for generating all explanations for a clause query (resp., term query) χ to the monotone dualization problem holds if χ contains at most k positive (resp., negative) literals for constant k, while the problem is not solvable in polynomial total-time, i.e., in time polynomial in the combined size of the input and the output, unless P=NP for general clause resp. term queries. Our results shed new light on the computational nature of abduction and Horn theories in particular, and might be interesting also for related problems, which remains to be explored.

In logic programming, a program is stipulated as a set of axioms; execution of such a program involves posing a goal statement (i.e., theorem) and having the system construct a proof. Mechanical reasoning programs are not able to operate with logical sentences expressed in a broad form instead they use a simpler and more restricted form known as Horn Clauses. Note that Horn clauses have the additional restriction of including at most one non‐negative disjunctive term. The origins of logic programming can be found in the work of the French mathematician Jacques Herbrand. He developed a theorem, published in his doctoral dissertation and which now bears his name, that provides a method for mechanically determining whether a set of clauses is satisfiable. Robinson published a paper in 1965 describing the unification algorithm and the resolution principle. Kowalski built upon this work and demonstrated that Horn clause statements can be interpreted as recursive procedures.

This paper deals with test case selection from axiomatic specifications whose axioms are quantifier-free first-order formulas with equality. We first prove the existence of an ideal exhaustive test set to start the selection from. We then propose an extension of the test selection method called axiom unfolding, originally defined for algebraic specifications, to quantifier-free first-order specifications with equality. This method basically consists of a case analysis of the property under test (the test purpose) according to the specification axioms. It is based on a proof search for the different instances of the test purpose. Since the calculus is sound and complete, this allows us to provide a full coverage of this property. The generalisation we propose allows to deal with any kind of predicate (not only equality) and with any form of axiom and test purpose (not only equations or Horn clauses). Moreover, it improves our previous works with efficiently dealing with the equality predicate, thanks to the paramodulation rule.

We consider constrained Horn clause solving from the more general point of view of solving formula equations. Constrained Horn clauses correspond to the subclass of Horn formula equations. We state and prove a fixed-point theorem for Horn formula equations which is based on expressing the fixed-point computation of a minimal model of a set of Horn clauses on the object level as a formula in first-order logic with a least fixed point operator. We describe several corollaries of this fixed-point theorem, in particular concerning the logical foundations of program verification, and sketch how to generalise it to incorporate abstract interpretations.

Logic programming is a language paradigm based on logic, more specifically on resolution theorem proving in the predicate calculus as proposed in Robinson [1965]. Robinson had the foresight to distinguish the importance of two components in automatic theorem proving: a single inference rule called resolution and the testing for equality of trees called unification. Resolution is an inference step used to prove the validity of predicate calculus formulas expressed as clauses. In its simplest version: P ~ Q and -P ~ R imply Q ~ R, which is called the resolvant. Unification is the matching of terms used in a resolution step. It consists of testing the satisfiability of the equality of terms (i.e., labeled trees) whose leaves may contain variables. For example, the unification of the terms p(X, q(Z, a)) and p(b, q(a, Y)) succeeds, yielding the bindings X 5 b, Z 5 a, and Y 5 a. Prolog, the main representative of LP, consists of a sequence of Horn clauses. A Horn clause is one containing (at most) one positive literal. The term definite clause is used to denote a clause with exactly one positive literal. Prolog programs can be viewed as a set of definite clauses in which the positive literal is the head of the rule and the negative literals constitute the body or tail of the rule. From a procedural point of view, a head corresponds to the definition of a Boolean function whose body consists of conjunctions of calls to the Boolean functions representing the tail [Kowalski 1979]. A quintessential example of a Prolog program is that of append. It consists of two Horn clauses specifying that list L3 is the concatenation of two lists, L1 and L2:

We present a method for specialising the constraints in constrained Horn clauses with respect to a goal. We use abstract interpretation to compute a model of a query-answer transformation of a given set of clauses and a goal. The effect is to propagate the constraints from the goal top-down and propagate answer constraints bottom-up. Our approach does not unfold the clauses at all; we use the constraints from the model to compute a specialised version of each clause in the program. The approach is independent of the abstract domain and the constraints theory underlying the clauses. Experimental results on verification problems show that this is an effective transformation, both in our own verification tools (convex polyhedra analyser) and as a pre-processor to other Horn clause verification tools.

Complexity of manipulation and bribery in premise-based judgment aggregation with simple formulas

Automatic program repair modifies a faulty program to make it correct with respect to a specification. Previous approaches have typically been restricted to specific programming languages and a fixed set of syntactical mutation techniques — e.g., changing the conditions of if statements. We present a more general technique based on repairing sets of unsolvable Horn clauses. Working with Horn clauses enables repairing programs from many different source languages, but also introduces challenges, such as navigating the large space of possible repairs. We propose a conservative semantic repair technique that only removes incorrect behaviors and does not introduce new behaviors. Our proposed framework allows the user to request the best repairs — it constructs an optimization lattice representing the space of possible repairs, and uses a novel local search technique that exploits heuristics to avoid searching through sub-lattices with no feasible repairs. To illustrate the applicability of our approach, we apply it to problems in software-defined networking (SDN), and illustrate how it is able to help network operators fix buggy configurations by properly filtering undesired traffic. We show that interval and Boolean lattices are effective choices of optimization lattices in this domain, and we enable optimization objectives such as modifying the minimal number of switches. We have implemented a prototype repair tool, and present preliminary experimental results on several benchmarks using real topologies and realistic repair scenarios in data centers and congested networks.

Many SRL models pose logical inference as weighted satisfiability solving. Performing logical inference after completely grounding clauses with all possible constants is computationally expensive and approaches such as LazySAT [8] utilize the sparseness of the domain to deal with this. Here, we investigate the efficiency of restricting the Knowledge Base (Σ) to the set of first order horn clauses. We propose an algorithm that prunes the search space for satisfiability in horn clauses and prove that the optimal solution is guaranteed to exist in the pruned space. The approach finds a model, if it exists, in polynomial time; otherwise it finds an interpretation that is most likely given the weights. We provide experimental evidence that our approach reduces the size of search space substantially.KeywordsFirst Order LogicHorn ClausesMaxSATSatisfiability

Automatic program repair modifies a faulty program to make it correct with respect to a specification. Previous approaches have typically been restricted to specific programming languages and a fixed set of syntactical mutation techniques-e.g., changing the conditions of if statements. We present a more general technique based on repairing sets of unsolvable Horn clauses. Working with Horn clauses enables repairing programs from many different source languages, but also introduces challenges, such as navigating the large space of possible repairs. We propose a conservative semantic repair technique that only removes incorrect behaviors and does not introduce new behaviors. Our proposed framework allows the user to request the best repairs-it constructs an optimization lattice representing the space of possible repairs, and uses a novel local search technique that exploits heuristics to avoid searching through sub-lattices with no feasible repairs. To illustrate the applicability of our approach, we apply it to problems in software-defined networking (SDN), and illustrate how it is able to help network operators fix buggy configurations by properly filtering undesired traffic. We show that interval and Boolean lattices are effective choices of optimization lattices in this domain, and we enable optimization objectives such as modifying the minimal number of switches. We have implemented a prototype repair tool, and present preliminary experimental results on several benchmarks using real topologies and realistic repair scenarios in data centers and congested networks.

Kobayashi proposed Horn clause computation by DNA molecules, which is more suitable for expressing complex algorithms than other models for DNA computing. This paper describes a new implementation of Horn clause computation by DNA. It employs branching DNA molecules for representing Horn clauses. As derivations are realized by self-assembly of such molecules, the implementation requires only a constant number of laboratory operations. Furthermore, it deals with first-order Horn clauses with some restrictions. In order to realize first-order logic, we implement variable substitutions by string tiling proposed by Winfree, et al. As we show the computational power of a Horn clause program in our model, we give another proof that a polynomial number of operations using self-assembly of DNA molecules can compute any problem in NP.KeywordsHorn ClauseDeductive InferenceFact MoleculeQuery MoleculeBody TileThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The purpose of this paper is to discuss the correctness of a method for constructing parallel processing programs from a problem description. The framework we adopt for this purpose is Equivalent Transformation Framework (ETF), which regards computation as transformation of definite clauses. In the framework, a problem's domain knowledge and a query are described in definite clauses, and its meaning is defined by a model of the set of definite clauses. Then meaning-preserving transformation rules for the query are generated. We propose a parallel processing method based on “specialization”, a part of operation in the transformations, and discuss new parallel processing method based on the specialization that maintains correctness of the computation. The specialization is generalized notion of substitution in logic programming, and it allows more rich representation. We examine the correctness of our approach based the specialization.

A revision algorithm is a learning algorithm that identifies the target concept, starting from an initial concept. Such an algorithm is considered efficient if its complexity (in terms of the measured resource) is polynomial in the syntactic distance between the initial and the target concept, but only polylogarithmic in the number of variables in the universe. We give efficient revision algorithms in the model of learning with equivalence and membership queries. The algorithms work in a general revision model where both deletion and addition revision operators are allowed. In this model one of the main open problems is the efficient revision of Horn formulas. Two revision algorithms are presented for special cases of this problem: for depth-1 acyclic Horn formulas, and for definite Horn formulas with unique heads.