We investigate the satisfiability problem, SAT(ID), of an extension of propositional logic with inductive definitions. We demonstrate how to extend existing SAT solvers to become SAT(ID) solvers, and provide an implementation on top of MiniSat. We also report on a performance study, in which our implementation exhibits the expected benefits: full use of the underlying SAT solver's potential.

Grounding is the task of reducing a first-order theory and finite domain to an equivalent propositional theory. It is used as preprocessing phase in many logic-based reasoning systems. Such systems provide a rich first-order input language to a user and can rely on efficient propositional solvers to perform the actual reasoning.Besides a first-order theory and finite domain, the input for grounders contains in many applications also additional data. By exploiting this data, the size of the grounder's output can often be reduced significantly. A common practice to improve the efficiency of a grounder in this context is by manually adding semantically redundant information to the input theory, indicating where and when the grounder should exploit the data. In this paper we present a method to compute and add such redundant information automatically. Our method therefore simplifies the task of writing input theories that can be grounded efficiently by current systems.We first present our method for classical first-order logic (FO) theories. Then we extend it to FO(ID), the extension of FO with inductive definitions, which allows for more concise and comprehensive input theories. We discuss implementation issues and experimentally validate the practical applicability of our method.

In this paper we present a proposal for a knowledge-based programming environment. In such an environment, declarative background knowledge, procedures, and concrete data are represented in suitable languages and combined in a flexible manner. This leads to a highly declarative programming style. We illustrate our approach on an example and report about our prototype implementation. ContextAn obvious requirement for a powerful and flexible programming paradigm seems to be that within the paradigm different types of information can be expressed in suitable languages. However, most traditional programming paradigms and languages do not really have this property. In imperative languages, for example, non-executable background knowledge can not be described. The consequences become clear when we try to solve a scheduling problem in an imperative language: the background knowledge, the constraints that need to be satisfied by the schedule, gets mixed up with the algorithms. This makes adding new constraints and finding and modifying existing ones cumbersome.On the other hand, most logic-based declarative programming paradigms lack the capacity to express procedures. Typically, they consist of a logic together with one specific type of inference. For example, Prolog uses Horn clause logic and does querying, in Description Logic the studied task is deduction, and Answer Set Programming and Constraint Programming make use of model generation. In such paradigms, whenever we try to perform a task that does not fit the inference mechanism at hand, the declarative aspect of the paradigm disappears. For example, when we try to solve a scheduling problem (which is a typical model-generation problem) in Prolog, then we need to represent the schedule as a term, say a list (rather than as a logical structure), and as a result the constraints do not really reside in the logic program, but will have to be expressed by clauses that iterate over a list [4]. Proving that a certain requirement is implied by another, is possible (in theory) for a theorem prover, but not in ASP. Etc.To overcome these restrictions of existing paradigms, we propose a paradigm in which each component can be expressed in an appropriate language. We distinguish three components: procedures, (non-executable) background knowledge, and concrete data. For the first we need an imperative language, for the second an (expressive) logic, for the third a logical structure (which corresponds to a database). The connection between these components is mostly realized by various reasoning tasks, such as theorem proving, model generation, model checking, model revision, belief revision, constraint propagation, querying, datamining, visualization, etc.The idea to support multiple forms of inference for the same logic or even for the same theories, was argued in [6]. Here it is argued that logic has a more flexible, multifunctional and therefore also more declarative role for problem solving than provided in many declarative programming paradigms, where typically one form of...

Constraint propagation is one of the basic forms of inference in many logic-based reasoning systems. In this paper, we investigate constraint propagation for first-order logic (FO), a suitable language to express a wide variety of constraints. We present an algorithm with polynomial-time data complexity for constraint propagation in the context of an FO theory and a finite structure. We show that constraint propagation in this manner can be represented by a datalog program and that the algorithm can be executed symbolically, i.e., independently of a structure. Next, we extend the algorithm to FO(ID), the extension of FO with inductive definitions. Finally, we discuss several applications.The first constraint states that mutually exclusive components cannot be selected both, the second one expresses that at least one module should be taken and the third one ensures that all courses of a selected module are selected. Consider a situation where there are, amongst others, two mutually exclusive courses c 1 and c 2 , that c 1 belongs to a certain module m 1 , and that at some point in the application, the student has selected m 1 and is still undecided about the other courses and modules. That is, an incomplete database or partial structure is given. One can check that in every total selection that completes this partial selection and satisfies the constraints, c 1 will be selected, c 2 will not be selected, and no module containing c 2 will be selected. Constraint propagation for FO aims to derive these facts.Given a theory T and a partial structureĨ, computing all the models of T that completeĨ, and making facts true (respectively false) that are true (respectively false) in all these models yields the most precise results. However, it is in general too expensive to perform constraint propagation in this way. The constraint propagation algorithm we present in this paper is less precise, but, for a fixed theory T , runs in polynomial time in the domain size ofĨ. The algorithm consists of two steps. First, T is rewritten in linear time to an equivalent theory T such that for each constraint in T , there exists a precise polynomial-time propagator. In the second step, these propagators are successively applied, yielding polynomial-time propagation for T , and hence for T .Besides its polynomial-time data complexity, our algorithm has two other benefits. First, the propagation can be represented by a set of (negation-free) rules under a least model semantics. Such sets of rules occur frequently in logic-based formalisms. Examples are Prolog, Datalog, Stable Logic Programming [Marek and Truszczyński 1999;Niemelä 1999], FO extended with inductive definitions [De-Often, we denote a formula ϕ by ϕ[x] to indicate that x is precisely the set of free variables of ϕ. That is, if y ∈ x, then y has at least one occurrence in ϕ outside the scope of quantifiers ∀y and ∃y. A formula without free variables is called a sentence. If ϕ is a formula, x a variable and t a term, then ϕ[x/t] denotes the result of replacing all free occurre...

In this dissertation, we investigate various sorts of reasoning on finite structures and theories in the logic FO(•), a rich extension of classical logic with, amongst others, inductive definitions and aggregates. In particular, we study the tasks of constraint propagation, grounding, model revision, and debugging for FO(•).