Ground Instances Research Articles

On Moderate Pluralism About Truth and Logic

According to moderate truth pluralism, truth is both One and Many. There is a single truth property that applies across all truth‐apt domains of discourse, but instances of this property are grounded in different ways. Propositions concerning medium‐sized dry goods might be true in virtue of corresponding with reality while propositions pertaining to the law might be true in virtue of cohering with the body of law. Moderate truth pluralists must answer two questions concerning logic: (Q1) Which logic governs inferences concerning each truth‐apt domain considered separately? (Q2) Which logic governs inferences that involve several truth‐apt domains? This paper has three objectives. The first objective is to present and explain the moderate pluralist’s answers to (Q1) and (Q2). The second objective is to argue that there is a tension between these answers. The answer to (Q1) involves a commitment to a form of logical pluralism. However, reflection on the moderate truth pluralist’s answer to (Q2) shows that they are committed to taking logic to be topic neutrality. This, in turn, forces a commitment to logical monism. It would seem that the moderate truth pluralist cannot have it both ways. The third objective is constructive in nature. I offer an account of what moderate truth pluralists should say about logic and how they might resolve the tension in their view. I suggest that, just like moderate truth pluralists distinguish truth proper and “quasi‐truth,” they should endorse a distinction between logic proper and “quasi‐logic.” Quasi‐truth is truth‐like in the sense that instances of quasi‐truth ground instances of truth. Quasi‐logic is logic‐like in the sense that it concerns arguments that are necessarily truth‐preserving but are not generally so in a topic neutral way. I suggest that moderate truth pluralists should be monists about truth proper and logic proper but pluralists about quasi‐truth and quasi‐logic. This allows them to say that logic proper is topic neutral while still accommodating the idea that, for different domains, different arguments may be necessarily truth‐preserving.

Relational Probabilistic Conditionals and Their Instantiations under Maximum Entropy Semantics for First-Order Knowledge Bases

For conditional probabilistic knowledge bases with conditionals based on propositional logic, the principle of maximum entropy (ME) is well-established, determining a unique model inductively completing the explicitly given knowledge. On the other hand, there is no general agreement on how to extend the ME principle to relational conditionals containing free variables. In this paper, we focus on two approaches to ME semantics that have been developed for first-order knowledge bases: aggregating semantics and a grounding semantics. Since they use different variants of conditionals, we define the logic PCI, which covers both approaches as special cases and provides a framework where the effects of both approaches can be studied in detail. While the ME models under PCI-grounding and PCI-aggregating semantics are different in general, we point out that parametric uniformity of a knowledge base ensures that both semantics coincide. Using some concrete knowledge bases, we illustrate the differences and common features of both approaches, looking in particular at the ground instances of the given conditionals.

A simple semantics for Haskell overloading

As originally proposed, type classes provide overloading and ad-hoc definition, but can still be understood (and implemented) in terms of strictly parametric calculi. This is not true of subsequent extensions of type classes. Functional dependencies and equality constraints allow the satisfiability of predicates to refine typing; this means that the interpretations of equivalent qualified types may not be interconvertible. Overlapping instances and instance chains allow predicates to be satisfied without determining the implementations of their associated class methods, introducing truly non-parametric behavior. We propose a new approach to the semantics of type classes, interpreting polymorphic expressions by the behavior of each of their ground instances, but without requiring that those behaviors be parametrically determined. We argue that this approach both matches the intuitive meanings of qualified types and accurately models the behavior of programs.

Multi-engine ASP solving with policy adaptation

The recent application of Machine Learning techniques to the Answer Set Programming (ASP) field proved to be effective. In particular, the multi-engine ASP solver ME-ASP is efficient: it is able to solve more instances than any other ASP system that participated to the 3rd ASP Competition on the System Track benchmarks. In the ME-ASP approach, classification methods inductively learn off-line algorithm selection policies starting from both a set of features of instances in a training set, and the solvers performance on such instances. In this paper we present an improvement to the multi-engine framework of ME-ASP , in which we add the capability of updating the learned policies when the original approach fails to give good predictions. An experimental analysis, conducted on training and test sets of ground instances obtained from the ones submitted to the System Track of the 3rd ASP Competition, shows that the policy adaptation improves the performance of ME-ASP when applied to test sets containing domains of instances that were not considered for training.

On Constructing Constrained Tree Automata Recognizing Ground Instances of Constrained Terms

An inductive theorem proving method for constrained term rewriting systems, which is based on rewriting induction, needs a decision procedure for reduction-completeness of constrained terms. In addition, the sufficient complete property of constrained term rewriting systems enables us to relax the side conditions of some inference rules in the proving method. These two properties can be reduced to intersection emptiness problems related to sets of ground instances for constrained terms. This paper proposes a method to construct deterministic, complete, and constraint-complete constrained tree automata recognizing ground instances of constrained terms.

