#	$Id: README,v 1.4 1994/07/24 09:59:17 posegga Exp $

			   The LeanTaP How-To
			   ------------------
        see also: <http://i12www.ira.uka.de/~posegga/leantap.html>


  		 Bernhard Beckert   &   Joachim Posegga
	
	       beckert@ira.uka.de	posegga@ira.uka.de	
<http://i12www.ira.uka.de/~beckert/>	<http://i12www.ira.uka.de/~posegga/>

			 Universit"at Karlsruhe
	Institut f"ur Logik, Komplexit"at und Deduktionssysteme
		Am Fasanengarten 5, 76128 Karlsruhe, FRG
		Phone: ++49 721 608 4322, Fax: ... 4329

			      12-July-1994

       (see also: <http://i12www.ira.uka.de/~posegga/leantap.html>)

What is LeanTaP?
----------------

LeanTaP is a complete and sound theorem prover for classical first-order
logic based on free-variable semantic tableaux.

The unique thing about LeanTaP is that it is probably the smallest
theorem prover around: The original LeanTaP program is only about 12
lines of Prolog.

Is there documentation on LeanTaP?
----------------------------------

Yes. The current reference for LeanTaP is:
		  
	@InProceedings{LeanTaPShort,
	  author = 	 "Bernhard Beckert and Joachim Posegga",
	  title = 	 "\mbox{{\sf lean}$T^{\!\!\textstyle A}\!\!P$}:
	                  lean, tableau-based theorem proving",
	  editor =	 "Alan Bundy",
	  volume =	 814,
	  series =	 LNAI,
	  booktitle =	 "Proc. CADE-12",
	  year =	 1994,
	  publisher =	 "Springer Verlag",
	  address =	 "Nancy, France",
	  month =	 "June/July"
	}

This describes the basic version of LeanTaP, which is an implementation
of standard free-variable semantic tableaux.

Besides this, there is an enhanced version of LeanTaP which includes a
powerful heuristic called "universal variables".  Both programs are
described in the long version of the above paper, which is currently
under review. We recommend that you read the long paper, rather than the
one cited above.

How can I obtain LeanTaP and the corresponding paper?
-------------------------------------------------------

Both the paper and the source code can be anonymously ftp-ed; the paper
lives as a compressed Postscript file in

	sonja.ira.uka.de:pub/posegga/LeanTaP.ps.Z

and the source code is in

	sonja.ira.uka.de:pub/posegga/LeanTaPsrc.shar.Z

Do not forget to switch to binary file transfer when ftp-ing!

(If you fail some reason, send email to one of the above addresses and
we will mail you the source code and the paper.)

How can I run the program?
--------------------------

Once you have received LeanTaPsrc.shar.Z, you have to unpack it; under
Unix, this works as follows:

% uncompress LeanTaPsrc.shar.Z  
% sh LeanTaPsrc.shar 
x - extracting README (Text)
x - extracting leantap.pl (Text)
x - extracting leantest.pl (Text)
x - extracting nnf.pl (Text)
x - extracting unify.pl (Text)

LeanTaP is written in Sicstus prolog, but it will run as well under
Quintus (all warnings of the Quintus compiler can be ignored). The
source code in leantest.pl defines four predicates which are supposed to
be something like a user interface:

	provefml/1	 the standard version of LeanTaP
	incprovefml/1	 the standard version using iterative deepening
	uv_provefml/1	 the version with universal variables
	uv_incprovefml/1 the version with universal variables and
			 iterative deepening.

All these predicates get one argument, which is the name of a formula in
the database. LeanTaP comes with a database of some of Pelletier's
problems (see leantest.pl).

The actual prover lives in leantap.pl and is defined as the predicates
prove/2 and prove_uv/2. See the comments there for details.

Are there other versions of LeanTaP?
------------------------------------

There are currently two other versions:
	- a variant which works on tableaux represented as graphs, and
	- a version which performs a compilation-based proof search.

These programs are currently not part of the standard distribution, as
they are still under development. Contact Joachim Posegga for details.

Further questions & the LeanTaP mailing list.
---------------------------------------------

Do not hesitate to contact one of the above addresses if you should have
further questions, suggestions, or comments.

There is also a mailing list of people who are interested in hearing
about future developments of LeanTaP. Drop one of us a line if you want
to be included.

Finally, if should you do something interesting with LeanTaP, please
inform us. This could be modifying or extending the program, applying it
to some domain, or whatever. We appreciate feedback.

Appendix: Running LeanTaP, an example:
-------------------------------------

629.dao % sicstus
SICStus 2.1 #8: Mon Aug 30 15:43:08 MET DST 1993
| ?- compile(leantest).
{compiling /home/emmy/posegga/tmp/leantest.pl...}
{compiling /home/emmy/posegga/tmp/leantap.pl...}
{loading /tools/sicstus2.1/library/lists.ql...}
{loaded /tools/sicstus2.1/library/lists.ql in module lists, 60 msec 31888 bytes}
{compiling /home/emmy/posegga/tmp/unify.pl...}
{compiled /home/emmy/posegga/tmp/unify.pl in module unify, 230 msec 11056 bytes}
{compiled /home/emmy/posegga/tmp/leantap.pl in module leantap, 630 msec 55360 bytes}
{compiling /home/emmy/posegga/tmp/nnf.pl...}
{compiled /home/emmy/posegga/tmp/nnf.pl in module nnf, 190 msec 9680 bytes}
{compiled /home/emmy/posegga/tmp/leantest.pl in module leantest, 1820 msec 101040 bytes}

yes
| ?- provefml(pel28).
pel28 proved in 0 msec, VarLim = 3 

yes
| ?- incprovefml(pel28).
pel28  proved in 10 msec, found VarLim = 3 

yes
| ?- uv_provefml(pel28).
pel28 proved in 10 msec, VarLim = 3 

yes
| ?- uv_incprovefml(pel28).
pel28  proved in 9 msec, found VarLim = 3 

yes
| ?- uv_provefml(X),fail.
pel1 proved in 0 msec, VarLim = 0 
pel2 proved in 0 msec, VarLim = 0 
pel3 proved in 0 msec, VarLim = 0 
pel4 proved in 0 msec, VarLim = 0 
pel5 proved in 0 msec, VarLim = 0 
pel6 proved in 0 msec, VarLim = 0 
pel7 proved in 0 msec, VarLim = 0 
pel8 proved in 10 msec, VarLim = 0 
pel9 proved in 0 msec, VarLim = 0 
pel10 proved in 0 msec, VarLim = 0 
pel11 proved in 0 msec, VarLim = 0 
pel12 proved in 10 msec, VarLim = 0 
pel13 proved in 0 msec, VarLim = 0 
pel14 proved in 0 msec, VarLim = 0 
pel15 proved in 0 msec, VarLim = 0 
pel16 proved in 0 msec, VarLim = 0 
pel17 proved in 0 msec, VarLim = 0 
pel18 proved in 0 msec, VarLim = 2 
pel19 proved in 0 msec, VarLim = 2 
pel20 proved in 9 msec, VarLim = 6 
pel21 proved in 0 msec, VarLim = 2 
pel22 proved in 0 msec, VarLim = 2 
pel23 proved in 0 msec, VarLim = 1 
pel24 proved in 30 msec, VarLim = 6 
pel25 proved in 0 msec, VarLim = 3 
pel26 proved in 10 msec, VarLim = 3 
pel27 proved in 9 msec, VarLim = 4 
pel28 proved in 10 msec, VarLim = 3 
pel29 proved in 9 msec, VarLim = 2 
pel30 proved in 10 msec, VarLim = 2 
pel31 proved in 9 msec, VarLim = 3 
pel32 proved in 10 msec, VarLim = 3 
pel33 proved in 9 msec, VarLim = 1 
pel34 proved in 109 msec, VarLim = 5 
pel35 proved in 0 msec, VarLim = 4 
pel36 proved in 0 msec, VarLim = 6 
pel37 proved in 20 msec, VarLim = 7 
pel38 proved in 339 msec, VarLim = 4 
pel39 proved in 10 msec, VarLim = 1 
pel40 proved in 9 msec, VarLim = 3 
pel41 proved in 0 msec, VarLim = 3 
pel42 proved in 10 msec, VarLim = 3 
pel43 proved in 109 msec, VarLim = 5 
pel44 proved in 10 msec, VarLim = 3 
pel45 proved in 40 msec, VarLim = 5 
pel46 proved in 100 msec, VarLim = 5 

no
| ?- 
