UNIVERSITY AT BUFFALO, THE STATE UNIVERSITY OF NEW YORK
The Department of Computer Science & Engineering

UB CSE 4/563 Documentation

Common Lisp
Discrete Event Calculus Reasoner (decreasoner)
GSAT
Prolog
Prover
Relsat
SNARK
SNePS
Walksat
Wang

Common Lisp

• Note that Allegro CL runs on UB CSE Linux machines, such as nickelback and timberlake.
• Index to all Allegro CL version 8.1 symbols
• The Common Lisp HyperSpec
• ANSI Common Lisp
• Stuart C. Shapiro & David R. Pierce, A Short Course in Common Lisp.
• Stuart C. Shapiro, Common Lisp: An Interactive Approach, W. H. Freeman, New York, 1992.
• On-line Course Notes from CSE202 of Fall 2000 to accompany the book Common Lisp: An Interactive Approach. (Note: this course is not currently operating)
• To run Common Lisp on a CSE Linux machine, either:
  1. (less recommended technique)
     Execute the Unix command

     composer
     

  2. (more recommended technique)
     Follow the instructions on the page SNePS Instructions through step (2), where you enter M-x run-acl.

Prolog

• SICStus Prolog 4.0.5 Manual
• Introduction to Prolog as a Logic Programming language.

Prover, a Pedagogical Resolution Theorem Prover

• To run the prover:
  1. Run Common Lisp on nickelback.cse.buffalo.edu or timberlake.cse.buffalo.edu.
  2. :ld /projects/shapiro/AIclass/prover
  3. :pa prover
  4. Try (prove <list of assumption wffs> <wff to be proven>),
     for example, (prove '( p (if p q) ) 'q)
• For instructions, see /projects/shapiro/AIclass/prover.cl

SNARK

