#### DMCA

## lolliCoP -- A Linear Logic Implementation of a Lean Connection-Method Theorem Prover for First-Order Classical Logic (2001)

### Cached

### Download Links

Venue: | PROCEEDINGS OF IJCAR: INTERNATIONAL JOINT CONFERENCE ON AUTOMATED REASONING, NUMBER 2083 IN LNCS |

Citations: | 3 - 0 self |

### Citations

822 | Linear logic
- Girard
- 1987
(Show Context)
Citation Context ...e with a global switch, affecting all unification in the system. In SICStus Prolog, used for the tests in this paper, it is done with the predicate unify_with_occurs_check. This predicate is used within the member_oc and append_oc predicates, whose definitions have been elided in the code above. Many of these complications could have been avoided by using λ-Prolog, which supports the use of λ-terms as data for representing name-binding structures, and whose unification algorithm is sound [11]. 4 A Brief Introduction to Linear Logic Programming Linear logic was first proposed by Girard in 1987 [4]. Figure 3 gives a Gentzen sequent calculus for part of the fragment of intuitionistic linear logic which forms the foundation of the logic programming language Lolli, named for the linear logic implication operator,−◦, known as lollipop. The calculus is not the standard one, but for this fragment is equivalent to it, and is easier to explain in the context of logic programming. In these sequents, the left-hand side has two parts: the context Γ holds assumptions that can be freely reused and discarded, as in traditional logics, while the assumptions in ∆, in contrast, must be used exactly once... |

429 | Uniform Proofs as a Foundation for Logic Programming
- Miller, Nadathur, et al.
- 1991
(Show Context)
Citation Context ...nage a collection of resources are rewritten to take advantage of the linear logic resource management provided by the logic programming language Lolli, they can obtain dramatic speedup. Thus far this has been demonstrated only for “toy” applications, such as n-queens. In this paper we present such a reimplementation of the lean connection-calculus prover leanCoP and obtain a theorem prover for first-order classical logic which rivals or outperforms state-of-the-art provers on a significant body of problems. 1 Introduction The development of logic programming languages based on intuitionistic [11] and linear logic [6] has been predicated on two principal assumptions. The first, and the one most argued in public, has been that, given the increased expressivity, programs written in these languages are more perspicuous, more natural, and easier to reason about formally. The second assumption, which the designers have largely kept to themselves, is that by moving the handling of various program features into the logic, and hence from the term level to the formula level, we would expose them to the compiler, and, thus, to optimization. In the end, we believed, this would yield programs that... |

341 | Logic Programming in a Fragment of Intuitionistic Linear Logic
- Hodas, Miller
- 1994
(Show Context)
Citation Context ...esources are rewritten to take advantage of the linear logic resource management provided by the logic programming language Lolli, they can obtain dramatic speedup. Thus far this has been demonstrated only for “toy” applications, such as n-queens. In this paper we present such a reimplementation of the lean connection-calculus prover leanCoP and obtain a theorem prover for first-order classical logic which rivals or outperforms state-of-the-art provers on a significant body of problems. 1 Introduction The development of logic programming languages based on intuitionistic [11] and linear logic [6] has been predicated on two principal assumptions. The first, and the one most argued in public, has been that, given the increased expressivity, programs written in these languages are more perspicuous, more natural, and easier to reason about formally. The second assumption, which the designers have largely kept to themselves, is that by moving the handling of various program features into the logic, and hence from the term level to the formula level, we would expose them to the compiler, and, thus, to optimization. In the end, we believed, this would yield programs that executed more effici... |

