
<<Theorem Parameters>>
This button opens a display in which the user can 
set the options to direct the prover on the current
 theorem.
It is very important to stress the fact that these
options or parameters are properties of the loaded 
theorem
and noit of the tool. Therefore the settings may be 
changed
only after a theorem is loaded. 
Pushing the <<Theorem Parameters>> button after loaded 
a new theorem, the user will see the parameter setting
for that theorem according to the preamble 
(the <<set(<param>, <value>)>> lines) of that file, or to 
the default settings.
The changes the user makes on the parameters using the
radio buttons of the Theorem Parameters display will 
only affect the next attempt to proof that theorem, 
and will be lost once a new theorem is loaded into the
system. 
Since every theorem may require its own selection of 
inference rules (e.g. a theorem using equality may 
need paramodulation), it is a good practice to put 
these selections directly in the source file.
Therefore changing the settings from the ATP tool is 
mainly useful to make experiments: when a satisfying 
set of inference rules and strategy options for a 
particular theorem has been found, it is a good idea 
to store put it in the header of the source file.
Here are the radio buttons to select strategy, 
inference rules and output format.

<<Output Format buttons>>
The user can choose between three different ways to 
display clauses on the output window:
---------------------------------------------
                 Correspondent command            
Button           in the header of source files   
----------------------------------------------
<<Clause>>         set(output-format, clause)          
<<Prolog>>         set(output-format, prolog)
<<Sequent>>        set(output-format, sequent)
<<No Output>>      set(output-format, no-output) 

The default output format is  <<Sequent>>   
These buttons are mutually exclusive.


Note that these output formats can be choosen 
independently from the strategy of the inference rules 
used. So, for instance the user may decide to follow the 
output of a prolog execution with sequent format and so on.

<<Inference Rules buttons>>
These parameters are very important since it is by 
selecting the inference rules that users can make the 
theorem proving tool to act as a resolution based 
system, a rewrite based system, a prolog system, and so on.

------------------------------------------------------------------------
                     Correspondent command            
Button               in the header of source files       Default Value
------------------------------------------------------------------------
<<Binary Resolution >>        set(resolution, t/nil)                     nil
<<Factoring>>                 set(factoring, t/nil)                      nil
<<Paramodulation>>            set(paramodulation, t/nil)                 nil
<<Restricted Paramodulation>> set(restricted-paramodulation , t/nil)     nil
<<Negative Resolution>>       set(neg-resolution, t/nil)                   t
<<Positive Atom Resolution>>  set(p-resolution, t/nil)                     t
<<SLD Resolution>>            set(p-resolution, t/nil)                   nil
<<Semantic simplification>>   set(semantic-simplification, t/nil)        nil
<<Answering>>                 set(answering, t/nil)                      nil

where t means enables and nil means disabled.
Paramodulation and Restricted Paramodulation are mutually exclusive.

The default setting implements the N-strategy (see Logic with PAIL,
a method complete for First Order Logic.
Adding Paramodulation you obtain EN-strategy which is complete for
First Order Logic + Equality.
The user can also Resolution + Factoring, obtaining the traditional 
resolution method, which can be extended to the equality predicate
adding Paramodulation.
For pure equational theories the well known Knuth Bendix completion
method can be obtained by selecting the only paramodulation 
inference rule.
Setting the Answering button, the system recognize formulas 
like 
          all x (P(x) => ?(x))
meaning "for every x if x has property P who is x?"
or "which x has property P?".
In this case the system stops whenever it encounters 
a clause containing an answer.

The simplest way to obtain the prolog method is to put in the 
source file the line 
  set(prolog-mode, t).
in this case the default values of the above flags are as follows:

<<Binary Resolution>>          nil
<<Factoring>>                  nil
<<Paramodulation>>             nil
<<Restricted Paramodulation>>  nil
<<Negative Resolution>>        nil
<<Positive Atom Resolution>>   nil
<<SLD Resolution>>               t
<<Semantic simplification>>      t
<<Answering>>                    t

and the prolog strategy is selected.
However you can select SLD Resolution  and the other options
independently from whether prolog-mode were set in the source
file or not.

<<Strategy buttons>>
The user can choose between a Prolog strategy (linear input)
a Set of Support strategy and  a breadth first (Standard) strategy. 
Additionally there is a manual strategy useful for debugging:
in this case user interacts with the prover choosing at every
inference step the next two clauses on which to apply the 
inference rules. This interaction is done in the message window
and ends when the user types "end".
-------------------------------------------------------
                     Correspondent command            
Button               in the header of source files      
-------------------------------------------------------
<<Set of Support>>       set(strategy, *sos*)                 
<<Standard>>             set(strategy, standard)
<<Prolog  Strategy>>     set(prolog-mode,t) or set(strategy, prolog)
<<Manual>>               set(strategy, *man*)    

The default strategy is the Standard strategy.


<<Insert Procedure buttons>>
These parameters specify the way in which a new clause is
added to the database. With a First In First Out policy
we add a breadth first component to the strategy. 
With a Last In Fist Out policy we add a depth first 
component to the strategy. The Smallest first (the default) 
keeps the database sorted by size of clauses so that the prover 
is committed to always choose the lightest pair of clauses. 

