Hooked-on-FRAPPS - Version 2.0

 ;;
 ;; The Framework for Resolution-Based Automated Proof Procedure Systems
 ;;                         FRAPPS Version 2.0
 ;;    Authors: Alan M. Frisch, Michael K. Mitchell and Tomas E. Uribe
 ;;               (C) 1992 The Board of Trustees of the
 ;;                       University of Illinois
 ;;                        All Rights Reserved
 ;;
 ;;                              NOTICE
 ;;
 ;;   Permission to   use,  copy,  modify,  and   distribute  this
 ;;   software  and  its  documentation for educational, research,
 ;;   and non-profit purposes  is  hereby  granted  provided  that
 ;;   the   above  copyright  notice, the original authors  names,
 ;;   and this permission notice appear in all  such  copies   and
 ;;   supporting   documentation; that no charge be  made for such
 ;;   copies; and that  the name of  the University of Illinois or
 ;;   that  of  any  of the Authors not be used for advertising or
 ;;   publicity  pertaining  to   distribution   of  the  software
 ;;   without   specific  prior  written   permission. Any  entity 
 ;;   desiring  permission to incorporate   this   software   into
 ;;   commercial  products  should  contact   Prof.  A. M. Frisch,
 ;;   Department  of Computer  Science,  University  of  Illinois,
 ;;   1304  W.  Springfield Avenue, Urbana, IL 61801. The  Univer-
 ;;   sity of  Illinois and the Authors  make  no  representations
 ;;   about   the suitability  of this  software  for any purpose.
 ;;   It is provided "as is" without  express or implied warranty.
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


NOTE: See the "Constraints in FRAPPS" manual ("doc-frapps/hooks")
for details.
This extension to FRAPPS has NOT been debugged and tested as
thoroughly as normal FRAPPS has been. All standard disclaimers apply.

	-----------------------------------------

To load the monomorphic sorted logic unifiation procedure, use the function
(load-simple-sorts).

To hook "H-On-FRAPPS" to a new unification procedure,
the user needs to define a function of the form

>>>> (NEW-UNIFIER <lit1> <lit2> <constraints1> <constraints2>)

This function should return 'FAIL or a list of the form:

( (binding-list-1 new-constraints-1) (binding-list-2 new-constraints-2) . . .
  (binding-list-N new-constraints-N) )

where each binding-list-i is a (regular) unifier and new-constraints-i
is the corresponding constraint field.

	-----------------------------------------

The global variable *unifier* should be set to the name of the new-unification
procedure, as for example in: (setq *unifier* 'sorted-unify)

The global variable *singleton* should be set to T if the new unification
procedure always produces a single unifier.

If multiple unifiers are produced, the user can define another
unification function for more efficient factoring, of the form

>>>> (FACTORING-UNIFIER <list> <const>)

This function should return 'FAIL or the unifier(s) of the expressions in
<list>, all of which are under the constraint <const>.

The global variable *general-unifer* should be set to the name of
this procedure.
If this function is not defined, H-FRAPPS uses the procedure defined
by *unifier* to obtain a (not necessarily minimal) set of unifiers
for factored literals.

The output is expected to be in the same format as that for the new
unification procedure.

	-----------------------------------------

To define clauses, (def-clause ...) can be used as before (see manual),
only now the ":const" option can be used to specify constraints, as
for example in:

	(def-clause '((barks ?x)) :const '((?x cat)))

node-info- and resolvent-info-structures now have a CONSTRAINTS field,
which can be accessed with the functions (get-constraints <node-id>) and
(get-resolvent-constraints <res-info-structure>), respectively.

	-----------------------------------------

H-FRAPPS assumes that constraints are lists.

IF CONSTRAINTS ARE STRUCTURES, users should redefine the following:

>>>> (increment-constraint-subscripts <constraint> <increase>)

This should return the constraint resulting from adding the integer 
<increase> to the subscript of each variable in <constraint>.



To do more space-efficient session management, it is recommended
that the following functions also be redefined:

>>>> (const-to-list <const>)
should return a list representing all the information in the constraint
<const>.

>>>> (list-to-const <list>)
should reverse this process, returning a constraint equivalent to <list>.

	-----------------------------------------

To carry out subsumption checks, users should define the following
functions:

>>>> (const-subsumes-p <clause1> <clause2> <const1> <const2>)

should return T if <clause1> subsumes <clause2>, under the
constraints <const1> and <const2> respectively.

>>>> (const-instance-p <clause1> <clause2> <const1> <const2>)

should return T if <clause2> is an instance of <clause1>, under
the given constraints. (That is, <clause1> is more general than <clause2>.)

>>>> (const-variant-p <clause1> <clause2> <const1> <const2>)
should return T if <clause1> and <clause2> are variants of each other.

The above three functions should return NIL if the test fails.