134 |
Setheo: a high-performance theorem prover.
- Letz, Schumann, et al.
- 1992
(Show Context)
Citation Context ...roduces lolliCoP; Section 6 presents the results and analysis of various performance tests and comparisons; and, Section 7 presents the two optimizations mentioned above. 2 Connection-Calculus Theorem Proving The connection calculus [2] is a matrix proof procedure for clausal first-order classical logic. (Variations have been proposed for other logics, but this is its primary application.) The calculus, which uses a positive representation, proving matrices of clauses in disjunctive normal form, has been utilized in a number of theorem proving systems, including KoMeT [3], Setheo and E-Setheo [9, 12]. It features two principal rules, extension and reduction. The extension step, which corresponds roughly to backchaining, consists of matching the complement of a literal in the active goal clause with the head of some clause in the matrix. The body of that clause is then proved, as is the remainder of the original clause. Γ |∅ ` A1, . . . , An Γ (start) (provided C ∈ Γ , C[t/x] = {A1, . . . , An} for some t, n ≥ 0) Γ |Π ` (extension0) Γ |Li, Π ` L11, . . . , L1m C, Γ |Π ` L1, . . . , Li−1, Li+1, . . . , Ln C, Γ |Π ` L1, . . . , Ln (extension1) (provided C is ground, C = {Li, L11, . . . , L1m... |

43 | Programming in Lygon: An Overview
- Harland, Pym, et al.
- 1996
(Show Context)
Citation Context ...olli calls “true”, can only be proved if all the linear assumptions have already been used. In contrast, > is provable even if some resources are, as yet, unused. Thus if a > occurs as one of the conjuncts in a ⊗ conjunction, then the conjunction may succeed even if the other conjuncts do not use all the linear resources. The > is seen to consume the leftovers. Therefore, Lolli calls this operator “erase”. It is beyond the scope of this paper to demonstrate the applications of all these operators. Many good examples can be found in the literature, particularly in the papers on Lygon and Lolli [5, 6]. The proof theory of this fragment has also been developed extensively [6]. Of crucial importance is that there is a straightforward goal-directed proof procedure (conceptually similar to the one used for Prolog) that is sound and complete for this fragment of linear logic. 5 The lolliCoP Theorem Prover Figure 4 gives the code for lolliCoP, a reimplementation of leanCoP in Lolli/LLP.1 The basic premise of its design is that, rather than being passed around as a list, the matrix will be loaded as assumptions into the proof context and accessed directly. In addition, ground clauses will be adde... |

28 | leanCoP: lean connection-based theorem proving.
- Otten, Bibel
- 2000
(Show Context)
Citation Context ...owing the elements in the list to instead be stored in the proof context –with the underlying rules ? This paper reports work done while the second author was on a sabbatical-leave from Kobe University. of linear logic managing their consumption– substantial speedups can occur. To date, however, that speedup has been demonstrated only on the execution of simple, “toy” applications, such as an n-queens problem solver [7]. Now we have turned our attention to a more sophisticated application: theorem proving. We have reimplemented the leanCoP connection-calculus theorem prover of Otten and Bibel [14] in Lolli. This “lean” theorem prover has been shown to have remarkably good performance relative to state-of-the-art systems, particularly considering that it is implemented in just a half-page of Prolog code. The reimplemented prover, which we call lolliCoP, is of comparable size, and, when compiled under LLP (the reference Lolli compiler [7]), provides a speedup of 40% over leanCoP. On many of the hardest problems that both can solve, it is roughly the same speed as the Otter theorem prover [8]. (Both leanCoP and lolliCoP solve a number of problems that Otter cannot. Conversely, Otter solve... |

26 |
Deduction. Automated Logic.
- Bibel
- 1993
(Show Context)
Citation Context ...and the number of problems solved expands even further. 1.1 Organization The remainder of this paper is organized as follows: Section 2 gives a brief introduction to the connection calculus for first-order classical logic; Section 3 describes the leanCoP theorem prover; Section 4 gives a brief introduction to linear logic, Lolli, and the LLP compiler; Section 5 introduces lolliCoP; Section 6 presents the results and analysis of various performance tests and comparisons; and, Section 7 presents the two optimizations mentioned above. 2 Connection-Calculus Theorem Proving The connection calculus [2] is a matrix proof procedure for clausal first-order classical logic. (Variations have been proposed for other logics, but this is its primary application.) The calculus, which uses a positive representation, proving matrices of clauses in disjunctive normal form, has been utilized in a number of theorem proving systems, including KoMeT [3], Setheo and E-Setheo [9, 12]. It features two principal rules, extension and reduction. The extension step, which corresponds roughly to backchaining, consists of matching the complement of a literal in the active goal clause with the head of some clause in... |

24 | leanTAP: lean tableau-based theorem proving.
- Beckert, Posegga
- 1994
(Show Context)
Citation Context ... check whatsoever for the ground status of a clause in the core (prove/2). This removes the potentially significant computational cost of checking the ground status each time a clause is selected: an operation linear in the size of the selected clause. Space constraints keep us from including the full program. Taken together these small improvements actually triple the performance of the system. While the first optimization can be added, awkwardly, to leanCoP, it is not possible to do away entirely with the groundness check in that setting. 8 Conclusion Lean theorem proving began with leanTAP [1], which provided an existence proof that it was possible to implement interesting theorem proving techniques using clear short Prolog programs. It was not expected, however, to provide particularly powerful systems. Recently, leanCoP showed that these programs can be at once perspicuous and powerful. However, to the extent that these programs rely on the use of term-level Prolog data structures to maintain their proof contexts, they require the use of list manipulation predicates that are neither particularly fast nor clear. In this paper we have shown that by representing the proof context wi... |

16 | Efficient Implementation of a Linear Logic Programming Language
- Hodas, Watkins, et al.
(Show Context)
Citation Context ...that by moving the handling of various program features into the logic, and hence from the term level to the formula level, we would expose them to the compiler, and, thus, to optimization. In the end, we believed, this would yield programs that executed more efficiently than the equivalent program written in more traditional logic programming languages. Until now, this view has been downplayed as most of these new languages have thus far been implemented only in relatively inefficient, interpreted systems. With the recent development of compilers for languages such as λ-Prolog [13] and Lolli [7], however, we are beginning to see this belief justified. In the case of Lolli, we are focused on logic programs which have used a term-level list as a sort of bag from which items are selected according to some rules. In earlier work we showed that when such code is rewritten in Lolli, allowing the elements in the list to instead be stored in the proof context –with the underlying rules ? This paper reports work done while the second author was on a sabbatical-leave from Kobe University. of linear logic managing their consumption– substantial speedups can occur. To date, however, that speedup... |

4 |
Setheo and E-Setheo—the CADE-13 systems.
- Moser, Ibens, et al.
- 1997
(Show Context)
Citation Context ...roduces lolliCoP; Section 6 presents the results and analysis of various performance tests and comparisons; and, Section 7 presents the two optimizations mentioned above. 2 Connection-Calculus Theorem Proving The connection calculus [2] is a matrix proof procedure for clausal first-order classical logic. (Variations have been proposed for other logics, but this is its primary application.) The calculus, which uses a positive representation, proving matrices of clauses in disjunctive normal form, has been utilized in a number of theorem proving systems, including KoMeT [3], Setheo and E-Setheo [9, 12]. It features two principal rules, extension and reduction. The extension step, which corresponds roughly to backchaining, consists of matching the complement of a literal in the active goal clause with the head of some clause in the matrix. The body of that clause is then proved, as is the remainder of the original clause. Γ |∅ ` A1, . . . , An Γ (start) (provided C ∈ Γ , C[t/x] = {A1, . . . , An} for some t, n ≥ 0) Γ |Π ` (extension0) Γ |Li, Π ` L11, . . . , L1m C, Γ |Π ` L1, . . . , Li−1, Li+1, . . . , Ln C, Γ |Π ` L1, . . . , Ln (extension1) (provided C is ground, C = {Li, L11, . . . , L1m... |

3 |
The TPTP problem library—CNF release v1.2.1.
- Sutcliffe, Suttner
- 1998
(Show Context)
Citation Context ...n their identity as logic variables and may become instantiated subsequently. In particular, the literals added to the path may contain instances of free variables from the goal clause from which they derive. Anything which causes these variables to become instantiated will similarly affect those occurrences in these assumptions. Thus, this technique could not be implemented using Prolog’s assert mechanism. In any case, asserted clauses are generally not as fast as compiled ones. 6 Performance Analysis We have tested lolliCoP on the 2200 clausal form problems in the TPTP library version 2.3.0 [15, 8]. These consist of 2193 problems known to be unsatisfiable (or valid using positive representation) and 7 propositional problems known to be satisfiable (or invalid). Each problem is rated from 0.00 to 1.00 relative to its difficulty. A rating of “?” means the difficulty is unknown. No reordering of clauses or literals has been done. The tests were performed on a Linux system with a 550MHz Pentium III processor and 128M bytes of memory. The programs were compiled with version 0.50 of LLP which generated abstract machine code executed by an emulator written in C. The time limit for all proof at... |

1 |
Otter 3.0 reference manual and guide.
- MacCune
- 1994
(Show Context)
Citation Context ...mit for all proof attempts was 300 seconds. Table 1. Overall performance of Otter, leanCoP, and lolliCoP Total Otter leanCoP lolliCoP lolliCoP2 Solved 2200 1602 (73%) 810 (37%) 822 (37%) 880 (40%) 0 to < 1 second 1209 541 554 614 1 to < 10 seconds 142 135 124 117 10 to <100 seconds 209 93 91 94 100 to <200 seconds 31 18 25 34 200 to <300 seconds 11 23 28 21 Problems rated 0.00 1308 1230 (94%) 713 (55%) 716 (55%) 737 (56%) Problems rated >0.00 733 249 (34%) 76 (10%) 83 (11%) 118 (16%) Problems rated ? 159 123 (77%) 21 (13%) 23 (14%) 25 (16%) The overall performance of Otter 3.1 (with MACE 1.4) [8, 10], leanCoP [14], and lolliCoP, in terms of the number of problems solved, are shown in Table 1. The table also includes data for an improved version of lolliCoP, called lolliCoP2, discussed in the next section. The results for leanCoP were obtained in the same environment as those for lolliCoP, using SICStus Prolog 3.7.1, and are better than those reported by the authors [14]. The results for Otter 3.1 (with MACE 1.4), which is not publicly available, are taken from a report by its developers [8]. These results were produced on a 400MHz Pentium II, which is somewhat slower than the machine we u... |

1 |
Teyjus—a compiler and abstract machine based implementation of lambda Prolog.
- Nadathur, Mitchell
- 1999
(Show Context)
Citation Context ...themselves, is that by moving the handling of various program features into the logic, and hence from the term level to the formula level, we would expose them to the compiler, and, thus, to optimization. In the end, we believed, this would yield programs that executed more efficiently than the equivalent program written in more traditional logic programming languages. Until now, this view has been downplayed as most of these new languages have thus far been implemented only in relatively inefficient, interpreted systems. With the recent development of compilers for languages such as λ-Prolog [13] and Lolli [7], however, we are beginning to see this belief justified. In the case of Lolli, we are focused on logic programs which have used a term-level list as a sort of bag from which items are selected according to some rules. In earlier work we showed that when such code is rewritten in Lolli, allowing the elements in the list to instead be stored in the proof context –with the underlying rules ? This paper reports work done while the second author was on a sabbatical-leave from Kobe University. of linear logic managing their consumption– substantial speedups can occur. To date, however... |

1 |
Laboratory. Otter and MACE on TPTP v2.3.0. Web page at http://www-unix.msc.anl.gov/AR/otter/tptp230.html,
- National
- 2000
(Show Context)
Citation Context ...proving. We have reimplemented the leanCoP connection-calculus theorem prover of Otten and Bibel [14] in Lolli. This “lean” theorem prover has been shown to have remarkably good performance relative to state-of-the-art systems, particularly considering that it is implemented in just a half-page of Prolog code. The reimplemented prover, which we call lolliCoP, is of comparable size, and, when compiled under LLP (the reference Lolli compiler [7]), provides a speedup of 40% over leanCoP. On many of the hardest problems that both can solve, it is roughly the same speed as the Otter theorem prover [8]. (Both leanCoP and lolliCoP solve a number of problems that Otter cannot. Conversely, Otter solves many problems that they cannot. On simpler problems that both solve, Otter is generally much faster than leanCoPand lolliCoP.) While this is a substantial improvement, it is not the full story. LLP is a relatively naive, first-generation compiler and run-time system. Whereas, it is being compared to a program compiled in a far more mature and optimized Prolog compiler (SICStus Prolog 3.7.1). When we adjust for this difference, we find that lolliCoP is more than twice as fast as leanCoP, and solv... |