Achieving parametric uniformity for knowledge bases in a relational probabilistic conditional logic with maximum entropy semantics

When extending probabilistic logic to a relational setting, it is desirable to still be able to use efficient computation mechanisms developed for the propositional case. In this paper, we investigate the relational probabilistic conditional logic FO-PCL whose semantics employs the principle of maximum entropy. While in general, this semantics is defined via the ground instances of the rules in an FO-PCL knowledge base ${\cal R}$ , the maximum entropy model can be computed on the level of rules rather than on the level of instances of the rules if ${\cal R}$ is parametrically uniform. We elaborate in detail the reasons that cause ${\cal R}$ to be not parametrically uniform. Based on this investigation, we derive a new syntactic criterion for parametric uniformity and develop an algorithm that transforms any FO-PCL knowledge base ${\cal R}$ into an equivalent knowledge base ${\cal R}^{\prime}$ that is parametrically uniform. This provides a basis for a simplified maximum entropy model computation since for this computation, ${\cal R}^{\prime}$ can be used instead of ${\cal R}$ .

On theorem prover-based testing

Abstract HOL -TestGen is a specification and test case generation environment extending the interactive theorem prover Isabelle/ HOL . As such, Testgen allows for an integrated workflow supporting interactive theorem proving, test case generation, and test data generation. The HOL -TestGen method is two-staged: first, the original formula is partitioned into test cases by transformation into a normal form called test theorem . Second, the test cases are analyzed for ground instances (the test data ) satisfying the constraints of the test cases. Particular emphasis is put on the control of explicit test-hypotheses which can be proven over concrete programs. Due to the generality of the underlying framework, our system can be used for black-box unit, sequence, reactive sequence and white-box test scenarios. Although based on particularly clean theoretical foundations, the system can be applied for substantial case-studies.

Simultaneous checking of completeness and ground confluence for algebraic specifications

Algebraic specifications provide a powerful method for the specification of abstract data types in programming languages and software systems. Completeness and ground confluence are fundamental notions for building algebraic specifications in a correct and modular way. Related works for checking ground confluence are based on the completion techniques or on the test that all critical pairs between axioms are valid with respect to a sufficient criterion for ground confluence. It is generally accepted that such techniques may be very inefficient, even for very small specifications. Indeed, the completion procedure often diverges and there often exist many critical pairs of the axioms. In this article, we present a procedure for simultaneously checking completeness and ground confluence for specifications with free/nonfree constructors and parameterized specifications. If the specification is not complete or not ground confluent, then our procedure will output the set of patterns on whose ground instances a function is not defined and it can easily identify the rules that break ground confluence. In contrast to previous work, our method does not rely on completion techniques and does not require the computation of critical pairs of the axioms. The method is entirely implemented and allowed us to prove the completeness and the ground confluence of many specifications in a completely automatic way, where related techniques diverge or generate very complex proofs. Our system offers two main components: (i) a completeness and ground confluence analyzer that computes pattern trees of defined functions and may generate some proof obligations; and (ii) a procedure to prove (joinable) inductive conjectures which is used to discharge these proof obligations.

Verifying Test-Hypotheses: An Experiment in Test and Proof

hol-TestGen is a specification and test case generation environment extending the interactive theorem prover Isabelle/hol. The hol-TestGen method is two-staged: first, the original formula, called test specification, is partitioned into test cases by transformation into a normal form called test theorem. Second, the test cases are analyzed for ground instances (the test data) satisfying the constraints of the test cases. Test data were used in an automatically generated test-driver running the program under test. Particular emphasis is put on the control of explicit test hypotheses which can be proven over concrete programs. As such, explicit test hypotheses establish a logical link between a validation by test and a validation by proof. Since hol-TestGen generates explicit test hypotheses and makes them amenable to formal proof, the system is in a unique position to explore the relations between them at an example.

Learning first-order probabilistic models with combining rules

Many real-world domains exhibit rich relational structure and stochasticity and motivate the development of models that combine predicate logic with probabilities. These models describe probabilistic influences between attributes of objects that are related to each other through known domain relationships. To keep these models succinct, each such influence is considered independent of others, which is called the assumption of "independence of causal influences" (ICI). In this paper, we describe a language that consists of quantified conditional influence statements and captures most relational probabilistic models based on directed graphs. The influences due to different statements are combined using a set of combining rules such as Noisy-OR. We motivate and introduce multi-level combining rules, where the lower level rules combine the influences due to different ground instances of the same statement, and the upper level rules combine the influences due to different statements. We present algorithms and empirical results for parameter learning in the presence of such combining rules. Specifically, we derive and implement algorithms based on gradient descent and expectation maximization for different combining rules and evaluate them on synthetic data and on a real-world task. The results demonstrate that the algorithms are able to learn both the conditional probability distributions of the influence statements and the parameters of the combining rules.

