1 Introduction
Firstorder 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 firstorder 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 firstorder logic. The system is written and embedded in SWIProlog [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 interpreterbased 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 Prologreadable syntax of firstorder logic formulas.

Formula prettyprinting in Prolog syntax and in LaTeX.

A versatile formula macro processor.

Support for processing documents that intersperse formula macro definitions, reasoner invocations and LaTeXformatted natural language text.

Interfaces to external firstorder and propositional reasoners.

A builtin Prologbased firstorder theorem prover.

Computation of firstorder Craig interpolants.

Secondorder 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 machinesupported 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 prettyprinted. Optionally documents can be also rendered in LaTeX, where macro definitions as well as output formulas are also prettyprinted, interspersed with natural language text in the fashion of literate programming [25]. Craig interpolation and secondorder quantifier elimination are reasoning techniques that compute formulas. Both are supported by PIE on the basis of firstorder 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].^{1}^{1}1Craig interpolation for firstorder logic is supported by Princess [6, 5] and by extensions of Vampire [22, 21]. For secondorder quantifier elimination and similar operations there are several implementations based on modal and description logics, but very few on firstorder logic.^{2}^{2}2A Web service http://www.mettelprover.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 secondorder 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 firstorder theorem proving, Craig interpolation, secondorder quantifier elimination and knowledge representation.
2 Formula Macros
PIE includes a formula macro system, where macros can have parameters and expand into first or secondorder 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 secondorder formula, where the parameters are the background knowledge base Kb, the set Na (nonassumables) of predicates that are not allowed to occur free in explanations, and the observation Ob. Universal secondorder 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 secondorder circumscription of predicate P in formula F can thus be defined as shown in the following example, where ~ represents negation and ex2 existential secondorder 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/An], p, [P_p], T1), mac_transfer_clauses([P/An], 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 userspecified 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 (SWIProlog 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 2colorability by an existential secondorder sentence and has the edge relationship as parameter E. The semicolon in the formula represents disjunction and all universal firstorder 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 secondorder quantification such as circumscription. As parameterized formula labels they are helpful to structure formalizations. Working practically with firstorder 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 metalevel technique to compose and relate the actual proof tasks submitted to firstorder reasoners. The PIE macro system tries to provide such a technique in a non adhoc, systematic way with a uniform mechanism that remains in spirit of firstorder 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 LaTeXformatted 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 secondorder 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 reloaded into the Prolog environment, which effects appropriate updates of the specified items.

Firstorder 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 prettyprinter 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 LaTeXformatted 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 unSkolemization.
4 Interfaced and Included Provers
PIE allows to invoke a variety of external reasoning systems: Most firstorder 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 userlevel predicate to test a firstorder 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 toplevel 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 firstorder 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 compilationbased 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, firstorder 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 unSkolemization 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 secondorder 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 equisatisfiability. 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 secondorder quantifier elimination discussed below.
5.2 Craig Interpolation
By Craig’s interpolation theorem [8], for given firstorder formulas and such that entails a firstorder 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.^{3}^{3}3Hypertableaux, 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 toplevel 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 secondorder formulas, although the underlying reasoning is in fact just firstorder: If and are secondorder formulas of the form of a secondorder quantifier prefix that is for just existential and for just universal, followed by a firstorder formula, then entails if and only if a firstorder formula entails the firstorder formula , where and are obtained from and , respectively, by renaming quantified predicates with fresh symbols and dropping the secondorder prefixes. An interpolant of and is then also an interpolant of and . PIE quietly translates such secondorder entailments to firstorder form when submitting them to provers.
5.3 SecondOrder Quantifier Elimination
Secondorder quantifier elimination is the task of computing for a given formula with secondorder quantifiers, that is, quantifiers upon predicate or function symbols, an equivalent firstorder formula. Of course, on the basis of firstorder logic this does not succeed in general. Along with variants termed forgetting, uniform interpolation or projection its applications include deciding fragments of firstorder 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 secondorder quantifier elimination on the basis of firstorder logic are rare.
PIE includes an implementation of the DLS algorithm [11] for secondorder quantifier elimination, a method based on formula rewriting until secondorder 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 unSkolemization, simplification of formulas in nonclausal 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 toplevel 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 toplevel 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 firstorder formula, involving unSkolemization 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 secondorder quantifier elimination with respect to ground atoms by an expansion method shown in [29], which always succeeds on the basis of firstorder logic. A secondorder quantifier is there, sotospeak, just upon a particular instance of a predicate.
The Boolean solution problem or Boolean unification with predicates is a computational task related to secondorder quantifier elimination [40, 38, 50]. So far, PIE includes experimental implementations for simple cases: Quantifierfree 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 firstorder 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 secondorder logics. Key features of the system are macros, LaTeX prettyprinting and integration into the Prolog programming environment. The system mediates between highlevel 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 rewritingbased secondorder quantifier elimination, strengthenings of Craig interpolation that ensure applicationrelevant 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 Interpolationbased Approach to Query Reformulation. Morgan & Claypool (2016)
 [5] Brillout, A., Kroening, D., Rümmer, P., Wahl, T.: Beyond quantifierfree 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 quantifierfree Presburger arithmetic. Journal of Automated Reasoning 47(4), 341–367 (2011)
 [7] Conradie, W.: On the strength and scope of DLS. Journal of Applied NonClasssical Logics 16(3–4), 279–296 (2006)
 [8] Craig, W.: Linear reasoning. A new form of the HerbrandGentzen theorem. Journal of Symbolic Logic 22(3), 250–268 (1957)
 [9] Craig, W.: Three uses of the HerbrandGentzen 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 firstorder formulas. In: IJCAI01. 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 SecondOrder Predicate Logic. Master’s thesis, MaxPlanckInstitut für Informatik, Saarbrücken (1996)
 [15] Fitting, M.: FirstOrder Logic and Automated Theorem Proving. Springer, 2nd edn. (1995)
 [16] Gabbay, D., Ohlbach, H.J.: Quantifier elimination in secondorder predicate logic. In: KR’92. pp. 425–435. Morgan Kaufmann (1992)
 [17] Gabbay, D.M., Schmidt, R.A., Szałas, A.: SecondOrder 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 secondorder logic. Tech. Rep. LiTHMATR9604, Univ. Linköping (1996)
 [21] Hoder, K., Holzer, A., Kovács, L., Voronkov, A.: Vinter: A Vampirebased 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 lowlevel 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: LPAR20. 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.: Firstorder 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: IJCAI11. 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.: UnSkolemizing 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(23), 159–182 (2010)
 [37] Pelzer, B., Wernhard, C.: System description: EKRHyper. In: CADE21. 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 secondorder 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.: FirstOrder Logic. Dover publications, New York (1995), corrected republication of the original edition by SpringerVerlag, 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 scopedetermined circumscription. Journal of Symbolic Computation 47, 1089–1108 (2012)
 [46] Wernhard, C.: Abduction in logic programming as secondorder 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.: Secondorder 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 firstorder tableaux. ArXiv eprints (2018), https://arxiv.org/abs/1802.04982
 [52] Wielemaker, J., Schrijvers, T., Triska, M., Lager, T.: SWIProlog. Theory and Practice of Logic Programming 12(12), 67–96 (2012)
Comments
There are no comments yet.