PIE – Proving, Interpolating and Eliminating on the Basis of First-Order Logic

08/29/2019 ∙ by Christoph Wernhard, et al. ∙ 0

PIE is a Prolog-embedded environment for automated reasoning on the basis of first-order logic. It includes a versatile formula macro system and supports the creation of documents that intersperse macro definitions, reasoner invocations and LaTeX-formatted natural language text. Invocation of various reasoners is supported: External provers as well as sub-systems of PIE, which include preprocessors, a Prolog-based first-order prover, methods for Craig interpolation and methods for second-order quantifier elimination.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

First-order logic is used widely and in many roles in philosophy, mathematics, and artificial intelligence as well as other branches of computer science. Many practically successful reasoning approaches can be viewed as derived from reasoning in first-order logic, for example, SAT solving, logic programming, database query processing and reasoning in description logics. The aim of the PIE system is to increase practicability of actual

reasoning in first-order logic. The system is written and embedded in SWI-Prolog [52]. Formulas are basically represented by Prolog ground terms, where explicit quantifiers distinguish Prolog atoms as formula variables. In addition, PIE supports clausal formulas represented as list of lists of terms (logic literals), with variables represented by Prolog variables. Prolog is very well suited as basis of a formula manipulation tool, in particular since it supports terms as readable and printable data structures that can be immediately used to represent logic formulas, since unification and on occasion also backtracking is quite useful to implement formula manipulating operations and since it offers an interpreter-based environment for development, which is also useful to develop mechanized formalizations. The functionality of PIE is provided essentially in form of a library of Prolog predicates. It includes:

  • Support for a Prolog-readable syntax of first-order logic formulas.

  • Formula pretty-printing in Prolog syntax and in LaTeX.

  • A versatile formula macro processor.

  • Support for processing documents that intersperse formula macro definitions, reasoner invocations and LaTeX-formatted natural language text.

  • Interfaces to external first-order and propositional reasoners.

  • A built-in Prolog-based first-order theorem prover.

  • Computation of first-order Craig interpolants.

  • Second-order quantifier elimination.

  • Various formula conversion operations for use in preprocessing, inprocessing and output presentation.

One possibility to use the system is to develop or inspect formalizations in a machine-supported way, similar to programming in AI languages like Prolog and Lisp, by (re-)loading documents with macro definitions and specifications of reasoner invocations as well as evaluating expressions interactively in the Prolog interpreter, where output formulas might be pretty-printed. Optionally documents can be also rendered in LaTeX, where macro definitions as well as output formulas are also pretty-printed, interspersed with natural language text in the fashion of literate programming [25]. Craig interpolation and second-order quantifier elimination are reasoning techniques that compute formulas. Both are supported by PIE on the basis of first-order logic. For interpolation it seems that most other implementations are on the basis of propositional logics with theory extensions and specialized for applications in verification [3].111Craig interpolation for first-order logic is supported by Princess [6, 5] and by extensions of Vampire [22, 21]. For second-order quantifier elimination and similar operations there are several implementations based on modal and description logics, but very few on first-order logic.222A Web service http://www.mettel-prover.org/scan/ invokes an implementation of the SCAN algorithm [16, 14]. Another system is DLSForgetter https://personalpages.manchester.ac.uk/staff/ruba.alassaf/software.html, which implements the DLS algorithm [11]. An earlier implementation of DLS [20] seems to be no longer available.

The system is available as free software from its homepage

http://cs.christophwernhard.com/pie.

It comes with several examples whose source files as well as rendered LaTeX presentations can also be accessed directly from the system page. Inspecting Gödel’s Ontological Proof is there an advanced application demo that utilizes some of the recently introduced system features. An earlier version of the system was presented at the 2016 workshop Practical Aspects of Automated Reasoning [49]. Many small improvements make it now more workable.

The rest of this system description is structured as follows: Features and uses of the formula macro system are presented in Sect. 2. In Sect. 3 the support for documents that integrate macro definitions, reasoner invocations and natural language text is shown. Interfaces to external provers and the prover included with PIE are described in Sect. 4, followed by the discussion of included reasoners that compute formulas by preprocessing conversions, Craig interpolation and second-order quantifier elimination in Sect. 5. Section 6 concludes the paper. The bibliography reflects that the system relates to methods as well as implementation and application aspects in a number of areas, including first-order theorem proving, Craig interpolation, second-order quantifier elimination and knowledge representation.