Enhancing DLV instantiator by backjumping techniques

Disjunctive logic programming (DLP) is a powerful formalism for knowledge representation and reasoning. The high expressiveness of DLP language, together with the recent availability of some efficient DLP system, has favoured the application of DLP in emerging areas like Knowledge Management and Information Integration. These applications have often to deal with huge input data, and have evidenced the need to improve the efficiency of DLP instantiators. Program instantiation is the first phase of a DLP computation; in this phase, variables are replaced by constants to generate a ground program which is then evaluated by propositional algorithms in the second phase of the computation. The instantiation process may be computationally expensive, and in fact its efficiency has been recognized to be a key issue for solving real-world problems by using disjunctive logic programming. Given a program P, a good instantiation for P is a ground program P? having precisely the same answer sets as P and such that: (1) P? can be computed efficiently from P, and (2) P? does not contain "useless" rules, (P? is as small as possible) and can thus be evaluated efficiently. In this paper, we present a structure-based backjumping algorithm for the instantiation of disjunctive logic programs, that meets the above requirements. In particular, given a rule r to be grounded, our algorithm exploits both the semantical and the structural information about r for computing efficiently the ground instances of r, avoiding the generation of "useless" rules. That is, from each general rule r, we compute only a relevant subset of its ground instances, avoiding the generation of "useless" instances, while fully preserving the semantic of the program. We have implemented this algorithm in DLV--the state-of-the-art implementation of DLP--and we have carried out an experimentation activity on an ample collection of benchmark problems. The experimental results are very positive: the new technique improves sensibly the efficiency of the DLV system on many program classes.

An Improvement of Herbrand's Theorem and Its Application to Model Generation Theorem Proving

This paper presents an improvement of Herbrand's theorem. We propose a method for specifying a subuniverse of the Herbrand universe of a clause set S for each argument of predicate symbols and function symbols in S. We prove that a clause set S is unsatisfiable if and only if there is a finite unsatisfiable set of ground instances of clauses of S that are derived by only instantiating each variable, which appears as an argument of predicate symbols or function symbols, in S over its corresponding argument's sub-universe of the Herbrand universe of S. Because such sub-universes are usually smaller (sometimes considerably) than the Herbrand universe of S, the number of ground instances may decrease considerably in many cases. We present an algorithm for automatically deriving the sub-universes for arguments in a given clause set, and show the correctness of our improvement. Moreover, we introduce an application of our approach to model generation theorem proving for non-range-restricted problems, show the range-restriction transformation algorithm based on our improvement and provide examples on benchmark problems to demonstrate the power of our approach.

On the complexity of equational problems in CNF

Equational problems (i.e. first-order formulae with quantifier prefix ∃ ∗ ∀ ∗ , whose only predicate symbol is syntactic equality) are an important tool in many areas of automated deduction, e.g. restricting the set of ground instances of a clause via equational constraints allows the definition of stronger redundancy criteria and hence, in general, of more efficient theorem provers. Moreover, the inference rules themselves can be restricted via constraints. In automated model building, equational problems play an important role both in the definition of an appropriate model representation and in the evaluation of clauses in such models. Also, many problems in the area of logic programming can be reduced to equational problem solving. Finally, equational problems over a finite domain correspond to the evaluation of certain queries over relational databases. The goal of this work is a complexity analysis of the satisfiability problem of equational problems. The main results will be a proof of the NP-completeness (and, in particular, the NP-membership) of equational problems in CNF over an infinite domain and of the Σ 2 p -completeness in the case of CNF over a finite domain.

Test Sets for the Universal and Existential Closure of Regular Tree Languages

Finite test sets are a useful tool for deciding the membership problem for the universal closure of a given tree language, that is, for deciding whether a term has all its ground instances in the given language. A uniform test set for the universal closure must serve the following purpose: In order to decide membership of a term, it is sufficient to check whether all its test set instances belong to the underlying language. A possible application, and our main motivation, is ground reducibility, an essential concept for many approaches to inductive reasoning. Ground reducibility modulo some rewrite system is membership in the universal closure of the set of reducible ground terms. Here, test sets always exist, and several algorithmic approaches are known. The resulting sets, however, are often unnecessarily large. In this paper we consider regular languages and linear closure operators. We prove that universal as well as existential closure, defined analogously, preserve regularity. By relating test sets to tree automata and to appropriate congruence relations, we show how to characterize, how to compute, and how to minimize ground and non-ground test sets. In particular, optimal solutions now replace previous ad hoc approximations for the ground reducibility problem.

Phase Transitions in Relational Learning

