	Startup Procedure for Scheme Prolog 1.1
	---------------------------------------

% cd prolog1.1
% scheme
Scheme ...
> (load "prolog.ss")
  ...
> (pro "<source-files>" ...)
  ...
?- q
bye
> (exit)
%

Refer to "ex.pro" for examples of Prolog programs, and to "ex.out" for
their expected output.

	Primitives Offered by Scheme Prolog 1.1
	---------------------------------------

[1]	(findall <var-list> <single-goal> <solns>)
	<var-list> is either a single Prolog variable or
	a LIST of variable names,
	and <single-goal> is a single Prolog goal.
	This predicate unifies <solns> with a list of bindings for <var-list>;
	each of these bindings is generated as part of the solution to
	<single-goal>.
[2]	(not <single-goal>)
	<single-goal> is a single Prolog goal.
	The predicate succeeds if <single-goal> fails.
[3]	(debug)
	This toggles user-level debugging, i.e., which predicate is being
	executed/backtracked and its argument terms.

	Built-In Routines for Dealing with Intervals
	--------------------------------------------

[1]	(add <arg1> <arg2> <arg3>)
	This implies the constraint that <arg1> + <arg2> = <arg3>.
[2]	(mult <arg1> <arg2> <arg3>)
	This implies the constraint that <arg1> * <arg2> = <arg3>.
[3]	(int <arg>)
	This implies the constraint that <arg> is an integer.
[4]	(gt <arg1> <arg2>)
	This implies the constraint that <arg1> > <arg2>.
[5]	(geq <arg1> <arg2>)
	This implies the constraint that <arg1> >= <arg2>.
[6]	(neq <arg1> <arg2>)
	This implies the constraint that <arg1> =/= <arg2>.
[7]	(split <interval>)
	(split-abs <precision> <interval>)
	(split-rel <precision> <interval>)
	(split-machine <interval>)
	These are control predicates which enable different alternatives
	to be explored by unifying <interval> to complementary ranges of
	values whenever possible.  Termination of splitting is controlled
	by <precision>, or, in the case of split-machine or split (which
	is actually synonymous with split-machine), by the finest
	precision representable on the machine.
[8]	(interval <single-var> <lower-bracket> <lower-bound> <upper-bound>
		<upper-bracket>)
	This delays until <single-var> has been instantiated to an arithmetic
	interval.  Following instantiation, it unifies
	<lower-bracket> with the lower bound bracket,
	<lower-bound> with the lower bound value,
	<upper-bound> with the upper bound value, and
	<upper-bracket> with the upper bound bracket of (the value of)
	<single-var>.
[9]	(monitor <single-var> <exp>)
	<single-var> is a single Prolog variable.
	<exp> is "any" displayable Prolog expression.
	This goal prints out (the value of) <single-var> followed by <exp>
	whenever <single-var> has its value narrowed (squeezed), and hence
	can be used for ascertaining the sequence of bindings a Prolog
	variable goes through.

	Interpretation of Arithmetic Intervals as Displayed in the Answers
	------------------------------------------------------------------
	An arithmetic interval is represented as a list of four elements:
	(<lower-bound-type> <lower-bound-value>
		<upper-bound-value> <upper-bound-type>)
	<lower-bound-type> can take the following values:
		'{' to represent a closed lower bound, and
		'<' to represent an open lower bound.
	<upper-bound-type> can take the following values:
		'}' to represent a closed upper bound, and
		'>' to represent an open upper bound.
	<lower-bound-value> and <upper-bound-value> are SPECIAL real
		numbers representing the values of the bounds--SPECIAL
		because they can additionally take the following values:
			'w' denoting +infinity, and
			'-w' denoting -infinity.

	For example:
		({ 0 w }) denotes the set of all non-negative real numbers,
		({ 1 1 }) denotes the integer 1 since it is a point interval,
		({ -w w }) denotes the set of all real numbers,
		(< -1.1 1.2 }) denotes the set
				S = { x: x is Real and -1.1 < x and x <= 1.2 },
		(< 1.3 1.3 >) denotes the set
				S = { x: x is Real and 1.3 < x and x < 1.3 },
				and hence is an empty interval.