2 Formula Macros

PIE includes a formula macro system, where macros can have parameters and expand into first- or second-order formulas. In the simplest case, a macro without parameters serves as a formula label that may be used in subformula position in other formulas and is expanded into its definiens. The following example of such a macro definition effects that kb1 is declared as label of a formula. In the formula syntax, the comma and -> represent conjunction and implication, respectively:

[fontsize=] def(kb1) :: (sprinkler_was_on -¿ wet(grass)), (rained_last_night -¿ wet(grass)), (wet(grass) -¿ wet(shoes)).

Prolog variables in macro specifications express macro parameters. The following example illustrates this with the schematic definition of a certain form of abductive explanation, the weakest sufficient condition [28, 12, 45], as a second-order formula, where the parameters are the background knowledge base Kb, the set Na (non-assumables) of predicates that are not allowed to occur free in explanations, and the observation Ob. Universal second-order quantification is represented in the formula syntax by all2.

[fontsize=] def(explanation(Kb, Na, Ob)) :: all2(Na, (Kb -¿ Ob)).

Pattern matching is applied to choose the effective declaration for expansion, allowing structural recursion in macro declarations. An optional Prolog body in a macro declaration permits expansions involving arbitrary computations. Utility predicates for use in these bodies are provided for common tasks. The second-order circumscription of predicate P in formula F can thus be defined as shown in the following example, where ~ represents negation and ex2 existential second-order quantification. The suffix _p is used for some variable names because it is translated to the prime superscript in the LaTeX  rendering, as shown below in Sect. 3.

[fontsize=] def(circ(P, F)) :: F,  ex2(P_p, (F_p, T1,  T2)) ::- mac_rename_free_predicate(F, P, pn, F_p, P_p), mac_get_arity(P, F, A), mac_transfer_clauses([P/A-n], p, [P_p], T1), mac_transfer_clauses([P/A-n], n, [P_p], T2).

With a macro declaration, properties of its lexical environment, in particular configuration settings that affect the expansion, are recorded. The macro system utilizes further features of Prolog variables to mimic some features of the processing of lambda expressions: A Prolog variable that is free after computing the user-specified part of the expansion is bound automatically to a freshly generated symbol. A Prolog variable used as macro parameter may occur in the definiens in predicate position (SWI-Prolog has an option that allows variables in predicate position). The parameter then can be instantiated with a predicate symbol (Prolog atom) or a lambda term. The following macro definition gives an example. It specifies 2-colorability by an existential second-order sentence and has the edge relationship as parameter E. The semicolon in the formula represents disjunction and all universal first-order quantification.

[fontsize=] def(col2(E)) :: ex2([r,g], (all(x, (r(x) ; g(x))), all([x,y], (E(x,y) -¿ ( ((r(x), r(y))),  ((g(x), g(y)))))))).

The macro can then be used with instantiating E to a predicate symbol, as in col2(e), or to lambda expression that might describe a particular graph, as in col2(lambda([u,v],((u=1,v=2);(u=2,v=3)))). At macro expansion, E(x,y) in the definiens of col2(E) is then replaced by e(x,y) or ((x=1,y=2);(x=2,y=3)), respectively.

Macros provide a convenient way to express abstractly properties of predicates such as transitivity and application patterns of second-order quantification such as circumscription. As parameterized formula labels they are helpful to structure formalizations. Working practically with first-order provers typically involves experimenting with a large and developing set of related proving problems, for example with alternate axiomatizations or different candidate theorems, and is thus often accompanied with some meta-level technique to compose and relate the actual proof tasks submitted to first-order reasoners. The PIE macro system tries to provide such a technique in a non ad-hoc, systematic way with a uniform mechanism that remains in spirit of first-order logic, which in mathematics is actually often used with schemas.

3 Pie Documents