One of the major limitations of relational learning is due to the complexity of verifying hypotheses on examples. In this paper we investigate this task in light of recent published results, which show that many hard problems exhibit a narrow “phase transition” with respect to some order parameter, coupled with a large increase in computational complexity. First we show that matching a class of artificially generated Horn clauses on ground instances presents a typical phase transition in solvability with respect to both the number of literals in the clause and the number of constants occurring in the instance to match. Then, we demonstrate that phase transitions also appear in real-world learning problems, and that learners tend to generate inductive hypotheses lying exactly on the phase transition. On the other hand, an extensive experimenting revealed that not every matching problem inside the phase transition region is intractable. However, unfortunately, identifying those that are feasible cannot be done solely on the basis of the order parameters. To face this problem, we propose a method, based on a Monte Carlo algorithm, to estimate on-line the likelihood that the current matching problem will exceed a given amount of computational resources. The impact of the above findings on relational learning is discussed.

A strong version of Herbrand's theorem for introvert sentences

A version of Herbrand's theorem tells us that a universal sentence of a first-order language with at least one constant is satisfiable if and only if the conjunction of all its ground instances is. In general the set of such instances is infinite, and arbitrarily large finite subsets may have to be inspected in order to detect inconsistency. Essentially, the reason that every member of such an infinite set may potentially matter, can be traced back to sentences like(1) Loosely put, such sentences effectively sabotage any attempt to build a model from below in a finite number of steps, since new members of the Herbrand universe are constantly brought to attention. Since they cause an indefinite expansion of the relevant part of the Herbrand universe, such sentences could quite appropriately be called expanding.When such sentences are banned, stronger versions of Herbrand's theorem can be stated. Define a clause (disjunction of literals) to be non-expanding if every non-ground term occurring in a positive literal also occurs (possibly as an embedded subterm) in a negative literal of the same clause. Written as a disjunction of literals, the matrix of (1) clearly fails this criterion. Moreover, say that a sentence is non-expanding if it is a universal sentence with a quantifier-free matrix that is a conjunction of non-expanding clauses. Such sentences do in a sense never reach out beyond themselves, and the relevant part of the Herbrand universe is therefore drastically reduced.

Learning unions of tree patterns using queries

This paper investigates efficient learning of TP k , the class of collections of at most k first-order terms, where each collection defines the union of the sets of ground instances of each first-order term in the collection. We present an algorithm that exactly learns every concept in TP k in polynomial time in k and n using equivalence and membership queries, where n is the size of the longest counterexample given so far. We also show some lower bound results on the number of queries, and apply our result to learning restricted version of logic programs whose computational mechanisms are only disjunctive definition and unification.

Value Constraints in the CLP Scheme

We define value constraints, a method for incorporating constraint propagation into logic programming. It is a subscheme of the CLP scheme and is applicable wherever one has an efficient method for representing sets of possible values. As examples we present: small finite sets, sets of ground instances of a term, and intervals of reals with floating-point numbers as bounds. Value constraints are defined by distinguishing two storage management strategies in the CLP scheme. In value constraints the infer step of the CLP scheme is implemented by Waltz filtering. We give a semantics for value constraints in terms of set algebra that gives algebraic characterizations of local and global consistency. The existing extremal fixpoint characterization of chaotic iteration is shown to be applicable to prove convergence of Waltz filtering.

CLIN-S - A Semantically Guided First-Order Theorem Prover

CLIN-S is an instance-based, clause-form first-order theorem prover. CLIN-S employs three inference procedures: semantic hyper-linking, which uses semantics to guide the proof search and performs well on non-Horn parts of the proofs involving small literals, rough resolution, which removes large literals in the proofs, and UR resolution, which proves the Horn parts of the proofs. A semantic structure for the input clauses is given as input. During the search for the proof, ground instances of the input clauses are generated and new semantic structures are built based on the input semantics and a model of the ground clause set. A proof is found if the ground clause set is unsatisfiable. In this article, we describe the system architecture and major inference rules used in CLIN-S.

A non-ground realization of the stable and well-founded semantics

The declarative semantics of nonmonotonic logic programming has largely been based on propositional programs. However, the ground instantiation of a logic program may be very large, and likewise, a ground stable model may also be very large. We develop a non-ground semantic theory for non-monotonic logic programming. Its principal advantage is that stable models and well-founded models can be represented as sets of atoms, rather than as sets of ground atoms. A set SI of atoms may be viewed as a compact representation of the Herbrand interpretation consisting of all ground instances of atoms in SI. We develop generalizations of the stable and well-founded semantics based on such non-ground interpretations SI. The key notions for our theory are those of covers and anticovers. A cover as well as its anticover are sets of substitutions — non-ground in general — representing all substitutions obtained by ground instantiating some substitution in the (anti)cover, with the additional requirement that each ground substitution is represented either by the cover or by the anticover, but not by both. We develop methods for computing anticovers for a given cover, show that membership in so-called optimal covers is decidable, and investigate the complexity in the Datalog case.