• Mark E. Stickel, SNARK - SRI's New Automated Reasoning Kit
• Mark E. Stickel, Richard J. Waldinger, & Vinay K. Chaudhri A Guide to SNARK
• The language in which SNARK formulas may be expressed is described in A Guide to SNARK, Sect. 2.1.1
• To run SNARK on UB CSE Department computers:
  1. Run Common Lisp on nickelback.cse.buffalo.edu or timberlake.cse.buffalo.edu.
  2. :ld /projects/shapiro/CSE563/snark
  3. :pa snark-user
  4. (initialize)
  5. Assert some wffs, then ask for a proof, for example,

     (assert 'p)
     (assert '(=> p q))
     (prove 'q)
     

• To use the ask and query front-ends to SNARK:
  1. Run Common Lisp on nickelback.cse.buffalo.edu or timberlake.cse.buffalo.edu.
  2. :ld /projects/shapiro/CSE563/ask
  3. :pa snark-user
  4. (initialize)
  5. Assert some wffs, then ask a question, for example,

     (assert 'p)
     (assert '(=> p q))
     (ask 'q)
     (query "Is q true, false, or unknown?" 'q)
     

SNePS

• Stuart C. Shapiro, SNePS: A Logic for Natural Language Understanding and Commonsense Reasoning. In Lucja M. Iwanska & Stuart C. Shapiro, Eds., Natural Language Processing and Knowledge Representation: Language for Knowledge and Knowledge for Language, AAAI Press/The MIT Press, Menlo Park, CA, 2000, 175-195.
• Stuart C. Shapiro, A SNePSLOG Guide to SNePS 2
• Stuart C. Shapiro and The SNePS Implementation Group, SNePS 2.7 User's Manual
• SNePS Research Group Home Page
• To run SNePS on UB CSE Department computers:
  1. Run Common Lisp on nickelback.cse.buffalo.edu or timberlake.cse.buffalo.edu.
  2. :ld /projects/snwiz/bin/sneps
  3. (snepslog)
  4. Assert some wffs, then ask a query, for example,

     p().
     p() => q().
     q()?
     

Wang Algorithm (Semantic Tableaux)

1. Run Common Lisp on nickelback.cse.buffalo.edu or timberlake.cse.buffalo.edu.
2. :ld /projects/shapiro/CSE563/wang
3. Use one of the functions:
   • wang:wang
   • wang:entails
   • wang:predicate-wang
   • wang:predicate-entails
4. See instructions, including syntax, in /projects/shapiro/CSE563/wang.cl
5. Trace the function wang:wang by evaluating (trace wang:wang) to see how it operates.

GSAT

Original Paper

Bart Selman, Hector Levesque and David Mitchell, A New Method for Solving Hard Satisfiability Problems, Proceedings AAAI-92.

Instructions

1. Run Common Lisp on nickelback.cse.buffalo.edu or timberlake.cse.buffalo.edu.
2. :ld /projects/shapiro/CSE563/gsat
3. :pa gsat
4. Try any of
   • (gsat wffs tries flips)
   • (gsat wffs tries flips :trace t)
   • (ask wff KB tries flips)
   • (ask wff KB tries flips :trace t)
5. See the example in /projects/shapiro/CSE563/Examples/GSAT/gsat.cl

Walksat

Relsat is the stochastic solver used by the version of the Discrete Event Calculus Reasoner installed at UB CSE.

• Walksat Home Page.
• Instructions:
  • Walksat runs on nickelback.cse.buffalo.edu and timberlake.cse.buffalo.edu.
  • The program is /projects/shapiro/CSE563/WalkSAT/Walksat_v46/walksat
  • Input can be from standard input or a file.
  • Input must follow the DIMACS CNF format.
  • Output can be to standard output or a file.
  • Enter the Unix command /projects/shapiro/CSE563/WalkSAT/Walksat_v46/walksat -help to see the command line options.
  • For an example try,

    /projects/shapiro/CSE563/WalkSAT/Walksat_v46/walksat -solcnf < /projects/shapiro/CSE563/Examples/Walksat/cpw.cnf
    

Relsat

Relsat is the systematic solver used by the version of the Discrete Event Calculus Reasoner installed at UB CSE. Some references are:

• R. J. Bayardo Jr. and R. C. Schrag. Using CSP look-back techniques to solve real world SAT instances. In Proc. of the 14th National Conf. on Artificial Intelligence, 203-208, 1997.
• Roberto Bayardo's Resources containing Relsat documents and code.

Discrete Event Calculus Reasoner

• User Manual: Erik T. Mueller, Discrete Event Calculus Reasoner Documentation, March 2, 2008. (HTML version)
• Discrete Event Calculus Reasoner Source Forge home page
• Eric T. Mueller Commonsense Reasoning, Morgan Kaufmann, 2006.
• Example input files are in /projects/shapiro/CSE563/decreasoner/examples/
  and /projects/shapiro/CSE563/decreasoner/examples/ShapiroCSE563/
• Instructions:
  1. Decreasoner runs on both nickelback.cse.buffalo.edu and timberlake.cse.buffalo.edu.

  2. cd /projects/shapiro/CSE563/decreasoner
     

  3. Propositional Logic

     • To take input from file and have output printed on your screen:

       python ubdecreasonerP.py file
       

     • or to take input from infile and have output put in outfile

       python ubdecreasonerP.py infile > outfile
       

     • Syntax of the input file for decreasonerP.py:
       • A comment starts with the character ";" and extends to the end of the line.
       • Blank lines are permitted anywhere in the file.
       • Each atomic proposition must be introduced by a line:

         proposition Symbol [comment]
         

       • Where a Symbol "consists of (a) one or more digits or (b) an uppercase letter followed by zero or more letters or digits." [Erik T. Mueller, Discrete Event Calculus Reasoner Documentation, March 2, 2008.]
       • After the atomic propositions are introduced, comes a sequence of wfps, each terminated with a period, and optionally followed by a comment, where the syntax of a wfp is:

         wfp ::= Symbol
                   | ! wfp
                   | wfp & wfp
                   | wfp | wfp
                   | wfp -> wfp
                   | wfp <-> wfp
                   | (wfp)
         

     Predicate Logic

     • To take input from file and have output printed on your screen:

       python ubdecreasoner.py file
       

     • or to take input from infile and have output put in outfile

       python ubdecreasoner.py infile > outfile