PIE supports the handling of documents that intersperse macro definitions, specifications of reasoning tasks and LaTeX-formatted natural language text. Such a PIE document can be loaded into the Prolog environment like a source code file and, in addition, be processed, which means to invoke the specified reasoning tasks and print the LaTeX fragments in the document interspersed with LaTeX presentations of the reasoning task outputs. The resulting output LaTeX document can then be displayed in PDF format. In such a document, the first definitions from Sect. 2, for example, would be rendered as follows:

First- and second-order quantifiers are not distinguished in the default LaTeX presentation. An intuitive idea of the effect of the Prolog code in the definition of the circ macro (presented as where clause in LaTeX) can be obtained by considering the expansion of an example instance: expands into

PIE documents serve various purposes:

  • They are useful in the workflow of developing a formalization, in particular as they can be re-loaded into the Prolog environment, which effects appropriate updates of the specified items.

  • First-order reasoners are often heavily dependent on configuration settings. A PIE document specifies all information needed to reproduce the results of reasoner invocations. Effective configuration parameters are combined by system defaults, defaults declared in the document and options supplied with particular specifications of reasoner invocations.

  • Formulas are presented nicely formatted in LaTeX. Aside of indentation, the LaTeX pretty-printer by default applies some symbol conversions to subscripted or primed symbols. Also a compact syntax where parentheses to separate arguments from functors and commas between arguments are omitted is available as an option for both Prolog and LaTeX forms.

  • The interspersing of formal specifications with LaTeX-formatted text allows to develop formalizations in analogy to literate programming [25], that is, embedded into explanation and discussions formulated in natural language.

Finding good presentations of formulas, in particular in presence of operations that yield formulas, seems a challenging topic. In practice often simply conjunctive normal form is used, possibly with representing clauses as implications. The PIE system supports the option to present output formulas in a shape that is similar and is obtained by computing conjunctive or disjunctive normal form followed by un-Skolemization.

4 Interfaced and Included Provers

PIE allows to invoke a variety of external reasoning systems: Most first-order provers via the TPTP formats, Otter, Prover9 and Mace4 via their own input format, as well as SAT and QBF solvers via DIMACS and QDIMACS. Large propositional formulas are supported with an internal representation based on destructive term operations. Most features for handling propositional formulas are inherited from the precursor system ToyElim [47].

A user-level predicate to test a first-order formula for validity invokes by default first the model searcher Mace4 with a short timeout, and, if it could not find a “counter”-model of the negated formula, the prover Prover9, again with a short timeout. Correspondingly, the predicate then prints one of three result values: valid, not valid or failed to validate. For example, the top-level goal

[fontsize=] :- ppl_printtime(ppl_valid((kb1, rained_last_night -¿ wet(shoes)))).

in a PIE document effects that during document processing (at “printtime”) Prover9 is invoked and, given the above definition of kb1, the following is inserted into the LaTeX output:

Alternatively, the ppl_valid statement can also be directly input as query to the Prolog interpreter, effecting then that *Valid* is printed to the console. Optionally Prolog term representations of Prover9’s resolution proof or Mace4’s model, respectively, can be obtained.

The PIE system also includes the first-order Prover CM, whose calculus can be understood as model elimination, clausal tableau construction [27], or the connection method, similar to provers of the leanCoP family [36, 23, 24]. The implementation of CM follows the compilation-based Prolog Technology Theorem Prover (PTTP) paradigm [42]. It can return clausal tableau proofs as Prolog terms, which allow the extraction of Craig interpolants (see Sect. 5.2 below). More details and evaluation results available at http://cs.christophwernhard.com/pie/cmprover.

5 Beyond Proving: Operations that Output Formulas

Beyond theorem proving in the strict sense and model construction, first-order logic is related to further mechanizable operations whose results are formulas with certain semantic and syntactic properties and which are supported by PIE.

5.1 Preprocessing Operations

Practically successful reasoners usually apply in some way conversions of low complexity as far as possible: as preprocessing on inputs, potentially during reasoning, which has been termed inprocessing, and to improve the syntactic shape of output formulas as discussed in Sect. 3. Abstracting from these situations, we subsume these conversions under preprocessing operations. Also the low complexity might be taken more or less literally and, for example, be achieved simply by trying an operation within a threshold limit of resources. The PIE system includes a number of preprocessing operations including normal form conversions, also in variants that produce structure preserving normalizations, various simplifications of clausal formulas, and an implementation of McCune’s un-Skolemization algorithm [33]. While some of these preserve equivalence, others preserve equivalence just with respect to a set of predicates, for example, purity simplification with respect to predicates that are not deleted or structure preserving clausification with respect to predicates that are not added. This can be understood as preserving the second-order equivalence , where and are in- and outputs of the conversion and are those predicates permitted to occur in or whose semantics needs not to be preserved. If includes all permitted predicates, the above equivalence expresses equi-satisfiability. Some of the simplifications implemented in PIE allow to specify explicitly a set of predicates whose semantics is to be preserved, which makes them applicable for Craig interpolation and second-order quantifier elimination discussed below.

5.2 Craig Interpolation

By Craig’s interpolation theorem [8], for given first-order formulas and such that entails a first-order formula can be constructed such that entails , entails and contains only symbols (predicates, functions, constants, free variables) that occur in both and . Craig interpolation has many applications in logics and philosophy. Main applications in computer science are in verification [35] and query reformulation, based on its relationship to definability and construction of definientia in terms of a given vocabulary [43, 4, 3]. The PIE system supports the computation of Craig interpolants  from a closed clausal tableau that represents a proof that  entails  with a novel adaption of Smullyan’s interpolation method [41, 15] for clausal tableaux [51]. Suitable clausal tableaux can be constructed by the CM prover. PIE also supports the conversion of proof terms returned by the hypertableau prover Hyper [37] to such tableaux and thus to interpolants, but this is currently at an experimental stage.333Hypertableaux, either obtained from a hypertableau prover or obtained from a clausal tableau prover like CM by restructuring the tableau seem interesting as basis for interpolant extraction in query reformulation, as they allow to ensure that the interpolants are range restricted. Some related preliminary results are in [51]. As an example, consider a PIE document with the top-level goal

[fontsize=] :- ppl_printtime(ppl_ipol((all(x, p(a,x)), q) -¿ (ex(x, p(x,b)) ; r))).

At document processing the interpolation procedure is invoked. The argument of ppl_ipol must be an implication, whose left and right side are taken as  and , respectively. The example leads to the following LaTeX  output:

The interpolants  constructed by PIE strengthen the requirements for Craig interpolants in that they are actually Lyndon interpolants, that is, predicates occur in  only in polarities in which they occur in both  and . Symmetric interpolation [9, Lemma 2][34, Sect. 5] is supported in PIE, implemented by computing a conventional interpolant for each of the input formulas, corresponding to the induction suggested in [9].

In some contexts, for example the application of interpolation to compute definientia, it is natural to use second-order formulas, although the underlying reasoning is in fact just first-order: If and are second-order formulas of the form of a second-order quantifier prefix that is for just existential and for just universal, followed by a first-order formula, then entails if and only if a first-order formula  entails the first-order formula , where and are obtained from and , respectively, by renaming quantified predicates with fresh symbols and dropping the second-order prefixes. An interpolant of  and  is then also an interpolant of and . PIE quietly translates such second-order entailments to first-order form when submitting them to provers.

5.3 Second-Order Quantifier Elimination

Second-order quantifier elimination is the task of computing for a given formula with second-order quantifiers, that is, quantifiers upon predicate or function symbols, an equivalent first-order formula. Of course, on the basis of first-order logic this does not succeed in general. Along with variants termed forgetting, uniform interpolation or projection its applications include deciding fragments of first-order logic, computation of frame correspondence properties from modal axioms, computation of circumscription, embedding nonmonotonic semantics in a classical setting, abduction with respect to classical and to nonmonotonic semantics, forgetting in knowledge bases, and approaches to modularization of knowledge bases derived from the notion of conservative extension [32, 2, 16, 29, 11, 44, 18, 17, 19, 31, 39, 45, 46, 26, 30, 10]. As already noted in the introduction, implementations of second-order quantifier elimination on the basis of first-order logic are rare.

PIE includes an implementation of the DLS algorithm [11] for second-order quantifier elimination, a method based on formula rewriting until second-order subformulas have a certain shape that allows elimination in one step by rewriting with Ackermann’s lemma, an equivalence due to [1]. Implementing DLS brings about many subtle issues [20, 7, 48], for example, dealing with un-Skolemization, simplification of formulas in non-clausal form, and ensuring success of the method for certain input classes. The current implementation in PIE is far from optimum solutions of these issues, but can nevertheless be used in nontrivial applications and might contribute to improvements by making experiments possible.

Given the macro definitions shown in Sect. 2 and 3, PIE can, for example, be used to compute abductive explanations or circumscriptions: The top-level goal

[fontsize=] :- ppl_printtime(ppl_elim(explanation(kb1,[wet],wet(shoes)))).

in the document effects invocation of the elimination procedure at document processing and printing the following phrases in the LaTeX  rendering:

Analogously, the circumscription of in can be computed with the top-level goal:

[fontsize=] :- ppl_printtime(ppl_elim(circ(wet,kb1), [simp_result=[c6]])).

This leads to the following LaTeX output:

The option [simp_result=[c6]] supplied here to ppl_elim effects that the elimination result is postprocessed by equivalence preserving conversions with the aim to make it more readable, as discussed above in Sect. 5.1. The conversion named c6 chosen for this example converts to conjunctive normal form, applies various clausal simplifications and then converts back to a quantified first-order formula, involving un-Skolemization if required. That the last conjunct of the result can be replaced by the more succinct is, however, not detected by the current implementation.

With options [printing=false, r=Result] the elimination result is not printed, but bound to Result for further processing by Prolog. Another way to access the result is with the supplied predicate last_ppl_result(Result), which may be used to define a macro def(last_result) :: X ::- last_ppl_result(X).

PIE also includes an implementation of second-order quantifier elimination with respect to ground atoms by an expansion method shown in [29], which always succeeds on the basis of first-order logic. A second-order quantifier is there, so-to-speak, just upon a particular instance of a predicate.

The Boolean solution problem or Boolean unification with predicates is a computational task related to second-order quantifier elimination [40, 38, 50]. So far, PIE includes experimental implementations for simple cases: Quantifier-free formulas with a technique from [13] and a version for finding solutions with respect to ground atoms, in analogy to the elimination of ground atoms.

6 Conclusion

The PIE system tries to supplement what is needed to use automated first-order proving techniques for developing and analyzing formalizations. Its main focus is on formulas, as constituents of complex formalizations and as results of interpolation and elimination. Special emphasis is made on utilizing some natural relationships between first- and second-order logics. Key features of the system are macros, LaTeX pretty-printing and integration into the Prolog programming environment. The system mediates between high-level logical presentation and detailed configuration of reasoning systems. It shows up a number of challenging and interesting open issues for research, for example improving practical realizations of rewriting-based second-order quantifier elimination, strengthenings of Craig interpolation that ensure application-relevant properties such as range restriction, and conversion of computed formulas that are basically just semantically characterized to comprehensible presentations. Progress in these issues can be directly experienced and verified with the system.

References

  • [1] Ackermann, W.: Untersuchungen über das Eliminationsproblem der mathematischen Logik. Mathematische Annalen 110, 390–413 (1935). https://doi.org/10.1007/BF01448035
  • [2] Behmann, H.: Beiträge zur Algebra der Logik, insbesondere zum Entscheidungsproblem. Mathematische Annalen 86(3–4), 163–229 (1922). https://doi.org/10.1007/BF01457985
  • [3] Benedikt, M., Kostylev, E.V., Mogavero, F., Tsamoura, E.: Reformulating queries: Theory and practice. In: IJCAI 2017. pp. 837–843. ijcai.org (2017)
  • [4] Benedikt, M., Leblay, J., ten Cate, B., Tsamoura, E.: Generating Plans from Proofs: The Interpolation-based Approach to Query Reformulation. Morgan & Claypool (2016)
  • [5] Brillout, A., Kroening, D., Rümmer, P., Wahl, T.: Beyond quantifier-free interpolation in extensions of Presburger arithmetic. In: VMCAI 2011. pp. 88–102 (2011)
  • [6] Brillout, A., Kroening, D., Rümmer, P., Wahl, T.: An interpolating sequent calculus for quantifier-free Presburger arithmetic. Journal of Automated Reasoning 47(4), 341–367 (2011)
  • [7] Conradie, W.: On the strength and scope of DLS. Journal of Applied Non-Classsical Logics 16(3–4), 279–296 (2006)
  • [8] Craig, W.: Linear reasoning. A new form of the Herbrand-Gentzen theorem. Journal of Symbolic Logic 22(3), 250–268 (1957)
  • [9] Craig, W.: Three uses of the Herbrand-Gentzen theorem in relating model theory and proof theory. Journal of Symbolic Logic 22(3), 269–285 (1957)
  • [10] Delgrande, J.P.: A knowledge level account of forgetting. Journal of Artificial Intelligence Research 60, 1165–1213 (2017)
  • [11] Doherty, P., Łukaszewicz, W., Szałas, A.: Computing circumscription revisited: A reduction algorithm. Journal of Automated Reasoning 18(3), 297–338 (1997)
  • [12] Doherty, P., Łukaszewicz, W., Szałas, A.: Computing strongest necessary and weakest sufficient conditions of first-order formulas. In: IJCAI-01. pp. 145–151. Morgan Kaufmann (2001)
  • [13] Eberhard, S., Hetzl, S., Weller, D.: Boolean unification with predicates. Journal of Logic and Computation 27(1), 109–128 (2017)
  • [14] Engel, T.: Quantifier Elimination in Second-Order Predicate Logic. Master’s thesis, Max-Planck-Institut für Informatik, Saarbrücken (1996)
  • [15] Fitting, M.: First-Order Logic and Automated Theorem Proving. Springer, 2nd edn. (1995)
  • [16] Gabbay, D., Ohlbach, H.J.: Quantifier elimination in second-order predicate logic. In: KR’92. pp. 425–435. Morgan Kaufmann (1992)
  • [17] Gabbay, D.M., Schmidt, R.A., Szałas, A.: Second-Order Quantifier Elimination: Foundations, Computational Aspects and Applications. College Publications (2008)
  • [18] Ghilardi, S., Lutz, C., Wolter, F.: Did I damage my ontology? A case for conservative extensions in description logics. In: KR 06. pp. 187–197. AAAI Press (2006)
  • [19] Grau, B.C., Horrocks, I., Kazakov, Y., Sattler, U.: Modular reuse of ontologies: Theory and practice. Journal of Artificial Intelligence Research 31(1), 273–318 (2008)
  • [20] Gustafsson, J.: An implementation and optimization of an algorithm for reducing formulae in second-order logic. Tech. Rep. LiTH-MAT-R-96-04, Univ. Linköping (1996)
  • [21] Hoder, K., Holzer, A., Kovács, L., Voronkov, A.: Vinter: A Vampire-based tool for interpolation. In: APLAS 2012. LNCS, vol. 7705, pp. 148–156. Springer (2012)
  • [22] Hoder, K., Kovács, L., Voronkov, A.: Interpolation and symbol elimination in Vampire. In: IJCAR 2010. LNCS, vol. 6173, pp. 188–195. Springer (2010)
  • [23] Kaliszyk, C.: Efficient low-level connection tableaux. In: TABLEAUX 2015. LNCS (LNAI), vol. 9323, pp. 102–111. Springer (2015)
  • [24]

    Kaliszyk, C., Urban, J.: FEMaLeCoP: Fairly efficient machine learning connection prover. In: LPAR-20. LNCS, vol. 9450, pp. 88–96. Springer (2015)

  • [25] Knuth, D.E.: Literate programming. The Computer Journal 27(2), 97–111 (1984)
  • [26] Koopmann, P., Schmidt, R.A.: Uniform interpolation of -ontologies using fixpoints. In: FroCoS 2013. LNCS (LNAI), vol. 8152, pp. 87–102. Springer (2013)
  • [27] Letz, R.: First-order tableau methods. In: Marcello D’Agostino, Dov M. Gabbay, R.H., Posegga, J. (eds.) Handbook of Tableau Methods, pp. 125–196. Kluwer Academic Publishers (1999)
  • [28] Lin, F.: On strongest necessary and weakest sufficient conditions. Artificial Intelligence 128, 143–159 (2001)
  • [29] Lin, F., Reiter, R.: Forget It! In: Working Notes, AAAI Fall Symp. on Relevance. pp. 154–159 (1994)
  • [30] Ludwig, M., Konev, B.: Practical uniform interpolation and forgetting for TBoxes with applications to logical difference. In: KR’14. AAAI Press (2014)
  • [31] Lutz, C., Wolter, F.: Foundations for uniform interpolation and forgetting in expressive description logics. In: IJCAI-11. pp. 989–995. AAAI Press (2011)
  • [32] Löwenheim, L.: Über Möglichkeiten im Relativkalkül. Mathematische Annalen 76, 447–470 (1915)
  • [33] McCune, W.: Un-Skolemizing clause sets. Information Processing Letters 29(5), 257–263 (1988)
  • [34] McMillan, K.L.: Applications of Craig interpolants in model checking. In: TACAS 2005. LNCS, vol. 3440, pp. 1–12. Springer, Berlin, Heidelberg (2005)
  • [35] McMillan, K.L.: Interpolation and model checking. In: Clarke, E.M., Henzinger, T.A., Veith, H., Bloem, R. (eds.) Handbook of Model Checking, pp. 421–446. Springer (2018)
  • [36] Otten, J.: Restricting backtracking in connection calculi. AI Communications 23(2-3), 159–182 (2010)
  • [37] Pelzer, B., Wernhard, C.: System description: E-KRHyper. In: CADE-21. LNCS (LNAI), vol. 4603, pp. 503–513. Springer (2007)
  • [38] Rudeanu, S.: Boolean Functions and Equations. Elsevier (1974)
  • [39] Schmidt, R.A.: The Ackermann approach for modal logic, correspondence theory and second-order reduction. Journal of Applied Logic 10(1), 52–74 (2012)
  • [40] Schröder, E.: Vorlesungen über die Algebra der Logik. Teubner (1890–1905)
  • [41] Smullyan, R.M.: First-Order Logic. Dover publications, New York (1995), corrected republication of the original edition by Springer-Verlag, New York, 1968
  • [42] Stickel, M.E.: A Prolog technology theorem prover: implementation by an extended Prolog compiler. Journal of Automated Reasoning 4(4), 353–380 (1988)
  • [43] Toman, D., Weddell, G.: Fundamentals of Physical Design and Query Compilation. Morgan and Claypool (2011)
  • [44] Wernhard, C.: Semantic knowledge partitioning. In: JELIA 04. LNCS (LNAI), vol. 3229, pp. 552–564. Springer (2004)
  • [45] Wernhard, C.: Projection and scope-determined circumscription. Journal of Symbolic Computation 47, 1089–1108 (2012)
  • [46] Wernhard, C.: Abduction in logic programming as second-order quantifier elimination. In: FroCoS 2013. LNCS (LNAI), vol. 8152, pp. 103–119. Springer (2013)
  • [47] Wernhard, C.: Computing with logic as operator elimination: The ToyElim system. In: INAP 2011/WLP 2011. LNCS (LNAI), vol. 7773, pp. 289–296. Springer (2013)
  • [48] Wernhard, C.: Second-order quantifier elimination on relational monadic formulas – A basic method and some less expected applications. In: TABLEAUX 2015. LNCS (LNAI), vol. 9323, pp. 249–265. Springer (2015)
  • [49] Wernhard, C.: The PIE system for proving, interpolating and eliminating. In: PAAR 2016 (2016)
  • [50] Wernhard, C.: The Boolean solution problem from the perspective of predicate logic. In: FroCoS 2017. LNCS (LNAI), vol. 10483, pp. 333–350. Springer (2017)
  • [51] Wernhard, C.: Craig interpolation and access interpolation with clausal first-order tableaux. ArXiv e-prints (2018), https://arxiv.org/abs/1802.04982
  • [52] Wielemaker, J., Schrijvers, T., Triska, M., Lager, T.: SWI-Prolog. Theory and Practice of Logic Programming 12(1-2), 67–96 (2012)