Prover9's actions allow the user to change the search
strategy during the search. For example, after a certain number
of given clauses have been used, the max_weight
can be changed.
Actions can be triggered in two ways:
by some counter, for example, after 100 clauses have been retained, and
when a clause containing an action attribute is used, for example,
when it is used in a proof.
Accepted Actions
The currently accepted actions are exit (which
terminates the search) and a subset of the ordinary flags and parameters.
Several kinds of attribute can be attached to input formulas
with the # operator, for example,
x * y = y * x # label(commutativity).
x * c != e # answer(x) # label("the denial").
-p(c) | -q(c) # answer("here it is").
a * b != b * a # action(in_proof -> exit) # answer(commutativity).
x * (y * z) = y * (x * z) # bsub_hint_wt(500).
Each attribute has a data type of string, integer, or term.
A string attribute is really just a term attribute that is
a constant. If a string attribute is not a legal constant,
it can be enclosed in double quotes to make it so.
Attributes can be attached only to the top level of a formula;
they cannot be attached to proper subformulas.
(This restriction might be lifted in future versions of Prover9.)
The accepted attributes are shown in the following table.
Name
Type
Inheritable
Purpose
label
string
No
Comment
answer
term
Yes
Record substitutions and what has been proved
action
term
No
Triggers action when clause is used
bsub_hint_wt
integer
No
Used for hints
Inheritable attributes are passed from parent to child during most
inference rules.
Label Attributes
Label attributes are simply comments that can be attached to input clauses,
including hint clauses.
Answer Attributes
Answer attributes on clauses are essentially answer literals.
They are inherited during application of inference rules, and if they contain
variables, the variables are instantiated by the substitution
used in the inference.
Answer attributes (like all other attributes) contain exactly
one argument. If you wish to record substitutions for more
than one variable, you must use a term that contains all of the
variables, for example, a list, as in the following clause.
-p(c,x,y,z) # answer([x,y,z]).
Answer attributes need not contain variables. For example,
when there are multiple goals, answer attributes can be used on
the goal formulas to identify the goals that are proved.
Answer attributes on non-clausal formulas cannot contain variables.
(This restriction might be lifted in future versions of Prover9.)
Action Attributes
Action attributes cause various things to happen when
clauses are used in various ways.
See the section on Actions.
Bsub_hint_wt Attribute
This attribute can be attached to a hint clause, and it is used
to override ordinary weight assigned to clauses that match the hint.
That is, if a hint matches
a clause, and if the hint has a
bsub_hint_wt attribute,
the clause gets the value of the attribute as its weight instead
of the weight that would be assigned by the ordinary weighting
method.
Next Section:
Goals and Denials
prover9-manual-2009-02A/auto.html 0000644 0001750 0001750 00000021325 11151021064 016005 0 ustar mccune mccune
Prover9 Manual: Automatic Modes
Prover9 Manual
Version 2009-02A
Automatic Modes
Prover9's automatic mode is set by default.
Otter's automatic mode must be explicitly set.
If you simply give Prover9 a set of clauses and/or formulas,
Prover9 will look at the clauses and decide which inference
rules and clause-processing operations to use.
If you don't like the automatic decisions that Prover9 makes,
you can clear the flag auto
or any of the secondary auto flags that depend on it.
Prover9 output files show in detail the effects of changing these flags.
Unlike ordinary option dependencies, the options that are changed by
auto_inference
cannot be undone by placing commands in the input file,
because they depend on the structure of the clauses.
Unlike ordinary option dependencies, the options that are changed by
auto_process
cannot be undone by placing commands in the input file,
because they depend on the structure of the clauses.
This is an experimental feature and is not recommended for general use.
Raw Mode
The default values of the options can interfere with specialized
search strategies. To avoid some of those problems, one can
start from scratch by setting the following option.
FOF (First-Order Formula) reduction is a method of attempting to
simplify a problem by reducing it to an equivalent set of
independent subproblems. A trivial example is to reduce the
conjecture A <-> B to the pair of problems
A -> B and B -> A.
The problem reduction uses a miniscope method
[Champeaux-miniscope]
that is quite powerful in some cases, but
it can easily blow up on complex formulas.
Therefore, if the reduction procedure fails to
terminate within a few seconds, or if the subproblems it produces are
more complex than the original problem, the reduction attempt is aborted
(and the user may wish to try the ordinary Prover9 program instead).
If the reduction succeeds, each subproblem is given to the
ordinary Prover9 search module.
Input files accepted by FOF-Prover9 are the same as those
accepted by Prover9, and when FOF-Prover9 runs the search
module on a subproblem, is uses all of the options given
in the input file.
An Example of FOF Reduction
This example was given by Peter Andrews as a challenge problem for resolution
systems in the 1970s. FOF-Prover9's miniscope procedure reduces it to 32
trivial subproblems. (More powerful miniscope methods can solve the problem
by reducing it to 0 subproblems.)
The preceding example is artificial and seems tailor-made for FOF reduction.
Other, more realistic examples can be found in the
standard set of Prover9 examples.
Next Section:
More Programs
prover9-manual-2009-02A/glossary.html 0000644 0001750 0001750 00000055326 11151021064 016710 0 ustar mccune mccune
Prover9 Manual: Glossary
Prover9 Manual
Version 2009-02A
Glossary
Under construction. (Send suggestions of terms to include.)
Terms, Clauses, Formulas, Interpretations
These definitions apply to first-order unsorted logic.
See a book on first-order logic for more formal definitions
of these concepts.
Term
Literal selection is a restriction of resolution
or paramdulation. In each clause, some subset of the
negative literals are marked as selected (the selection
may be arbitrary), and in some cases inferences can be
restricted to selected literals.
The assumptions list is identical to the sos list; that is,
"assumptions" is a synonym for "sos".
Prover9 also accepts non-clausal formulas in lists named usable or sos.
Such formulas are transformed to clauses which are placed in the
clause list of the same name.
The name "sos" is used because it can be employed to achieve the
set-of-support strategy, which requires that all lines of reasoning
start with a subset of the input clauses called the set of support.
The clauses or formulas in the initial set of support are placed
the sos list, and the rest of the clauses or formulas are placed in the
usable list.
In Prover9 terminology, a
negative clause
in a Horn set is
called a denial, because such clauses usually come from the
negation of a conclusion.
(The term does not apply to non-Horn sets, because a proof of a non-Horn
set may require more than one negative clause.)
Next Section:
References
prover9-manual-2009-02A/err 0000644 0001750 0001750 00000015761 11150635673 014711 0 ustar mccune mccune -------- Proof 1 --------
------ process 1478 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1479 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1480 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1481 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1482 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1483 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1484 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1485 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1486 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1487 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1488 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1489 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1490 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1491 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1492 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1493 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1494 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1495 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1496 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1497 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1498 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1499 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1500 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1501 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1502 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1503 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1504 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1505 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1506 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1507 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1508 exit (max_proofs) ------
-------- Proof 1 --------
------ process 1509 exit (max_proofs) ------
THEOREM PROVED
------ process 1477 exit (max_proofs) ------
-------- Proof 1 --------
THEOREM PROVED
------ process 1510 exit (max_proofs) ------
-------- Proof 1 --------
THEOREM PROVED
------ process 1511 exit (max_proofs) ------
-------- Proof 1 --------
THEOREM PROVED
------ process 1512 exit (max_proofs) ------
-------- Proof 1 --------
THEOREM PROVED
------ process 1513 exit (max_proofs) ------
-------- Proof 1 --------
THEOREM PROVED
------ process 1514 exit (max_proofs) ------
-------- Proof 1 --------
THEOREM PROVED
------ process 1515 exit (max_proofs) ------
-------- Proof 1 -------- H2.
THEOREM PROVED
------ process 1516 exit (max_proofs) ------
WARNING: clear(process_initial_sos) is not well tested.
We usually recommend against using it.
SEARCH FAILED
------ process 1521 exit (sos_empty) ------
SEARCH FAILED
------ process 1523 exit (sos_empty) ------
-------- Proof 1 -------- absorb.
-------- Proof 2 -------- one.
-------- Proof 3 -------- combined.
-------- Proof 4 -------- assoc.
THEOREM PROVED
------ process 1524 exit (max_proofs) ------
-------- Proof 1 -------- right_cancellation.
THEOREM PROVED
------ process 1527 exit (max_proofs) ------
-------- Proof 1 -------- Sheffer_1.
-------- Proof 2 -------- Sheffer_2.
-------- Proof 3 -------- Sheffer_3.
THEOREM PROVED
------ process 1528 exit (max_proofs) ------
-------- Proof 1 -------- Sheffer_1.
-------- Proof 2 -------- Sheffer_2.
-------- Proof 3 -------- Sheffer_3.
THEOREM PROVED
------ process 1530 exit (max_proofs) ------
-------- Proof 1 -------- Sheffer_1.
-------- Proof 2 -------- Sheffer_2.
-------- Proof 3 -------- Sheffer_3.
THEOREM PROVED
------ process 1533 exit (max_proofs) ------
=== Mace4 starting on domain size 2. ===
=== Mace4 starting on domain size 3. ===
=== Mace4 starting on domain size 4. ===
=== Mace4 starting on domain size 5. ===
=== Mace4 starting on domain size 6. ===
------ process 1534 exit (max_models) ------
=== Mace4 starting on domain size 2. ===
=== Mace4 starting on domain size 3. ===
=== Mace4 starting on domain size 4. ===
=== Mace4 starting on domain size 5. ===
=== Mace4 starting on domain size 6. ===
------ process 1535 exit (max_models) ------
=== Mace4 starting on domain size 2. ===
=== Mace4 starting on domain size 3. ===
=== Mace4 starting on domain size 5. ===
=== Mace4 starting on domain size 7. ===
=== Mace4 starting on domain size 11. ===
=== Mace4 starting on domain size 13. ===
=== Mace4 starting on domain size 17. ===
=== Mace4 starting on domain size 19. ===
------ process 1536 exit (max_models) ------
=== Mace4 starting on domain size 2. ===
=== Mace4 starting on domain size 3. ===
=== Mace4 starting on domain size 4. ===
------ process 1554 exit (max_models) ------
=== Mace4 starting on domain size 2. ===
=== Mace4 starting on domain size 3. ===
=== Mace4 starting on domain size 4. ===
=== Mace4 starting on domain size 5. ===
=== Mace4 starting on domain size 6. ===
------ process 1560 exit (all_models) ------
=== Mace4 starting on domain size 2. ===
=== Mace4 starting on domain size 3. ===
=== Mace4 starting on domain size 4. ===
=== Mace4 starting on domain size 5. ===
=== Mace4 starting on domain size 6. ===
------ process 1564 exit (all_models) ------
=== Mace4 starting on domain size 2. ===
=== Mace4 starting on domain size 3. ===
=== Mace4 starting on domain size 4. ===
=== Mace4 starting on domain size 5. ===
=== Mace4 starting on domain size 6. ===
------ process 1568 exit (all_models) ------
-------- Proof 1 --------
THEOREM PROVED
------ process 1575 exit (max_proofs) ------
-------- Proof 1 --------
THEOREM PROVED
------ process 1577 exit (max_proofs) ------
=== Mace4 starting on domain size 8. ===
------ process 1580 exit (max_models) ------
=== Mace4 starting on domain size 8. ===
------ process 1581 exit (max_models) ------
=== Mace4 starting on domain size 6. ===
------ process 1582 exit (all_models) ------
=== Mace4 starting on domain size 10. ===
------ process 1583 exit (max_models) ------
=== Mace4 starting on domain size 5. ===
------ process 1585 exit (max_models) ------
-------- Proof 1 -------- [5,7,2,6,3,1,4,8].
THEOREM PROVED
------ process 1586 exit (max_proofs) ------
SEARCH FAILED
------ process 1587 exit (sos_empty) ------
-------- Proof 1 -------- goat # none # wolf # goat # cabbage # none # goat.
THEOREM PROVED
------ process 1588 exit (max_proofs) ------
-------- Proof 1 --------
THEOREM PROVED
------ process 1589 exit (max_proofs) ------
-------- Proof 1 --------
THEOREM PROVED
------ process 1590 exit (max_proofs) ------
See the files checked-jobs/*.diffs
prover9-manual-2009-02A/go.options 0000755 0001750 0001750 00000000426 10467124007 016205 0 ustar mccune mccune #!/bin/csh
foreach i (*.html)
sed -n '/start option/,/end option/p' $i\
| egrep '^(set|clear|assign)\(.*default' \
| sed -e '/^set/s/)\..*/ TRUE/'\
| sed -e '/^clear/s/)\..*/ FALSE/'\
| sed -e '/^assign/s/,.*=/ /' -e 's/,.*//'\
| sed -e 's/.*(//'
end
prover9-manual-2009-02A/go.outputs 0000644 0001750 0001750 00000001034 10467503043 016227 0 ustar mccune mccune andrews.out
andrews.out2
subset_trans.out
subset_trans.out2
subset_trans.out3
subset_trans.out4
LT-82-2.out
weight_test.out
x2.prover9.out
olsax.out
x2.mace4.out
LT-82-2-interp.out
subset_trans.proof1
subset_trans.proof2
subset_trans.proof3
subset_trans.proof4
subset_trans.proof5.xml
subset_trans.proof6
subset_trans.proof7
subset_trans.proof8
x2.portable
x2.portable2
x2.tabular
x2.raw
x2.cooked
x2.xml
x2.tex
MOL-cand.238
uc-hunt.out
BA2.interps
BA2.interps2
BA2.interps3
BA2.interps4
BA2.interps5
group-terms.out
bool-ring.out
BA4.out
prover9-manual-2009-02A/goals.html 0000644 0001750 0001750 00000021151 11151021064 016137 0 ustar mccune mccune
Prover9 Manual: Goals and Denials
Prover9 Manual
Version 2009-02A
Goals and Denials
This section shows how the conclusion(s) of a conjecture
can be stated in positive form, how one can search for
direct proofs as opposed to bidirectional proofs, and
how multiple conclusions are stated and handled.
Terminology
Conclusion: this term is used informally.
Goal: this term refers to a conclusion stated in positive form.
Denial clause: this term refers to a negative clause in a
Horn set,
because such clauses usually correspond to the negation
of a conclusion.
Goals: Stating Conclusions in Positive Form
In Otter, the conclusions are always stated in negated form.
Prover9 allows the user to state conclusions in positive
form by using the list
formulas(goals).
However, Prover9 always works by refutation, so
the clauses or formulas in the goals lists
are negated as described below, and the
results are appended to the sos clause list
before the search starts.
In other words, goals are "syntactic sugar"
for input, and have nothing to do with the way Prover9
conducts its search for refutations.
When the conclusion is given in positive form, the
user has no control over the Skolem symbols (if any)
that Prover9 introduces. If the user needs some control
of the Skolem symbols, for example, to insert them
into the symbol precedence at a particular spot,
or to include them in the weighting function,
the user should do the Skolemizing and give the
conclusion in negated form.
If there is just one formula in formulas(goals),
the meaning is clear: the formula is processed by
first taking its universal closure, then negating.
The formula is then handled exactly as if it had
been input in formulas(sos), that is, by
Skolemizing and transforming to clauses.
Multiple Goals
If there is more than one formula in formulas(goals),
the meaning is not clear. Is the conclusion the
disjunction of those formulas? Or the conjunction?
The answer: disjunction: if any goal is proved,
the proof is reported, printed, and counted.
Multiple complex goals are not allowed, because
the quantification of free variables can be very confusing.
Therefore Prover9 enforces the following rule.
If there is more than one formula in the goals list,
each must be a positive universal conjunctive formula, that is
a formula constructed from atomic formulas, universal
quantification, and conjunction only.
To avoid this restriction, one can always
write the conclusion clearly as a single goal formula
containing any of the logic connectives and quantification.
However, if the conjecture involves multiple
complex conclusions, we recommend, for search efficiency,
separate Prover9 searches.
If there are multiple goals, each is processed separately
by applying universal closure, negation, and transformation
to clauses. After this processing, Prover9 forgets that
there were multiple goals and simply searches for
refutations.
When there are multiple goals,
and when the user wishes to prove more than one goal,
the parameter max_proofs should be set to an
appropriate value. (The flag auto_denials
(default set) can do so automatically.)
If this flag is clear, then when a proof is found,
the denial and all of its descendants are disabled so that they
will not appear in subsequent proofs.
If a Horn set has more than one denial (negative) clause, we
assume they correspond to separate conclusions, and the user
wishes to have a separate proof of each conclusion.
Therefore, if
max_proofs
has not been changed from its default value of 1,
we assign to
max_proofs
the number of negative clauses.
(Note that when
reuse_denials
is clear (the default),
Prover9 prevents multiple proofs of the same conclusion.)
Also, if a negative clause in a Horn set has label attribute
but no answer attribute, the clause is given an answer attribute
corresponding to the first label attribute. This saves the user
from changing "label" to "answer" when moving formulas from
the sos list to the goals list.
Forward or Direct Proofs
The following flag restricts the use of negative clauses,
with the aim of finding proofs that are more direct; that
is, proofs that go forward from the hypotheses to the conclusion
rather than proofs that reason backward from the conclusion.
Ordinarily, the term denial refers to a negative
clause in a Horn set. Here, we use it for any negative
clause. Originally, the flag restrict_denials
applied only to Horn sets, but we eliminated that restriction
when we realized that it can be useful for non-Horn sets.
However, its use has been well analyzed for non-Horn sets.
In addition, restricted denials will not be deleted if they
are over the weight limit (max_weight).
The effect of setting restrict_denials is that proofs
will usually be more forward or direct.
This option can speed up proofs, it can delay proofs, and it can
block all proofs.
An Example
The following example illustrates multiple goals
(including a goal that is a combination of other goals),
auto_denials,
and
restrict_denials.
Next Section:
Production Mode
prover9-manual-2009-02A/group-terms.in 0000644 0001750 0001750 00000000306 10445522505 016772 0 ustar mccune mccune % The stream of objects to be rewritten can include
% terms, clauses, and formulas. They are parsed
% as Prover9/LADR "terms".
(a' * b) * (a' * b)'.
y * (z * (((w * w') * (x * z)') * y))' = x.
prover9-manual-2009-02A/weight_test.out 0000644 0001750 0001750 00000000132 11151315512 017223 0 ustar mccune mccune given #1 (I,wt=4): 1 p(a). [assumption].
given #2 (I,wt=155): 2 p(a * b). [assumption].
prover9-manual-2009-02A/group.demods 0000644 0001750 0001750 00000000473 10456775540 016527 0 ustar mccune mccune formulas(demodulators).
% This is the complete set of reductions for free groups.
% It can be used to canonicalize group terms.
(x * y) * z = x * (y * z).
e * x = x.
x * e = x.
x' * x = e.
x * x' = e.
x' ' = x.
e' = e.
x * (x' * y) = y.
x' * (x * y) = y.
(x * y)' = y' * x'.
end_of_list.
prover9-manual-2009-02A/x2.prover9.out 0000644 0001750 0001750 00000011353 11151315512 016642 0 ustar mccune mccune ============================== Prover9 ===============================
Prover9 (32) version 2009-02A, February 2009.
Process 15837 was started by mccune on cleo,
Wed Feb 25 12:26:02 2009
The command was "/home/mccune/bin/prover9 -f x2.in".
============================== end of head ===========================
============================== INPUT =================================
% Reading from file x2.in
assign(max_seconds,5).
formulas(sos).
(x * y) * z = x * (y * z).
x * e = x.
x * x' = e.
end_of_list.
formulas(goals).
x * y = y * x.
end_of_list.
============================== end of input ==========================
============================== PROCESS NON-CLAUSAL FORMULAS ==========
% Formulas that are not ordinary clauses:
1 x * y = y * x # label(non_clause) # label(goal). [goal].
============================== end of process non-clausal formulas ===
============================== PROCESS INITIAL CLAUSES ===============
% Clauses before input processing:
formulas(usable).
end_of_list.
formulas(sos).
(x * y) * z = x * (y * z). [assumption].
x * e = x. [assumption].
x * x' = e. [assumption].
c2 * c1 != c1 * c2. [deny(1)].
end_of_list.
formulas(demodulators).
end_of_list.
============================== PREDICATE ELIMINATION =================
No predicates eliminated.
============================== end predicate elimination =============
Auto_denials: (no changes).
Term ordering decisions:
Predicate symbol precedence: predicate_order([ = ]).
Function symbol precedence: function_order([ e, c1, c2, *, ' ]).
After inverse_order: Function symbol precedence: function_order([ e, c1, c2, *, ' ]).
Unfolding symbols: (none).
Auto_inference settings:
% set(paramodulation). % (positive equality literals)
Auto_process settings: (no changes).
kept: 2 (x * y) * z = x * (y * z). [assumption].
kept: 3 x * e = x. [assumption].
kept: 4 x * x' = e. [assumption].
kept: 5 c2 * c1 != c1 * c2. [deny(1)].
============================== end of process initial clauses ========
============================== CLAUSES FOR SEARCH ====================
% Clauses after input processing:
formulas(usable).
end_of_list.
formulas(sos).
2 (x * y) * z = x * (y * z). [assumption].
3 x * e = x. [assumption].
4 x * x' = e. [assumption].
5 c2 * c1 != c1 * c2. [deny(1)].
end_of_list.
formulas(demodulators).
2 (x * y) * z = x * (y * z). [assumption].
3 x * e = x. [assumption].
4 x * x' = e. [assumption].
end_of_list.
============================== end of clauses for search =============
============================== SEARCH ================================
% Starting search at 0.01 seconds.
given #1 (I,wt=11): 2 (x * y) * z = x * (y * z). [assumption].
given #2 (I,wt=5): 3 x * e = x. [assumption].
given #3 (I,wt=6): 4 x * x' = e. [assumption].
given #4 (I,wt=7): 5 c2 * c1 != c1 * c2. [deny(1)].
given #5 (A,wt=9): 6 x * (e * y) = x * y. [para(3(a,1),2(a,1,1)),flip(a)].
given #6 (T,wt=6): 9 x * e' = x. [para(4(a,1),6(a,1,2)),rewrite([3(2)]),flip(a)].
given #7 (T,wt=10): 7 x * (x' * y) = e * y. [para(4(a,1),2(a,1,1)),flip(a)].
given #8 (T,wt=7): 12 e * x'' = x. [para(4(a,1),7(a,1,2)),rewrite([3(2)]),flip(a)].
given #9 (T,wt=5): 15 e * x = x. [para(12(a,1),6(a,2)),rewrite([14(5),6(4)])].
given #10 (A,wt=10): 8 x * (y * (x * y)') = e. [para(4(a,1),2(a,1)),flip(a)].
given #11 (T,wt=4): 19 e' = e. [para(15(a,1),4(a,1))].
given #12 (T,wt=8): 18 x * (x' * y) = y. [back_rewrite(7),rewrite([15(5)])].
given #13 (T,wt=5): 21 x'' = x. [para(4(a,1),18(a,1,2)),rewrite([3(2)]),flip(a)].
given #14 (T,wt=6): 23 x' * x = e. [para(21(a,1),4(a,1,2))].
given #15 (A,wt=12): 17 x * (y * ((x * y)' * z)) = z. [back_rewrite(11),rewrite([15(7)])].
given #16 (T,wt=8): 24 x' * (x * y) = y. [para(21(a,1),18(a,1,2,1))].
given #17 (T,wt=9): 29 x * (y * x)' = y'. [para(8(a,1),24(a,1,2)),rewrite([3(3)]),flip(a)].
given #18 (T,wt=10): 34 (x * y)' = y' * x'. [para(29(a,1),24(a,1,2)),flip(a)].
============================== STATISTICS ============================
Given=18. Generated=232. Kept=33. proofs=0.
Usable=11. Sos=0. Demods=10. Limbo=0, Disabled=26. Hints=0.
Kept_by_rule=0, Deleted_by_rule=0.
Forward_subsumed=199. Back_subsumed=0.
Sos_limit_deleted=0. Sos_displaced=0. Sos_removed=0.
New_demodulators=32 (0 lex), Back_demodulated=22. Back_unit_deleted=0.
Demod_attempts=1806. Demod_rewrites=419.
Res_instance_prunes=0. Para_instance_prunes=0. Basic_paramod_prunes=0.
Nonunit_fsub_feature_tests=0. Nonunit_bsub_feature_tests=0.
Megabytes=0.04.
User_CPU=0.01, System_CPU=0.00, Wall_clock=0.
============================== end of statistics =====================
============================== end of search =========================
SEARCH FAILED
Exiting with failure.
Process 15837 exit (sos_empty) Wed Feb 25 12:26:02 2009
prover9-manual-2009-02A/hard.in 0000644 0001750 0001750 00000001267 10571121153 015425 0 ustar mccune mccune % assign(new_constants, 1).
assign(eq_defs, fold).
set(restrict_denials).
formulas(assumptions).
% Veroff's 2-basis for BA in terms of the Sheffer stroke.
f(x,y) = f(y,x).
f(f(x,y),f(x,f(y,z))) = x.
% Define a new operation (which turns out to be complement).
% The "assign(eq_defs, fold)" above causes this definition to be
% oriented as a rewrite rule so that the operation is introduced
% whenever possible.
x' = f(x,x).
end_of_list.
formulas(goals).
% Sheffer basis for Boolean Algebra
f(f(x,x),f(x,x)) = x # label(Sheffer_1).
f(x,f(y,f(y,y))) = f(x,x) # label(Sheffer_2).
f(f(f(y,y),x),f(f(z,z),x)) = f(f(x,f(y,z)),f(x,f(y,z))) # label(Sheffer_3).
end_of_list.
prover9-manual-2009-02A/x2.raw 0000644 0001750 0001750 00000000470 11151315541 015217 0 ustar mccune mccune % number = 1
% seconds = 0
% Interpretation of size 6
% Function * / 2 :
0 1 2 3 4 5
1 0 3 2 5 4
2 4 0 5 1 3
3 5 1 4 0 2
4 2 5 0 3 1
5 3 4 1 2 0
% Function ' / 1 :
0 1 2 4 3 5
% Function e / 0 :
0
% Function c1 / 0 :
1
% Function c2 / 0 :
2
prover9-manual-2009-02A/hints.html 0000644 0001750 0001750 00000023302 11151021064 016157 0 ustar mccune mccune
Prover9 Manual: Hints
Prover9 Manual
Version 2009-02A
Hints
Hint clauses can be used to help guide Prover9's search.
Prover9's input can contain any number of hint lists (which are
simply concatenated by Prover9).
Each list of hint clauses must start with formulas(hints).
and end with end_of_list.
Any clause is acceptable as a hint.
For example (the label attributes are optional),
formulas(hints).
x ' * (x * y) = y # label(6).
x * (x * y) = y # label(7).
x * (y * (x * y)) = e # label(8).
x ' ' * e = x # label(9).
x ' * e = x # label(10).
x ' = x # label(11).
x * e = x # label(12).
x * (y * x) = y # label(13).
x * y = y * x # label(14).
end_of_list.
A derived clause matches a hint if it subsumes the hint.
If a clause matches more than one hint, the first matching hint
is used.
In Otter, "matching a hint" can mean (depending on the parameter
settings) subsumes, subsumed by, or equivalent to.
These other types of matching may be added to Prover9
if there is any demand for them.
Hints are used primarily when selecting given clauses.
The mechanism for doing this is the
given-clause selection procedure.
In short, the default value of the
hints_part
parameter says to select clauses that match hints (lightest
first) whenever any are available.
Hints are also used when deciding to keep a new clause.
Clauses that match hints are not deleted by any of the
parameters
max_weight,
max_vars,
max_literals, or
max_depth.
Where do Hints Come From?
Hints frequently consist of proofs, perhaps many, of related theorems.
Bob Veroff developed the concept, installing code for hints
in an early version of Otter, to experiment with his method
of proof sketches
[Veroff-hints,
Veroff-sketches].
In the proof sketches
method, a difficult conjecture is attacked by first proving
several (or many) weakened variants of the conjecture, and
using those proofs as hints to guide searches for a proof
of the original conjecture.
The program Prooftrans, which is distributed
along with Prover9, can be used to extract proofs from a Prover9
output file and transform the proofs to lists of hints suitable
for input to subsequent Prover9 jobs.
An Example
This example consists of four jobs. The first is a proof of a nontrivial
theorem called "hard". The other three jobs prove the hard theorem
indirectly by first proving an easier theorem (in this case, the easier
theorem simply the harder theorem with an extra assumption); then using
the proof of the easier theorem as hints to help prove the hard theorem.
Proving the hard theorem indirectly (jobs 2,3,4) takes about 1/4 the
time as proving it directly (job 1). Of course the difficult and
interesting part of working this way is finding good "easy" theorems.
Special Weight Assignments
When the given clause selection procedure calls for
a clause that matches a hint, the lightest such clause is chosen.
Ordinarily, clauses that match hints are weighed just as any other clause
is weighed.
However, if one believes some hints are more important that others,
one can, in effect, say "any clause that matches this hint gets
a specific weight". This is accomplished by attaching a bsub_hint_wt
attribute to the hint, as in the following example.
formulas(hints).
x ' * (x * y) = y # label("very important hint") # bsub_hint_wt(-100).
end_of_list.
Another way to assign a special weight is with the following flag.
In many searches that use hints, a given hint can match many different
derived clauses. As a hint matches more and more clauses, we wish
its influence to diminish.
This is the idea behind Veroff's hint degradation method.
Otherwise (the default), those limits will not be
applied to clauses that match hints.
Back Demodulation of Hints
When hints come from proofs in which equality and rewriting
play a major role, they may have trouble guiding a search,
because the rewriting may occur in different ways in the
new search. In particular, a hint may fail to match a
clause, because the clause has been rewritten and the hint
has not. This is the motivation for the following feature.
Next Section:
Semantics
prover9-manual-2009-02A/README.util 0000644 0001750 0001750 00000001174 10606455225 016021 0 ustar mccune mccune util/options-make > temp
This extracts all of the options from the various html files
and sends them to stdout. These should be placed in the
file options.html.
It also installs links back to the option defs.
It also creates a file sed.option-refs that can be used to
create links to the option defs wherever the option name
is enclosed in .
rewrite-files sed.option-refs *.html
-------------------------
util/glossary.py glossary.html
This creates a file sed.glossary that can be used to create
links to the glossary for each term enclosed in .
rewrite-files sed.glossary *.html
prover9-manual-2009-02A/index.html 0000644 0001750 0001750 00000000310 11151021064 016133 0 ustar mccune mccune
When a given clause is selected, all of the enabled inference rules
are applied to it. For each inference, one of
the parents is the given clause, and all other parents
must be in the usable list.
Most inference rules distinguish the parents by the roles
they play in the inference, e.g., positive or negative literal for
binary resolution, nucleus or satellite for hyper rules,
and from and into for paramodulation. The given clause can
play any role in the inference.
After an inference rule generates a new clause,
the clause is processed,
which includes simplification operations such
as demodulation and unit_deletion,
and retention tests, such as max_weight.
Processing also includes several operations
that might be considered inference rules, such as
factor and
new_constants.
Prover9 uses ordered resolution and paramodulation with
literal selection. These methods restrict the literals that
are eligible for inference.
The resolution and paramodulation inference rules are
intended to be
complete
(exceptions are given in the descriptions
of the options below), but we have not done a rigorous
analysis of the algorithms, so users should not make any
assumptions about completeness.
For an overview of ordered inference with literal selection,
see the section
Ordered Inference below.
Note that there is no inference rule "pos_binary_resolution".
Positive binary resolution can be achieved by using the parameter
literal_selection
so that at least one negative literal is always selected.
Positive binary resolution is not the dual of
neg_binary_resolution,
because the
literal_selection
technique is not symmetric between positive and negative literals;
in particular, selected literals are always negative.
The literal_selection
parameter is always ignored for negative binary resolution.
The Hyper and UR resultion rules can resolve more than one literal
of one of the parent clauses (the nucleus) with other
parent clauses (the satellites), all in one step. An
application of one of these inference rules can be viewed as
a sequence of binary resolution steps.
maximal.
If the flags
ordered_res and
check_res_instances
are both set, the maximality check is done after the substitution
for the inference has been applied to the parents.
Literal selection is not applied to hyperresolution.
If this flag is set,
negative hyperresolution
is applied to the given clause.
If the flag
ordered_res
is set, the resolved literals in the satellites (negative parents)
must be maximal.
If the flags
ordered_res and
check_res_instances
are both set, the maximality check is done after the substitution
for the inference has been applied to the parents.
Literal selection is not applied to hyperresolution.
If this flag is set, positive UR resolution is applied
to the given clause. That is, the resulting unit clause is
a positive clause.
Neither ordering constraints nor literal selection
is applied to UR resolution.
If this flag is set, negative UR resolution is applied
to the given clause. That is, the resulting unit clause is
a negative clause.
Neither ordering constraints nor literal selection
is applied to UR resolution.
Prover9 uses ordered inference with literal selection.
Ordered inference.Within a clause, there is a partial
order on literals, determined by the
term ordering.
A subset of the literals is marked as maximal.
(If the clause is ground, the order is total, and the greatest
literal is marked as maximal.) The inference rules may be
restricted in some cases so that they apply only to maximal literals.
Literal selection. In each clause, a subset of the
negative literals of a clause is marked as selected.
(Different clauses may have the subset chosen by different methods.)
The inference rules may be restricted in some cases so that they
apply only to selected literals.
Ordered inference and literal selection are typically used
together, but each can be used without the other, by changing
the options
ordered_res
and
literal_selection. In the following,
if ordered_res is disabled,
simply assume all literals are maximal.
The setting assign(literal_selection, none) has the
effect of disabling literal selection.
Ordered Binary Resolution with Literal Selection
A positive literal PL in a clause C is eligible for resolution if
no literal is selected in C, and PL is maximal in C.
A negative literal NL in a clause C is eligible for resolution if
(1) NL is selected in C, or
(2) no literal is selected in C, and NL is maximal in C.
Note that if at least one negative literals is selected in every clause,
we have a version of positive binary resolution, because no literal may
be selected in the clause containing the positive resolved literal.
Ordered Factoring
Prover9 does not do ordered factoring. Instead, if factoring is enabled
(see flag factor),
factoring is applied as much as possible to all newly kept clauses.
In theory, factoring can be restricted to maximal literals without
losing completeness, but we believe applying it eagerly is more
practical.
Ordered Paramodulation with Selection
For ordered paramodulation with selection, literal eligibility
for the "from" literal is that same as eligibilty of the
positive literal for ordered resolution with selection.
Literal eligibility for positive "into" literals
is that same as eligibilty of the
positive literal for ordered resolution with selection.
Literal eligibility for negative "into" literals
is the same as eligibilty of the negative literal for
ordered resolution with selection.
In other words,
A positive literal PL in a clause C is eligible for paramodularion
(as the "from" or the "into" parent) if no literal is selected in C,
and PL is maximal in C.
A negative literal NL in a clause C is eligible for paramodulation if
(1) NL is selected in C, or
(2) no literal is selected in C, and NL is maximal in C.
Negative Ordered Binary Resolution
A positive literal NL in a clause C is eligible for resolution if
NL is maximal among the positive literals of C.
A negative literal NL in a clause C is eligible for resolution if
C has no positive literals, and NL is maximal in C.
Note that negative ordered binary resolution is not the dual
of positive ordered binary resolution, because the negative version
ignores literal selection.
Next Section:
Process Inferred
prover9-manual-2009-02A/input.html 0000644 0001750 0001750 00000017002 11151021064 016171 0 ustar mccune mccune
Prover9 Manual: Input Files
Prover9 Manual
Version 2009-02A
Prover9 Input Files
Prover9 takes its input from one or more (usually one) files.
If there is more than one input file, lists of objects
(formulas, weighting rules, etc.) cannot be
split across more than one file.
The page Running Prover9
shows how to specify the files in the commands to run Prover9.
Comments and Whitespace
There are two kinds of comment:
Line comment. If the first '%' (percent sign) on a line
is not the start of a block comment ('%BEGIN'), everything from that symbol
through the end of the line is ignored.
Block comment. If the parser sees the string '%BEGIN',
that is not in a line comment,
it will ignore everything up through the next occurrence of 'END%'.
Line breaks are irrelevant. If there is no 'END%', the rest of
the file is ignored, without causing an error.
Comments are not echoed to the output file. Clauses can have
label attributes which can serve as
different kind of comment which does appear in the output file.
Whitespace (spaces, newlines, tabs, etc.) is optional in most
places. The important exception is that whitespace is
required around some operations in clauses and formulas
(see the page Clauses and Formulas).
A Simple Example
The most basic kind of input file consists of list of clauses named
"sos" representing the negation of the conjecture, as in
the following example.
formulas(sos). % clauses to be placed in the sos list
-man(x) | mortal(x).
man(george).
-mortal(george).
end_of_list.
Prover9 will take the clauses, use its automatic mode to
decide on the inference rules, and then search for a refutation.
The preceding example can also be stated in a more natural
way by using a non-clausal formula for the man-implies-mortal rule and the
goals list for the conclusion, as follows.
formulas(assumptions). % synonym for formulas(sos).
man(x) -> mortal(x). % open formula with free variable x
man(george).
end_of_list.
formulas(goals). % to be negated and placed in the sos list
mortal(george).
end_of_list.
Prover9 will transform the formulas in this input to
the same clauses as in the basic input above before
starting the search for a refutation.
In Otter and in earlier versions of Prover9,
"clauses" and "formulas" were distinct types of object,
and formulas could not have free variables.
Now, clauses are a subset of formulas, and Prover9 decides
which formulas are non-clausal and takes the appropriate
actions to transform them to clauses.
Prover9 input consists of lists of objects (formulas or terms)
and commands.
Lists of Objects
Lists of objects start with a type (formulas or terms)
and name (sos, goals, weights, etc.),
and end with end_of_list. The following display show an example
of each type of accepted list, with one object in each list.
formulas(sos). p(x). end_of_list. % the primary input list
formulas(assumptions). p(x). end_of_list. % synonym for formulas(sos)
formulas(goals). p(x). end_of_list. % some restrictions (see Goals)
formulas(usable). p(x). end_of_list. % seldom used
formulas(demodulators). f(x)=x. end_of_list. % seldom used, must be equalities
formulas(hints). p(x). end_of_list. % should be used more often (see Hints)
list(weights). weight(a) = 10. end_of_list. % see Weighting
list(kbo_weights). a = 3. end_of_list. % see Term Ordering
list(actions). given = 100 -> set(print_kept). end_of_list. % see Actions
list(interpretations). interpretation(2,[],[relation(p,[1])]). end_of_list. % see Semantics
If the input contains more than one list of a particular type/name, the lists
are simply concatenated by Prover9 as they are read.
Commands
Eleven types of command are accepted. Here is an example of each.
op(400, infix_right, ["+", "--"]). % declare parse precedence and type (see Clauses and Formulas)
redeclare(negation, "~"]). % change the negation symbol (see Clauses and Formulas)
set(print_kept). % set a flag
clear(auto_inference). % clear a flag
assign(max_weight, 40). % integer parameter
assign(stats, some). % string parameter
assoc_comm(*). % not currently used for Prover9
commutative(g). % not currently used for Prover9
predicate_order([=,<=,P,Q). % predicate symbol precedence (see Term Ordering)
function_order([0,1,a,b,f,g,*,+]). % function symbol precedence (see Term Ordering)
lex([0,1,a,b,f,g,*,+]). % synonym for "function_order"
skolem([a,b,f,g]). % declare symbols to be Skolem functions (rarely used)
Order of Commands and Lists of Objects
For the most part, the order of things in the input file(s) is irrelevant.
For example, commands can usually be mixed with lists of objects.
The situations in which order matters are listed here.
The op(precedence, type, symbols) commands must occur
before any clauses or formulas that contain the affected symbols.
Some of the flags and parameters alter other flags and parameters.
The alterations can be undone by placing the appropriate command
after the command that alters. The output file clearly shows
what happens in these cases.
Note that changing the order of clauses or formulas within a list,
changing the order of literals in a clause,
or changing the order of subformulas in a formula
can change the search, occasionally in substantial ways.
Conditional Inclusion
Many input files can be used for multiple programs (e.g., Prover9 and Mace4).
The following construct says to include the enclosed input
for the given program only.
The conditional-inclusion construct cannot occur within a list of
objects (formulas, weighting rules, etc.).
Next Section:
Clauses & Formulas
prover9-manual-2009-02A/options.html 0000644 0001750 0001750 00000055343 11151021064 016537 0 ustar mccune mccune
Prover9 Manual: Options
Prover9 Manual
Version 2009-02A
Prover9 Options
There are three kinds of options:
Flags are Boolean-valued options which can be changed
with the set and clear commands, e.g., set(clocks). set(print_given).
Parms are integer-valued options which can be changed
with the assign command, e.g., assign(max_weight, 30).
Stringparms are string-valued options which can be changed
with the assign command, e.g., assign(order, kbo).
Option Dependencies
Several of the flags and parameters cause other flags and parameters
to be changed. In some cases, that is the only direct effect they have.
For example, if you clear(auto), you will see the following
in the output.
Here is a quick example for Unix-like systems, including Linux and Macintosh OS X.
Visit the Prover9 Web page
and download the current version of LADR. The filename should be something
like LADR-June-2006A.tar.gz; make sure that file is in your current
directory. Run the following commands.
% zcat LADR-June-2006A.tar.gz | tar xvf -
% cd LADR-June-2006A
% make all
Prover9, Mace4, Prooftrans, and several other programs should now
be in the directory LADR-June-2006A/bin. You can either include
that directory in your search path or copy those programs to
some directory that is already in your search path.
Microsoft Windows
For now, see that the
Prover9 Web page.
Next Section:
Running Prover9
prover9-manual-2009-02A/interp3.dtd 0000644 0001750 0001750 00000002456 10441372161 016244 0 ustar mccune mccune
prover9-manual-2009-02A/interp3.xsl 0000644 0001750 0001750 00000007334 10441372161 016277 0 ustar mccune mccune
Prover9
is a resolution/paramodulation automated theorem prover
for first-order and equational logic.
Prover9 is a successor of the
Otter Prover
[McCune-Otter33].
Getting Started
Prover9 has a fully automatic mode
in which the user simply
gives it formulas representing the problem.
See the Section Clauses and Formulas.
An good way to learn about Prover9 is to browse and study the
example input and output files.
Users are encouraged to contribute examples from their own
work with Prover9 (and Mace4).
Related Programs
Several programs come bundled with Prover9.
The most important is
Mace4, which looks for finite models and
counterexamples.
Mace4 can help avoid wasting time searching for a proof with Prover9 by
first finding a counterexample or by first helping to debug
logical specifications.
Another useful program is
Prooftrans, which can transform
proofs found by Prover9 in various ways, including producing
more detailed proofs, simplifying the justifications,
renumbering the steps, producing proofs in XML,
and producing proofs for input to other programs.
Terms of Use
Prover9, Mace4, related programs, and the LADR libraries
(with which they were all constructed)
are distributed under the terms of the
GNU General Public License (v2).
Waldmeister
is a fast prover for equational logic.
Vampire
has lately been winning the MIX category of
CASC.
Paradox is
an excellent program for finding finite models and counterexamples.
Format Conventions for this Manual
Many parts of this manual are displayed in boxes with different
background colors.
A display like the following indicates part of an input or output file.
formulas(sos).
all x all y (subset(x,y) <-> (all z (member(z,x) -> member(z,y)))).
end_of_list.
formulas(goals).
all x all y all z (subset(x,y) & subset(y,z) -> subset(x,z)).
end_of_list.
A display like the following indicates a job that is
run on a command line, for example, a command to run a Prover9 job.
Simplify clause (c):
demodulate c
merge identical literals
A display like the following notes an important difference
between Prover9 and Otter.
Prover9's automatic mode is set by default.
Otter's automatic mode must be explicitly set.
Next Section:
Installation
prover9-manual-2009-02A/JA.in 0000644 0001750 0001750 00000000550 10537310347 015002 0 ustar mccune mccune formulas(theory).
% Abundant Semigroups
(x * y) * z = x * (y * z). % associativity
R(u,v) <-> (x * u = y * u <-> x * v = y * v).
L(u,v) <-> (u * x = u * y <-> v * x = v * y).
all x exists y (y * y = y & R(x,y)).
all x exists y (y * y = y & L(x,y)).
end_of_list.
formulas(goals).
% Regular Semigroups
all x exists y ( (x * y) * x = x).
end_of_list.
prover9-manual-2009-02A/limits.html 0000644 0001750 0001750 00000007511 11151021064 016337 0 ustar mccune mccune
Prover9 Manual: Search Limits
This is a little bit tricky (and sometimes too clever for its own good).
When the sos is half full, it starts being selective about keeping
clauses, and as it fills up, it gradually becomes more selective.
When it is full, it is very selective about keeping clauses.
(The method is not applied to clauses that match hints.)
When it decides to keep a clause, and the sos is already full, the
"worst" clause in sos is deleted to make room for the new clause.
Next Section:
The Loop
prover9-manual-2009-02A/loop.html 0000644 0001750 0001750 00000005451 11151021064 016010 0 ustar mccune mccune
Prover9 Manual: The Inference Loop
Prover9 Manual
Version 2009-02A
The Inference Loop
The main loop for inferring and processing clauses
and searching for a proof is sometimes called the given
clause algorithm.
It operates mainly on the sos and usable lists.
While the sos list is not empty:
1. Select a given clause from sos and move it to the usable list;
2. Infer new clauses using the inference rules in effect;
each new clause must have the given clause as one of its
parents and members of the usable list as its other parents;
3. process each new clause;
4. append new clauses that pass the retention tests to the sos list.
end of while loop.
Two Frequently Asked Questions
At some point in the search,
Prover9 has all of the clauses needed to make an important
inference, and one of the potential parents is selected as
the given clause. But Prover9 fails to make the inference.
Why is that?
Why do all parents have to be in the usable list?
The answer to both questions is the same, and it has to do
with redundancy. Assume
clause C can be inferred from clauses
A and B;
both A and B are in the
sos list; and
A is selected first.
According to the algorithm, C is not derived
until B has also been selected.
Otherwise, C would be derived twice from
A and B.
Variations of the Loop
There are two common versions of the given clause algorithm
that differ in how and when simplification (i.e., rewriting) occurs.
In the Otter loop, which Prover9 uses, clauses in
the sos list can simplify new clauses,
and new simplifiers are applied immediately to all clauses,
including sos clauses.
In the Discount loop, clauses in the sos
list (also called the passive list) cannot simplify
or be simplified until they are selected as given clauses.
The tradeoff between the two versions is
straightforward --- the Otter loop spends much more time
simplifying with the possible benefit of
making an important simplification sooner.
Next Section:
Select Given
prover9-manual-2009-02A/mace4.html 0000644 0001750 0001750 00000006306 11151021064 016030 0 ustar mccune mccune
Prover9 Manual: Mace4
Prover9 Manual
Version 2009-02A
Mace4 (Models And CounterExamples)
The program
Mace4
[McCune-Mace4]
searches for finite structures satisfying first-order
and equational statements (the same kind of statement that
Prover9 accepts). If the statement is the denial of
some conjecture, any structures found by Mace4 are
counterexamples to the conjecture.
Mace4 can be a valuable complement to Prover9, looking
for counterexamples before (or at the same time as)
using Prover9 to search for a proof. It can also be
used to help debug input clauses and formulas for
Prover9.
For the most part, Mace4 accepts the same input files
as Prover9. If the input file contains commands that
Mace4 does not understand, then the argument "-c"
must be given to tell Mace4 to ignore those commands.
For example, say we're learning group theory,
and we're wondering whether all groups are commutative.
We can run the following two jobs in parallel,
with Prover9 looking for a proof, and Mace4 looking
for a counterexample.
Most of the options accepted by Mace4 can be given either on the
command line or in the input file.
The following command lists the command-line options accepted by Mace4.
mace4 -help
Terminology. We use the terms interpretation,
model, and structure for the objects that Mace4 produces.
From a logic point of view, Mace4 produces interpretations which
are models of the input formulas. From a math point of view,
Mace4 produces structures satisfying the input formulas.
What Mace4 Does
Mace4 searches for unsorted finite structures only.
That is, a structure (model) has one underlying
finite set, called the domain
(the members are always 0,1,...,n-1
for a set of size n), and structures are
functions and relations (tables) over the domain, corresponding
to the operations and relation symbols in the specification.
By default, Mace4 starts searching for a structure of
domain size 2, and then it increments the size until
it succeeds or reaches some limit.
The Original Mace4 Manual
The
original Mace4 manual
[McCune-Mace4]
(PDF)
is out of date with respect to features and options,
but it contains useful information on
the history of Mace4, details on the search methods, and
the differences between Mace2 and Mace4.
Next Section:
Mace4 Input
prover9-manual-2009-02A/LT-82-2-interp.in 0000644 0001750 0001750 00000000766 10456772765 016745 0 ustar mccune mccune formulas(sos).
% lattice theory
x v y = y v x.
(x v y) v z = x v (y v z).
x ^ y = y ^ x.
(x ^ y) ^ z = x^ (y ^ z).
x ^ (x v y) = x.
x v (x ^ y) = x.
% This input is for Mace4, so we can include the following,
% because finite lattices always have 0 and 1.
x v 0 = x.
x ^ 1 = x.
end_of_list.
formulas(sos).
end_of_list.
% We want the following to be false, so we put it in the goals list.
formulas(goals).
x ^ (y v (x ^ z)) = x ^ (y v (z ^ ((x ^ (y v z)) v (y ^ z)))) # label(H2).
end_of_list.
prover9-manual-2009-02A/subset_trans.out4 0000644 0001750 0001750 00000014445 11151315476 017522 0 ustar mccune mccune ============================== Prover9 ===============================
Prover9 (32) version 2009-02A, February 2009.
Process 15829 was started by mccune on cleo,
Wed Feb 25 12:25:50 2009
The command was "/home/mccune/bin/prover9 -t 10 -f subset_trans.in".
============================== end of head ===========================
============================== INPUT =================================
% Reading from file subset_trans.in
formulas(sos).
(all x all y (subset(x,y) <-> (all z (member(z,x) -> member(z,y))))).
end_of_list.
formulas(goals).
(all x all y all z (subset(x,y) & subset(y,z) -> subset(x,z))).
end_of_list.
============================== end of input ==========================
% From the command line: assign(max_seconds, 10).
============================== PROCESS NON-CLAUSAL FORMULAS ==========
% Formulas that are not ordinary clauses:
1 (all x all y (subset(x,y) <-> (all z (member(z,x) -> member(z,y))))) # label(non_clause). [assumption].
2 (all x all y all z (subset(x,y) & subset(y,z) -> subset(x,z))) # label(non_clause) # label(goal). [goal].
============================== end of process non-clausal formulas ===
============================== PROCESS INITIAL CLAUSES ===============
% Clauses before input processing:
formulas(usable).
end_of_list.
formulas(sos).
-subset(x,y) | -member(z,x) | member(z,y). [clausify(1)].
subset(x,y) | member(f1(x,y),x). [clausify(1)].
subset(x,y) | -member(f1(x,y),y). [clausify(1)].
subset(c1,c2). [deny(2)].
subset(c2,c3). [deny(2)].
-subset(c1,c3). [deny(2)].
end_of_list.
formulas(demodulators).
end_of_list.
============================== PREDICATE ELIMINATION =================
Eliminating subset/2
3 subset(x,y) | member(f1(x,y),x). [clausify(1)].
4 -subset(x,y) | -member(z,x) | member(z,y). [clausify(1)].
Derived: member(f1(x,y),x) | -member(z,x) | member(z,y). [resolve(3,a,4,a)].
5 subset(x,y) | -member(f1(x,y),y). [clausify(1)].
Derived: -member(f1(x,y),y) | -member(z,x) | member(z,y). [resolve(5,a,4,a)].
6 subset(c1,c2). [deny(2)].
Derived: -member(x,c1) | member(x,c2). [resolve(6,a,4,a)].
7 subset(c2,c3). [deny(2)].
Derived: -member(x,c2) | member(x,c3). [resolve(7,a,4,a)].
8 -subset(c1,c3). [deny(2)].
Derived: member(f1(c1,c3),c1). [resolve(8,a,3,a)].
Derived: -member(f1(c1,c3),c3). [resolve(8,a,5,a)].
============================== end predicate elimination =============
Auto_denials: (non-Horn, no changes).
Term ordering decisions:
Predicate symbol precedence: predicate_order([ member ]).
Function symbol precedence: function_order([ c1, c2, c3, f1 ]).
After inverse_order: (no changes).
Unfolding symbols: (none).
Auto_inference settings:
% set(binary_resolution). % (non-Horn)
% set(neg_ur_resolution). % (non-Horn, less than 100 clauses)
Auto_process settings:
% set(factor). % (non-Horn)
% set(unit_deletion). % (non-Horn)
kept: 9 member(f1(x,y),x) | -member(z,x) | member(z,y). [resolve(3,a,4,a)].
kept: 10 -member(f1(x,y),y) | -member(z,x) | member(z,y). [resolve(5,a,4,a)].
kept: 11 -member(x,c1) | member(x,c2). [resolve(6,a,4,a)].
kept: 12 -member(x,c2) | member(x,c3). [resolve(7,a,4,a)].
kept: 13 member(f1(c1,c3),c1). [resolve(8,a,3,a)].
kept: 14 -member(f1(c1,c3),c3). [resolve(8,a,5,a)].
============================== end of process initial clauses ========
============================== CLAUSES FOR SEARCH ====================
% Clauses after input processing:
formulas(usable).
end_of_list.
formulas(sos).
9 member(f1(x,y),x) | -member(z,x) | member(z,y). [resolve(3,a,4,a)].
10 -member(f1(x,y),y) | -member(z,x) | member(z,y). [resolve(5,a,4,a)].
11 -member(x,c1) | member(x,c2). [resolve(6,a,4,a)].
12 -member(x,c2) | member(x,c3). [resolve(7,a,4,a)].
13 member(f1(c1,c3),c1). [resolve(8,a,3,a)].
14 -member(f1(c1,c3),c3). [resolve(8,a,5,a)].
end_of_list.
formulas(demodulators).
end_of_list.
============================== end of clauses for search =============
============================== SEARCH ================================
% Starting search at 0.00 seconds.
given #1 (I,wt=11): 9 member(f1(x,y),x) | -member(z,x) | member(z,y). [resolve(3,a,4,a)].
given #2 (I,wt=11): 10 -member(f1(x,y),y) | -member(z,x) | member(z,y). [resolve(5,a,4,a)].
given #3 (I,wt=6): 11 -member(x,c1) | member(x,c2). [resolve(6,a,4,a)].
given #4 (I,wt=6): 12 -member(x,c2) | member(x,c3). [resolve(7,a,4,a)].
given #5 (I,wt=5): 13 member(f1(c1,c3),c1). [resolve(8,a,3,a)].
given #6 (I,wt=5): 14 -member(f1(c1,c3),c3). [resolve(8,a,5,a)].
============================== PROOF =================================
% Proof 1 at 0.00 (+ 0.01) seconds.
% Length of proof is 14.
% Level of proof is 4.
% Maximum clause weight is 6.
% Given clauses 6.
1 (all x all y (subset(x,y) <-> (all z (member(z,x) -> member(z,y))))) # label(non_clause). [assumption].
2 (all x all y all z (subset(x,y) & subset(y,z) -> subset(x,z))) # label(non_clause) # label(goal). [goal].
3 subset(x,y) | member(f1(x,y),x). [clausify(1)].
4 -subset(x,y) | -member(z,x) | member(z,y). [clausify(1)].
5 subset(x,y) | -member(f1(x,y),y). [clausify(1)].
6 subset(c1,c2). [deny(2)].
7 subset(c2,c3). [deny(2)].
8 -subset(c1,c3). [deny(2)].
11 -member(x,c1) | member(x,c2). [resolve(6,a,4,a)].
12 -member(x,c2) | member(x,c3). [resolve(7,a,4,a)].
13 member(f1(c1,c3),c1). [resolve(8,a,3,a)].
14 -member(f1(c1,c3),c3). [resolve(8,a,5,a)].
15 member(f1(c1,c3),c2). [resolve(13,a,11,a)].
18 $F. [ur(12,b,14,a),unit_del(a,15)].
============================== end of proof ==========================
============================== STATISTICS ============================
Given=6. Generated=12. Kept=9. proofs=1.
Usable=6. Sos=3. Demods=0. Limbo=0, Disabled=12. Hints=0.
Kept_by_rule=0, Deleted_by_rule=0.
Forward_subsumed=2. Back_subsumed=0.
Sos_limit_deleted=0. Sos_displaced=0. Sos_removed=0.
New_demodulators=0 (0 lex), Back_demodulated=0. Back_unit_deleted=0.
Demod_attempts=0. Demod_rewrites=0.
Res_instance_prunes=0. Para_instance_prunes=0. Basic_paramod_prunes=0.
Nonunit_fsub_feature_tests=0. Nonunit_bsub_feature_tests=6.
Megabytes=0.03.
User_CPU=0.00, System_CPU=0.01, Wall_clock=0.
============================== end of statistics =====================
============================== end of search =========================
THEOREM PROVED
Exiting with 1 proof.
Process 15829 exit (max_proofs) Wed Feb 25 12:25:50 2009
prover9-manual-2009-02A/LT-82-2-x.in 0000644 0001750 0001750 00000000675 10456772765 015712 0 ustar mccune mccune assign(order, kbo).
assign(max_weight, 25).
assign(max_seconds, 3600).
formulas(sos).
% lattice theory
x v y = y v x.
(x v y) v z = x v (y v z).
x ^ y = y ^ x.
(x ^ y) ^ z = x^ (y ^ z).
x ^ (x v y) = x.
x v (x ^ y) = x.
end_of_list.
formulas(sos).
(x ^ y) v (x ^ z) = x ^ ((y ^ (x v z)) v (z ^ (x v y))) # label(H82).
end_of_list.
formulas(goals).
x ^ (y v (x ^ z)) = x ^ (y v (z ^ ((x ^ (y v z)) v (y ^ z)))) # label(H2).
end_of_list.
prover9-manual-2009-02A/LT-82-2.in 0000644 0001750 0001750 00000001541 10456772765 015436 0 ustar mccune mccune assign(order, kbo).
assign(max_weight, 25).
assign(max_seconds, 3600).
formulas(sos).
% lattice theory
x v y = y v x.
(x v y) v z = x v (y v z).
x ^ y = y ^ x.
(x ^ y) ^ z = x^ (y ^ z).
x ^ (x v y) = x.
x v (x ^ y) = x.
end_of_list.
formulas(sos).
(x ^ y) v (x ^ z) = x ^ ((y ^ (x v z)) v (z ^ (x v y))) # label(H82).
end_of_list.
formulas(goals).
x ^ (y v (x ^ z)) = x ^ (y v (z ^ ((x ^ (y v z)) v (y ^ z)))) # label(H2).
end_of_list.
list(interpretations).
% This is the smallest lattice in which H2 is false.
interpretation(6, [], [
function(^(_,_), [
0,0,0,0,0,0,
0,1,2,3,4,5,
0,2,2,0,0,0,
0,3,0,3,5,5,
0,4,0,5,4,5,
0,5,0,5,5,5]),
function(v(_,_), [
0,1,2,3,4,5,
1,1,1,1,1,1,
2,1,2,1,1,1,
3,1,1,3,1,3,
4,1,1,1,4,4,
5,1,1,3,4,5])]).
end_of_list.
prover9-manual-2009-02A/easy.hints 0000644 0001750 0001750 00000004760 11151315532 016171 0 ustar mccune mccune
formulas(hints).
% 72 hints from 3 proof(s) in file easy.out, Wed Feb 25 12:26:18 2009
f(f(x,x),f(x,x)) = x # label(Sheffer_1) # label(non_clause) # label(goal).
f(f(x,y),f(x,f(y,z))) = x.
f(x,f(y,f(x',z))) = f(x,y').
x' = f(x,x).
f(x,x) = x'.
f(f(c1,c1),f(c1,c1)) != c1 # label(Sheffer_1) # answer(Sheffer_1).
c1'' != c1 # answer(Sheffer_1).
f(f(x,y),f(x,y')) = x.
f(x',f(x,x')) = x.
f(x,f(y,x)) = f(x,y').
x'' = x.
$F # answer(Sheffer_1).
f(x,f(y,f(y,y))) = f(x,x) # label(Sheffer_2) # label(non_clause) # label(goal).
f(x,y) = f(y,x).
f(c2,f(c3,f(c3,c3))) != f(c2,c2) # label(Sheffer_2) # answer(Sheffer_2).
f(c2,f(c3,c3')) != c2' # answer(Sheffer_2).
f(f(x,y),f(y,f(x,z))) = y.
f(f(x,y),f(x,f(z,y))) = x.
f(x',f(x,y)) = x.
f(x',f(y,x)) = x.
f(x,f(x,y)') = f(x,y).
f(x,f(y,x)') = f(y,x).
f(x,f(x,y)) = f(x,y').
f(f(x,y),f(x,y)') = f(x',f(x,y)').
f(x',f(y,x)') = f(y',f(y,x)').
f(x',f(x,y)') = f(x,x').
f(x',f(y,x)') = f(x,x').
f(x,x') = f(y,y').
f(x,f(y,y')) = x'.
f(f(f(x,x),y),f(f(z,z),y)) = f(f(y,f(x,z)),f(y,f(x,z))) # label(Sheffer_3) # label(non_clause) # label(goal).
f(f(f(c4,c4),c5),f(f(c6,c6),c5)) != f(f(c5,f(c4,c6)),f(c5,f(c4,c6))) # label(Sheffer_3) # answer(Sheffer_3).
f(f(c5,c4'),f(c5,c6')) != f(c5,f(c4,c6))' # answer(Sheffer_3).
f(f(x,y),f(f(y,z),x)) = x.
f(x,f(f(x,y),f(f(x,f(y,z)),u))) = f(x,y).
f(x,f(y,f(z,x'))) = f(x,y').
f(x,f(f(x',y),z)) = f(x,z').
f(x,f(x',y)') = f(x,x').
f(f(x,y),f(f(x,z),y)) = y.
f(f(x,y),f(y,x')) = y.
f(f(f(x,y),z),f(z,y)) = z.
f(x',f(y,f(x,z))) = f(x',y').
f(f(x,y),f(f(z,y),x)) = x.
f(x,f(f(x,y),f(y,z))) = f(x,y).
f(x,f(f(x,f(y,z)),f(f(x,z),u))) = f(x,f(y,z)).
f(f(x,f(y,z)),f(z,x)) = x.
f(f(x,y),f(f(y,x'),f(y,z))) = f(y,x').
f(f(x,y'),f(x,f(f(x,y),z))) = x.
f(f(x,y'),f(x,f(z,f(x,y)))) = x.
f(x',f(f(x,y),z)) = f(x',z').
f(f(x,y)',f(f(x,z),y)) = f(y,f(x,z)').
f(x,f(f(y,x'),z)') = f(x,z).
f(f(f(x,y),z),f(z,y)') = f(z,f(x,y)').
f(f(x,f(y,z')),f(f(y,z),x)) = x.
f(x,f(f(x',y)',z)) = x'.
f(x',f(f(x,y)',z)) = x.
f(x',f(f(y,x)',z)) = x.
f(x',f(y,f(z,x)')) = x.
f(x,f(y,f(z,x)')') = f(y,f(z,x)').
f(f(x,y),f(y,z)') = f(x',f(y,z)').
f(f(x,y)',f(z,y)') = f(z,f(x,y)').
f(f(x,y)',f(z,y)) = f(f(x,y)',z').
f(f(x,y)',f(x,z)') = f(f(x,y)',z).
f(f(x,y)',z) = f(y,f(x,z)').
f(x,f(y,z)') = f(y,f(x,z)').
f(x',f(f(y,x),z)') = f(x',z).
f(f(x,y),f(z,f(x,y'))') = f(z,x').
f(x,f(y,f(x,z)')) = f(x,f(y,z)).
f(x,f(f(x,y),z)) = f(x,f(y',z)).
f(x,f(y,f(z,f(f(x,y),u))')) = f(x,f(z,y)).
f(x,f(y,f(x,z))) = f(x,f(y,z')).
f(f(x,y'),f(x,f(y,z))) = f(x,f(y,z))'.
f(f(x,y'),f(x,z)) = f(x,f(y,z'))'.
end_of_list.
prover9-manual-2009-02A/m4-input.html 0000644 0001750 0001750 00000010655 11151021064 016516 0 ustar mccune mccune
Prover9 Manual: Mace4 Input
Prover9 Manual
Version 2009-02A
Mace4 Input
Mace4 has been designed so that it accepts most Prover9 input files.
This allows users to prepare one input file which can be used
by Prover9 (to search for proofs) and by Mace4 (to search for
counterexamples).
Mace4 Options
Mace4 and Prover9 accept different sets of flags and parameters.
In order to use the same input files for both programs, we let Mace4
take its options from the command line instead of from
the input file. If Mace4 is given a Prover9 input file,
along with the command-line option -c, it will ignore any
unrecognized (e.g., Prover9) options in the input file.
The Mace4 options are described on the
next page.
In one important case, formulas have different meanings
in Prover9 and Mace4:
If a formula contains constants that
are natural-numbers, {0,1,...}, Mace4 assumes they
are members of the domain of some structure, that is,
they are distinct objects; in effect, Mace4 operates under the
assumptions 0 ≠ 1, 0 ≠ 2, ... .
To Prover9, natural numbers are just ordinary constants.
For example, to Prover9 the statement 0=1 is satisfiable,
and to Mace4 it is unsatisfiable.
Because Mace4 assumes that natural-number constants are
members of the domain, if a formula contains a natural
number that is out of range (≥ n), when searching
for a structure of size n), Mace4 will terminate its
search for size n (and continue with larger sizes if
the specification says to do so).
An Exception. When the flag arithmetic is set,
natural numbers outside of {0,1,...,n-1} can occur.
Lists of Formulas (including Clauses)
Prover9 accepts a fixed set of lists of formulas (e.g.,
assumptions,
usable,
goals,
hints).
Mace4 accepts any lists of formulas.
All are treated
as ordinary formulas except the following two lists.
formulas(hints). These are intended to help
Prover9 find proofs and are ignored by Mace4.
formulas(goals). These are negated by Mace4, just as
they are by Prover9.
formulas(goals)
Prover9 has several restrictions on the goals it accepts
(see Prover9 Goals and Denials),
and Mace4 has the same restrictions. Mace4 negates
goals and translates them to clauses in the same way
as Prover9. (The term "goal" might seem to be bad
teminology for Mace4 users, because Mace4 does not prove theorems;
however, one can think of Mace4 as searching for a counterexample
to the goal.)
When there are multiple goals, Mace handles them the same
as Prover9. For example, consider the following goals.
formulas(goals).
x * y = y * x # label(commutativity).
(x * y) * z = x * (y * z) # label(associativity).
end_of_list.
Logically, this is a disjunction: Prover9 gives a proof
if either goal is proved, and Mace4 gives a counterexample
if both are falsified. In particular, this pair of goals
is equivalent (for both Prover9 and Mace4) to the
following pair of assumptions.
formulas(assumptions).
exists x exists y (x * y != y * x).
exists x exists y exists z (x * y) * z != x * (y * z).
end_of_list.
Distinct Objects
Mace4 accepts a shorthand method for stating that sets of objects
are distinct. Here is an example of two sets of distinct objects.
list(distinct).
[a,b,c]. % equivalent to (a!=b & a!=c & b!=c).
[d,e,f(a)]. % equivalent to (d!=e & d!=f(a) & e!=f(a)).
end_of_list.
Although list(distinct) will probably be used mostly for
constants and other ground terms, terms with variables can occur.
Next Section:
Mace4 Options
prover9-manual-2009-02A/m4-interpformat.html 0000644 0001750 0001750 00000014477 11151021064 020077 0 ustar mccune mccune
Prover9 Manual: Interpformat
Prover9 Manual
Version 2009-02A
Interpformat
The models (structures) in Mace4 output files can be transformed in various
ways with the program Interpformat.
The transformations are listed here.
standard: This transformation simply extracts the structure
from the file and reprints it in the same (standard) format, with one line for each
operation. The result should be acceptable to any of the LADR
programs that take standard structures.
standard2: This is similar to standard, except that
the binary operations are split across multiple lines to make them more
human-readable. The result should be acceptable to any of the LADR
programs that take standard structures.
portable: This form is list of ... of lists of
strings and natural numbers. It can be parsed by seveal
scripting systems such as GAP, Python, and Javascript.
See the section Portable Format.
tabular: This form is designed to be easily readable
by humans. It is not meant for input to other programs.
raw: This form is a sequence of natural numbers.
cooked: This form is a sequence of ground terms.
xml: This is an XML form. Here is a
DTD for LADR interpretations, and here is an
XML stylesheet for transforming the XML to HTML.
tex: This generates LaTeX source for the interpretation.
Examples
The following Mace4 job creates an output file containing one model
in "standard" (the default) format.
The portable format for interpretations can be parsed by several
scriping languages including
Python
and
GAP.
Here is a
counterexample on ternary relations in lattice theory.
The result contains one interpretation of size 4 containing
two binary functions (meet and join), one binary relation
(less-or-equal), two ternary relations, and three constants.
If Mace4 produces more than one structure, some of them are
very likely to be isomorphic to others. The program Isofilter
can be used to remove isomorphic structures.
Determining whether two structures are isomorphic is
a hard problem in general, but isofilter can cope with
some large structures in reasonable time. It
depends on the type of the strucure. For example,
quasigroups usually take more time than lattices.
Isofilter accepts structures in LADR standard format,
which is the default format produced by Mace4. However,
the Mace4 output contains a lot of extraneous information,
which can be stripped out with the command
interpformat standard.
Isofilter also accepts the following command-line arguments,
which are described in the examples below.
ignore_constants: ignore all constants during the isomorphism tests.
check '<operations>' : consider only the listed operations in the isomorphism tests.
output '<operations>' : output only the listed operations.
wrap: enclose the resulting structures in list(interpretations). ... end_of_list.
Examples
We start with a Mace4 job and extract the interpretations; then we run Isofilter.
Note that the two models in BA2.interps2 differ only in one of the constants.
In this case the constants come from existentially quantified variables in the
goal, and all we really care about is the lattice. We can tell Isofilter to
ignore differences in constants by giving it the argument
ignore_constants as in the following command.
Another way to use only a subset of the operations is the
check argument, which us used to specify exactly
which operations to test for isomorphism. In the following example,
only the meet and join operations are checked. (If there is more than
one operation, or if the operation may be interpreted by the shell,
they should be enclosed in single quotes.)
The output of isofilter is frequently used as input to a program that
expects the interpretations to be in a list of interpretations;
we can tell isofilter to put the output in that form by giving it
the argument wrap as in the following command.
Mace4 accepts set, clear, and assign
commands in the input file. Several of these are in common with
Prover9 (e.g., assign(max_seconds, 30)), but most
are specifically for Mace4.
If Mace4 is called with the command-line option -c
(compatability mode), it will ignore any set, clear,
and assign that it does not recognize, assuming they
are meant for some other program (Prover9).
Most Mace4 options can be specified on the command line instead
of in the input file.
When Mace4 options are specified on the command line, single-character
codes are used. For example, the command-line option
-t 30 means the same as assign(max_second, 30)
in the input file. If an option is given in both places,
the one on the command line takes precedence.
Command-line options for Boolean-valued options (flags)
always take an argument: 1 means "set", and 0 means "clear".
For example, -V 1 means set(prolog_style_vaiables,
and -V 0 means clear(prolog_style_variables).
The command "mace4 -help" shows the correspondence between
the command-line codes and the option names, and it shows the default
values.
Symbol Ordering
Like Prover9, Mace4 accepts function_order and
relation_order commands that specify an order on the
symbols in the problem. The syntax of the commands is the
same as in Prover9, for example,
predicate_order([=, <=, P, Q]). % = < P < Q
function_order([a, b, c, +, *, h, g]). % a < b < c < + < * < h < g
Mace4's the default symbol order is the
same as Prover9's.
As in Prover9, function symbols are always less than predicate symbols.
The symbol order can have a big effect on the time it takes to find
a model or exhaust a domain size, because it determines the order in which
Mace4 tries to fill in the function and relation tables. Unfortunately,
we do not know of any general-purpose heuristics for selecting a
good symbol order. If Mace4 takes too long to go through a particular
domain size, we suggest trying a different symbol order.
Option Listing
Basic Options
assign(start_size, n). % default n=2, range [2 .. INT_MAX] % command-line -n n
assign(end_size, n). % default n=-1, range [-1 .. INT_MAX] % command-line -N n
assign(increment, n). % default n=1, range [1 .. INT_MAX] % command-line -i n
These three parameter work together to determine the domain sizes
to be searched. The search starts for structures of size
start_size; if that search fails,
the size is incremented, and another search starts. This continues
up through the value end_size (or until some other limit
terminates the process). If end_size is -1, there is no limit.
(Also see the iterate parameter below.)
For example, the command-line options "-n 5 -N 11 -i 2"
say to try domain sizes 5,7,9,11.
assign(domain_size, n). % default n=0, range [0 .. INT_MAX] % command-line -n n
This parameter says to search only the given size.
This (meta-) parameter works simply by making the following changes.
assign(iterate, string). % default string=all, range [all,evens,odds,primes,nonprimes]
The iterate parameter can be used to add an additional constraint
to the domain sizes. It can be used together with the increment
parameter. The iterate parameter cannot be specified on the
command line.
assign(max_models, n). % default n=1, range [-1 .. INT_MAX] % command-line -m n
The parameter max_models says to stop searching when the n-th structure has been found.
A value of -1 means there is no limit.
assign(max_seconds, n). % default n=-1, range [-1 .. INT_MAX] % command-line -t n
The parameter
max_seconds
says to stop searching after n seconds.
A value of -1 means there is no limit.
assign(max_seconds_per, n). % default n=-1, range [-1 .. INT_MAX] % command-line -s n
The parameter allows at most n seconds for each domain size.
The parameter max_seconds can be used (together with max_seconds_per)
to given an overall time limit.
A value of -1 means there is no limit.
assign(max_megs, n). % default n=200, range [-1 .. INT_MAX] % command-line -b n
The parameter max_megs
says to stop searching when (about) n megabytes of memory have been used.
A value of -1 means there is no limit.
A rule is needed for distinguishing variables from constants in
clauses and formulas with free variables.
If this flag is clear, variables start with
(lower case) 'u' through 'z'.
If this flag is set, variables in clauses start with
(upper case) 'A' through 'Z' or '_'.
If this flag is set, all structures that are found are printed
in "standard" form, which means they are suitable as
input to other LADR programs such as
isofilter and
interpformat.
If this flag is set, and if is clear,
all structures that are found are printed in a tabular form.
If both print_models and print_models_standard
are set, the last one in the input takes effect.
If this flag is set, a ring structure is is applied to the search.
The operations {+,-,*} are assumed to be the ring of integers
(mod domain_size). This method puts a tight constraint on
the search, allowing much larger structures to be investigated.
Here is an example.
If this flag is set, several function and relation symbols understood
by Mace4 as operations and relations on the integers, and evaluation
of terms involving those symbols occurs during the search for models.
See the page Arithmetic for Mace4.
If the verbose flag is set, the output file receives
information about the search, including the initial partial model (the
part of the model that can be determined before backtracking starts)
and timing and other statistics for each domain size. (It does not
give a trace of the backtracking, so it does not consume a lot of file
space.)
If the trace flag is set, detailed information about the
search, including a trace of all assignments and backtracking, is
printed to the standard output. This flag causes a lot of output, so
it should be used only on small searches.
Advanced Options
These options are used for experimentation with search methods.
They can be ignored by nearly all users. For descriptions of
most of these options, see the original Mace4 manual
[McCune-Mace4]
(PDF).
prover9-manual-2009-02A/manual.css 0000644 0001750 0001750 00000005510 10726154312 016146 0 ustar mccune mccune /* margins and padding: top right bottom left */
div.header
{
font-style: italic;
text-align: right;
margin: 1em 0 0 0;
}
body
{
background-color: #ffeebb;
padding-left: 3em;
padding-right: 5em;
}
ul.navbar
{
padding: 0;
margin: 0;
position: relative;
top: .5em;
left: -2.5em;
width: 10em;
}
ul.navbar a:hover {background-color:white}
ul.navbar li.first
{
background-color: #ffeebb;
border-right: 0;
border-bottom: 0;
border-left: 0;
border-top: 0;
text-align: center;
}
ul.navbar li
{
background: #ffe491;
list-style-type: none;
margin: 0.1em 0;
padding: 0.1em;
border-right: 2px solid #ff6c1c;
border-bottom: 2px solid #ff6c1c;
border-left: 2px solid white;
border-top: 2px solid white;
}
ul.navbar ul
{
padding: 0 0 0 1em; /* inner lists */
}
ul.navbar2 li
{
list-style-type: none;
font-size: 80% ;
padding: 0 ;
margin: 0 ;
border-right: none;
border-bottom: none;
border-left: none;
border-top: none;
}
ul.navbar a
{
text-decoration: none;
}
pre.my_file
{
background-color : white;
font : small/1.0 "Courier New", courier, monospace;
text-align : left;
border : 2px solid;
border-color : darkred;
vertical-align : middle;
padding : 5px; /* within box, all 4 sides */
margin : 10px; /* outside of box, all 4 sides */
overflow : auto;
}
pre.my_option
{
background-color : white;
font : small/1.2 "Courier New", courier, monospace;
text-align : left;
border : 2px solid;
border-color : darkred;
vertical-align : middle;
padding : 5px; /* within box, all 4 sides */
margin : 10px; /* outside of box, all 4 sides */
overflow : auto;
}
pre.my_job
{
background-color : #d9e1eb;
font : small/1.2 "Courier New", courier, monospace;
text-align : left;
border : 2px solid;
border-color : darkred;
vertical-align : middle;
padding : 5px; /* within box, all 4 sides */
margin : 10px; /* outside of box, all 4 sides */
overflow : auto;
}
pre.my_screen
{
background-color : #a8e7a8;
font : small/1.2 "Courier New", courier, monospace;
text-align : left;
border : 2px solid;
border-color : darkred;
vertical-align : middle;
padding : 5px; /* within box, all 4 sides */
margin : 10px; /* outside of box, all 4 sides */
overflow : auto;
}
pre.my_code
{
background-color : #f7c9b5;
font : small/1.2 "Courier New", courier, monospace;
text-align : left;
border : 2px solid;
border-color : darkred;
vertical-align : middle;
padding : 5px; /* within box, all 4 sides */
margin : 10px; /* outside of box, all 4 sides */
overflow : auto;
}
blockquote.otter_diff
{
background-color : #ffffaa;
font-style: italic;
text-align : left;
border : 2px solid;
border-color : darkred;
vertical-align : middle;
padding : 5px; /* within box, all 4 sides */
margin : 10px; /* outside of box, all 4 sides */
overflow : auto;
}
dl.references dt
{
padding: 1em 0 0 0;
}
i.g
{
color : #D80700;
}
prover9-manual-2009-02A/redeclare.out 0000644 0001750 0001750 00000017134 11151315523 016637 0 ustar mccune mccune ============================== Prover9 ===============================
Prover9 (32) version 2009-02A, February 2009.
Process 15841 was started by mccune on cleo,
Wed Feb 25 12:26:11 2009
The command was "/home/mccune/bin/prover9 -f redeclare.in".
============================== end of head ===========================
============================== INPUT =================================
% Reading from file redeclare.in
redeclare(true,TRUE).
redeclare(false,FALSE).
redeclare(negation,~).
% op(350, prefix, ~). % copying parse/print properties from - to ~
redeclare(disjunction,OR).
% op(790, infix_right, OR). % copying parse/print properties from | to OR
redeclare(conjunction,AND).
% op(780, infix_right, AND). % copying parse/print properties from & to AND
redeclare(implication,IMPLIES).
% op(800, infix, IMPLIES). % copying parse/print properties from -> to IMPLIES
redeclare(backward_implication,"<--").
% op(800, infix, <--). % copying parse/print properties from <- to <--
redeclare(equivalence,IFF).
% op(800, infix, IFF). % copying parse/print properties from <-> to IFF
redeclare(universal_quantification,ALL).
redeclare(existential_quantification,EXISTS).
redeclare(equality,"==").
% op(700, infix, ==). % copying parse/print properties from = to ==
redeclare(negated_equality,"=/=").
% op(700, infix, =/=). % copying parse/print properties from != to =/=
redeclare(attribute,@).
% op(810, infix_right, @). % copying parse/print properties from # to @
formulas(assumptions).
(x * y) * z == z * (y * z) @ label(associativity).
(EXISTS e ((ALL x e * x == x) AND (ALL x EXISTS y y * x == e))) @ label(left_identity_inverse).
end_of_list.
formulas(goals).
x * y == x * z IMPLIES y == z @ label(right_cancellation).
end_of_list.
============================== end of input ==========================
============================== PROCESS NON-CLAUSAL FORMULAS ==========
% Formulas that are not ordinary clauses:
1 (EXISTS e ((ALL x e * x == x) AND (ALL x EXISTS y y * x == e))) @ label(left_identity_inverse) @ label(non_clause). [assumption].
2 x * y == x * z IMPLIES y == z @ label(right_cancellation) @ label(non_clause) @ label(goal). [goal].
============================== end of process non-clausal formulas ===
============================== PROCESS INITIAL CLAUSES ===============
% Clauses before input processing:
formulas(usable).
end_of_list.
formulas(sos).
(x * y) * z == z * (y * z) @ label(associativity). [assumption].
c1 * x == x @ label(left_identity_inverse). [clausify(1)].
f1(x) * x == c1 @ label(left_identity_inverse). [clausify(1)].
c2 * c4 == c2 * c3 @ label(right_cancellation). [deny(2)].
c4 =/= c3 @ label(right_cancellation). [deny(2)].
end_of_list.
formulas(demodulators).
end_of_list.
============================== PREDICATE ELIMINATION =================
No predicates eliminated.
============================== end predicate elimination =============
Auto_denials:
% copying label right_cancellation to answer in negative clause
Term ordering decisions:
Predicate symbol precedence: predicate_order([ == ]).
Function symbol precedence: function_order([ c1, c2, c3, c4, *, f1 ]).
After inverse_order: Function symbol precedence: function_order([ c1, c2, c3, c4, *, f1 ]).
Unfolding symbols: (none).
Auto_inference settings:
% set(paramodulation). % (positive equality literals)
Auto_process settings: (no changes).
kept: 3 (x * y) * z == z * (y * z) @ label(associativity). [assumption].
kept: 4 c1 * x == x @ label(left_identity_inverse). [clausify(1)].
kept: 5 f1(x) * x == c1 @ label(left_identity_inverse). [clausify(1)].
kept: 6 c2 * c4 == c2 * c3 @ label(right_cancellation). [deny(2)].
kept: 7 c4 =/= c3 @ label(right_cancellation) @ answer(right_cancellation). [deny(2)].
============================== end of process initial clauses ========
============================== CLAUSES FOR SEARCH ====================
% Clauses after input processing:
formulas(usable).
end_of_list.
formulas(sos).
3 (x * y) * z == z * (y * z) @ label(associativity). [assumption].
4 c1 * x == x @ label(left_identity_inverse). [clausify(1)].
5 f1(x) * x == c1 @ label(left_identity_inverse). [clausify(1)].
6 c2 * c4 == c2 * c3 @ label(right_cancellation). [deny(2)].
7 c4 =/= c3 @ label(right_cancellation) @ answer(right_cancellation). [deny(2)].
end_of_list.
formulas(demodulators).
3 (x * y) * z == z * (y * z) @ label(associativity). [assumption].
% (lex-dep)
4 c1 * x == x @ label(left_identity_inverse). [clausify(1)].
5 f1(x) * x == c1 @ label(left_identity_inverse). [clausify(1)].
6 c2 * c4 == c2 * c3 @ label(right_cancellation). [deny(2)].
end_of_list.
============================== end of clauses for search =============
============================== SEARCH ================================
% Starting search at 0.01 seconds.
given #1 (I,wt=11): 3 (x * y) * z == z * (y * z) @ label(associativity). [assumption].
given #2 (I,wt=5): 4 c1 * x == x @ label(left_identity_inverse). [clausify(1)].
given #3 (I,wt=6): 5 f1(x) * x == c1 @ label(left_identity_inverse). [clausify(1)].
given #4 (I,wt=7): 6 c2 * c4 == c2 * c3 @ label(right_cancellation). [deny(2)].
given #5 (I,wt=3): 7 c4 =/= c3 @ label(right_cancellation) @ answer(right_cancellation). [deny(2)].
given #6 (A,wt=9): 14 x * (y * x) == y * x. [para(4(a,1),3(a,1,1)),flip(a)].
given #7 (T,wt=5): 20 x * x == x. [back_rewrite(15),rewrite([18(3),4(2)]),flip(a)].
given #8 (T,wt=5): 21 x * c1 == c1. [para(5(a,1),14(a,1,2)),rewrite([5(4)])].
given #9 (T,wt=9): 18 (x * y) * z == y * z. [back_rewrite(8),rewrite([14(2),14(4)])].
============================== PROOF =================================
% Proof 1 at 0.01 (+ 0.00) seconds: right_cancellation.
% Length of proof is 13.
% Level of proof is 6.
% Maximum clause weight is 13.
% Given clauses 9.
1 (EXISTS e ((ALL x e * x == x) AND (ALL x EXISTS y y * x == e))) @ label(left_identity_inverse) @ label(non_clause). [assumption].
2 x * y == x * z IMPLIES y == z @ label(right_cancellation) @ label(non_clause) @ label(goal). [goal].
3 (x * y) * z == z * (y * z) @ label(associativity). [assumption].
4 c1 * x == x @ label(left_identity_inverse). [clausify(1)].
5 f1(x) * x == c1 @ label(left_identity_inverse). [clausify(1)].
6 c2 * c4 == c2 * c3 @ label(right_cancellation). [deny(2)].
7 c4 =/= c3 @ label(right_cancellation) @ answer(right_cancellation). [deny(2)].
8 (x * (y * x)) * z == z * (x * z). [para(3(a,1),3(a,1,1))].
14 x * (y * x) == y * x. [para(4(a,1),3(a,1,1)),flip(a)].
18 (x * y) * z == y * z. [back_rewrite(8),rewrite([14(2),14(4)])].
23 x * y == y. [para(5(a,1),18(a,1,1)),rewrite([4(2)]),flip(a)].
25 c4 == c3. [para(6(a,1),18(a,2)),rewrite([23(2),23(3),23(4)])].
26 FALSE @ answer(right_cancellation). [resolve(25,a,7,a)].
============================== end of proof ==========================
============================== STATISTICS ============================
Given=9. Generated=61. Kept=23. proofs=1.
Usable=8. Sos=2. Demods=10. Limbo=2, Disabled=15. Hints=0.
Kept_by_rule=0, Deleted_by_rule=0.
Forward_subsumed=38. Back_subsumed=0.
Sos_limit_deleted=0. Sos_displaced=0. Sos_removed=0.
New_demodulators=12 (1 lex), Back_demodulated=10. Back_unit_deleted=0.
Demod_attempts=383. Demod_rewrites=58.
Res_instance_prunes=0. Para_instance_prunes=0. Basic_paramod_prunes=0.
Nonunit_fsub_feature_tests=0. Nonunit_bsub_feature_tests=0.
Megabytes=0.04.
User_CPU=0.01, System_CPU=0.00, Wall_clock=0.
============================== end of statistics =====================
============================== end of search =========================
THEOREM PROVED
Exiting with 1 proof.
Process 15841 exit (max_proofs) Wed Feb 25 12:26:11 2009
prover9-manual-2009-02A/MOL-cand.296 0000644 0001750 0001750 00000036040 07744033771 015770 0 ustar mccune mccune f(f(f(f(f(x,z),y),y),z),f(f(f(x,z),f(y,z)),x)) = z.
f(f(f(f(f(x,z),y),y),z),f(x,f(f(z,x),f(z,y)))) = z.
f(f(f(f(f(x,z),y),y),z),f(x,f(f(y,z),f(z,x)))) = z.
f(f(f(f(f(x,z),y),y),z),f(x,f(f(x,z),f(z,y)))) = z.
f(f(f(f(f(x,z),y),y),z),f(x,f(f(z,z),f(z,y)))) = z.
f(f(f(f(f(x,z),y),y),z),f(x,f(f(z,z),f(z,x)))) = z.
f(f(f(f(x,f(z,y)),x),z),f(f(f(y,z),f(y,z)),y)) = z.
f(f(f(f(x,f(y,z)),x),z),f(f(f(y,z),f(y,z)),y)) = z.
f(f(f(f(x,f(z,y)),x),z),f(f(f(y,z),f(x,z)),y)) = z.
f(f(f(f(x,f(z,y)),x),z),f(f(f(x,z),f(y,z)),y)) = z.
f(f(f(f(x,f(y,z)),x),z),f(f(f(y,z),f(x,z)),y)) = z.
f(f(f(f(x,f(y,z)),x),z),f(f(f(x,z),f(y,z)),y)) = z.
f(f(f(f(x,f(z,y)),x),z),f(y,f(f(y,z),f(z,y)))) = z.
f(f(f(f(x,f(z,y)),x),z),f(y,f(f(z,y),f(z,x)))) = z.
f(f(f(f(x,f(y,z)),x),z),f(y,f(f(z,y),f(z,x)))) = z.
f(f(f(f(x,f(y,z)),x),z),f(y,f(f(z,x),f(z,y)))) = z.
f(f(f(f(x,f(y,z)),x),z),f(y,f(f(x,z),f(z,y)))) = z.
f(f(f(f(x,f(z,y)),x),z),f(y,f(f(z,z),f(z,x)))) = z.
f(f(f(f(x,f(y,z)),x),z),f(y,f(f(z,z),f(z,y)))) = z.
f(f(f(f(x,f(y,z)),x),z),f(y,f(f(z,z),f(z,x)))) = z.
f(f(f(f(x,z),f(z,x)),x),f(z,f(f(f(z,x),y),y))) = z.
f(f(f(f(x,z),f(z,y)),y),f(z,f(f(f(z,y),x),x))) = z.
f(f(f(f(x,z),f(z,y)),y),f(z,f(f(f(y,z),x),x))) = z.
f(f(f(f(x,z),f(z,y)),x),f(z,f(f(f(z,x),y),y))) = z.
f(f(f(f(x,z),f(z,y)),x),f(z,f(f(f(x,z),y),y))) = z.
f(f(f(f(x,z),f(y,z)),y),f(z,f(f(f(z,y),x),x))) = z.
f(f(f(f(x,z),f(y,z)),y),f(z,f(f(f(y,z),x),x))) = z.
f(f(f(f(x,z),f(y,z)),x),f(z,f(f(f(x,z),y),y))) = z.
f(f(f(f(x,z),f(z,z)),y),f(z,f(f(f(z,y),x),x))) = z.
f(f(f(f(x,z),f(z,z)),y),f(z,f(f(f(y,z),x),x))) = z.
f(f(f(f(x,z),f(z,x)),x),f(z,f(f(y,f(z,x)),y))) = z.
f(f(f(f(x,z),f(z,y)),y),f(z,f(f(x,f(y,z)),x))) = z.
f(f(f(f(x,z),f(z,y)),x),f(z,f(f(y,f(x,z)),y))) = z.
f(f(f(f(x,z),f(y,z)),y),f(z,f(f(x,f(z,y)),x))) = z.
f(f(f(f(x,z),f(y,z)),y),f(z,f(f(x,f(y,z)),x))) = z.
f(f(f(f(x,z),f(y,z)),x),f(z,f(f(y,f(z,x)),y))) = z.
f(f(f(f(x,z),f(z,z)),y),f(z,f(f(x,f(z,y)),x))) = z.
f(f(f(f(x,z),f(z,z)),y),f(z,f(f(x,f(y,z)),x))) = z.
f(f(f(f(x,z),f(z,y)),x),f(z,f(y,f(f(z,x),y)))) = z.
f(f(f(f(x,z),f(y,z)),y),f(z,f(x,f(f(z,y),x)))) = z.
f(f(f(f(x,z),f(y,z)),y),f(z,f(x,f(f(y,z),x)))) = z.
f(f(f(f(x,z),f(y,z)),x),f(z,f(y,f(f(z,x),y)))) = z.
f(f(f(f(x,z),f(z,z)),y),f(z,f(x,f(f(z,y),x)))) = z.
f(f(f(f(x,z),f(z,z)),y),f(z,f(x,f(f(y,z),x)))) = z.
f(f(f(f(x,z),f(z,z)),x),f(z,f(y,f(f(z,x),y)))) = z.
f(f(f(f(x,z),f(z,y)),x),f(z,f(y,f(y,f(z,x))))) = z.
f(f(f(f(x,z),f(y,z)),y),f(z,f(x,f(x,f(z,y))))) = z.
f(f(f(f(x,z),f(z,z)),y),f(z,f(x,f(x,f(z,y))))) = z.
f(f(f(f(x,z),f(z,z)),x),f(z,f(y,f(y,f(z,x))))) = z.
f(f(f(x,f(f(z,y),x)),z),f(f(f(y,z),f(y,z)),y)) = z.
f(f(f(x,f(f(y,z),x)),z),f(f(f(y,z),f(y,z)),y)) = z.
f(f(f(x,f(f(z,y),x)),z),f(f(f(x,z),f(y,z)),y)) = z.
f(f(f(x,f(f(y,z),x)),z),f(f(f(y,z),f(x,z)),y)) = z.
f(f(f(x,f(f(y,z),x)),z),f(f(f(x,z),f(y,z)),y)) = z.
f(f(f(x,f(f(y,z),x)),z),f(y,f(f(y,z),f(z,y)))) = z.
f(f(f(x,f(f(z,y),x)),z),f(y,f(f(z,y),f(z,x)))) = z.
f(f(f(x,f(f(z,y),x)),z),f(y,f(f(y,z),f(z,x)))) = z.
f(f(f(x,f(f(z,y),x)),z),f(y,f(f(x,z),f(z,y)))) = z.
f(f(f(x,f(f(y,z),x)),z),f(y,f(f(z,y),f(z,x)))) = z.
f(f(f(x,f(f(y,z),x)),z),f(y,f(f(z,x),f(z,y)))) = z.
f(f(f(x,f(f(z,y),x)),z),f(y,f(f(z,z),f(z,x)))) = z.
f(f(f(x,f(f(y,z),x)),z),f(y,f(f(z,z),f(z,x)))) = z.
f(f(f(x,f(x,f(z,y))),z),f(f(f(y,z),f(x,z)),y)) = z.
f(f(f(x,f(x,f(y,z))),z),f(f(f(y,z),f(x,z)),y)) = z.
f(f(f(x,f(x,f(y,z))),z),f(f(f(x,z),f(y,z)),y)) = z.
f(f(f(x,f(x,f(y,z))),z),f(y,f(f(y,z),f(z,y)))) = z.
f(f(f(x,f(x,f(z,y))),z),f(y,f(f(z,y),f(z,x)))) = z.
f(f(f(x,f(x,f(z,y))),z),f(y,f(f(z,x),f(z,y)))) = z.
f(f(f(x,f(x,f(z,y))),z),f(y,f(f(y,z),f(z,x)))) = z.
f(f(f(x,f(x,f(z,y))),z),f(y,f(f(x,z),f(z,y)))) = z.
f(f(f(x,f(x,f(y,z))),z),f(y,f(f(z,y),f(z,x)))) = z.
f(f(f(x,f(x,f(y,z))),z),f(y,f(f(x,z),f(z,y)))) = z.
f(f(f(x,f(x,f(z,y))),z),f(y,f(f(z,z),f(z,x)))) = z.
f(f(f(x,f(x,f(y,z))),z),f(y,f(f(z,z),f(z,x)))) = z.
f(f(x,f(f(z,x),f(z,x))),f(z,f(f(f(x,z),y),y))) = z.
f(f(x,f(f(z,y),f(z,x))),f(z,f(f(f(z,x),y),y))) = z.
f(f(x,f(f(z,y),f(z,x))),f(z,f(f(f(x,z),y),y))) = z.
f(f(x,f(f(z,x),f(z,y))),f(z,f(f(f(z,x),y),y))) = z.
f(f(x,f(f(z,x),f(z,x))),f(z,f(f(y,f(z,x)),y))) = z.
f(f(x,f(f(z,x),f(z,x))),f(z,f(f(y,f(x,z)),y))) = z.
f(f(x,f(f(z,y),f(z,x))),f(z,f(f(y,f(z,x)),y))) = z.
f(f(x,f(f(z,x),f(z,y))),f(z,f(f(y,f(z,x)),y))) = z.
f(f(x,f(f(z,x),f(z,y))),f(z,f(f(y,f(x,z)),y))) = z.
f(f(x,f(f(z,x),f(z,x))),f(z,f(y,f(f(z,x),y)))) = z.
f(f(x,f(f(z,x),f(z,x))),f(z,f(y,f(f(x,z),y)))) = z.
f(f(x,f(f(z,y),f(z,x))),f(z,f(y,f(f(z,x),y)))) = z.
f(f(x,f(f(z,y),f(z,x))),f(z,f(y,f(f(x,z),y)))) = z.
f(f(x,f(f(z,x),f(z,y))),f(z,f(y,f(f(z,x),y)))) = z.
f(f(x,f(f(z,x),f(z,y))),f(z,f(y,f(f(x,z),y)))) = z.
f(f(x,f(f(z,y),f(z,x))),f(z,f(y,f(y,f(z,x))))) = z.
f(f(f(x,f(z,z)),z),f(f(f(f(y,x),x),f(y,z)),y)) = z.
f(f(f(x,f(z,z)),z),f(f(f(f(x,y),x),f(y,z)),y)) = z.
f(f(f(x,f(z,z)),z),f(f(f(x,f(y,x)),f(y,z)),y)) = z.
f(f(f(x,f(z,z)),z),f(f(f(y,z),f(f(y,x),x)),y)) = z.
f(f(f(x,f(z,z)),z),f(f(f(y,z),f(f(x,y),x)),y)) = z.
f(f(f(x,f(z,z)),z),f(f(f(y,z),f(x,f(y,x))),y)) = z.
f(f(f(x,f(z,z)),z),f(f(f(y,z),f(x,f(x,y))),y)) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(f(x,y),x),f(z,y)))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(x,f(y,x)),f(z,y)))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(x,f(x,y)),f(z,y)))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(z,y),f(f(y,x),x)))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(z,y),f(f(x,y),x)))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(y,z),f(f(y,x),x)))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(y,z),f(f(x,y),x)))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(z,y),f(x,f(y,x))))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(z,y),f(x,f(x,y))))) = z.
f(f(f(x,z),z),f(f(f(z,y),f(x,z)),f(f(x,x),y))) = z.
f(f(f(x,z),z),f(f(f(y,z),f(x,z)),f(y,f(x,x)))) = z.
f(f(f(x,z),z),f(f(y,f(x,x)),f(f(z,y),f(z,x)))) = z.
f(f(f(x,z),z),f(f(y,f(x,x)),f(f(x,z),f(z,y)))) = z.
f(f(f(x,f(x,z)),x),f(z,f(z,f(f(y,x),f(u,x))))) = z.
f(f(f(x,f(x,z)),x),f(z,f(z,f(f(y,x),f(x,u))))) = z.
f(f(f(x,f(x,z)),x),f(z,f(z,f(f(x,y),f(u,x))))) = z.
f(f(f(x,f(x,z)),x),f(z,f(z,f(f(x,y),f(x,u))))) = z.
f(f(x,f(x,f(z,x))),f(z,f(z,f(f(y,x),f(u,x))))) = z.
f(f(x,f(x,f(z,x))),f(z,f(z,f(f(y,x),f(x,u))))) = z.
f(f(x,f(x,f(z,x))),f(z,f(z,f(f(x,y),f(u,x))))) = z.
f(f(x,f(x,f(z,x))),f(z,f(z,f(f(x,y),f(x,u))))) = z.
f(f(x,f(x,f(x,z))),f(z,f(z,f(f(y,x),f(u,x))))) = z.
f(f(x,f(x,f(x,z))),f(z,f(z,f(f(y,x),f(x,u))))) = z.
f(f(x,f(x,f(x,z))),f(z,f(z,f(f(x,y),f(u,x))))) = z.
f(f(x,f(x,f(x,z))),f(z,f(z,f(f(x,y),f(x,u))))) = z.
f(f(f(f(f(x,z),y),y),z),f(f(f(u,z),f(x,z)),x)) = z.
f(f(f(f(f(x,z),y),y),z),f(f(f(z,u),f(x,z)),x)) = z.
f(f(f(f(f(x,z),y),y),z),f(f(f(x,z),f(u,z)),x)) = z.
f(f(f(f(f(x,z),y),y),z),f(x,f(f(u,z),f(z,x)))) = z.
f(f(f(f(f(x,z),y),y),z),f(x,f(f(z,u),f(z,x)))) = z.
f(f(f(f(f(x,z),y),y),z),f(x,f(f(z,x),f(z,u)))) = z.
f(f(f(f(f(x,z),y),y),z),f(x,f(f(x,z),f(z,u)))) = z.
f(f(f(f(f(x,z),y),y),z),f(x,f(f(z,z),f(z,u)))) = z.
f(f(f(f(x,f(z,y)),x),z),f(f(f(u,z),f(y,z)),y)) = z.
f(f(f(f(x,f(z,y)),x),z),f(f(f(z,u),f(y,z)),y)) = z.
f(f(f(f(x,f(z,y)),x),z),f(f(f(y,z),f(u,z)),y)) = z.
f(f(f(f(x,f(y,z)),x),z),f(f(f(u,z),f(y,z)),y)) = z.
f(f(f(f(x,f(y,z)),x),z),f(f(f(z,u),f(y,z)),y)) = z.
f(f(f(f(x,f(y,z)),x),z),f(f(f(y,z),f(u,z)),y)) = z.
f(f(f(f(x,f(z,y)),x),z),f(y,f(f(u,z),f(z,y)))) = z.
f(f(f(f(x,f(z,y)),x),z),f(y,f(f(z,u),f(z,y)))) = z.
f(f(f(f(x,f(z,y)),x),z),f(y,f(f(z,y),f(z,u)))) = z.
f(f(f(f(x,f(z,y)),x),z),f(y,f(f(y,z),f(z,u)))) = z.
f(f(f(f(x,f(y,z)),x),z),f(y,f(f(u,z),f(z,y)))) = z.
f(f(f(f(x,f(y,z)),x),z),f(y,f(f(z,u),f(z,y)))) = z.
f(f(f(f(x,f(y,z)),x),z),f(y,f(f(z,y),f(z,u)))) = z.
f(f(f(f(x,f(y,z)),x),z),f(y,f(f(y,z),f(z,u)))) = z.
f(f(f(f(x,f(z,y)),x),z),f(y,f(f(z,z),f(z,u)))) = z.
f(f(f(f(x,f(y,z)),x),z),f(y,f(f(z,z),f(z,u)))) = z.
f(f(f(f(x,z),f(z,y)),y),f(z,f(f(f(z,y),u),u))) = z.
f(f(f(f(x,z),f(z,y)),y),f(z,f(f(f(y,z),u),u))) = z.
f(f(f(f(x,z),f(z,y)),x),f(z,f(f(f(z,x),u),u))) = z.
f(f(f(f(x,z),f(z,y)),x),f(z,f(f(f(x,z),u),u))) = z.
f(f(f(f(x,z),f(y,z)),y),f(z,f(f(f(z,y),u),u))) = z.
f(f(f(f(x,z),f(y,z)),y),f(z,f(f(f(y,z),u),u))) = z.
f(f(f(f(x,z),f(y,z)),x),f(z,f(f(f(z,x),u),u))) = z.
f(f(f(f(x,z),f(y,z)),x),f(z,f(f(f(x,z),u),u))) = z.
f(f(f(f(x,z),f(z,z)),y),f(z,f(f(f(z,y),u),u))) = z.
f(f(f(f(x,z),f(z,z)),y),f(z,f(f(f(y,z),u),u))) = z.
f(f(f(f(x,z),f(z,y)),y),f(z,f(f(u,f(z,y)),u))) = z.
f(f(f(f(x,z),f(z,y)),y),f(z,f(f(u,f(y,z)),u))) = z.
f(f(f(f(x,z),f(z,y)),x),f(z,f(f(u,f(z,x)),u))) = z.
f(f(f(f(x,z),f(z,y)),x),f(z,f(f(u,f(x,z)),u))) = z.
f(f(f(f(x,z),f(y,z)),y),f(z,f(f(u,f(z,y)),u))) = z.
f(f(f(f(x,z),f(y,z)),y),f(z,f(f(u,f(y,z)),u))) = z.
f(f(f(f(x,z),f(y,z)),x),f(z,f(f(u,f(z,x)),u))) = z.
f(f(f(f(x,z),f(y,z)),x),f(z,f(f(u,f(x,z)),u))) = z.
f(f(f(f(x,z),f(z,z)),y),f(z,f(f(u,f(z,y)),u))) = z.
f(f(f(f(x,z),f(z,z)),y),f(z,f(f(u,f(y,z)),u))) = z.
f(f(f(f(x,z),f(z,y)),y),f(z,f(u,f(f(z,y),u)))) = z.
f(f(f(f(x,z),f(z,y)),y),f(z,f(u,f(f(y,z),u)))) = z.
f(f(f(f(x,z),f(z,y)),x),f(z,f(u,f(f(z,x),u)))) = z.
f(f(f(f(x,z),f(z,y)),x),f(z,f(u,f(f(x,z),u)))) = z.
f(f(f(f(x,z),f(y,z)),y),f(z,f(u,f(f(z,y),u)))) = z.
f(f(f(f(x,z),f(y,z)),y),f(z,f(u,f(f(y,z),u)))) = z.
f(f(f(f(x,z),f(y,z)),x),f(z,f(u,f(f(z,x),u)))) = z.
f(f(f(f(x,z),f(y,z)),x),f(z,f(u,f(f(x,z),u)))) = z.
f(f(f(f(x,z),f(z,z)),y),f(z,f(u,f(f(z,y),u)))) = z.
f(f(f(f(x,z),f(z,z)),y),f(z,f(u,f(f(y,z),u)))) = z.
f(f(f(f(x,z),f(z,y)),y),f(z,f(u,f(u,f(z,y))))) = z.
f(f(f(f(x,z),f(z,y)),x),f(z,f(u,f(u,f(z,x))))) = z.
f(f(f(f(x,z),f(y,z)),y),f(z,f(u,f(u,f(z,y))))) = z.
f(f(f(f(x,z),f(y,z)),x),f(z,f(u,f(u,f(z,x))))) = z.
f(f(f(f(x,z),f(z,z)),y),f(z,f(u,f(u,f(z,y))))) = z.
f(f(f(x,f(f(z,y),x)),z),f(f(f(u,z),f(y,z)),y)) = z.
f(f(f(x,f(f(z,y),x)),z),f(f(f(z,u),f(y,z)),y)) = z.
f(f(f(x,f(f(z,y),x)),z),f(f(f(y,z),f(u,z)),y)) = z.
f(f(f(x,f(f(y,z),x)),z),f(f(f(u,z),f(y,z)),y)) = z.
f(f(f(x,f(f(y,z),x)),z),f(f(f(z,u),f(y,z)),y)) = z.
f(f(f(x,f(f(y,z),x)),z),f(f(f(y,z),f(u,z)),y)) = z.
f(f(f(x,f(f(z,y),x)),z),f(y,f(f(u,z),f(z,y)))) = z.
f(f(f(x,f(f(z,y),x)),z),f(y,f(f(z,u),f(z,y)))) = z.
f(f(f(x,f(f(z,y),x)),z),f(y,f(f(z,y),f(z,u)))) = z.
f(f(f(x,f(f(z,y),x)),z),f(y,f(f(y,z),f(z,u)))) = z.
f(f(f(x,f(f(y,z),x)),z),f(y,f(f(u,z),f(z,y)))) = z.
f(f(f(x,f(f(y,z),x)),z),f(y,f(f(z,u),f(z,y)))) = z.
f(f(f(x,f(f(y,z),x)),z),f(y,f(f(z,y),f(z,u)))) = z.
f(f(f(x,f(f(y,z),x)),z),f(y,f(f(y,z),f(z,u)))) = z.
f(f(f(x,f(f(z,y),x)),z),f(y,f(f(z,z),f(z,u)))) = z.
f(f(f(x,f(f(y,z),x)),z),f(y,f(f(z,z),f(z,u)))) = z.
f(f(f(x,f(x,f(z,y))),z),f(f(f(u,z),f(y,z)),y)) = z.
f(f(f(x,f(x,f(z,y))),z),f(f(f(z,u),f(y,z)),y)) = z.
f(f(f(x,f(x,f(z,y))),z),f(f(f(y,z),f(u,z)),y)) = z.
f(f(f(x,f(x,f(y,z))),z),f(f(f(u,z),f(y,z)),y)) = z.
f(f(f(x,f(x,f(y,z))),z),f(f(f(z,u),f(y,z)),y)) = z.
f(f(f(x,f(x,f(y,z))),z),f(f(f(y,z),f(u,z)),y)) = z.
f(f(f(x,f(x,f(z,y))),z),f(y,f(f(u,z),f(z,y)))) = z.
f(f(f(x,f(x,f(z,y))),z),f(y,f(f(z,u),f(z,y)))) = z.
f(f(f(x,f(x,f(z,y))),z),f(y,f(f(z,y),f(z,u)))) = z.
f(f(f(x,f(x,f(z,y))),z),f(y,f(f(y,z),f(z,u)))) = z.
f(f(f(x,f(x,f(y,z))),z),f(y,f(f(u,z),f(z,y)))) = z.
f(f(f(x,f(x,f(y,z))),z),f(y,f(f(z,u),f(z,y)))) = z.
f(f(f(x,f(x,f(y,z))),z),f(y,f(f(z,y),f(z,u)))) = z.
f(f(f(x,f(x,f(y,z))),z),f(y,f(f(y,z),f(z,u)))) = z.
f(f(f(x,f(x,f(z,y))),z),f(y,f(f(z,z),f(z,u)))) = z.
f(f(f(x,f(x,f(y,z))),z),f(y,f(f(z,z),f(z,u)))) = z.
f(f(x,f(f(z,y),f(z,x))),f(z,f(f(f(z,x),u),u))) = z.
f(f(x,f(f(z,y),f(z,x))),f(z,f(f(f(x,z),u),u))) = z.
f(f(x,f(f(z,x),f(z,y))),f(z,f(f(f(z,x),u),u))) = z.
f(f(x,f(f(z,x),f(z,y))),f(z,f(f(f(x,z),u),u))) = z.
f(f(x,f(f(z,x),f(y,z))),f(z,f(f(f(z,x),u),u))) = z.
f(f(x,f(f(z,x),f(y,z))),f(z,f(f(f(x,z),u),u))) = z.
f(f(x,f(f(z,y),f(z,x))),f(z,f(f(u,f(z,x)),u))) = z.
f(f(x,f(f(z,y),f(z,x))),f(z,f(f(u,f(x,z)),u))) = z.
f(f(x,f(f(z,x),f(z,y))),f(z,f(f(u,f(z,x)),u))) = z.
f(f(x,f(f(z,x),f(z,y))),f(z,f(f(u,f(x,z)),u))) = z.
f(f(x,f(f(z,x),f(y,z))),f(z,f(f(u,f(z,x)),u))) = z.
f(f(x,f(f(z,x),f(y,z))),f(z,f(f(u,f(x,z)),u))) = z.
f(f(x,f(f(z,y),f(z,x))),f(z,f(u,f(f(z,x),u)))) = z.
f(f(x,f(f(z,y),f(z,x))),f(z,f(u,f(f(x,z),u)))) = z.
f(f(x,f(f(z,x),f(z,y))),f(z,f(u,f(f(z,x),u)))) = z.
f(f(x,f(f(z,x),f(z,y))),f(z,f(u,f(f(x,z),u)))) = z.
f(f(x,f(f(z,x),f(y,z))),f(z,f(u,f(f(z,x),u)))) = z.
f(f(x,f(f(z,x),f(y,z))),f(z,f(u,f(f(x,z),u)))) = z.
f(f(x,f(f(z,y),f(z,x))),f(z,f(u,f(u,f(z,x))))) = z.
f(f(x,f(f(z,x),f(z,y))),f(z,f(u,f(u,f(z,x))))) = z.
f(f(x,f(f(z,x),f(y,z))),f(z,f(u,f(u,f(z,x))))) = z.
f(f(f(x,f(z,z)),z),f(f(f(f(y,u),u),f(y,z)),y)) = z.
f(f(f(x,f(z,z)),z),f(f(f(f(y,u),y),f(u,z)),u)) = z.
f(f(f(x,f(z,z)),z),f(f(f(y,f(u,y)),f(u,z)),u)) = z.
f(f(f(x,f(z,z)),z),f(f(f(y,f(y,u)),f(u,z)),u)) = z.
f(f(f(x,f(z,z)),z),f(f(f(y,z),f(f(u,y),u)),y)) = z.
f(f(f(x,f(z,z)),z),f(f(f(y,z),f(f(y,u),u)),y)) = z.
f(f(f(x,f(z,z)),z),f(f(f(y,z),f(u,f(u,y))),y)) = z.
f(f(f(x,f(z,z)),z),f(f(f(y,z),f(u,f(y,u))),y)) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(f(u,y),u),f(z,y)))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(f(y,u),u),f(z,y)))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(u,f(u,y)),f(z,y)))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(u,f(y,u)),f(z,y)))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(z,y),f(f(u,y),u)))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(z,y),f(f(y,u),u)))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(y,z),f(f(u,y),u)))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(y,z),f(f(y,u),u)))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(z,y),f(u,f(u,y))))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(z,y),f(u,f(y,u))))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(y,z),f(u,f(u,y))))) = z.
f(f(f(x,f(z,z)),z),f(y,f(f(y,z),f(u,f(y,u))))) = z.
f(f(f(x,z),z),f(f(f(f(f(x,x),y),z),f(u,z)),x)) = z.
f(f(f(x,z),z),f(f(f(f(y,f(x,x)),z),f(u,z)),x)) = z.
f(f(f(x,z),z),f(f(f(z,y),f(f(f(x,x),u),z)),x)) = z.
f(f(f(x,z),z),f(f(f(y,z),f(f(f(x,x),u),z)),x)) = z.
f(f(f(x,z),z),f(f(f(z,y),f(f(u,f(x,x)),z)),x)) = z.
f(f(f(x,z),z),f(f(f(y,z),f(f(u,f(x,x)),z)),x)) = z.
f(f(f(x,z),z),f(f(f(z,y),f(x,z)),f(f(x,x),u))) = z.
f(f(f(x,z),z),f(f(f(y,z),f(x,z)),f(f(x,x),u))) = z.
f(f(f(x,z),z),f(f(f(x,z),f(y,z)),f(f(x,x),u))) = z.
f(f(f(x,z),z),f(f(f(z,y),f(x,z)),f(f(z,z),u))) = z.
f(f(f(x,z),z),f(f(f(y,z),f(x,z)),f(f(z,z),u))) = z.
f(f(f(x,z),z),f(f(f(x,z),f(y,z)),f(f(z,z),u))) = z.
f(f(f(x,z),z),f(f(f(z,y),f(x,z)),f(u,f(x,x)))) = z.
f(f(f(x,z),z),f(f(f(y,z),f(x,z)),f(u,f(x,x)))) = z.
f(f(f(x,z),z),f(f(f(x,z),f(y,z)),f(u,f(x,x)))) = z.
f(f(f(x,z),z),f(f(f(x,x),y),f(f(u,z),f(z,x)))) = z.
f(f(f(x,z),z),f(f(f(x,x),y),f(f(z,u),f(z,x)))) = z.
f(f(f(x,z),z),f(f(f(x,x),y),f(f(z,x),f(z,u)))) = z.
f(f(f(x,z),z),f(f(f(x,x),y),f(f(x,z),f(z,u)))) = z.
f(f(f(x,z),z),f(f(f(z,z),y),f(f(u,z),f(z,x)))) = z.
f(f(f(x,z),z),f(f(f(z,z),y),f(f(x,z),f(z,u)))) = z.
f(f(f(x,z),z),f(f(y,f(x,x)),f(f(u,z),f(z,x)))) = z.
f(f(f(x,z),z),f(f(y,f(x,x)),f(f(z,u),f(z,x)))) = z.
f(f(f(x,z),z),f(f(y,f(x,x)),f(f(z,x),f(z,u)))) = z.
f(f(f(x,z),z),f(f(y,f(x,x)),f(f(x,z),f(z,u)))) = z.
f(f(f(x,z),z),f(x,f(f(f(f(x,x),y),z),f(z,u)))) = z.
f(f(f(x,z),z),f(x,f(f(f(y,f(x,x)),z),f(z,u)))) = z.
f(f(f(x,z),z),f(x,f(f(z,f(f(x,x),y)),f(z,u)))) = z.
f(f(f(x,z),z),f(x,f(f(z,f(y,f(x,x))),f(z,u)))) = z.
f(f(f(x,z),z),f(x,f(f(z,y),f(z,f(f(x,x),u))))) = z.
f(f(f(x,z),z),f(x,f(f(y,z),f(z,f(f(x,x),u))))) = z.
f(f(f(x,z),z),f(x,f(f(z,y),f(z,f(u,f(x,x)))))) = z.
f(f(f(x,z),z),f(x,f(f(y,z),f(z,f(u,f(x,x)))))) = z.
f(f(x,z),f(f(f(f(z,x),z),f(y,z)),f(f(z,z),u))) = z.
f(f(x,z),f(f(f(f(x,z),z),f(y,z)),f(f(z,z),u))) = z.
f(f(x,z),f(f(f(z,f(z,x)),f(y,z)),f(f(z,z),u))) = z.
f(f(x,z),f(f(f(z,f(x,z)),f(y,z)),f(f(z,z),u))) = z.
f(f(x,z),f(f(f(z,z),y),f(f(f(z,x),z),f(z,u)))) = z.
f(f(x,z),f(f(f(z,z),y),f(f(f(x,z),z),f(z,u)))) = z.
f(f(x,z),f(f(f(z,z),y),f(f(z,f(z,x)),f(z,u)))) = z.
f(f(x,z),f(f(f(z,z),y),f(f(z,f(x,z)),f(z,u)))) = z.
f(f(x,z),f(f(f(z,z),y),f(f(z,u),f(z,f(z,x))))) = z.
prover9-manual-2009-02A/MOL.in 0000644 0001750 0001750 00000000531 10537311223 015130 0 ustar mccune mccune
formulas(assumptions).
x v (y v z) = y v (x v z). % AJ
x v (x ^ y) = x. % B1
x ^ y = (x' v y')'. % DM
x'' = x. % CC
x v x' = y v y'. % ONE
x v (y ^ (x v z)) = x v (z ^ (x v y)). % MOD
end_of_list.
formulas(goals).
x ^ (y v z) = (x ^ y) v (x ^ z).
end_of_list.
prover9-manual-2009-02A/subset_trans_expand.out 0000644 0001750 0001750 00000012365 11151315476 020774 0 ustar mccune mccune ============================== Prover9 ===============================
Prover9 (32) version 2009-02A, February 2009.
Process 15830 was started by mccune on cleo,
Wed Feb 25 12:25:50 2009
The command was "/home/mccune/bin/prover9 -f subset_trans_expand.in".
============================== end of head ===========================
============================== INPUT =================================
% Reading from file subset_trans_expand.in
set(expand_relational_defs).
formulas(assumptions).
(all x all y (subset(x,y) <-> (all z (member(z,x) -> member(z,y))))).
end_of_list.
formulas(goals).
(all x all y all z (subset(x,y) & subset(y,z) -> subset(x,z))).
end_of_list.
============================== end of input ==========================
============================== EXPAND RELATIONAL DEFINITIONS =========
% Relational Definitions:
1 (all x all y (subset(x,y) <-> (all z (member(z,x) -> member(z,y))))). [assumption].
% Formulas Being Expanded:
2 (all x all y all z (subset(x,y) & subset(y,z) -> subset(x,z))). [goal].
============================== end of expand relational definitions ==
============================== PROCESS NON-CLAUSAL FORMULAS ==========
% Formulas that are not ordinary clauses:
3 (all x0 all x1 all x2 ((all z (member(z,x0) -> member(z,x1))) & (all z (member(z,x1) -> member(z,x2))) -> (all z (member(z,x0) -> member(z,x2))))) # label(non_clause) # label(goal). [expand_def(2,1)].
============================== end of process non-clausal formulas ===
============================== PROCESS INITIAL CLAUSES ===============
% Clauses before input processing:
formulas(usable).
end_of_list.
formulas(sos).
-member(x,c1) | member(x,c2). [deny(3)].
-member(x,c2) | member(x,c3). [deny(3)].
member(c4,c1). [deny(3)].
-member(c4,c3). [deny(3)].
end_of_list.
formulas(demodulators).
end_of_list.
============================== PREDICATE ELIMINATION =================
No predicates eliminated.
============================== end predicate elimination =============
Auto_denials: (no changes).
Term ordering decisions:
Predicate symbol precedence: predicate_order([ member ]).
Function symbol precedence: function_order([ c1, c2, c3, c4 ]).
After inverse_order: (no changes).
Unfolding symbols: (none).
Auto_inference settings:
% set(neg_binary_resolution). % (HNE depth_diff=0)
% clear(ordered_res). % (HNE depth_diff=0)
% set(ur_resolution). % (HNE depth_diff=0)
% set(ur_resolution) -> set(pos_ur_resolution).
% set(ur_resolution) -> set(neg_ur_resolution).
Auto_process settings: (no changes).
kept: 4 -member(x,c1) | member(x,c2). [deny(3)].
kept: 5 -member(x,c2) | member(x,c3). [deny(3)].
kept: 6 member(c4,c1). [deny(3)].
kept: 7 -member(c4,c3). [deny(3)].
============================== end of process initial clauses ========
============================== CLAUSES FOR SEARCH ====================
% Clauses after input processing:
formulas(usable).
end_of_list.
formulas(sos).
4 -member(x,c1) | member(x,c2). [deny(3)].
5 -member(x,c2) | member(x,c3). [deny(3)].
6 member(c4,c1). [deny(3)].
7 -member(c4,c3). [deny(3)].
end_of_list.
formulas(demodulators).
end_of_list.
============================== end of clauses for search =============
============================== SEARCH ================================
% Starting search at 0.01 seconds.
given #1 (I,wt=6): 4 -member(x,c1) | member(x,c2). [deny(3)].
given #2 (I,wt=6): 5 -member(x,c2) | member(x,c3). [deny(3)].
given #3 (I,wt=3): 6 member(c4,c1). [deny(3)].
given #4 (I,wt=3): 7 -member(c4,c3). [deny(3)].
============================== PROOF =================================
% Proof 1 at 0.01 (+ 0.00) seconds.
% Length of proof is 10.
% Level of proof is 4.
% Maximum clause weight is 6.
% Given clauses 4.
1 (all x all y (subset(x,y) <-> (all z (member(z,x) -> member(z,y))))) # label(non_clause). [assumption].
2 (all x all y all z (subset(x,y) & subset(y,z) -> subset(x,z))) # label(non_clause). [goal].
3 (all x0 all x1 all x2 ((all z (member(z,x0) -> member(z,x1))) & (all z (member(z,x1) -> member(z,x2))) -> (all z (member(z,x0) -> member(z,x2))))) # label(non_clause) # label(goal). [expand_def(2,1)].
4 -member(x,c1) | member(x,c2). [deny(3)].
5 -member(x,c2) | member(x,c3). [deny(3)].
6 member(c4,c1). [deny(3)].
7 -member(c4,c3). [deny(3)].
8 member(c4,c2). [ur(4,a,6,a)].
9 -member(c4,c2). [resolve(7,a,5,b)].
10 $F. [resolve(9,a,8,a)].
============================== end of proof ==========================
============================== STATISTICS ============================
Given=4. Generated=6. Kept=6. proofs=1.
Usable=4. Sos=1. Demods=0. Limbo=0, Disabled=4. Hints=0.
Kept_by_rule=0, Deleted_by_rule=0.
Forward_subsumed=0. Back_subsumed=0.
Sos_limit_deleted=0. Sos_displaced=0. Sos_removed=0.
New_demodulators=0 (0 lex), Back_demodulated=0. Back_unit_deleted=0.
Demod_attempts=0. Demod_rewrites=0.
Res_instance_prunes=0. Para_instance_prunes=0. Basic_paramod_prunes=0.
Nonunit_fsub_feature_tests=0. Nonunit_bsub_feature_tests=2.
Megabytes=0.03.
User_CPU=0.01, System_CPU=0.00, Wall_clock=0.
============================== end of statistics =====================
============================== end of search =========================
THEOREM PROVED
Exiting with 1 proof.
Process 15830 exit (max_proofs) Wed Feb 25 12:25:50 2009
prover9-manual-2009-02A/more-prep.html 0000644 0001750 0001750 00000011737 11151021064 016751 0 ustar mccune mccune
Prover9 Manual: More Search Prep
If this flag is set, Prover9 looks for
relational definitions
in the assumptions and uses them to rewrite all occurrences of the
defined relations elsewhere in the input, before the start of the search.
The expansion steps are detailed in the output file and appear
in proofs with the justification expand_def.
Relational definitions must be
closed formulas
for example,
formulas(assumptions).
all x all y all z (A(x,y,z) <-> ((x <= y & y <= z) | (z <= y & y <= x))).
end_of_list.
If there are circular definitions, Prover9 will immediately exit
with a fatal error.
This flag eliminates predicate symbols, and its effects overlap
somewhat with the flag
predicate_elim.
Here is a trivial example, using the transitivity-of-subset problem.
This flag should be cleared only in very rare circumstances.
Next Section:
Search Limits
prover9-manual-2009-02A/others.html 0000644 0001750 0001750 00000016705 11151021064 016347 0 ustar mccune mccune
Prover9 Manual: Other LADR Prograns
Prover9 Manual
Version 2009-02A
Other LADR Prograns
The page describes several other programs that have constructed
with the same code base (LADR) as
Prover9,
Prooftrans,
Mace4, and
Interpformat.
When we write that a program takes a "stream" of objects, we mean
that it reads them from the standard input, and the objects are
not enclosed in objects(..) and end_of_list.
When we write that a program takes a "set" of objects, we mean
that the filename containing the objects is an argument to
the program, and the objects are not enclosed in
objects(..) and end_of_list.
When we write that a program takes a "list" of objects, we mean
that the filename containing the objects is an argument to
the program, and the objects are enclosed in
objects(..) and end_of_list.
Given a set of interpretations, a test to perform,
and a stream of formulas, this program outputs the formulas
that pass the test. (If non-clausal formulas with free
variables are given, their universal closures are used and output.)
The accepted tests are
true_in_all, true_in_some,
false_in_all, and false_in_some.
Example: given a set of non-modular orthomodular lattices
and a stream of identities, print the identities that
are false in all of the lattices. This job was used
when searching for modular ortholattice (MOL)
single axioms: any MOL single axiom is false in all non MOLs.
This program takes a set of interpretations and stream of
formulas. For each formula, the interpretations in
which the formula is true are shown, and at the end
the number of formulas true in each interpretation is
shown. (If non-clausal formulas with free
variables are given, their universal closures are used and output.)
Given a set of formulas, a test to perform,
and a stream of interpretations, this program
outputs the interpretations that pass the test.
(If non-clausal formulas with free
variables are given, their universal closures are used.)
The accepted tests are
all_true, some_true,
all_false, and some_false.
Example: from a list of quasigroups, extract the associative-commutaive ones.
The TPTP Problem Library contains
thousands of problems for theorem provers, and the
TPTP Language
is widely used in the community.
LADR has two programs to translate between the LADR and TPTP languages.
These programs are new and experimenal, and they do not support all of the
language features.
TPTP_to_LADR
This program takes a TPTP problem file and produces a bare input file
suitable for input to Prover9 or Mace4. For example,
Some of the TPTP language features that are not yet supported
are comment blocks, system comments, real numbers, natural
numbers as distinct objects, and distinct objects with double quotes.
Some future version of LADR will likely support direct input of TPTP
files to Prover9 and Mace4, without having to invoke a translator.
LADR_to_TPTP
This program takes a Prover9 input file and produces a TPTP problem file.
A difficulty with this kind of translation is that TPTP accepts
a more restriced class of function and predicate symbols. When the
translator sees symbols that are not accepted by TPTP, it introduces
new symbols, and it gives the symbol mapping as comments in the output.
Ordinary TPTP constant, function, and predicate symbols must
start with lower case a-z, and any remaining characters must be
alphanumeric or _ (underscore). That is, they must match the
(Unix-style) regular expression "[a-z][a-zA-Z0-9_]*".
Here is an example that contains several unacceptable symbols.
Instead of introducing new symbols such as tptp0,
you can tell ladr_to_tptp to put single quotes around
unacceptable symbols by using the command-line option -q.
See the following example.
Next Section:
All Options
prover9-manual-2009-02A/output.html 0000644 0001750 0001750 00000034177 11151021064 016406 0 ustar mccune mccune
Prover9 Manual: Output Files
Prover9 Manual
Version 2009-02A
Output Files
Even when Prover9 fails to find a proof, its output file
usually has lots of valuable information about the search.
The output file can suggest many ways of improving the
search for subsequent jobs as in the following examples.
The output shows how equalities are oriented; different
term ordering parameters
may give better or more intuitive orientations.
If Prover9 focused the search on uninteresting clauses
(see the sequence of given clauses), different
inference rules, a different
pick_given_ratio, or a specialized
weighting function
can be used.
If Prover9 ran out of time or memory with a huge sos list
and small usable list (i.e., few given clauses were used),
the sos_limit should be reduced.
Basic Structure of Output Files
Prover9 output files are divided into sections and subsections
so the users (people and programs) can find what they are looking
for. The delimiters are self-explanatory. A few comments about
the sections are given here. For a specific example, see
the output file subset_trans.out.
============================== Prover9 ===============================
Version, date, host computer, command.
============================== end of head ===========================
============================== INPUT =================================
Echo of the input. Everything in this section that is not
in the input is commented with "%", so copy-and-paste can be
done on this section to create a new input file.
============================== end of input ==========================
============================== PROCESS GOALS =========================
The search is always by refutation, and this section shows
how goals are negated in preparation for the search.
============================== end of process goals ==================
============================== PROCESS INITIAL CLAUSES ===============
This section shows the starting clauses (after Skomemization,
if applicable) and then some of what Prover9 does in preparation
for the search. This includes predicate_elim, term ordering
decisions, and auto_inference settings. At this stage, clauses
may be deleted by subsumption and equations may be copied to the
list demodulators. See the flag process_initial_sos.
============================== end of process initial clauses ========
============================== CLAUSES FOR SEARCH ====================
This section shows the clauses just before the start of the
search, that is, just before selection of the first given clause.
============================== end of clauses for search =============
============================== SEARCH ================================
This section typically shows the sequence of given clauses,
and it may also include PROOF and STATISTICS sections.
============================== PROOF =================================
A proof in standard form.
============================== end of proof ==========================
============================== STATISTICS ============================
We encourage users to look at statistics!
============================== end of statistics =====================
============================== end of search =========================
factor(59,b,c) -- factor clause 59 by unifying the second
and third literals.
xx_res(59,b) -- resolve the second literal of clause 59 with
x=x.
propositional -- not used in standard proofs.
instantiate -- not used in standard proofs.
ivy -- not used in standard proofs.
Secondary Steps (each assumes a working clause, which is either the result of a
primary step or a previous secondary step).
rewrite([38(5,R),47(5),59(6,R)]) -- rewriting (demodulation)
with equations
38, 47, then 59; the arguments (5), (5), and (6) identify the positions
of the rewritten subterms (in an obscure way), and the argument R
indicates that the demodulator is used backward (right-to-left).
flip(c) -- the third literal is an equality that has been
flipped by the term ordering. This does not necessarily mean that
the equality is orientable by the primary term ordering, e.g., KBO.
merge(d) -- the fourth literal has been removed because it
was identical to a preceding literal.
unit_del(b,38) -- the second literal has been removed because
it was an instance of the negation clause 38 (which is a unit clause).
xx(b) -- the second literal has been removed because it was
an instance of x!=x.
Standard Proofs
Prover9 proofs may be transformed by separate programs,
e.g., by Prooftrans.
Prover9's actions allow the user to change the search
strategy during the search. For example, after a certain number
of given clauses have been used, the max_weight
can be changed.
Actions can be triggered in two ways:
by statistics, for example, after 100 clauses have been retained, and
when a clause containing an action attribute is used, for example,
when it is used in a proof.
Accepted Actions
The currently accepted actions are exit (which
terminates the search) and a subset of the ordinary flags and parameters.
Author: list the subset here!
Actions Triggered by Statistics
Statistic actions are given as a list of rules trigger -> action
in the input file.
Here are the currently recognized triggers for statistic actions.
given: the number of given clauses that have been processed.
generated: the number of clauses that have been inferred.
kept: the number of clauses that have been inferred and retained.
level: the search level (this applies to breadth-first searches).
The list must start with terms(actions).
and end with end_of_list.
Here is an example list of statistic action rules.
Clause actions occur as attributes on clauses, for example,
A * B != B * A # action(in_proof -> assign(max_weight, 30)).
In this example (which only makes sense if max_proofs > 1),
if the clause occurs in a proof, the action is applied.
The only trigger currently recognized for clause actions is in_proof.
Others will likely be added.
prover9-manual-2009-02A/navbar-version/attributes.html 0000644 0001750 0001750 00000011356 10442157520 022173 0 ustar mccune mccune
Several kinds of attribute can be attached to input clauses
with the # operator, for example,
x * y = y * x # label(commutativity).
x * c != e # answer(x) # label("the denial").
-p(c) | -q(c) # answer("here it is").
a * b != b * a # action(in_proof -> exit) # answer(commutativity).
x * (y * z) = y * (x * z) # bsub_hint_wt(500).
Each attribute has a data type of string, integer, or term.
A string attribute is really just a term attribute that is
a constant. If a string attribute is not a legal constant,
it can be enclosed in double quotes to make it so.
The accepted attributes are shown in the following table.
Name
Type
Inheritable
Purpose
label
string
No
Comment
answer
term
Yes
Record substitutions and what has been proved
action
term
No
Triggers action when clause is used
bsub_hint_add_wt
integer
No
Used for hints
bsub_hint_wt
integer
No
Used for hints
Inheritable attributes are passed from parent to child during most
inference rules.
Label Attributes
Label attributes are simply comments that can be attached to input clauses,
including hint clauses.
Answer Attributes
Answer attributes are essentially answer literals. They are inherited
during application of inference rules, and if they contain
variables, the variables are instantiated by the substitution
used in the inference.
Answer attributes (like all other attributes) contain exactly
one argument. If you wish to record substitutions for more
than one variable, you must use a term that contains all of the
variables, for example, a list, as in the following clause.
-p(c,x,y,z) # answer([x,y,z]).
Action Attributes
Action attributes cause various things to happen when
clauses are used in various ways.
See the section on Actions.
Bsub_hint_wt and Bsub_hint_add_wt Attributes
The hint attributes are attached to hint clauses, and they are used
to override the settings of the corresponding parameters.
That is, if a hint matches
a clause, and if the hint has a bsub_hint_wt attribute, the value
of the attribute is used to calculate the weight of the clause instead
of the ordinary bsub_hint_wt parameter.
prover9-manual-2009-02A/navbar-version/auto.html 0000644 0001750 0001750 00000014302 10442157520 020747 0 ustar mccune mccune
Prover9 Manual: Automatic Modes
Prover9's automatic mode is set by default.
Otter's automatic mode must be explicitly set.
If you simply give Prover9 a set of clauses and/or formulas,
Prover9 will look at the clauses and decide which inference
rules to use. In addition, it will use two default
limits (max_weight and sos_limit)
that, although good in practice, can prevent proofs from being found.
If don't like the inference rules that Prover9 selects,
you can clear the flag auto_inference and select your own rules.
If you wish to remove the limits max_weight and sos_limit,
you can clear the flag auto_limits. If you wish to do
both, you can clear the flag auto. Prover9 output files
show the effects of changing these flags.
FOF (First-Order Formula) reduction is a method of attempting to
simplify a problem by reducing it to an equivalent set of
independent subproblems. A trivial example is to reduce the
conjecture A <-> B to the pair of problems
A -> B and B -> A.
The preceding example is artificial and seems tailor-made for FOF reduction.
Other, more realistic examples can be found in the
standard set of Prover9 examples.
prover9-manual-2009-02A/navbar-version/glossary.html 0000644 0001750 0001750 00000017433 10442157520 021652 0 ustar mccune mccune
This section shows how the conclusion(s) of a conjecture
can be stated in positive form, how one can search for
direct proofs as opposed to bidirectional proofs, and
how multiple conclusions are stated and handled.
Stating Conclusions in Positive Form
In Otter, the conclusions are always stated in negated form.
Prover9 allows the user to state conclusions in positive
form by using the lists clauses(goals) and
formulas(goals).
However, Prover9 always works by refutation, so
the clauses or formulas in the goals lists
are negated as described below, and the
results are appended to the sos clause list
before the search starts.
If there is just one clause in clauses(goals),
the meaning is clear, and the clause is processed by
taking first taking universal closure, then negating.
The formula is then handled exactly as if it had
been input in formulas(sos), that is, by
Skolemizing and transforming to clauses.
If there is just one formula in formulas(goals),
the meaning is clear, and
it is simply negated and then Skolemized as usual.
If there is more than one clause in clauses(goals)
or more than one formula in formulas(goals), the
meaning is not clear. For example, if there are two
clauses in clauses(goals), is the conclusion
the disjunction or the conjunction of those clauses?
What does a list of goal clauses mean if some of them are
non-units or non-positive?
To simplify the meanings of multiple goals, the following
restrictions are in place.
All clauses in clauses(goals) must be positive units.
At most one formula is accepted in formulas(goals).
One cannot input both clauses(goals) and formulas(goals).
To avoid any of these restrictions, one can always
write the conclusions clearly as a single formula for
formulas(goals).
When there are multiple goals in clauses(goals),
should the proofs of the goals be presented together as one proof
or as separate proofs? We have chosen the latter for the simple
reason that if any goal is proved, we wish to have a proof.
Forward or Direct Proofs
This subsection refers to the negative clauses that exist at the start
of the search. These include ones that are input, ones that are
derived from ordinary Skolemization, and those that are derived from
clauses(goals) and formulas(goals).
The following flag restricts the use of negative clauses,
with the aim of finding proofs that are more direct. That
is, proofs that go forward from the hypotheses to the conclusion
rather than proofs that reason backward from the conclusion.
The secondary effect of this flag is that when there are
multiple conclusions, Prover9 will not give more than one
proof of the same conclusion.
Note that the flag restrict_denials can substantially
alter the search, so one must be aware of situations like the
following. One runs a job that finds a quick proof of a single goal;
then a second job is run, containing a second goal and also
assign(max_proofs,2); the first goal may no longer be proved,
because the first proof has bidirectional reasoning which
is not allowed by restrict_denials.
Of course, the option dependency can be undone with
clear(restrict_denials).
Multiple Proofs of the Same Conclusion
If the flag restrict_denials is set, and
if there are multiple denials, then by default, when
a denial is refuted, it is disabled so that it is not
refuted again later in the search. The following flag
allows for multiple refutations using the same denial.
Hint clauses can be used to help guide Prover9's search.
Prover9's input can contain any number of hint lists (which are
simply concatenated by Prover9).
Each list of hint clauses must start with clauses(hints).
and end with end_of_list.
Any clause is acceptable as a hint.
For example (the labels attributes are optional),
clauses(hints).
x ' * (x * y) = y # label(6).
x * (x * y) = y # label(7).
x * (y * (x * y)) = e # label(8).
x ' ' * e = x # label(9).
x ' * e = x # label(10).
x ' = x # label(11).
x * e = x # label(12).
x * (y * x) = y # label(13).
x * y = y * x # label(14).
end_of_list.
Hints are used when selecting given clauses. The mechanism for doing
this is that when a derived clause matches a hint, its weight is
adjusted so that it is selected sooner (or maybe later, if the
hint is for avoiding paths) as the given clause.
A derived clause matches a hint if it subsumes the hint.
If a clause matches more than one hint, the first matching hint
is used.
In Otter, "matching a hint" can mean (depending on the parameter
settings) subsumes, subsumed by, or equivalent to.
These other types of matching may be added to Prover9
if there is any demand for them.
Where do Hints Come From?
Hints frequently consist of proofs, perhaps many, of related theorems.
Bob Veroff developed the concept, installing code for hints
in an early version of Otter, to experiment with his method
of proof sketches
[Veroff-hints,
Veroff-sketches].
In the proof sketches
method, a difficult conjecture is attacked by first proving
several (or many) weakened variants of the conjecture, and
using those proofs as hints to guide searches for a proof
of the original conjecture.
The program Prooftrans, which is distributed
along with Prover9, can be used to extract proofs from a Prover9
output file and transform the proofs to lists of hints suitable
for input to subsequent Prover9 jobs.
An Example
This example consists of three jobs (Author: make up an example):
When a clause matches a hint, the weight of the clause can be adjusted
in two ways: (1) by assigning a fixed weight, or (2) by adding some value
to the ordinary weight. These two methods are determined by the following two
parameters.
Label attributes on hint clauses get special treatment. When a hint containing
a label matches a clause, the label attribute is copied to the clause.
The following flag addresses the situation in which the input contains
sets of equivalent hints. (This situation frequently occurs when the
hints contain many proofs of similar theorems.)
Prover9
is a resolution/paramodulation automated theorem prover
for first-order and equational logic.
Prover9 is a successor of the
Otter Prover
[McCune-Otter33].
Getting Started
Prover9 has a fully automatic mode
in which the user simply
gives it clauses or formulas representing the problem.
See the Section Clauses and Formulas.
An important way to learn about Prover9 is to browse and study the
example input and output files that are available.
Users are encouraged to contribute examples from their own
work with Prover9 (and Mace4).
Related Programs
Several useful programs come bundled with Prover9.
The most important is
Mace4, which looks for finite models and
counterexamples.
Mace4 can help avoid wasting time searching for a proof with Prover9 by
first finding a counterexample or by first helping to debug
logical specifications.
Another useful program is
Prooftrans, which can transform
proofs found by Prover9 in various ways, including producing
more detailed proofs, simplifying the justifications,
renumbering the steps, producing proofs in XML,
and producing proofs for input to other programs.
Waldmeister
is a fast prover for equational logic.
Vampire
has lately been winning the MIX category of
CASC.
Paradox is
an excellent program for finding finite models and counterexamples.
Format Conventions for this Manual
Many parts of this manual are displayed in boxes with different
background colors.
A display like the following indicates part of an input or output file.
formulas(sos).
all x all y (subset(x,y) <-> (all z (member(z,x) -> member(z,y)))).
end_of_list.
formulas(goals).
all x all y all z (subset(x,y) & subset(y,z) -> subset(x,z)).
end_of_list.
A display like the following indicates a job that is
run on a command line, for example, a command to run a Prover9 job.
When a given clause is selected, all of the inference rules
in effect are applied to it. For each inference, one of
the parents is the given clause, and all other parents
must be in the usable list.
Most inference rules distinguish the parents by the roles
they play in the inference, e.g., positive and nonpositive for
binary resolution, nucleus and satellite for hyper rules,
and from and into for paramodulation. The given clause can
play any role in the inference.
After an inference rule generates a new clause,
the clause is processed,
which includes simplification operations such
as demodulation and unit_deletion,
and retention tests, such as max_weight.
Processing also includes several operations
that might be considered inference rules,
such as factor and new_constants.
If the flag ordered_res is set, there
are additional restrictions on both parents: the literal
resolved in the positive parent must be maximal,
and the literal in the nonpositive parent must satisfy
the literal_selection parameter.
If the flags check_res_instances and
ordered_res aren both set, then the ordering
tests described in the preceding paragraphs are applied
after the substitution for the inference has been applied
to the parent clauses.
If the flag ordered_res is set, there
are additional restrictions on both parents: the literal
resolved in the negative parent must be maximal,
and the literal in the nonnegative parent must satisfy
the literal_selection parameter.
If the flags check_res_instances and
ordered_res aren both set, then the ordering
tests described in the preceding paratgraphs are applied
after the substitution for the inference has been applied
to the parent clauses.
If this flag is set and the
from literal
cannot be oriented,
Prover9 applies the substitution for
the inference to the
from literal to determine if the instance can
be oriented. If so, it will not apply the paramodulation
backward (light-to-heavy).
If this flag is clear, paramodulation occurs from
both sides of nonorientedable equality literals.
Prover9 takes its input from one or more (usually one) files.
If there is more than one input file, lists of objects
(clauses, formulas, weighting rules, etc.) cannot be
split across more than one file.
The page Running Prover9
shows how to specify the files in the commands to run Prover9.
The difference between clauses and formulas is a frequent
source of confusion for Prover9 (and Otter) users.
The page Clauses and Formulas
describes the differences.
For now, simply note that clauses and formulas are different
types of objects; either or both can be used to state the
logical specification of the problem.
Comments and Whitespace
Everything from the first % (percent sign) on a line through the
end of the line is treated as a comment and ignored. In particular,
comments are not echoed to the output file. (Clauses can have
label attributes which can serve as
different kind of comment which does appear in the output file.)
Whitespace (spaces, newlines, tabs, etc.) is optional in most
situations. The important exception is that whitespace is
required around some operations in clauses and formulas
(see the page Clauses and Formulas).
A Simple Example
The most basic kind of input file consists of list of clauses named
"sos" representing the negation of the conjecture, as in
the following example.
clauses(sos). % clauses to be placed in the sos list
-man(x) | mortal(x).
man(george).
-mortal(george).
end_of_list.
Prover9 will take the clauses, use its automatic mode to
decide on the inference rules, and then search for a refutation.
The preceding example can also be stated in a positive
form by usine the goals list, as follows.
clauses(sos). % clauses to be placed in the sos list
-man(x) | mortal(x).
man(george).
end_of_list.
clauses(goals). % positive units to be negated and placed in the sos list
mortal(george).
end_of_list.
A third way of stating the conjecture uses formulas instead of clauses.
Note that a clause without variables is also a formula, with the same meaning.
formulas(sos). % formulas to be translated to clauses and placed in the sos list
all x (man(x) -> mortal(x)).
man(george).
end_of_list.
formulas(goals). % formulas to be negated, translated to clauses, placed in sos
mortal(george).
end_of_list.
The searches for the the three preceding inputs should all be similar,
but they are not guaranteed to be identical, because clause order
and symbols may be different.
Types of Input
Prover9 input consists of lists of objects (clauses, formulas, or terms)
and commands.
Lists of Objects
Lists of objects start with a type (clauses, formulas,
or terms) and name (sos, goals, weights, etc.),
and end with end_of_list. The following display show an example
of each type of accepted list, with one object in each list.
clauses(sos). p(x). end_of_list. % heavily used
clauses(goals). p(x). end_of_list. % must be positive units (see Goals)
clauses(usable). p(x). end_of_list. % seldom used
clauses(demodulators). f(x)=x. end_of_list. % seldom used, must be equalities
clauses(hints). p(x). end_of_list. % should be used more often (see Hints)
formulas(sos). all x p(x). end_of_list. % heavily used
formulas(goals). all x p(x). end_of_list. % at most one formula (see Goals)
formulas(usable). all x p(x). end_of_list. % seldom used
terms(weights). weight(a) = 10. end_of_list. % see Weighting
terms(kb_weights). a = 3. end_of_list. % see Term Ordering
terms(actions). given = 100 -> set(print_kept). end_of_list. % see Actions
terms(interpretations). interpretation(2,[],[relation(p,[1])]). end_of_list. % see Semantics
If the input contains morethan one list of a particular type/name, the lists
are simply concatenated by Prover9 as they are read.
Commands
Eight types of command are accepted. Here is an example of each.
op(400, infix_right, [+, --]). % declare parse precedence and type (see Clauses and Formulas)
set(fof_reduction). % set a flag
clear(auto_inference). % clear a flag
assign(sos_limit, 20000). % integer parameter
assign(stats, some). % string parameter
assoc_comm(*). % not currently used
commutative(g). % not currently used
lex([0,1,a,b,f,g,*,+]). % symbol precedence (see Term Ordering)
skolem([a,b,f,g]). % declare symbols to be Skolem function (rarely used)
Order of Commands and Lists of Objects
For the most part, the order of things in the input file(s) is irrelevant.
For example, commands can usually be mixed with lists of objects.
The situations in which order matters are listed here.
The op(precedence, type, symbols) commands must occur
before any clauses or formulas that contain the affected symbols.
Some of the flags and parameters alter other flags and parameters.
The alterations can be undone by placing the appropriate command
after the command that alters. The output file clearly shows
what happens in these cases.
Note that changing the order of clauses or formulas within a list,
changing the order of literals in a clause,
or changing the order of subformulas in a formula
can change the search, occasionally in profound ways.
prover9-manual-2009-02A/navbar-version/install.html 0000644 0001750 0001750 00000005452 10442157520 021453 0 ustar mccune mccune
Prover9 Manual: Installation
Here is a quick example for Unix-like systems, including Linux and Macintosh OS X.
Visit the Prover9 Web page
and download the current version of LADR. The filename should be something
like LADR-June-2006A.tar.gz; make sure that file is in your current
directory. Run the following commands.
% zcat LADR-June-2006A.tar.gz | tar xvf -
% cd LADR-June-2006A
% make all
Prover9, mace4, prooftrans, and several other programs should now
be in the directory LADR-June-2006A/bin. You can either include
that directory in your search path or copy those programs to
some directory that is already in your search path.
Microsoft Windows
Get a new hard drive, install Linux, then see the preceding section.
Just kidding---there is a Windows version. For now, see that the
Prover9 Web page.
prover9-manual-2009-02A/navbar-version/limits.html 0000644 0001750 0001750 00000007744 10442157520 021314 0 ustar mccune mccune
Prover9 Manual: Search Limits
This is a little bit tricky (and sometimes too clever for its own good).
When the sos is half full, it starts being selective about keeping
clauses, and as it fills up, it gradually becomes more selective.
When it is full, it is very selective about keeping clauses.
When it decides to keep a clause, and the sos is already full, the
"worst" clause in sos is deleted to make room for the new clause.
The main loop for inferring and processing clauses
and searching for a proof is sometimes called the given
clause algorithm.
It operates mainly on the sos and usable lists.
While the sos list is not empty:
1. Select a given clause from sos and move it to the usable list;
2. Infer new clauses using the inference rules in effect;
each new clause must have the given clause as one of its
parents and members of the usable list as its other parents;
3. process each new clause;
4. append new clauses that pass the retention tests to the sos list.
end of while loop.
Two Frequently Asked Questions
At some point in the search,
Prover9 has all of the clauses needed to make an important
inference, and one of the potential parents is selected as
the given clause. But Prover9 fails to make the inference.
Why is that?
Why do all parents have to be in the usable list?
The answer to both questions is the same, and it has to do
with redundancy. Assume
clause C can be inferred from clauses
A and B;
both A and B are in the
sos list; and
A is selected first.
According to the algorithm, C is not derived
until B has also been selected.
Otherwise, C would be derived twice from
A and B.
Variations of the Loop
There are two common versions of the given clause algorithm
that differ in how newly inferred clauses are processed, in
particular, what clauses can operate on (rewrite, simplify)
newly generated clauses.
In the Otter loop, which Prover9 uses, clauses in
the sos list can operate on new clauses.
In the Discount loop, clauses in the sos
list (also called the passive list) cannot operate on
new clauses. The tradeoff between the two versions is
straightforward --- the Otter loop spends more time
simplifying new clauses with the possible benefit of
making an important simplification sooner. Some
experimental analysis of the tradeoff has been done
[Voronkov-loop???].
prover9-manual-2009-02A/navbar-version/mace4.html 0000644 0001750 0001750 00000010117 10442157520 020770 0 ustar mccune mccune
The program
Mace4
[McCune-Mace4]
searches for finite models of first-order
and equational statements, the same kind of statement that
Prover9 accepts. If the statement is the denial of
some conjecture, any models found by Mace4 are
counterexamples to the conjecture.
Mace4 can be a valuable complement to Prover9, looking
for counterexamples before (or at the same time as)
using Prover9 to search for a proof. It can also be
used to help debug input clauses and formulas for
Prover9.
For the most part, Mace4 accepts the same input files
as Prover9. If the input file contains commands that
Mace4 does not understand, then the argument "-c"
must be given to tell Mace4 to ignore those commands.
For example, say you've just invented group theory,
and you're wondering if all groups are commutative.
You can run the following two jobs in parallel,
with Prover9 looking for a proof, and Mace4 looking
for a counterexample.
For further information see the Mace4 Web page.
(The PDF manual on the Mace4 Web page is somewhat out of date.)
prover9-manual-2009-02A/navbar-version/manual-index.html 0000644 0001750 0001750 00000003504 10442157520 022363 0 ustar mccune mccune
Flags are Boolean-valued options which can be changed
with the set and clear commands, e.g., set(clocks). set(print_given).
Parms are integer-valued options which can be changed
with the assign command, e.g., assign(max_weight, 30).
Stringparms are string-valued options which can be changed
with the assign command, e.g., assign(order, kbo).
Option Dependencies
Several of the flags and parameters cause other flags and parameters
to be changed. In some cases, that is the only direct effect they have.
For example, if you clear(auto), you will see the following
in the output.
Even when Prover9 fails to find a proof, its output file
usually has lots of valuable information about the search.
The output file can suggest many ways of improving the
search for subsequent jobs as in the following examples.
The output shows how equalities are oriented; different
term ordering parameters
may give better or more intuitive orientations.
If Prover9 focused the search on uninteresting clauses
(see the sequence of given clauses), different
inference rules, a different
pick_given_ratio, or a specialized
weighting function
can be used.
If Prover9 ran out of time or memory with a huge sos list
and small usable list (i.e., few given clauses were used),
the sos_limit should be reduced.
Basic Structure of Output Files
Prover9 output files are divided into sections and subsections
so the users (people and programs) can find what they are looking
for. The delimiters are self-explanatory. A few comments about
the sections are given here. For a specific example, see
the output file subset_trans.out.
============================== Prover9 ===============================
Version, date, host computer, command.
============================== end of head ===========================
============================== INPUT =================================
Echo of the input. Everything in this section that is not
in the input is commented with "%", so copy-and-paste can be
done on this section to create a new input file.
============================== end of input ==========================
============================== PROCESS GOALS =========================
The search is always by refutation, and this section shows
how goals are negated in preparation for the search.
============================== end of process goals ==================
============================== PROCESS INITIAL CLAUSES ===============
This section shows the starting clauses (after Skomemization,
if applicable) and then some of what Prover9 does in preparation
for the search. This includes predicate_elim, term ordering
decisions, and auto_inference settings. At this stage, clauses
may be deleted by subsumption and equations may be copied to the
list demodulators. See the flag process_initial_sos.
============================== end of process initial clauses ========
============================== CLAUSES FOR SEARCH ====================
This section shows the clauses just before the start of the
search, that is, just before selection of the first given clause.
============================== end of clauses for search =============
============================== SEARCH ================================
This section typically shows the sequence of given clauses,
and it may also include PROOF and STATISTICS sections.
============================== PROOF =================================
A proof in standard form.
============================== end of proof ==========================
============================== STATISTICS ============================
We encourage users to look at statistics!
============================== end of statistics =====================
============================== end of search =========================
factor(59,b,c) -- factor clause 59 by unifying the second
and third literals.
xx_res(59,b) -- resolve the second literal of clause 59 with
x=x.
propositional -- not used in standard proofs.
instantiate -- not used in standard proofs.
ivy -- not used in standard proofs.
Secondary Steps (each assumes a working clause, which is either the result of a
primary step or a previous secondary step).
demod(38(5,R),47(5),59(6,R)) -- demodulation with clauses
38, 47, then 59; the arguments (5), (5), and (6) identify the positions
of the rewritten subterms (in an obscure way), and the argument R
indicates that the demodulator is used backward (right-to-left).
flip(c) -- the third literal is an equality that has been
flipped by the term ordering. This does not necessarily mean that
the equality is orientable by the primary term ordering, e.g., KBO.
merge(d) -- the fourth literal has been removed because it
was identical to a preceding literal.
unit_del(b,38) -- the second literal has been removed because
it was an instance of the negation clause 38 (which is a unit clause).
xx(b) -- the second literal has been removed because it was
an instance of x!=x.
Standard Proofs
Prover9 proofs may be transformed by separate programs,
e.g., by Prooftrans.
Processing of inferred clauses is separated into two
stages: (1) simplifying the clause and deciding whether
to keep it, and if it is kept, (2) using the clause to
operate on other clauses.
Processing Initial Clauses
Initial clauses in the sos list are processed,
for the most part, as if they were derived by some inference
rule. This process helps to ensure that Prover9's working set
of clauses starts out in a good state, in particular, that
no clause subsumes another, and that all clauses are simplified
according the the working set of demodulators.
Note the following exceptions.
The main exceptions to processing initial clauses is that
the parameters
max_literals,
max_vars, and
max_weight
are not applied.
All processing of initial sos clauses can be disabled
by clearing the flag
process_initial_sos.
Clauses in the initial usable list are never processed.
If there is an initial demodulators list,
the clauses therein will be checked.
If an equation is orientable but backward,
it will be flipped, and a warning message will be printed.
Otherwise, it must satisfy all of the ordinary constraints
on demodulators.
Having an initial demodulators list is useful,
along with clearing the flag
back_demod,
if the user wishes to have a set of demodulators that is fixed throughout
the search.
Processing Denials
If the flag restrict_denials has been set,
initial negative sos clauses are moved to
the special list denials.
Processing of clauses in the denials list
is restricted to simplification, and after processing,
clauses are replaced in the denials list.
The options back_demod and
back_unit_deletion
are applied to clauses in the denials list;
in fact, these operations are often the keys to the
success of the denials list.
Algorithms for Processing Clauses
Processing initial and inferred clauses.
Start with clause c:
1. Simplify c:
1a. demodulate
1b. orient equalities
1c. simplify literals
1d. merge identical literals
1e. unit_deletion
1f. cac_redundancy
2. max_literals check
3. max_vars check
4. safe_unit_conflict check
5. max_weight check
6. subsumption check (forward)
7. assign an ID and keep the clause
8. unsafe unit conflict check
9. check if the clause should be a demodulator
---- (the following steps are delayed until finished with the given clause) ---
15. factor c
16. apply new_constants to c
17. apply back_subsume with c
18. apply back_demod with c
19. apply back_unit_deletion with c
20. move c to the sos list
If an equation is added to demodulators,
Then each clause in usable or sos
that can be rewritten with the equation is copied
and deleted, then the copy is treated as if it were
generated by an inference rule. In particular,
it will be processed, including demodulation, which
will apply the new demodulator.
Clauses in denials will also be back
demodulated and reprocessed, but if they
are kept, they will be placed back in denials
instead of in sos.
This parameter is a limit on the flag lex_dep_demod.
A non-orientable equation cannot become a demodulator
if it has more than n symbols. (The equation (x*y)*z=x*(y*z) has 11 symbols.)
If n = -1, there is no limit.
When Prover9 proves a theorem, it sends the proof to its output
file in a standard form. The standard form contains, for each step,
justifications
with enough detail to reconstruct or check the
proof without any search.
An Exception: Prover9 proofs start with clauses. If the
theorem was given to Prover9 as (non-clausal) formulas,
the original formulas and the clausification steps are not
included in the printed proofs; the proofs start with the
clauses produced by clausification, and those clauses have
the justification "clausify" instead of "input". See the
proof in following example
Prooftrans can extract proofs from Prover9 output files
and transform them in various ways, including the following.
No transformation,
renumber steps,
simplify justifications,
expand all steps, turning secondary justifications into explicit steps,
produce proofs in XML,
produce proofs for checking by the IVY proof checker, and
produce hints for guiding subsequent searches.
Prooftrans is part of the LADR/Prover9/Mace4 package. When
the package is installed, the Prooftrans program should be
in the same directory as Prover9 and Mace4.
Using Prooftrans
The Prover9 output file containing the proof(s) is usually given to
Prooftrans with the argument "-f <filename>".
If there is no "-f <filename>" argument, Prooftrans
takes its input from the standard input.
The arguments that tell Prooftrans what to do with the proof(s)
are described in the following sections, using the output
file subset_trans.out
as a running example.
If there is more than one proof in the file, the transformations
will be applied to each proof. The hints transformation
collects all of the clauses in the proof(s) into one list of
hints. The other transformations produce one proof for each
proof in the input file.
Here is a synopsis of the Prooftrans command; the arguments in
square brackets are optional.
Note that more than one transformation can be applied in several cases.
Unfortunately, the output of Prooftrans usually cannot be used
as the input to another Prooftrans job, because Prooftrans
expects its input to have specific keywords and standard-form proofs.
No Transformation
If no additional argument is given, Prooftrans simply extracts
the proof from the Prover9 output file.
The argument renumber tells Prooftrans to renumber the
steps of each proof consecutively, starting with step 1.
The expand, parents_only, and xml
transformations can be used with the renumber transformation.
The argument parents_only tells Prooftrans list only
the parents in the justifications, not the details about inference
rules or positions.
The expand and renumber transformations can be
used with the parents_only transformation.
Note that when a step is expanded (step 22 in this example), the
new steps are identified by appending 'A', 'B', etc. to the number
of the original step.
The renumber, parents_only, and hints
transformations can be used with the expand transformation.
XML Proofs
The options xml or XML tell Prooftrans to
produce proofs in XML. The options expand and
renumber can be used with the XML transformation.
The preceding output is displayed by your browser not as XML, but as
some transformation of the XML, because the XML refers to an XML stylesheet,
telling the browser how to transform the XML into HTML.
To see the XML source, click "View -> Page Source" (or something like that) in your
browser while viewing the proof.
Ivy proofs have a only 5 types of step:
input,
propositional,
new_symbol,
flip,
instantiate,
resolve, and
paramod.
The resolve and paramod do not involve unification;
instances are generated first as separate steps, and then
resolve or paramod are applied to identical
atomic formulas or terms.
The Ivy proof checker cannot check steps justified by new_symbol.
Proofs to Hints
The option hints tells Prooftrans to
take all of the proofs in the file and produce
one list of hints that can be given to Prover9
to guide subsequent searches for related
conjectures.
If there is more than one proof in the file, the proofs
will probably share many steps. The list of hints
that Prooftrans produces will be the union of the
steps in the proofs; that is, the duplicate steps
will be removed.
The expand transformation can be used with the
hints transformation.
Note that the hints clauses that are produced have label attributes
consisting of a unique integer identifiers. A string, say "job8" can be
prepended to each identifier with the arguments -label "job8"
as in the following example.
The standard way of running Prover9 is to (1) prepare an input file
containing the logical specification of a conjecture and the
search parameters, (2) issue a command that runs Prover9 on the
input file and produces an output file, (3) look at the output, and
(4) maybe run Prover9 again with different search parameters.
A graphical user interface (GUI) for Prover9 is under development,
but it is not described in this manual.
Nearly all of the information in this manual applies also
when using the GUI.
An Input File
Here is an input file; assume it is named subset_trans.in.
(Use a plain text editor, not a word processor, to create input files.)
formulas(sos).
all x all y (subset(x,y) <-> (all z (member(z,x) -> member(z,y)))).
end_of_list.
formulas(goals).
all x all y all z (subset(x,y) & subset(y,z) -> subset(x,z)).
end_of_list.
A Basic Prover9 Command
Here is a command to run Prover9 on the preceding file and
send the output to a file called subset_trans.out.
All arguments after the "-f" are taken as input filenames,
and there can be as many as you like.
When multiple filnames are given on the command line,
a list of objects (clauses, formulas, or terms)
cannot be split across more than one file.
Time Limit on the Command Line
Prover9 also accepts a time limit, in seconds, on the command line.
The following command limits the job to about 10 seconds.
If "-t" and "-f" are both in the command, the "-t" must occur first.
Getting Statistics During the Search
This section applies to Unix-like systems only.
If a Prover9 process is running in the background, one can tell it
to send search statistics (without killing the job) to the output file
sending a "USR1" signal to the process. For example,
% prover9 -f p3a.in > p3a.outb &
[1] 31613
% kill -USR1 31613
A report (17.75 seconds) has been sent to the output.
Calling Prover9 From Another Program
If Prover9 is called from another program (e.g., a shell script,
a Perl script, or a Python script), Prover9's exit codes can
tell the other program the reason Prover9 terminates. The following
table shows the exit codes.
Exit Code
Reason for Termination
0 (MAX_PROOFS)
The specified number of proofs (max_proofs) was found.
1 (FATAL)
A fatal error occurred (user's syntax error or Prover9's bug).
2 (SOS_EMPTY)
Prover9 ran out of things to do (sos list exhausted).
3 (MAX_MEGS)
The max_megs (memory limit) parameter was exceeded.
The calling program will probably want to look in Prover9's output,
for example, to extract a proof. See the page on
Prover9 output files.
prover9-manual-2009-02A/navbar-version/sed.navbar 0000644 0001750 0001750 00000003432 10441320642 021055 0 ustar mccune mccune # insert new stuff
/-- Site navigation menu --/i\
\
\
\
\
# get rid of old stuff
/-- Site navigation menu --/,/-- Main content --/d
prover9-manual-2009-02A/navbar-version/select.html 0000644 0001750 0001750 00000015153 10442157520 021263 0 ustar mccune mccune
Prover9 Manual: Selecting the Given Clause
At each iteration of the main loop,
Prover9 selects a given clause from the sos list,
moves it to the usable list, and makes inferences
from it and other clauses in the usable list.
A basic way to select the given clause is to always select
the lightest clause in sos.
Otter has the ability to mix two methods of selecting
the given clause in a ratio determined by a parameter ---
selecting the lightest clause and selecting the oldest
clause. This method adds a breadth-first component
to the search. See the pick_given_ratio parameter
below.
Prover9 uses three components, dividing the "lightest"
component into two components based on semantics.
The following options are used.
The true/false distinction is determined by a set of interpretations.
The default interpretation is that non-negative clauses are
true, and negative clauses are false. To use explicit interpretations,
see the section on semantic guidance.
Under the default interpretation, for example, if
age_part = 1,
true_part = 2, and
false_part = 3,
given clauses will be selected in a cycle of size six: one clause
by lowest ID, then two clauses because they are the lightest
non-negative (i.e., true) clauses, then three clauses because they are the
lightest negative (i.e., false) clauses. And so on.
Anomalies:
If one of false_part and true_part is 0 and the other is not,
the false/true distinction disappears,
and selection for that part is simply by weight.
If it is time to select a false clause, and none is available,
a true clause is selected instead (and vice versa).
That is, we don't skip the selection of the
false clause; we substitute a true one.
Prover9 has a method of using finite interpretations
to guide the search for a proof; in particular, to
help select the given clause.
To use semantic guidance the user gives one
or more interpretations along with the ordinary
Prover9 input. All clauses (input and derived) that are eligible to be
selected as given clauses are evaluated in the interpretations.
If a clause is false in any of the interpretations, it is
marked as "false" and given the attribute label(false);
if it is true in all of the interpretations, it is marked as "true".
(There is an exception: see the parameter
eval_limit
below.)
If a clause being evaluated contains a symbol that is
not in an interpretation, a warning message is given, and
the clause receives the value "true".
When selecting the given clause,
Prover9 always uses the parameters
age_part,
true_part,and
false_part,
as described on the page
Selecting the Given Clause.
With semantic guidance (explicit interpretations), the
"true_part" and "false_part" refer simply to clauses marked as
"true" and "false" with respect to the interpretations.
Format of Interpretations for Semantic Guidance
The interpretations are finite and must be in the format
produced by Mace4. They must
appear in a list that starts with terms(interpretations).
and ends with and_of_list. The following example
is a lattice in terms of the meet and join operations.
The interpretation is the only additional input needed to give
semantic guidance.
The default values of the parameters
age_part,
true_part,
false_part, and
eval_limit,
work well for this job (and many others).
The interpretation does not contain Skolem constants that appear in
the denial, and warning messages are given when Prover9 attempts
to evaluate clauses containing those Skolem constants.
(They receive the value "true".)
One of the input clauses is assigned the attribute
label(false)., because it is false in the interpretation.
The "false" given clauses (#12, #13, #17, #18, #22, #23, ...)
are mostly heavier than the "true" given clauses, showing that they
would likely not enter the search at such an early stage without
semantic guidance.
At given clause #138, there are no more false clauses to select;
and then several more are inferred and given near the end of the search,
leading to a proof.
This job takes about 11 seconds. A similar job without
semantic guidance takes about 25 minutes to find a proof.
Advice on Selecting Interpretations
If the conjecture formulates naturally as
theory, hypotheses -> conclusion,
a good first step is to try the smallest model of the theory
in which the hypothesis and conclusion are both false.
The preceding example has that form, and
the interpretation used in the that example
can be easily found with the following Mace4 job.
with no obvious hypothesis, one can try to slightly weaken the theory
in some way that relates to the conclusion,
and use a model of the weakened theory in which the conclusion is
false.
Options for Semantic Guidance
Aside from the parameters
age_part,
true_part,and
false_part,
which used regardless of whether semantic guidance is in effect,
there is just one option,
eval_limit,
to control semantic guidance.
If an interpretation is large, or if a clause being
evaluated has many variables, evaluation can take too long,
because it must consider each instance of the clause over
the domain of the interpretation. That is if an interpretation
has size d, and a clause has v variables, evaluation
has to consider dv instances of the clause to
determine that it is true.
The following parameter
causes large evaluations to be skipped.
The Glossary Page contains definitions
of term, atomic formula, literal, clause,
and formula from a logical point of view. This page contains
descriptions of how those kinds of things are parsed and printed,
and we refer to them collectively as objects.
The Difference Between Clauses and Formulas
When speaking about formulas in Prover9 input, we mean
a restricted kind of first-order formula in which all variables are
explicitly quantified; that is, closed formulas.
Variables in clauses are not explicitly quantified,
so clauses with variables are not Prover9 formulas.
The distinction between clauses and formulas is a frequent source
of confusion for Prover9 (and Otter) users. When writing
logical specifications for Prover9, we urge users to be careful,
because clauses go in one kind of list, and formulas go into another.
Here are the important points.
Formulas can have any of the logic connectives, and all variables
are explicitly quantified. Formulas go into lists that
start with formulas(list_name).
Clauses are simple disjunctions in which all variables are
implicitly universally quantified.
Clauses go into lists that
start with clauses(list_name).
Clauses without variables are also formulas, so they
can go into either kind of list. (An exception: clauses can
have attributes, and formulas cannot.)
Because variables in clauses are not explicitly quantified,
a rule is needed for distinguishing variables from constants
in clauses (see terms below). No such rule is needed for formulas.
Prover9's inference rules operate on clauses. If formulas are input,
Prover9 immediately translates them clauses by NNF, Skolemization,
and CNF conversions.
Parsing and Printing Objects
The prefix standard form of an object with an n-ary symbol, say f,
at the root is
f( argument_1, ..., argument_n )
Whitespace (spaces, tabs, newline, etc.) is accepted anywhere
except within symbols.
Prover9 will accept any term, clause, or formula written
prefix standard form. However, clauses, formulas, and
many terms can be written in more convenient ways, for example,
"a=b | a!=c'" instead of "|(=(a,b),-(=(a,'(c))))".
Prover9 uses a general mechanism in which binary and unary symbols
can have special parsing properties such as "infix",
"infix-right-associated", "postfix". In addition, each of
those symbols has a precedence so that many parentheses
can be omitted. (The mechanism is similar to those used by
most Prolog systems.)
Many symbols have built-in parsing properties
(see the table below),
and the user can declare parsing properties for
other symbols with the "op" command.
Clauses and formulas make extensive use of the built-in
parsing properties for the equality relation and the logic connectives.
Instead of first presenting the general mechanism,
we will present the syntax for clauses and formulas
under the assumption of the built-in parsing properties.
The general mechanism is described below in the
section Infix, Prefix, and Postfix Declarations.
Symbols
Symbols include variables, constants, function symbols, predicate symbols,
logic connectives. Symbols do not include parentheses or commas.
Prover9 recognizes several kinds of symbol.
An ordinary symbol is a maximal string made from the
characters a-z, A-Z, 0-9, $, and _.
A special symbol is a maximal string made from
characters in the set
{+-*/\^<>=`~?@&|!#';}.
A quoted symbol is any string enclosed in double quotes.
The empty list symbol is []. This is a special case.
The reason for separating ordinary and special symbols is so that
objects like a+b; that is, +(a,b),
can be written without any whitespace around the +.
Objects (terms, clauses, and formulas) are constructed from
symbols, parentheses, and commas.
Overloaded Symbols
In most cases, symbol overloading is not allowed. For example
a symbol cannot be both a function symbol and a predicate symbol,
or both a constant and a binary function symbol. There
are a few exceptions.
The logic connectives can also be used as function or
predicate symbols of the same arity. For example,
- is typically used as unary arithmetic minus
well as for logical negation.
The symbol | is used as a delimiter in the Prolog-style
list notation as well as disjunction in clauses and formulas.
Prover9 is much more strict about overloading symbols than Otter is.
In the context of a clause, a rule is needed for distinguishing
variables from constants, because variables do not have explicit
quantifiers.
The default rule is that a symbol is a variable iff it starts with
(lower case) 'u' through 'z'.
(Setting the flag prolog_style_variables
changes the rule so that symbols starting with upper case letters
are variables.)
As a special case, Prolog-style list notation can be used
to write terms that represent lists.
Term
Internal Representation
What it Is
[]
$nil
the empty list
[a,b,c]
$cons(a,$cons(b,$cons(c,$nil)))
list of three objects
[a|b]
$cons(a,b)
first, rest
[a,b|c]
$cons(a,$cons(b,c))
first, second, rest
Lists are frequently used in Prover9 commands such as the "lex" command,
and they are sometimes also used in clauses and formulas.
Atomic Formulas
Equality is a built-in special case.
The binary predicate symbol =
is usually written as an infix relation.
The binary symbol != is an abbreviation for "not equal";
that is, the formula a!=b stands for -(a=b),
or more precisely, -(=(a,b)).
From the semantics point of view,
the binary predicate symbol =
is the one and only equality symbol for the inference
rules that use equality.
Clauses
The disjunction symbol is |, and the negation symbol is -.
If the negation symbol follows the disjunction symbol, some whitespace
must separate them; otherwise |- would be parsed as one symbol.
The disjunction symbol has higher precedence than the equality symbol,
so equations in clauses do not need parentheses. Every clause ends
with a period.
Examples of clauses with minimum whitespace follow (Prover9 adds some
extra space when printing clauses).
When writing formulas, the built-in parsing declarations
allow many parentheses to be omitted. For example, the following two formulas
are really the same formula.
formulas(sos).
all x all y (p <-> -q | r & -s) .
(all x (all y (p <-> ((-q) | (r & (-s)))))).
end_of_list.
For Prover9 formulas, each quantified variable must have its own
quantifier; Otter allows quantifiers to be omitted in a sequence
of quantified variables with the same quantifier. For example,
Otter allows (all x y z p(x,y,z)), and Prover9 requires
(all x all y all z p(x,y,z)).
Several symbols are understood by Prover9 as having special
parsing properties that determine how terms involving those
symbols can be arranged.
In addition, the user can declare additional symbols to have special
parsing properties.
Parsing Declarations
The "op" command is used to declare parse types and precedences.
op( precedence, type, symbols(s) ). % declare parse type and precedence
1 ≤ precedence ≤ 998.
type is one of
{ infix, infix_left, infix_right, prefix, prefix_paren, postfix, postfix_paren, clear }.
symbol(s) is either a symbol or a list of symbols.
The following table shows an example of each type of parsing
property (and ignores precedence).
Type
Example
Standard Prefix
Comment
infix
a*(b*c)
*(a,*(b,c))
infix_left
a*b*c
*(*(a,b),c)
infix_right
a*b*c
*(a,*(b,c))
prefix
- -p
-(-(p))
space required in - -p
prefix_paren
-(-p)
-(-(p))
postfix
a' '
'('(a))
space required in a' '
postfix_paren
(a')'
'('(a))
clear
*(a,b)
*(a,b)
takes away parsing properties
Higher precedence means closer to the root of the object,
and lower precedence means the the symbol binds more closely.
For example, assume that the following declarations are in effect.
op(790, infix_right, | ). % disjunction in formulas or clauses
op(780, infix_right, & ). % conjunction in formulas
Then the object a & b | c is an abbreviation for (a & b) | c.
The built-in parsing declarations are shown in the following box.
The ones with comments have built-in meanings;
the others are for general use as function or predicate symbols.
Changing prolog_style_variables after some clauses
have already been read file is allowed, but strongly
discouraged. In such situations, Prover9 can print a clause
P(A,A) in which the first A is a constant and
the second is a variable. Prover9 will (happily and correctly)
make deductions with clauses like that, but the user will go crazy.
Prover9's term ordering procedures and options are simpler than
Otter's, but somewhat less flexible.
We recommend that those who use Otter's "ad hoc" ordering try
Prover9's KBO ordering.
Prover9 has available several methods for comparing terms.
(Although
atomic formulas,
literals, and
clauses are not,
strictly speaking,
terms,
the term orderings we
write about here apply to those objects as well.)
The term orderings are partial (and sometimes total on ground terms),
and they are used in two ways.
To orient equalities (positive and negative). If one side of the
equality is greater than the other, the greater side is placed on the
left-hand side, and the equality is marked as oriented.
To decide which literals in clauses are admissible
for application of inference rules. Several of the resolution and
paramodulation rules require that some of the literals be
maximal in their clause.
For many problems, especially those involving equality,
a good term ordering can determine the difference between
success and failure.
The default settings work well in many cases, but many difficult
problems require adjustments to the term ordering.
The primary choice (via parameter order)
is type of ordering: LPO, RPO, or KBO.
Each of those types uses a symbol precedence (see the
lex command), and KBO
also uses a symbol weighting function (see the
terms(kb_weights) command).
In addition, the options
eq_defs and
inverse_order
cause changes to the term ordering.
The symbol precedence is is a total order on function and
predicate symbols (including constants). The symbol weighting
function maps symbols to nonnegative integers.
LPO (Lexicographic Path Ordering). The term ordering is determined
entirely by the symbol precedence. It is total on ground terms.
RPO (Recursive Path Ordering). The term ordering is determined
entirely by the symbol precedence. It is not necessarily total
on ground terms, because the order of subterms is not considered.
KBO (Knuth-Bendix Ordering). This ordering uses a weighting
function on symbols as well as the symbol precedence. The
weighting function is used first, and the symbol precedence
breaks ties. It is total on ground terms.
KBO is perhaps the most natural of the three,
because it it based on weights of symbols, but it is more cumbersome
to specify because it is determined both by the symbol weights and
by the symbol precedence. However, if one of the two terms being
compared has more occurrences of a variable, it cannot be smaller.
For example, the distributivity equation cannot be oriented so that
it distributes (expands) terms.
LPO is perhaps the most powerful of the three, because it can usually
orient more equations. However, it allows rewrite rules that
expand terms in explosive ways, for example (this is from a real problem),
(x * y) * z rewrites to E * (x * (E * (x * (E * (y * (E * (x * (E * (x * (E * z))))))))))
RPO is perhaps the least useful of the three, because it is not necessarily
total on ground terms. That is, not all ground equations can be oriented.
Also, see the sections on
demodulation options and on
inference rules.
The reasonable choice is usually between LPO (the default) and KBO.
For many problems, either one is good. The main reason LPO is the
the default is that it is a bit faster than KBO.
If this flag is set, if there is no
lex command
(which defines the symbol precedence), and if the term ordering is
LPO or RPO, then Prover9
will attempt to adjust the default symbol precedence if there are any
input equations that specify an inverse operation. For example,
if f(x,g(x)) = c is input, g will be placed after
f in the precedence. This allows an equation such as
g(f(x,y)) = f(g(y),g(x)) to be oriented as shown for
demodulation and paramodulation. If this flag is set, the
PROCESS INPUT section of the output file shows how
the flag changes the symbol precedence.
Prover9's weighting function maps clauses to integers, and
it is used primarily for two purposes:
selecting the given clause, and
discarding inferred clauses (with the parameter max_weight).
Otter accepts two weighting functions, one for selecting the
given clause, and the other for discarding inferred clauses.
Prover9 always uses the same weighting function for both
purposes.
In Otter's weighting rules, a variable matches any variable
and only variables. The role is similar to the anonymous variables "_"
in Prover9's weighting rules.
Prover9 does not (yet) have anything analogous to Otter's $DOTS weighting feature.
Default Weights
The default weight of a clause is its symbol count,
excluding commas, parentheses, negation symbols, and disjunction symbols.
That is,
the default weight of a constant or variable is 1,
the default weight of a term or atomic formula is one more
than the sum of the weights of its arguments,
the default weight of a literal is the weight of its atomic formula,
the default weight of a clause is the sum of the weights of its literals.
Weighting Rules
The weighting function can be modified by giving a list of rules
in the input file. The list must start with terms(weights).
and end with end_of_list.
Here is an example.
terms(weights).
weight(a) = 3. % the weight of the constant a is 3
weight(f(a,x) = 5 * weight(x). % weight( f(a,term) ) = 5 * weight( term )
weight(f(a,_) = -1. % _ matches any variable
weight(x | y) = 2 + (weight(x) + weight(y)). % add 2 for each "or" symbol
end_of_list.
Here is a summary of the weighting language.
Each weighting rule is an equation.
The left-hand side of the rule must be weight(pattern).
A rule applies to a term if its pattern matches the term in the ordinary sense of
demodulation or term rewriting. An exception is that the
symbol "_" matches any variable.
The right-hand side of a rule consists of an integer-arithmetic
expression applied to weight(...) terms.
When applying a rule, the substitution of the pattern match
is applied to the the weight(...) terms, which are
then weighed recursively, and then the integer expression is
evaluated to compute the weight of the term.
The accepted integer operations are
binary: {+, *, /, min, max}
unary: {-, depth}
The rules are parsed with the ordinary term-parsing code,
so (unless the user as included an op command
to change the parsing rules), the arithmetic expressions
must be fully parenthesized, e.g., a + (b + c).
Weighting rules are applied to a clause as follows.
The clause is weighed top-down. That is, a term is weighed
before its subterms are weighed.
When weighing a term, the first rule that matches is applied.
If no rule matches, the weight of the term is more more than
the sum of the weights of its arguments.
prover9-manual-2009-02A/non-MOL-OML.interps 0000644 0001750 0001750 00000032251 10445536762 017446 0 ustar mccune mccune % These are all of the nonmodular OMLs up through size 16.
interpretation(10, [], [
function(c(_), [1,0,5,6,7,2,3,4,9,8]),
function(v(_,_), [0,1,2,3,4,5,6,7,8,9,1,1,1,1,1,1,1,1,1,1,2,1,2,1,1,1,1,2,1,2,3,1,1,3,1,1,1,1,1,1,4,1,1,1,4,4,1,1,1,4,5,1,1,1,4,5,1,8,8,4,6,1,1,1,1,1,6,1,1,1,7,1,2,1,1,8,1,7,8,2,8,1,1,1,1,8,1,8,8,1,9,1,2,1,4,4,1,2,1,9]),
function(^(_,_), [0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,0,2,2,0,9,0,0,7,7,9,0,3,0,3,0,0,0,0,0,0,0,4,9,0,4,5,0,0,5,9,0,5,0,0,5,5,0,0,5,0,0,6,0,0,0,0,6,0,0,0,0,7,7,0,0,0,0,7,7,0,0,8,7,0,5,5,0,7,8,0,0,9,9,0,9,0,0,0,0,9]),
function(f(_,_), [1,1,1,1,1,1,1,1,1,1,1,0,5,6,7,2,3,4,9,8,1,5,5,1,8,1,1,4,4,8,1,6,1,6,1,1,1,1,1,1,1,7,8,1,7,2,1,1,2,8,1,2,1,1,2,2,1,1,2,1,1,3,1,1,1,1,3,1,1,1,1,4,4,1,1,1,1,4,4,1,1,9,4,1,2,2,1,4,9,1,1,8,8,1,8,1,1,1,1,8])]).
% isofilter: input=2, kept=1, checks=1, perms=5, 0.02 seconds.
interpretation(12, [], [
function(c(_), [1,0,5,6,7,2,3,4,9,8,11,10]),
function(v(_,_), [0,1,2,3,4,5,6,7,8,9,10,11,1,1,1,1,1,1,1,1,1,1,1,1,2,1,2,1,1,1,1,2,1,2,1,1,3,1,1,3,1,1,1,1,1,1,1,1,4,1,1,1,4,4,1,1,1,4,1,1,5,1,1,1,4,5,1,8,8,4,1,1,6,1,1,1,1,1,6,1,1,1,1,1,7,1,2,1,1,8,1,7,8,2,1,1,8,1,1,1,1,8,1,8,8,1,1,1,9,1,2,1,4,4,1,2,1,9,1,1,10,1,1,1,1,1,1,1,1,1,10,1,11,1,1,1,1,1,1,1,1,1,1,11]),
function(^(_,_), [0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,10,11,0,2,2,0,9,0,0,7,7,9,0,0,0,3,0,3,0,0,0,0,0,0,0,0,0,4,9,0,4,5,0,0,5,9,0,0,0,5,0,0,5,5,0,0,5,0,0,0,0,6,0,0,0,0,6,0,0,0,0,0,0,7,7,0,0,0,0,7,7,0,0,0,0,8,7,0,5,5,0,7,8,0,0,0,0,9,9,0,9,0,0,0,0,9,0,0,0,10,0,0,0,0,0,0,0,0,10,0,0,11,0,0,0,0,0,0,0,0,0,11]),
function(f(_,_), [1,1,1,1,1,1,1,1,1,1,1,1,1,0,5,6,7,2,3,4,9,8,11,10,1,5,5,1,8,1,1,4,4,8,1,1,1,6,1,6,1,1,1,1,1,1,1,1,1,7,8,1,7,2,1,1,2,8,1,1,1,2,1,1,2,2,1,1,2,1,1,1,1,3,1,1,1,1,3,1,1,1,1,1,1,4,4,1,1,1,1,4,4,1,1,1,1,9,4,1,2,2,1,4,9,1,1,1,1,8,8,1,8,1,1,1,1,8,1,1,1,11,1,1,1,1,1,1,1,1,11,1,1,10,1,1,1,1,1,1,1,1,1,10])]).
% isofilter: input=2, kept=1, checks=1, perms=49, 0.03 seconds.
interpretation(14, [], [
function(c(_), [1,0,5,6,7,2,3,4,9,8,11,10,13,12]),
function(v(_,_), [0,1,2,3,4,5,6,7,8,9,10,11,12,13,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,2,1,1,1,1,1,1,2,1,2,1,1,3,1,1,3,1,1,1,1,1,1,1,1,1,1,4,1,1,1,4,1,1,1,1,4,1,1,1,4,5,1,1,1,1,5,1,8,8,10,10,8,1,8,6,1,1,1,1,1,6,1,1,1,1,1,1,1,7,1,1,1,1,8,1,7,8,12,1,8,12,8,8,1,1,1,1,8,1,8,8,1,1,8,1,8,9,1,2,1,4,10,1,12,1,9,10,2,12,4,10,1,1,1,1,10,1,1,1,10,10,1,1,1,11,1,2,1,1,8,1,8,8,2,1,11,1,8,12,1,1,1,1,1,1,12,1,12,1,1,12,1,13,1,1,1,4,8,1,8,8,4,1,8,1,13]),
function(^(_,_), [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,0,2,2,0,9,0,0,0,11,9,9,11,9,0,0,3,0,3,0,0,0,0,0,0,0,0,0,0,0,4,9,0,4,0,0,0,13,9,9,0,9,13,0,5,0,0,0,5,0,0,5,0,5,0,0,0,0,6,0,0,0,0,6,0,0,0,0,0,0,0,0,7,0,0,0,0,0,7,7,0,0,0,7,0,0,8,11,0,13,5,0,7,8,0,5,11,7,13,0,9,9,0,9,0,0,0,0,9,9,0,9,0,0,10,9,0,9,5,0,0,5,9,10,0,9,0,0,11,11,0,0,0,0,0,11,0,0,11,0,0,0,12,9,0,9,0,0,7,7,9,9,0,12,0,0,13,0,0,13,0,0,0,13,0,0,0,0,13]),
function(f(_,_), [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,5,6,7,2,3,4,9,8,11,10,13,12,1,5,5,1,8,1,1,1,10,8,8,10,8,1,1,6,1,6,1,1,1,1,1,1,1,1,1,1,1,7,8,1,7,1,1,1,12,8,8,1,8,12,1,2,1,1,1,2,1,1,2,1,2,1,1,1,1,3,1,1,1,1,3,1,1,1,1,1,1,1,1,4,1,1,1,1,1,4,4,1,1,1,4,1,1,9,10,1,12,2,1,4,9,1,2,10,4,12,1,8,8,1,8,1,1,1,1,8,8,1,8,1,1,11,8,1,8,2,1,1,2,8,11,1,8,1,1,10,10,1,1,1,1,1,10,1,1,10,1,1,1,13,8,1,8,1,1,4,4,8,8,1,13,1,1,12,1,1,12,1,1,1,12,1,1,1,1,12])]).
interpretation(14, [], [
function(c(_), [1,0,5,6,7,2,3,4,9,8,11,10,13,12]),
function(v(_,_), [0,1,2,3,4,5,6,7,8,9,10,11,12,13,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,2,1,1,1,1,2,1,2,1,1,1,1,3,1,1,3,1,1,1,1,1,1,1,1,1,1,4,1,1,1,4,4,1,1,1,4,1,1,1,1,5,1,1,1,4,5,1,8,8,4,1,1,1,1,6,1,1,1,1,1,6,1,1,1,1,1,1,1,7,1,2,1,1,8,1,7,8,2,1,1,1,1,8,1,1,1,1,8,1,8,8,1,1,1,1,1,9,1,2,1,4,4,1,2,1,9,1,1,1,1,10,1,1,1,1,1,1,1,1,1,10,1,1,1,11,1,1,1,1,1,1,1,1,1,1,11,1,1,12,1,1,1,1,1,1,1,1,1,1,1,12,1,13,1,1,1,1,1,1,1,1,1,1,1,1,13]),
function(^(_,_), [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,0,2,2,0,9,0,0,7,7,9,0,0,0,0,0,3,0,3,0,0,0,0,0,0,0,0,0,0,0,4,9,0,4,5,0,0,5,9,0,0,0,0,0,5,0,0,5,5,0,0,5,0,0,0,0,0,0,6,0,0,0,0,6,0,0,0,0,0,0,0,0,7,7,0,0,0,0,7,7,0,0,0,0,0,0,8,7,0,5,5,0,7,8,0,0,0,0,0,0,9,9,0,9,0,0,0,0,9,0,0,0,0,0,10,0,0,0,0,0,0,0,0,10,0,0,0,0,11,0,0,0,0,0,0,0,0,0,11,0,0,0,12,0,0,0,0,0,0,0,0,0,0,12,0,0,13,0,0,0,0,0,0,0,0,0,0,0,13]),
function(f(_,_), [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,5,6,7,2,3,4,9,8,11,10,13,12,1,5,5,1,8,1,1,4,4,8,1,1,1,1,1,6,1,6,1,1,1,1,1,1,1,1,1,1,1,7,8,1,7,2,1,1,2,8,1,1,1,1,1,2,1,1,2,2,1,1,2,1,1,1,1,1,1,3,1,1,1,1,3,1,1,1,1,1,1,1,1,4,4,1,1,1,1,4,4,1,1,1,1,1,1,9,4,1,2,2,1,4,9,1,1,1,1,1,1,8,8,1,8,1,1,1,1,8,1,1,1,1,1,11,1,1,1,1,1,1,1,1,11,1,1,1,1,10,1,1,1,1,1,1,1,1,1,10,1,1,1,13,1,1,1,1,1,1,1,1,1,1,13,1,1,12,1,1,1,1,1,1,1,1,1,1,1,12])]).
interpretation(14, [], [
function(c(_), [1,0,5,6,7,2,3,4,9,8,11,10,13,12]),
function(v(_,_), [0,1,2,3,4,5,6,7,8,9,10,11,12,13,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,2,1,1,1,1,2,1,2,1,1,1,1,3,1,1,3,1,1,1,1,1,1,1,3,1,3,4,1,1,1,4,4,1,1,1,4,1,1,1,1,5,1,1,1,4,5,1,8,8,4,1,1,1,1,6,1,1,1,1,1,6,1,1,1,10,12,12,10,7,1,2,1,1,8,1,7,8,2,1,1,1,1,8,1,1,1,1,8,1,8,8,1,1,1,1,1,9,1,2,1,4,4,1,2,1,9,1,1,1,1,10,1,1,1,1,1,10,1,1,1,10,1,1,10,11,1,1,3,1,1,12,1,1,1,1,11,12,3,12,1,1,1,1,1,12,1,1,1,1,12,12,1,13,1,1,3,1,1,10,1,1,1,10,3,1,13]),
function(^(_,_), [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,0,2,2,0,9,0,0,7,7,9,0,0,0,0,0,3,0,3,0,0,0,0,0,0,13,11,11,13,0,4,9,0,4,5,0,0,5,9,0,0,0,0,0,5,0,0,5,5,0,0,5,0,0,0,0,0,0,6,0,0,0,0,6,0,0,0,6,0,6,0,0,7,7,0,0,0,0,7,7,0,0,0,0,0,0,8,7,0,5,5,0,7,8,0,0,0,0,0,0,9,9,0,9,0,0,0,0,9,0,0,0,0,0,10,0,13,0,0,6,0,0,0,10,0,6,13,0,11,0,11,0,0,0,0,0,0,0,11,11,0,0,12,0,11,0,0,6,0,0,0,6,11,12,0,0,13,0,13,0,0,0,0,0,0,13,0,0,13]),
function(f(_,_), [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,5,6,7,2,3,4,9,8,11,10,13,12,1,5,5,1,8,1,1,4,4,8,1,1,1,1,1,6,1,6,1,1,1,1,1,1,12,10,10,12,1,7,8,1,7,2,1,1,2,8,1,1,1,1,1,2,1,1,2,2,1,1,2,1,1,1,1,1,1,3,1,1,1,1,3,1,1,1,3,1,3,1,1,4,4,1,1,1,1,4,4,1,1,1,1,1,1,9,4,1,2,2,1,4,9,1,1,1,1,1,1,8,8,1,8,1,1,1,1,8,1,1,1,1,1,11,1,12,1,1,3,1,1,1,11,1,3,12,1,10,1,10,1,1,1,1,1,1,1,10,10,1,1,13,1,10,1,1,3,1,1,1,3,10,13,1,1,12,1,12,1,1,1,1,1,1,12,1,1,12])]).
% isofilter: input=23, kept=3, checks=20, perms=38324, 0.52 seconds.
interpretation(16, [], [
function(c(_), [1,0,5,6,7,2,3,4,9,8,11,10,13,12,15,14]),
function(v(_,_), [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,2,1,1,1,1,1,1,2,1,2,1,1,1,1,3,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,4,1,1,1,1,4,1,1,1,4,1,1,5,1,1,1,1,5,1,8,8,10,10,8,1,8,1,1,6,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,7,1,1,1,1,8,1,7,8,12,1,8,12,8,1,1,8,1,1,1,1,8,1,8,8,1,1,8,1,8,1,1,9,1,2,1,4,10,1,12,1,9,10,2,12,4,1,1,10,1,1,1,1,10,1,1,1,10,10,1,1,1,1,1,11,1,2,1,1,8,1,8,8,2,1,11,1,8,1,1,12,1,1,1,1,1,1,12,1,12,1,1,12,1,1,1,13,1,1,1,4,8,1,8,8,4,1,8,1,13,1,1,14,1,1,1,1,1,1,1,1,1,1,1,1,1,14,1,15,1,1,1,1,1,1,1,1,1,1,1,1,1,1,15]),
function(^(_,_), [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0,2,2,0,9,0,0,0,11,9,9,11,9,0,0,0,0,3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,4,9,0,4,0,0,0,13,9,9,0,9,13,0,0,0,5,0,0,0,5,0,0,5,0,5,0,0,0,0,0,0,6,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,7,7,0,0,0,7,0,0,0,0,8,11,0,13,5,0,7,8,0,5,11,7,13,0,0,0,9,9,0,9,0,0,0,0,9,9,0,9,0,0,0,0,10,9,0,9,5,0,0,5,9,10,0,9,0,0,0,0,11,11,0,0,0,0,0,11,0,0,11,0,0,0,0,0,12,9,0,9,0,0,7,7,9,9,0,12,0,0,0,0,13,0,0,13,0,0,0,13,0,0,0,0,13,0,0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,15]),
function(f(_,_), [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,5,6,7,2,3,4,9,8,11,10,13,12,15,14,1,5,5,1,8,1,1,1,10,8,8,10,8,1,1,1,1,6,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,7,8,1,7,1,1,1,12,8,8,1,8,12,1,1,1,2,1,1,1,2,1,1,2,1,2,1,1,1,1,1,1,3,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,4,4,1,1,1,4,1,1,1,1,9,10,1,12,2,1,4,9,1,2,10,4,12,1,1,1,8,8,1,8,1,1,1,1,8,8,1,8,1,1,1,1,11,8,1,8,2,1,1,2,8,11,1,8,1,1,1,1,10,10,1,1,1,1,1,10,1,1,10,1,1,1,1,1,13,8,1,8,1,1,4,4,8,8,1,13,1,1,1,1,12,1,1,12,1,1,1,12,1,1,1,1,12,1,1,1,15,1,1,1,1,1,1,1,1,1,1,1,1,15,1,1,14,1,1,1,1,1,1,1,1,1,1,1,1,1,14])]).
interpretation(16, [], [
function(c(_), [1,0,5,6,7,2,3,4,9,8,11,10,13,12,15,14]),
function(v(_,_), [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,2,1,1,1,1,1,1,2,1,2,1,1,1,1,3,1,1,3,1,1,1,1,1,1,1,1,1,3,1,3,4,1,1,1,4,1,1,1,1,4,1,1,1,4,1,1,5,1,1,1,1,5,1,8,8,10,10,8,1,8,1,1,6,1,1,1,1,1,6,12,1,12,1,1,12,14,14,12,7,1,1,1,1,8,12,7,8,12,1,8,12,8,1,12,8,1,1,1,1,8,1,8,8,1,1,8,1,8,1,1,9,1,2,1,4,10,12,12,1,9,10,2,12,4,1,12,10,1,1,1,1,10,1,1,1,10,10,1,1,1,1,1,11,1,2,1,1,8,1,8,8,2,1,11,1,8,1,1,12,1,1,1,1,1,12,12,1,12,1,1,12,1,1,12,13,1,1,3,4,8,14,8,8,4,1,8,1,13,14,3,14,1,1,1,1,1,14,1,1,1,1,1,1,14,14,1,15,1,1,3,1,1,12,12,1,12,1,1,12,3,1,15]),
function(^(_,_), [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0,2,2,0,9,0,0,0,11,9,9,11,9,0,0,0,0,3,0,3,13,0,0,0,13,0,0,0,15,13,13,15,0,4,9,13,4,0,0,0,13,9,9,0,9,13,13,0,0,5,0,0,0,5,0,0,5,0,5,0,0,0,0,0,0,6,0,0,0,0,6,0,0,0,0,0,6,0,6,0,0,7,0,0,0,0,0,7,7,0,0,0,7,0,0,0,0,8,11,13,13,5,0,7,8,0,5,11,7,13,13,0,0,9,9,0,9,0,0,0,0,9,9,0,9,0,0,0,0,10,9,0,9,5,0,0,5,9,10,0,9,0,0,0,0,11,11,0,0,0,0,0,11,0,0,11,0,0,0,0,0,12,9,15,9,0,6,7,7,9,9,0,12,0,6,15,0,13,0,13,13,0,0,0,13,0,0,0,0,13,13,0,0,14,0,13,13,0,6,0,13,0,0,0,6,13,14,0,0,15,0,15,0,0,0,0,0,0,0,0,15,0,0,15]),
function(f(_,_), [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,5,6,7,2,3,4,9,8,11,10,13,12,15,14,1,5,5,1,8,1,1,1,10,8,8,10,8,1,1,1,1,6,1,6,12,1,1,1,12,1,1,1,14,12,12,14,1,7,8,12,7,1,1,1,12,8,8,1,8,12,12,1,1,2,1,1,1,2,1,1,2,1,2,1,1,1,1,1,1,3,1,1,1,1,3,1,1,1,1,1,3,1,3,1,1,4,1,1,1,1,1,4,4,1,1,1,4,1,1,1,1,9,10,12,12,2,1,4,9,1,2,10,4,12,12,1,1,8,8,1,8,1,1,1,1,8,8,1,8,1,1,1,1,11,8,1,8,2,1,1,2,8,11,1,8,1,1,1,1,10,10,1,1,1,1,1,10,1,1,10,1,1,1,1,1,13,8,14,8,1,3,4,4,8,8,1,13,1,3,14,1,12,1,12,12,1,1,1,12,1,1,1,1,12,12,1,1,15,1,12,12,1,3,1,12,1,1,1,3,12,15,1,1,14,1,14,1,1,1,1,1,1,1,1,14,1,1,14])]).
interpretation(16, [], [
function(c(_), [1,0,5,6,7,2,3,4,9,8,11,10,13,12,15,14]),
function(v(_,_), [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,2,1,1,1,1,2,1,2,1,1,1,1,1,1,3,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,4,4,1,1,1,4,1,1,1,1,1,1,5,1,1,1,4,5,1,8,8,4,1,1,1,1,1,1,6,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,7,1,2,1,1,8,1,7,8,2,1,1,1,1,1,1,8,1,1,1,1,8,1,8,8,1,1,1,1,1,1,1,9,1,2,1,4,4,1,2,1,9,1,1,1,1,1,1,10,1,1,1,1,1,1,1,1,1,10,1,1,1,1,1,11,1,1,1,1,1,1,1,1,1,1,11,1,1,1,1,12,1,1,1,1,1,1,1,1,1,1,1,12,1,1,1,13,1,1,1,1,1,1,1,1,1,1,1,1,13,1,1,14,1,1,1,1,1,1,1,1,1,1,1,1,1,14,1,15,1,1,1,1,1,1,1,1,1,1,1,1,1,1,15]),
function(^(_,_), [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0,2,2,0,9,0,0,7,7,9,0,0,0,0,0,0,0,3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,4,9,0,4,5,0,0,5,9,0,0,0,0,0,0,0,5,0,0,5,5,0,0,5,0,0,0,0,0,0,0,0,6,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,7,7,0,0,0,0,7,7,0,0,0,0,0,0,0,0,8,7,0,5,5,0,7,8,0,0,0,0,0,0,0,0,9,9,0,9,0,0,0,0,9,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,13,0,0,0,0,0,0,0,0,0,0,0,13,0,0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,15]),
function(f(_,_), [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,5,6,7,2,3,4,9,8,11,10,13,12,15,14,1,5,5,1,8,1,1,4,4,8,1,1,1,1,1,1,1,6,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,7,8,1,7,2,1,1,2,8,1,1,1,1,1,1,1,2,1,1,2,2,1,1,2,1,1,1,1,1,1,1,1,3,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,4,4,1,1,1,1,4,4,1,1,1,1,1,1,1,1,9,4,1,2,2,1,4,9,1,1,1,1,1,1,1,1,8,8,1,8,1,1,1,1,8,1,1,1,1,1,1,1,11,1,1,1,1,1,1,1,1,11,1,1,1,1,1,1,10,1,1,1,1,1,1,1,1,1,10,1,1,1,1,1,13,1,1,1,1,1,1,1,1,1,1,13,1,1,1,1,12,1,1,1,1,1,1,1,1,1,1,1,12,1,1,1,15,1,1,1,1,1,1,1,1,1,1,1,1,15,1,1,14,1,1,1,1,1,1,1,1,1,1,1,1,1,14])]).
interpretation(16, [], [
function(c(_), [1,0,5,6,7,2,3,4,9,8,11,10,13,12,15,14]),
function(v(_,_), [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,2,1,1,1,1,2,1,2,1,1,1,1,1,1,3,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,4,4,1,1,1,4,1,1,1,1,1,1,5,1,1,1,4,5,1,8,8,4,1,1,1,1,1,1,6,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,7,1,2,1,1,8,1,7,8,2,1,1,1,1,1,1,8,1,1,1,1,8,1,8,8,1,1,1,1,1,1,1,9,1,2,1,4,4,1,2,1,9,1,1,1,1,1,1,10,1,1,1,1,1,1,1,1,1,10,1,1,10,1,10,11,1,1,1,1,1,1,1,1,1,1,11,12,14,14,12,12,1,1,1,1,1,1,1,1,1,1,12,12,1,1,12,13,1,1,1,1,1,1,1,1,1,10,14,1,13,14,10,14,1,1,1,1,1,1,1,1,1,1,14,1,14,14,1,15,1,1,1,1,1,1,1,1,1,10,12,12,10,1,15]),
function(^(_,_), [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0,2,2,0,9,0,0,7,7,9,0,0,0,0,0,0,0,3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,4,9,0,4,5,0,0,5,9,0,0,0,0,0,0,0,5,0,0,5,5,0,0,5,0,0,0,0,0,0,0,0,6,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,7,7,0,0,0,0,7,7,0,0,0,0,0,0,0,0,8,7,0,5,5,0,7,8,0,0,0,0,0,0,0,0,9,9,0,9,0,0,0,0,9,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,10,0,15,13,13,15,0,11,0,0,0,0,0,0,0,0,0,11,11,0,11,0,0,12,0,0,0,0,0,0,0,0,15,11,12,0,11,15,0,13,0,0,0,0,0,0,0,0,13,0,0,13,13,0,0,14,0,0,0,0,0,0,0,0,13,11,11,13,14,0,0,15,0,0,0,0,0,0,0,0,15,0,15,0,0,15]),
function(f(_,_), [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,5,6,7,2,3,4,9,8,11,10,13,12,15,14,1,5,5,1,8,1,1,4,4,8,1,1,1,1,1,1,1,6,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,7,8,1,7,2,1,1,2,8,1,1,1,1,1,1,1,2,1,1,2,2,1,1,2,1,1,1,1,1,1,1,1,3,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,4,4,1,1,1,1,4,4,1,1,1,1,1,1,1,1,9,4,1,2,2,1,4,9,1,1,1,1,1,1,1,1,8,8,1,8,1,1,1,1,8,1,1,1,1,1,1,1,11,1,1,1,1,1,1,1,1,11,1,14,12,12,14,1,10,1,1,1,1,1,1,1,1,1,10,10,1,10,1,1,13,1,1,1,1,1,1,1,1,14,10,13,1,10,14,1,12,1,1,1,1,1,1,1,1,12,1,1,12,12,1,1,15,1,1,1,1,1,1,1,1,12,10,10,12,15,1,1,14,1,1,1,1,1,1,1,1,14,1,14,1,1,14])]).
% isofilter: input=61, kept=4, checks=57, perms=993828, 3.45 seconds.
prover9-manual-2009-02A/olsax.in 0000644 0001750 0001750 00000003060 10557720003 015631 0 ustar mccune mccune % Prove an ortholattice (OL) 3-basis from an ortholattice single axiom.
assign(new_constants, 1). % Introduce a new constant when possible.
lex([ ', ^, v, f ]). % We will get warning about skolem constants not being here.
assign(pick_given_ratio, 5). % 5 parts "lightest first" : 1 part "age first"
set(restrict_denials). % Try for direct proofs.
assign(max_weight, 40). % Weight limit.
formulas(assumptions).
% A single axiom for ortholattices (OL) in terms of the Sheffer stroke.
f(f(f(f(y,x),f(x,z)),u),f(x,f(f(x,f(f(y,y),y)),z))) = x # label(OL_Sh).
% Even though the hypothesis and the conclusions are in terms of the
% Sheffer stroke, we define meet, join, and complementation.
% The lex command above orders the symbols so that these defined
% operations are introduced when possible. Prover9 proves these
% theorems more easily when it searches in terms of the defined
% operations.
x v y = f(f(x,x),f(y,y)) # label(definition_join).
x ^ y = f(f(x,y),f(x,y)) # label(definition_meet).
x' = f(x,x) # label(definition_complementation).
end_of_list.
formulas(goals).
% We ask for 4 proofs: three parts and a combination of the three parts.
% The three parts are a basis for OL in terms of the Sheffer stroke.
f(x,f(f(y,z),f(y,z))) = f(y,f(f(x,z),f(x,z))) # answer(assoc).
f(f(x,x),f(x,y)) = x # answer(absorb).
f(x,f(x,x)) = f(y,f(y,y)) # answer(one).
f(x,f(f(y,z),f(y,z))) = f(y,f(f(x,z),f(x,z))) & f(f(x,x),f(x,y)) = x & f(x,f(x,x)) = f(y,f(y,y)) # answer(combined).
end_of_list.
prover9-manual-2009-02A/x2.mace4.out 0000644 0001750 0001750 00000010333 11151315533 016225 0 ustar mccune mccune ============================== Mace4 =================================
Mace4 (32) version 2009-02A, February 2009.
Process 15847 was started by mccune on cleo,
Wed Feb 25 12:26:19 2009
The command was "/home/mccune/bin/mace4 -c -f x2.in".
============================== end of head ===========================
============================== INPUT =================================
% Reading from file x2.in
assign(max_seconds,5).
formulas(sos).
(x * y) * z = x * (y * z).
x * e = x.
x * x' = e.
end_of_list.
formulas(goals).
x * y = y * x.
end_of_list.
============================== end of input ==========================
============================== PROCESS NON-CLAUSAL FORMULAS ==========
% Formulas that are not ordinary clauses:
1 x * y = y * x # label(non_clause) # label(goal). [goal].
============================== end of process non-clausal formulas ===
============================== CLAUSES FOR SEARCH ====================
formulas(mace4_clauses).
(x * y) * z = x * (y * z).
x * e = x.
x * x' = e.
c2 * c1 != c1 * c2.
end_of_list.
============================== end of clauses for search =============
% There are no natural numbers in the input.
============================== DOMAIN SIZE 2 =========================
============================== STATISTICS ============================
For domain size 2.
Current CPU time: 0.00 seconds (total CPU time: 0.01 seconds).
Ground clauses: seen=13, kept=13.
Selections=4, assignments=7, propagations=6, current_models=0.
Rewrite_terms=62, rewrite_bools=16, indexes=8.
Rules_from_neg_clauses=2, cross_offs=2.
============================== end of statistics =====================
============================== DOMAIN SIZE 3 =========================
============================== STATISTICS ============================
For domain size 3.
Current CPU time: 0.00 seconds (total CPU time: 0.01 seconds).
Ground clauses: seen=34, kept=34.
Selections=7, assignments=17, propagations=30, current_models=0.
Rewrite_terms=298, rewrite_bools=71, indexes=52.
Rules_from_neg_clauses=8, cross_offs=24.
============================== end of statistics =====================
============================== DOMAIN SIZE 4 =========================
============================== STATISTICS ============================
For domain size 4.
Current CPU time: 0.00 seconds (total CPU time: 0.01 seconds).
Ground clauses: seen=73, kept=73.
Selections=14, assignments=45, propagations=110, current_models=0.
Rewrite_terms=1132, rewrite_bools=232, indexes=206.
Rules_from_neg_clauses=18, cross_offs=98.
============================== end of statistics =====================
============================== DOMAIN SIZE 5 =========================
============================== STATISTICS ============================
For domain size 5.
Current CPU time: 0.00 seconds (total CPU time: 0.01 seconds).
Ground clauses: seen=136, kept=136.
Selections=24, assignments=91, propagations=201, current_models=0.
Rewrite_terms=2416, rewrite_bools=472, indexes=582.
Rules_from_neg_clauses=31, cross_offs=228.
============================== end of statistics =====================
============================== DOMAIN SIZE 6 =========================
============================== MODEL =================================
interpretation( 6, [number=1, seconds=0], [
function(e, [ 0 ]),
function(c1, [ 1 ]),
function(c2, [ 2 ]),
function('(_), [ 0, 1, 2, 4, 3, 5 ]),
function(*(_,_), [
0, 1, 2, 3, 4, 5,
1, 0, 3, 2, 5, 4,
2, 4, 0, 5, 1, 3,
3, 5, 1, 4, 0, 2,
4, 2, 5, 0, 3, 1,
5, 3, 4, 1, 2, 0 ])
]).
============================== end of model ==========================
============================== STATISTICS ============================
For domain size 6.
Current CPU time: 0.00 seconds (total CPU time: 0.01 seconds).
Ground clauses: seen=229, kept=229.
Selections=14, assignments=44, propagations=94, current_models=1.
Rewrite_terms=1566, rewrite_bools=339, indexes=370.
Rules_from_neg_clauses=8, cross_offs=138.
============================== end of statistics =====================
User_CPU=0.01, System_CPU=0.00, Wall_clock=0.
Exiting with 1 model.
Process 15847 exit (max_models) Wed Feb 25 12:26:19 2009
The process finished Wed Feb 25 12:26:19 2009
prover9-manual-2009-02A/options 0000644 0001750 0001750 00000027534 10421456350 015606 0 ustar mccune mccune Prover_options init_prover_options(void)
{
Prover_options p = calloc(1, sizeof(struct prover_options));
// FLAGS:
// internal name external name default
// The following are now in ../ladr/std_options.c.
// ?? = init_flag("prolog_style_variables", FALSE);
// ?? = init_flag("clocks", FALSE);
p->binary_resolution = init_flag("binary_resolution", FALSE);
p->neg_binary_resolution = init_flag("neg_binary_resolution", FALSE);
p->hyper_resolution = init_flag("hyper_resolution", FALSE);
p->neg_hyper_resolution = init_flag("neg_hyper_resolution", FALSE);
p->ur_resolution = init_flag("ur_resolution", FALSE);
p->pos_ur_resolution = init_flag("pos_ur_resolution", FALSE);
p->neg_ur_resolution = init_flag("neg_ur_resolution", FALSE);
p->factor = init_flag("factor", FALSE);
p->paramodulation = init_flag("paramodulation", FALSE);
p->ordered_inference = init_flag("ordered_inference", TRUE);
p->ordered_instance = init_flag("ordered_instance", FALSE);
p->para_units_only = init_flag("para_units_only", FALSE);
p->basic_paramodulation = init_flag("basic_paramodulation", FALSE);
p->initial_nuclei = init_flag("initial_nuclei", FALSE);
p->process_initial_sos = init_flag("process_initial_sos", TRUE);
p->back_demod = init_flag("back_demod", FALSE);
p->lex_dep_demod = init_flag("lex_dep_demod", TRUE);
p->lex_dep_demod_sane = init_flag("lex_dep_demod_sane", TRUE);
p->safe_unit_conflict = init_flag("safe_unit_conflict", FALSE);
p->back_subsume = init_flag("back_subsume", TRUE);
p->degrade_hints = init_flag("degrade_hints", TRUE);
p->collect_hint_labels = init_flag("collect_hint_labels", FALSE);
p->reuse_denials = init_flag("reuse_denials", FALSE);
p->cac_redundancy = init_flag("cac_redundancy", TRUE);
p->unit_deletion = init_flag("unit_deletion", FALSE);
p->back_unit_deletion = init_flag("back_unit_deletion", FALSE);
p->dont_flip_input = init_flag("dont_flip_input", FALSE);
p->echo_input = init_flag("echo_input", TRUE);
p->quiet = init_flag("quiet", FALSE);
p->print_subproblems = init_flag("print_subproblems", TRUE);
p->print_initial_clauses = init_flag("print_initial_clauses", TRUE);
p->print_given = init_flag("print_given", TRUE);
p->print_gen = init_flag("print_gen", FALSE);
p->print_kept = init_flag("print_kept", FALSE);
p->print_labeled = init_flag("print_labeled", FALSE);
p->print_proofs = init_flag("print_proofs", TRUE);
p->default_output = init_flag("default_output", TRUE);
p->fof_reduction = init_flag("fof_reduction", FALSE);
p->predicate_elimination = init_flag("predicate_elimination", FALSE);
p->inverse_order = init_flag("inverse_order", TRUE);
p->unfold_eq = init_flag("unfold_eq", FALSE);
p->fold_eq = init_flag("fold_eq", FALSE);
p->sort_initial_sos = init_flag("sort_initial_sos", FALSE);
p->restrict_denials = init_flag("restrict_denials", FALSE);
p->breadth_first = init_flag("breadth_first", FALSE);
p->input_sos_first = init_flag("input_sos_first", TRUE);
p->automatic = init_flag("auto", FALSE);
p->auto_inference = init_flag("auto_inference", FALSE);
p->hands_off_options = init_flag("hands_off_options", FALSE);
p->auto2 = init_flag("auto2", FALSE);
p->lex_order_vars = init_flag("lex_order_vars", FALSE);
// PARMS:
// internal name external name default min max
p->max_given = init_parm("max_given", -1, -1,INT_MAX);
p->max_kept = init_parm("max_kept", -1, -1,INT_MAX);
p->max_proofs = init_parm("max_proofs", 1, -1,INT_MAX);
p->max_megs = init_parm("max_megs", 200, -1,INT_MAX);
p->max_seconds = init_parm("max_seconds", -1, -1,INT_MAX);
p->new_constants = init_parm("new_constants", 0, -1,INT_MAX);
p->para_lit_limit = init_parm("para_lit_limit", -1, -1,INT_MAX);
p->nucleus_limit = init_parm("nucleus_limit", -1, -1,INT_MAX);
p->unfold_eq_limit = init_parm("unfold_eq_limit", -1, -1,INT_MAX);
p->fold_denial_max = init_parm("fold_denial_max", 0, -1,INT_MAX);
p->pick_given_ratio = init_parm("pick_given_ratio", 0, 0,INT_MAX);
p->age_part = init_parm("age_part", 1, 0,INT_MAX);
p->true_part = init_parm("true_part", 2, 0,INT_MAX);
p->false_part = init_parm("false_part", 2, 0,INT_MAX);
p->eval_limit = init_parm("eval_limit", 1000, -1,INT_MAX);
p->max_weight = init_parm("max_weight", INT_MAX,INT_MIN,INT_MAX);
p->lex_dep_demod_lim =init_parm("lex_dep_demod_lim", 11, -1,INT_MAX);
p->max_literals = init_parm("max_literals", -1, -1,INT_MAX);
p->max_vars = init_parm("max_vars", -1, -1,INT_MAX);
p->demod_step_limit = init_parm("demod_step_limit", 1000, -1,INT_MAX);
p->demod_size_limit = init_parm("demod_size_limit", 1000, -1,INT_MAX);
p->variable_weight = init_parm("variable_weight", 1,INT_MIN,INT_MAX);
p->constant_weight = init_parm("constant_weight", 1,INT_MIN,INT_MAX);
p->not_weight = init_parm("not_weight", 0,INT_MIN,INT_MAX);
p->or_weight = init_parm("or_weight", 0,INT_MIN,INT_MAX);
p->sk_constant_weight=init_parm("sk_constant_weight", 1,INT_MIN,INT_MAX);
p->prop_atom_weight = init_parm("prop_atom_weight", 1,INT_MIN,INT_MAX);
p->skolem_penalty = init_parm("skolem_penalty", 1, 0,INT_MAX);
p->nest_penalty = init_parm("nest_penalty", 0, 0,INT_MAX);
p->bsub_hint_add_wt = init_parm("bsub_hint_add_wt", -1000,INT_MIN,INT_MAX);
p->bsub_hint_wt = init_parm("bsub_hint_wt", INT_MAX,INT_MIN,INT_MAX);
p->default_weight = init_parm("default_weight", INT_MAX,INT_MIN,INT_MAX);
p->sos_limit = init_parm("sos_limit", -1, -1,INT_MAX);
p->min_sos_limit = init_parm("min_sos_limit", 0, 0,INT_MAX);
p->lrs_interval = init_parm("lrs_interval", 50, 1,INT_MAX);
p->lrs_ticks = init_parm("lrs_ticks", -1, -1,INT_MAX);
p->report = init_parm("report", -1, -1,INT_MAX);
// STRINGPARMS:
// (internal-name, external-name, number-of-strings, str1, str2, ... )
// str1 is always the default
p->order = init_stringparm("order", 3,
"lpo",
"rpo",
"kbo");
p->literal_selection = init_stringparm("literal_selection", 4,
"maximal",
"all",
"first_maximal",
"first");
p->stats = init_stringparm("stats", 4,
"lots",
"all",
"some",
"none");
// Flag and parm Dependencies. These cause other flags and parms
// to be changed. The changes happen immediately and can be undone
// by later settings in the input.
// DEPENDENCIES ARE NOT APPLIED TO DEFAULT SETTINGS!
flag_flag_dependency(p->paramodulation, TRUE, p->back_demod, TRUE);
flag_parm_dependency(p->para_units_only, TRUE, p->para_lit_limit, 1);
flag_flag_dependency(p->back_unit_deletion, TRUE, p->unit_deletion, TRUE);
flag_flag_dependency(p->ur_resolution, TRUE, p->pos_ur_resolution, TRUE);
flag_flag_dependency(p->ur_resolution, TRUE, p->neg_ur_resolution, TRUE);
flag_parm_dependency(p->lex_dep_demod, FALSE, p->lex_dep_demod_lim, 0);
flag_parm_dependency(p->lex_dep_demod, TRUE, p->lex_dep_demod_lim, -1);
flag_parm_dependency(p->unfold_eq, TRUE, p->unfold_eq_limit, INT_MAX);
flag_parm_dependency(p->unfold_eq, FALSE, p->unfold_eq_limit, -1);
flag_flag_dependency(p->unfold_eq, TRUE, p->fold_eq, FALSE);
flag_flag_dependency(p->fold_eq, TRUE, p->unfold_eq, FALSE);
flag_parm_dependency(p->breadth_first, TRUE, p->age_part, 1);
flag_parm_dependency(p->breadth_first, TRUE, p->true_part, 0);
flag_parm_dependency(p->breadth_first, TRUE, p->false_part, 0);
parm_parm_dependency(p->pick_given_ratio, p->age_part, 1);
parm_parm_dependency(p->pick_given_ratio, p->true_part, INT_MIN); // copy
parm_parm_dependency(p->pick_given_ratio, p->false_part, 0);
flag_flag_dependency(p->default_output, TRUE, p->quiet, FALSE);
flag_flag_dependency(p->default_output, TRUE, p->echo_input, TRUE);
flag_flag_dependency(p->default_output, TRUE, p->print_initial_clauses,TRUE);
flag_flag_dependency(p->default_output, TRUE, p->print_given, TRUE);
flag_flag_dependency(p->default_output, TRUE, p->print_subproblems, TRUE);
flag_flag_dependency(p->default_output, TRUE, p->print_proofs, TRUE);
flag_stringparm_dependency(p->default_output, TRUE, p->stats, "lots");
flag_flag_dependency(p->default_output, TRUE, p->print_kept, FALSE);
flag_flag_dependency(p->default_output, TRUE, p->print_gen, FALSE);
// automatic
flag_flag_dependency(p->automatic, TRUE, p->auto_inference, TRUE);
flag_flag_dependency(p->automatic, TRUE, p->predicate_elimination, TRUE);
flag_flag_dependency(p->automatic, TRUE, p->unfold_eq, TRUE);
flag_parm_dependency(p->automatic, TRUE, p->max_weight, 100);
flag_parm_dependency(p->automatic, TRUE, p->sos_limit, 10000);
flag_flag_dependency(p->automatic, FALSE, p->auto_inference, FALSE);
flag_flag_dependency(p->automatic, FALSE, p->predicate_elimination, FALSE);
flag_flag_dependency(p->automatic, FALSE, p->unfold_eq, FALSE);
flag_parm_dependency(p->automatic, FALSE, p->max_weight, INT_MAX);
flag_parm_dependency(p->automatic, FALSE, p->sos_limit, -1);
// auto2 (also triggered by -x on the command line)
flag_flag_dependency(p->auto2, TRUE, p->automatic, TRUE);
flag_flag_dependency(p->auto2, TRUE, p->fof_reduction, TRUE);
flag_parm_dependency(p->auto2, TRUE, p->new_constants, 1);
flag_parm_dependency(p->auto2, TRUE, p->fold_denial_max, 3);
flag_parm_dependency(p->auto2, TRUE, p->max_weight, 200);
flag_parm_dependency(p->auto2, TRUE, p->nest_penalty, 1);
flag_parm_dependency(p->auto2, TRUE, p->skolem_penalty, 3);
flag_parm_dependency(p->auto2, TRUE, p->sk_constant_weight, 0);
flag_parm_dependency(p->auto2, TRUE, p->prop_atom_weight, 5);
flag_flag_dependency(p->auto2, TRUE, p->sort_initial_sos, TRUE);
flag_parm_dependency(p->auto2, TRUE, p->sos_limit, -1);
flag_parm_dependency(p->auto2, TRUE, p->lrs_ticks, 3000);
flag_parm_dependency(p->auto2, TRUE, p->max_megs, 400);
flag_stringparm_dependency(p->auto2, TRUE, p->stats, "some");
flag_flag_dependency(p->auto2, TRUE, p->echo_input, FALSE);
flag_flag_dependency(p->auto2, TRUE, p->quiet, TRUE);
flag_flag_dependency(p->auto2, TRUE, p->print_subproblems, FALSE);
flag_flag_dependency(p->auto2, TRUE, p->print_initial_clauses, FALSE);
flag_flag_dependency(p->auto2, TRUE, p->print_given, FALSE);
return p;
} // init_prover_options
prover9-manual-2009-02A/process-inf.html 0000644 0001750 0001750 00000040761 11151021064 017272 0 ustar mccune mccune
Prover9 Manual: Processing Inferred Clauses
Prover9 Manual
Version 2009-02A
Processing Inferred Clauses
Processing of inferred clauses is separated into two
stages: (1) simplifying the clause and deciding whether
to keep it, and if it is kept, (2) using the clause to
operate on other clauses.
Processing Initial Clauses
Initial clauses in the sos list are processed,
for the most part, as if they were derived by some inference
rule. This process helps to ensure that Prover9's working set
of clauses starts out in a good state, in particular, that
no clause subsumes another, and that all clauses are simplified
according to the working set of demodulators.
Note the following exceptions.
All processing of initial sos clauses can be disabled
by clearing the flag
process_initial_sos.
Clauses in the initial usable list are never processed.
If there is an initial demodulators list,
the clauses therein will be checked.
If an equation is orientable but backward,
it will be flipped, and a warning message will be printed.
Otherwise, it must satisfy all of the ordinary constraints
on demodulators.
Having an initial demodulators list is useful,
along with clearing the flag
back_demod,
if the user wishes to have a set of demodulators that is fixed throughout
the search.
check
6. subsumption check (forward)
7. assign an ID and keep the clause
8. unsafe unit conflict check
9. check if the clause should be a demodulator
---- (the following steps are delayed until finished with the given clause) ---
10. factor c
11. apply new_constants to c
12. apply back_subsume with c
13. apply back_demod with c
14. apply back_unit_deletion with c
15. move c to the sos list
Restricted denials (see flag
restrict_denials)
are not subject to the
max_weight test.
If an equation is added to demodulators,
Then each clause in usable or sos
that can be rewritten with the equation is copied
and deleted, then the copy is treated as if it were
generated by an inference rule. In particular,
it will be processed, including demodulation, which
will apply the new demodulator.
This parameter is a limit on the flag lex_dep_demod.
A non-orientable equation cannot become a demodulator
if it has more than n symbols. (The equation (x*y)*z=x*(y*z) has 11 symbols.)
If n = -1, there is no limit.
If this flag is set, binary factoring is applied to
newly-kept clauses. Note that factoring is an inference rule
rather than a simplification rule, because a child is generated
and the parent is retained. (If the child happens to subsume
the parent, the parent will be deleted by the back subsumption
process). Unlike other inference rules such as resolution,
factoring is applied to a clause when it is kept,
not when it is given.
The standard way of running Prover9 is to (1) prepare an input file
containing the logical specification of a conjecture and the
search parameters, (2) issue a command that runs Prover9 on the
input file and produces an output file, (3) look at the output, and
(4) maybe run Prover9 again with different search parameters.
A
graphical user interface (GUI) for Prover9
is under development,
but it is not described in this manual.
Nearly all of the information in this manual applies also
when using the GUI.
An Input File
Here is an input file; assume it is named subset_trans.in.
(Use a plain text editor, not a word processor, to create input files.)
formulas(sos).
all x all y (subset(x,y) <-> (all z (member(z,x) -> member(z,y)))).
end_of_list.
formulas(goals).
all x all y all z (subset(x,y) & subset(y,z) -> subset(x,z)).
end_of_list.
A Basic Prover9 Command
Here is a command to run Prover9 on the preceding file and
send the output to a file called subset_trans.out.
All arguments after the "-f" are taken as input filenames,
and there can be as many as you like.
When multiple filnames are given on the command line,
a list of objects (clauses, formulas, or terms)
cannot be split across more than one file.
Time Limit on the Command Line
Prover9 also accepts a time limit, in seconds, on the command line.
The following command limits the job to about 10 seconds.
If "-t" and "-f" are both in the command, the "-t" must occur first.
Getting Statistics During the Search
This section applies to Unix-like systems only.
If a Prover9 process is running in the background, one can tell it
to send search statistics (without killing the job) to the output file
sending a "USR1" signal to the process. For example,
% prover9 -f p3a.in > p3a.outb &
[1] 31613
% kill -USR1 31613
A report (17.75 seconds) has been sent to the output.
Calling Prover9 From Another Program
If Prover9 is called from another program (e.g., a shell script,
a Perl script, or a Python script), Prover9's exit codes can
tell the other program the reason Prover9 terminates. The following
table shows the exit codes.
Exit Code
Reason for Termination
0 (MAX_PROOFS)
The specified number of proofs (max_proofs) was found.
1 (FATAL)
A fatal error occurred (user's syntax error or Prover9's bug).
2 (SOS_EMPTY)
Prover9 ran out of things to do (sos list exhausted).
3 (MAX_MEGS)
The max_megs (memory limit) parameter was exceeded.
When Prover9 proves a theorem, it sends the proof to its output
file in a standard form. The standard form contains, for each step,
justifications
with enough detail to reconstruct or check the
proof without any search.
Prover9 proofs may contain non-clausal assumptions and
goals,
as well as ordinary clauses. Non-clausal assumptions are translated
to clauses, and goals are negated and then translated to clauses.
See the proof in following example
Prooftrans can extract proofs from Prover9 output files
and transform them in various ways, including the following.
No transformation,
renumber steps,
simplify justifications,
expand all steps, turning secondary justifications into explicit steps,
produce proofs in XML,
produce proofs for checking by the IVY proof checker, and
produce hints for guiding subsequent searches.
Prooftrans is part of the LADR/Prover9/Mace4 package. When
the package is installed, the Prooftrans program should be
in the same directory as Prover9 and Mace4.
Using Prooftrans
The Prover9 output file containing the proof(s) is usually given to
Prooftrans with the argument "-f <filename>".
If there is no "-f <filename>" argument, Prooftrans
takes its input from the standard input.
The arguments that tell Prooftrans what to do with the proof(s)
are described in the following sections, using the output
file subset_trans.out
as a running example.
If there is more than one proof in the file, the transformations
will be applied to each proof. The hints transformation
collects all of the clauses in the proof(s) into one list of
hints. The other transformations produce one proof for each
proof in the input file.
Here is a synopsis of the Prooftrans command; the arguments in
square brackets are optional.
Note that more than one transformation can be applied in several cases.
The option "striplabels" tells prooftrans to remove all label
attributes on clauses.
Unfortunately, the output of Prooftrans usually cannot be used
as the input to another Prooftrans job, because Prooftrans
expects its input to have specific keywords and standard-form proofs.
No Transformation
If no additional argument is given, Prooftrans simply extracts
the proof from the Prover9 output file.
The argument renumber tells Prooftrans to renumber the
steps of each proof consecutively, starting with step 1.
The expand, parents_only, and xml
transformations can be used with the renumber transformation.
The argument parents_only tells Prooftrans list only
the parents in the justifications, not the details about inference
rules or positions.
The expand and renumber transformations can be
used with the parents_only transformation.
Note that when a step is expanded (step 22 in this example), the
new steps are identified by appending 'A', 'B', etc. to the number
of the original step.
The renumber, parents_only, and hints
transformations can be used with the expand transformation.
XML Proofs
The options xml or XML tell Prooftrans to
produce proofs in XML. The options expand and
renumber can be used with the XML transformation.
The preceding output is displayed by your browser not as XML, but as
some transformation of the XML, because the XML refers to an XML stylesheet,
telling the browser how to transform the XML into HTML.
To see the XML source, click "View -> Frame Source" (or something like that) in your
browser while viewing the proof.
Ivy proofs have a only 5 types of step:
input,
propositional,
new_symbol,
flip,
instantiate,
resolve, and
paramod.
The resolve and paramod do not involve unification;
instances are generated first as separate steps, and then
resolve or paramod are applied to identical
atomic formulas or terms.
The Ivy proof checker cannot check steps justified by new_symbol.
Proofs to Hints
The option hints tells Prooftrans to
take all of the proofs in the file and produce
one list of hints that can be given to Prover9
to guide subsequent searches on related
conjectures.
If there is more than one proof in the file, the proofs
will probably share many steps. The list of hints
that Prooftrans produces will be the union of the
steps in the proofs; that is, the duplicate steps
will be removed.
The expand transformation can be used with the
hints transformation.
The label option tells prooftrans to attach label attributes
to the hint clauses. The labels consist of the string given
on the command line and a sequence number generated by
prooftrans.
The user's command shell may require that
the label be quoted, and if the
the label is not a legal LADR constant,
prooftrans will enclose the label in double quotes.
prover9-manual-2009-02A/hard-hints.out 0000644 0001750 0001750 00000065565 11151315533 016766 0 ustar mccune mccune ============================== Prover9 ===============================
Prover9 (32) version 2009-02A, February 2009.
Process 15846 was started by mccune on cleo,
Wed Feb 25 12:26:18 2009
The command was "/home/mccune/bin/prover9 -f hard.in easy.hints".
============================== end of head ===========================
============================== INPUT =================================
% Reading from file hard.in
assign(eq_defs,fold).
set(restrict_denials).
formulas(assumptions).
f(x,y) = f(y,x).
f(f(x,y),f(x,f(y,z))) = x.
x' = f(x,x).
end_of_list.
formulas(goals).
f(f(x,x),f(x,x)) = x # label(Sheffer_1).
f(x,f(y,f(y,y))) = f(x,x) # label(Sheffer_2).
f(f(f(y,y),x),f(f(z,z),x)) = f(f(x,f(y,z)),f(x,f(y,z))) # label(Sheffer_3).
end_of_list.
% Reading from file easy.hints
formulas(hints).
f(f(x,x),f(x,x)) = x # label(Sheffer_1) # label(non_clause) # label(goal).
f(f(x,y),f(x,f(y,z))) = x.
f(x,f(y,f(x',z))) = f(x,y').
x' = f(x,x).
f(x,x) = x'.
f(f(c1,c1),f(c1,c1)) != c1 # label(Sheffer_1) # answer(Sheffer_1).
c1'' != c1 # answer(Sheffer_1).
f(f(x,y),f(x,y')) = x.
f(x',f(x,x')) = x.
f(x,f(y,x)) = f(x,y').
x'' = x.
$F # answer(Sheffer_1).
f(x,f(y,f(y,y))) = f(x,x) # label(Sheffer_2) # label(non_clause) # label(goal).
f(x,y) = f(y,x).
f(c2,f(c3,f(c3,c3))) != f(c2,c2) # label(Sheffer_2) # answer(Sheffer_2).
f(c2,f(c3,c3')) != c2' # answer(Sheffer_2).
f(f(x,y),f(y,f(x,z))) = y.
f(f(x,y),f(x,f(z,y))) = x.
f(x',f(x,y)) = x.
f(x',f(y,x)) = x.
f(x,f(x,y)') = f(x,y).
f(x,f(y,x)') = f(y,x).
f(x,f(x,y)) = f(x,y').
f(f(x,y),f(x,y)') = f(x',f(x,y)').
f(x',f(y,x)') = f(y',f(y,x)').
f(x',f(x,y)') = f(x,x').
f(x',f(y,x)') = f(x,x').
f(x,x') = f(y,y').
f(x,f(y,y')) = x'.
f(f(f(x,x),y),f(f(z,z),y)) = f(f(y,f(x,z)),f(y,f(x,z))) # label(Sheffer_3) # label(non_clause) # label(goal).
f(f(f(c4,c4),c5),f(f(c6,c6),c5)) != f(f(c5,f(c4,c6)),f(c5,f(c4,c6))) # label(Sheffer_3) # answer(Sheffer_3).
f(f(c5,c4'),f(c5,c6')) != f(c5,f(c4,c6))' # answer(Sheffer_3).
f(f(x,y),f(f(y,z),x)) = x.
f(x,f(f(x,y),f(f(x,f(y,z)),u))) = f(x,y).
f(x,f(y,f(z,x'))) = f(x,y').
f(x,f(f(x',y),z)) = f(x,z').
f(x,f(x',y)') = f(x,x').
f(f(x,y),f(f(x,z),y)) = y.
f(f(x,y),f(y,x')) = y.
f(f(f(x,y),z),f(z,y)) = z.
f(x',f(y,f(x,z))) = f(x',y').
f(f(x,y),f(f(z,y),x)) = x.
f(x,f(f(x,y),f(y,z))) = f(x,y).
f(x,f(f(x,f(y,z)),f(f(x,z),u))) = f(x,f(y,z)).
f(f(x,f(y,z)),f(z,x)) = x.
f(f(x,y),f(f(y,x'),f(y,z))) = f(y,x').
f(f(x,y'),f(x,f(f(x,y),z))) = x.
f(f(x,y'),f(x,f(z,f(x,y)))) = x.
f(x',f(f(x,y),z)) = f(x',z').
f(f(x,y)',f(f(x,z),y)) = f(y,f(x,z)').
f(x,f(f(y,x'),z)') = f(x,z).
f(f(f(x,y),z),f(z,y)') = f(z,f(x,y)').
f(f(x,f(y,z')),f(f(y,z),x)) = x.
f(x,f(f(x',y)',z)) = x'.
f(x',f(f(x,y)',z)) = x.
f(x',f(f(y,x)',z)) = x.
f(x',f(y,f(z,x)')) = x.
f(x,f(y,f(z,x)')') = f(y,f(z,x)').
f(f(x,y),f(y,z)') = f(x',f(y,z)').
f(f(x,y)',f(z,y)') = f(z,f(x,y)').
f(f(x,y)',f(z,y)) = f(f(x,y)',z').
f(f(x,y)',f(x,z)') = f(f(x,y)',z).
f(f(x,y)',z) = f(y,f(x,z)').
f(x,f(y,z)') = f(y,f(x,z)').
f(x',f(f(y,x),z)') = f(x',z).
f(f(x,y),f(z,f(x,y'))') = f(z,x').
f(x,f(y,f(x,z)')) = f(x,f(y,z)).
f(x,f(f(x,y),z)) = f(x,f(y',z)).
f(x,f(y,f(z,f(f(x,y),u))')) = f(x,f(z,y)).
f(x,f(y,f(x,z))) = f(x,f(y,z')).
f(f(x,y'),f(x,f(y,z))) = f(x,f(y,z))'.
f(f(x,y'),f(x,z)) = f(x,f(y,z'))'.
end_of_list.
============================== end of input ==========================
============================== PROCESS NON-CLAUSAL FORMULAS ==========
% Formulas that are not ordinary clauses:
1 f(f(x,x),f(x,x)) = x # label(Sheffer_1) # label(non_clause) # label(goal). [goal].
2 f(x,f(y,f(y,y))) = f(x,x) # label(Sheffer_2) # label(non_clause) # label(goal). [goal].
3 f(f(f(y,y),x),f(f(z,z),x)) = f(f(x,f(y,z)),f(x,f(y,z))) # label(Sheffer_3) # label(non_clause) # label(goal). [goal].
============================== end of process non-clausal formulas ===
============================== PROCESS INITIAL CLAUSES ===============
% Clauses before input processing:
formulas(usable).
end_of_list.
formulas(sos).
f(x,y) = f(y,x). [assumption].
f(f(x,y),f(x,f(y,z))) = x. [assumption].
x' = f(x,x). [assumption].
f(f(c1,c1),f(c1,c1)) != c1 # label(Sheffer_1). [deny(1)].
f(c2,f(c3,f(c3,c3))) != f(c2,c2) # label(Sheffer_2). [deny(2)].
f(f(f(c4,c4),c5),f(f(c6,c6),c5)) != f(f(c5,f(c4,c6)),f(c5,f(c4,c6))) # label(Sheffer_3). [deny(3)].
end_of_list.
formulas(demodulators).
end_of_list.
% 72 hints input.
============================== PREDICATE ELIMINATION =================
No predicates eliminated.
============================== end predicate elimination =============
Auto_denials:
% copying label Sheffer_1 to answer in negative clause
% copying label Sheffer_2 to answer in negative clause
% copying label Sheffer_3 to answer in negative clause
% assign(max_proofs, 3). % (Horn set with more than one neg. clause)
Term ordering decisions:
Predicate symbol precedence: predicate_order([ = ]).
Function symbol precedence: function_order([ c1, c2, c3, c4, c5, c6, f, ' ]).
After inverse_order: (no changes).
Folding symbols: '/1.
After fold_eq: Function symbol precedence: function_order([ c1, c2, c3, c4, c5, c6, ', f ]).
Auto_inference settings:
% set(paramodulation). % (positive equality literals)
Auto_process settings: (no changes).
% Operation f is commutative; C redundancy checks enabled.
kept: 4 f(x,y) = f(y,x). [assumption].
kept: 5 f(f(x,y),f(x,f(y,z))) = x. [assumption].
6 x' = f(x,x). [assumption].
kept: 7 f(x,x) = x'. [copy(6),flip(a)].
8 f(f(c1,c1),f(c1,c1)) != c1 # label(Sheffer_1) # answer(Sheffer_1). [deny(1)].
kept: 9 c1'' != c1 # answer(Sheffer_1). [copy(8),rewrite([7(3),7(5),7(5)])].
10 f(c2,f(c3,f(c3,c3))) != f(c2,c2) # label(Sheffer_2) # answer(Sheffer_2). [deny(2)].
kept: 11 f(c2,f(c3,c3')) != c2' # answer(Sheffer_2). [copy(10),rewrite([7(5),7(9)])].
12 f(f(f(c4,c4),c5),f(f(c6,c6),c5)) != f(f(c5,f(c4,c6)),f(c5,f(c4,c6))) # label(Sheffer_3) # answer(Sheffer_3). [deny(3)].
kept: 13 f(f(c5,c4'),f(c5,c6')) != f(c5,f(c4,c6))' # answer(Sheffer_3). [copy(12),rewrite([7(3),4(4),7(7),4(8),7(20)])].
============================== end of process initial clauses ========
============================== CLAUSES FOR SEARCH ====================
% Clauses after input processing:
formulas(usable).
9 c1'' != c1 # answer(Sheffer_1). [copy(8),rewrite([7(3),7(5),7(5)])].
11 f(c2,f(c3,c3')) != c2' # answer(Sheffer_2). [copy(10),rewrite([7(5),7(9)])].
13 f(f(c5,c4'),f(c5,c6')) != f(c5,f(c4,c6))' # answer(Sheffer_3). [copy(12),rewrite([7(3),4(4),7(7),4(8),7(20)])].
end_of_list.
formulas(sos).
4 f(x,y) = f(y,x). [assumption].
5 f(f(x,y),f(x,f(y,z))) = x. [assumption].
7 f(x,x) = x'. [copy(6),flip(a)].
end_of_list.
formulas(demodulators).
4 f(x,y) = f(y,x). [assumption].
% (lex-dep)
5 f(f(x,y),f(x,f(y,z))) = x. [assumption].
7 f(x,x) = x'. [copy(6),flip(a)].
end_of_list.
% 65 hints (72 processed, 7 redundant).
============================== end of clauses for search =============
============================== SEARCH ================================
% Starting search at 0.02 seconds.
given #1 (I,wt=7): 4 f(x,y) = f(y,x). [assumption].
given #2 (I,wt=11): 5 f(f(x,y),f(x,f(y,z))) = x. [assumption].
given #3 (I,wt=6): 7 f(x,x) = x'. [copy(6),flip(a)].
given #4 (H,wt=10): 20 f(f(x,y),f(x,y')) = x. [para(7(a,1),5(a,1,2,2))].
given #5 (H,wt=9): 26 f(x',f(x,x')) = x. [para(7(a,1),20(a,1,1))].
given #6 (H,wt=10): 22 f(f(x,y),f(y,x')) = y. [para(4(a,1),20(a,1,1))].
given #7 (H,wt=11): 14 f(f(x,y),f(y,f(x,z))) = y. [para(4(a,1),5(a,1,1))].
given #8 (H,wt=11): 15 f(f(x,y),f(x,f(z,y))) = x. [para(4(a,1),5(a,1,2,2))].
given #9 (H,wt=11): 16 f(f(x,y),f(f(y,z),x)) = x. [para(4(a,1),5(a,1,2))].
given #10 (H,wt=11): 42 f(f(x,y),f(f(x,z),y)) = y. [para(4(a,1),14(a,1,2))].
given #11 (H,wt=11): 52 f(f(f(x,y),z),f(z,y)) = z. [para(22(a,1),14(a,1,2,2))].
given #12 (H,wt=11): 54 f(f(x,y),f(f(z,y),x)) = x. [para(4(a,1),15(a,1,2))].
given #13 (H,wt=11): 76 f(f(x,f(y,z)),f(z,x)) = x. [para(22(a,1),16(a,1,2,1))].
given #14 (H,wt=13): 57 f(x,f(f(x,y),f(y,z))) = f(x,y). [para(5(a,1),15(a,1,2)),rewrite([4(4)])].
given #15 (H,wt=17): 17 f(x,f(f(x,y),f(f(x,f(y,z)),u))) = f(x,y). [para(5(a,1),5(a,1,1))].
given #16 (H,wt=19): 68 f(x,f(f(x,f(y,z)),f(f(x,z),u))) = f(x,f(y,z)). [para(15(a,1),14(a,1,1))].
given #17 (A,wt=11): 18 f(x,f(x,f(x,y))) = f(x,y). [para(5(a,1),5(a,1,2)),rewrite([4(2),4(3)])].
given #18 (H,wt=8): 212 f(x',f(x,y)) = x. [para(18(a,1),5(a,1,2)),rewrite([7(1)])].
============================== PROOF =================================
% Proof 1 at 0.04 (+ 0.00) seconds: Sheffer_1.
% Length of proof is 11.
% Level of proof is 4.
% Maximum clause weight is 11.
% Given clauses 18.
1 f(f(x,x),f(x,x)) = x # label(Sheffer_1) # label(non_clause) # label(goal). [goal].
4 f(x,y) = f(y,x). [assumption].
5 f(f(x,y),f(x,f(y,z))) = x. [assumption].
6 x' = f(x,x). [assumption].
7 f(x,x) = x'. [copy(6),flip(a)].
8 f(f(c1,c1),f(c1,c1)) != c1 # label(Sheffer_1) # answer(Sheffer_1). [deny(1)].
9 c1'' != c1 # answer(Sheffer_1). [copy(8),rewrite([7(3),7(5),7(5)])].
18 f(x,f(x,f(x,y))) = f(x,y). [para(5(a,1),5(a,1,2)),rewrite([4(2),4(3)])].
212 f(x',f(x,y)) = x. [para(18(a,1),5(a,1,2)),rewrite([7(1)])].
220 x'' = x. [para(7(a,1),212(a,1,2)),rewrite([7(3)])].
221 $F # answer(Sheffer_1). [resolve(220,a,9,a)].
============================== end of proof ==========================
% Redundant proof: 231 $F # answer(Sheffer_1). [back_rewrite(9),rewrite([220(3)]),xx(a)].
% Disable descendants (x means already disabled):
8x 9x
given #19 (H,wt=5): 220 x'' = x. [para(7(a,1),212(a,1,2)),rewrite([7(3)])].
given #20 (H,wt=8): 218 f(x',f(y,x)) = x. [para(4(a,1),212(a,1,2))].
given #21 (H,wt=10): 219 f(x,f(x,y)') = f(x,y). [para(5(a,1),212(a,1,2)),rewrite([4(3)])].
given #22 (H,wt=10): 223 f(x,f(y,x)') = f(y,x). [para(22(a,1),212(a,1,2)),rewrite([4(3)])].
given #23 (T,wt=9): 226 f(x,f(x',y)) = x'. [para(212(a,1),15(a,1,2)),rewrite([4(3)])].
given #24 (T,wt=9): 228 f(x,f(y,x')) = x'. [para(212(a,1),76(a,1,1))].
given #25 (T,wt=10): 23 f(f(x,y),f(y',x)) = x. [para(4(a,1),20(a,1,2))].
given #26 (T,wt=10): 32 f(f(x,y'),f(y,x)) = x. [para(22(a,1),4(a,1)),flip(a)].
given #27 (A,wt=16): 24 f(x,f(f(x,y),f(f(x,y'),z))) = f(x,y). [para(20(a,1),5(a,1,1))].
given #28 (T,wt=10): 33 f(f(x,y),f(x',y)) = y. [para(4(a,1),22(a,1,2))].
given #29 (T,wt=10): 49 f(f(x',y),f(y,x)) = y. [para(26(a,1),14(a,1,2,2))].
given #30 (T,wt=11): 35 f(x,f(x,f(y,x))) = f(y,x). [para(22(a,1),5(a,1,2)),rewrite([4(2),4(3)])].
given #31 (T,wt=11): 40 f(f(x,f(y,z)),f(y,x)) = x. [para(14(a,1),4(a,1)),flip(a)].
given #32 (A,wt=16): 25 f(x,f(f(x,y),f(x,f(y,z))')) = f(x,y). [para(5(a,1),20(a,1,1))].
given #33 (T,wt=10): 334 f(x,f(y,f(x,y))) = x'. [para(40(a,1),68(a,1,2)),rewrite([7(1),4(3)]),flip(a)].
given #34 (T,wt=10): 375 f(x,f(y,f(y,x))) = x'. [para(4(a,1),334(a,1,2,2))].
given #35 (T,wt=11): 41 f(f(x,y),f(y,f(z,x))) = y. [para(4(a,1),14(a,1,2,2))].
given #36 (T,wt=11): 45 f(f(f(x,y),z),f(z,x)) = z. [para(5(a,1),14(a,1,2,2))].
given #37 (A,wt=15): 28 f(x,f(f(x,y),f(x,y')')) = f(x,y). [para(20(a,1),20(a,1,1))].
given #38 (T,wt=11): 82 f(f(x,y),f(f(z,x),y)) = y. [para(4(a,1),42(a,1,2,1))].
given #39 (T,wt=13): 70 f(x,f(f(y,x),f(y,z))) = f(y,x). [para(14(a,1),15(a,1,2)),rewrite([4(4)])].
given #40 (H,wt=14): 537 f(f(x,y'),f(x,f(f(x,y),z))) = x. [para(20(a,1),70(a,1,2,1)),rewrite([20(10)])].
given #41 (H,wt=14): 563 f(f(x,y'),f(x,f(z,f(x,y)))) = x. [para(4(a,1),537(a,1,2,2))].
given #42 (T,wt=13): 72 f(x,f(f(x,y),f(z,y))) = f(x,y). [para(15(a,1),15(a,1,2)),rewrite([4(4)])].
given #43 (T,wt=13): 79 f(x,f(f(y,z),f(x,y))) = f(x,y). [para(16(a,1),14(a,1,2)),rewrite([4(4)])].
given #44 (A,wt=16): 34 f(x,f(f(y,x),f(f(x,y'),z))) = f(y,x). [para(22(a,1),5(a,1,1))].
given #45 (T,wt=13): 88 f(x,f(f(y,z),f(y,x))) = f(y,x). [para(42(a,1),14(a,1,2)),rewrite([4(4)])].
given #46 (T,wt=13): 106 f(x,f(f(y,z),f(x,z))) = f(x,z). [para(52(a,1),42(a,1,2)),rewrite([4(4)])].
given #47 (T,wt=13): 123 f(x,f(f(y,x),f(z,y))) = f(y,x). [para(76(a,1),52(a,1,1))].
given #48 (T,wt=13): 401 f(x,f(f(x,y),f(x,y)')) = x'. [para(219(a,1),334(a,1,2,2)),rewrite([4(4)])].
given #49 (A,wt=18): 36 f(x,f(f(x,y)',f(x,f(y,z)))) = f(x,f(y,z)). [para(5(a,1),22(a,1,1)),rewrite([4(5)])].
given #50 (T,wt=13): 402 f(x,f(f(y,x),f(y,x)')) = x'. [para(223(a,1),334(a,1,2,2)),rewrite([4(4)])].
given #51 (T,wt=13): 432 f(f(x,y),f(x,x')) = f(x,y)'. [para(212(a,1),375(a,1,2,2)),rewrite([4(3)])].
============================== PROOF =================================
% Proof 2 at 0.19 (+ 0.00) seconds: Sheffer_2.
% Length of proof is 35.
% Level of proof is 11.
% Maximum clause weight is 23.
% Given clauses 51.
2 f(x,f(y,f(y,y))) = f(x,x) # label(Sheffer_2) # label(non_clause) # label(goal). [goal].
4 f(x,y) = f(y,x). [assumption].
5 f(f(x,y),f(x,f(y,z))) = x. [assumption].
6 x' = f(x,x). [assumption].
7 f(x,x) = x'. [copy(6),flip(a)].
10 f(c2,f(c3,f(c3,c3))) != f(c2,c2) # label(Sheffer_2) # answer(Sheffer_2). [deny(2)].
11 f(c2,f(c3,c3')) != c2' # answer(Sheffer_2). [copy(10),rewrite([7(5),7(9)])].
14 f(f(x,y),f(y,f(x,z))) = y. [para(4(a,1),5(a,1,1))].
15 f(f(x,y),f(x,f(z,y))) = x. [para(4(a,1),5(a,1,2,2))].
16 f(f(x,y),f(f(y,z),x)) = x. [para(4(a,1),5(a,1,2))].
18 f(x,f(x,f(x,y))) = f(x,y). [para(5(a,1),5(a,1,2)),rewrite([4(2),4(3)])].
20 f(f(x,y),f(x,y')) = x. [para(7(a,1),5(a,1,2,2))].
22 f(f(x,y),f(y,x')) = y. [para(4(a,1),20(a,1,1))].
40 f(f(x,f(y,z)),f(y,x)) = x. [para(14(a,1),4(a,1)),flip(a)].
68 f(x,f(f(x,f(y,z)),f(f(x,z),u))) = f(x,f(y,z)). [para(15(a,1),14(a,1,1))].
76 f(f(x,f(y,z)),f(z,x)) = x. [para(22(a,1),16(a,1,2,1))].
212 f(x',f(x,y)) = x. [para(18(a,1),5(a,1,2)),rewrite([7(1)])].
218 f(x',f(y,x)) = x. [para(4(a,1),212(a,1,2))].
219 f(x,f(x,y)') = f(x,y). [para(5(a,1),212(a,1,2)),rewrite([4(3)])].
223 f(x,f(y,x)') = f(y,x). [para(22(a,1),212(a,1,2)),rewrite([4(3)])].
228 f(x,f(y,x')) = x'. [para(212(a,1),76(a,1,1))].
334 f(x,f(y,f(x,y))) = x'. [para(40(a,1),68(a,1,2)),rewrite([7(1),4(3)]),flip(a)].
375 f(x,f(y,f(y,x))) = x'. [para(4(a,1),334(a,1,2,2))].
401 f(x,f(f(x,y),f(x,y)')) = x'. [para(219(a,1),334(a,1,2,2)),rewrite([4(4)])].
402 f(x,f(f(y,x),f(y,x)')) = x'. [para(223(a,1),334(a,1,2,2)),rewrite([4(4)])].
432 f(f(x,y),f(x,x')) = f(x,y)'. [para(212(a,1),375(a,1,2,2)),rewrite([4(3)])].
887 f(x',f(f(x,y),f(x,y)')') = f(f(x,y),f(x,y)'). [para(401(a,1),218(a,1,2)),rewrite([4(7)])].
890 f(f(x,x'),f(f(x,y),f(x,y)')) = f(f(x,y),f(x,y)')'. [para(401(a,1),375(a,1,2,2)),rewrite([4(7)])].
967 f(x',f(f(y,x),f(y,x)')') = f(f(y,x),f(y,x)'). [para(402(a,1),218(a,1,2)),rewrite([4(7)])].
997 f(f(x,y),f(x,y)')' = f(x,x')'. [para(432(a,1),375(a,1,2,2)),rewrite([890(7)])].
1007 f(f(x,y),f(x,y)') = f(y',f(x,x')'). [back_rewrite(967),rewrite([997(6)]),flip(a)].
1008 f(x',f(y,y')')' = f(y,y')'. [back_rewrite(890),rewrite([1007(6),228(8),1007(7)]),flip(a)].
1009 f(x',f(y,y')') = f(y,y'). [back_rewrite(887),rewrite([1007(5),1008(7),223(5),1007(6)]),flip(a)].
1030 f(x,f(y,y')) = x'. [back_rewrite(402),rewrite([1007(4),1009(5)])].
1031 $F # answer(Sheffer_2). [resolve(1030,a,11,a)].
============================== end of proof ==========================
% Redundant proof: 1036 $F # answer(Sheffer_2). [back_rewrite(11),rewrite([1030(6)]),xx(a)].
% Disable descendants (x means already disabled):
10x 11x
given #52 (H,wt=9): 1030 f(x,f(y,y')) = x'. [back_rewrite(402),rewrite([1007(4),1009(5)])].
given #53 (H,wt=9): 1033 f(x,x') = f(y,y'). [back_rewrite(1028),rewrite([1030(5),220(3),4(2)])].
given #54 (H,wt=12): 987 f(x',f(x,y)') = f(x,x'). [para(432(a,1),16(a,1,2)),rewrite([4(3),228(3)])].
given #55 (H,wt=12): 1029 f(x',f(y,x)') = f(x,x'). [back_rewrite(892),rewrite([1007(6),1009(7),434(5),1007(8),1009(9)])].
given #56 (H,wt=11): 1070 f(x',f(f(y,x)',z)) = x. [back_rewrite(1068),rewrite([1069(10),1030(4),220(2)]),flip(a)].
given #57 (H,wt=11): 1071 f(x',f(f(x,y)',z)) = x. [back_rewrite(1053),rewrite([1069(10),1030(4),220(2)]),flip(a)].
given #58 (H,wt=11): 1073 f(x',f(y,f(z,x)')) = x. [para(4(a,1),1070(a,1,2))].
given #59 (H,wt=10): 1159 f(x,f(y,x)) = f(x,y'). [back_rewrite(277),rewrite([1135(5)])].
given #60 (H,wt=10): 1160 f(x,f(x,y)) = f(x,y'). [back_rewrite(38),rewrite([1139(5)])].
given #61 (H,wt=12): 1038 f(x,f(x',y)') = f(x,x'). [para(1030(a,1),79(a,1,2))].
given #62 (H,wt=12): 1115 f(x,f(f(x',y)',z)) = x'. [para(220(a,1),1071(a,1,1))].
given #63 (H,wt=13): 1009 f(x',f(y,y')') = f(y,y'). [back_rewrite(887),rewrite([1007(5),1008(7),223(5),1007(6)]),flip(a)].
given #64 (H,wt=14): 1263 f(f(x,f(y,z')),f(f(y,z),x)) = x. [para(1160(a,1),76(a,1,1,2))].
given #65 (H,wt=16): 1142 f(x,f(y,f(z,x)')') = f(y,f(z,x)'). [para(1073(a,1),218(a,1,2)),rewrite([4(5)])].
given #66 (H,wt=17): 1172 f(f(x,y'),f(x,f(y,z))) = f(x,f(y,z))'. [back_rewrite(410),rewrite([1159(4),4(5)])].
given #67 (H,wt=17): 1207 f(f(x,y)',f(f(x,z),y)) = f(y,f(x,z)'). [para(42(a,1),1159(a,1,2)),rewrite([4(3),1159(3),4(8)]),flip(a)].
given #68 (H,wt=17): 1232 f(f(x,y),f(f(y,x'),f(y,z))) = f(y,x'). [para(1159(a,1),70(a,1,2,1)),rewrite([1159(8)])].
given #69 (T,wt=9): 1034 f(f(x,x'),y) = y'. [back_rewrite(1017),rewrite([1030(6),220(4)])].
given #70 (T,wt=11): 1035 f(x,x')' = f(y,y')'. [back_rewrite(1010),rewrite([1030(5)])].
given #71 (A,wt=17): 43 f(x,f(f(y,x),f(f(x,f(y,z)),u))) = f(y,x). [para(14(a,1),5(a,1,1))].
given #72 (T,wt=11): 1105 f(x',f(y,f(x,z)')) = x. [para(4(a,1),1071(a,1,2))].
given #73 (T,wt=12): 1039 f(x,f(y,x')') = f(x,x'). [para(1030(a,1),106(a,1,2))].
given #74 (T,wt=12): 1069 f(f(x,x')',y) = f(x,x'). [para(1030(a,1),1029(a,1,2,1)),rewrite([220(5),1034(10),220(8)])].
given #75 (T,wt=12): 1088 f(x,f(f(y,x')',z)) = x'. [para(220(a,1),1070(a,1,1))].
given #76 (A,wt=19): 44 f(x,f(f(x,f(y,z)),f(f(x,y),u))) = f(x,f(y,z)). [para(5(a,1),14(a,1,1))].
given #77 (T,wt=12): 1141 f(x,f(y,f(z,x')')) = x'. [para(220(a,1),1073(a,1,1))].
given #78 (T,wt=12): 1173 f(f(x,y),f(y,x)) = f(x,y)'. [back_rewrite(407),rewrite([1159(4),220(3)])].
given #79 (T,wt=12): 1296 f(x,f(y,f(x',z)')) = x'. [para(4(a,1),1115(a,1,2))].
given #80 (T,wt=12): 1306 f(x,f(y,y')') = f(y,y'). [para(220(a,1),1009(a,1,1))].
given #81 (A,wt=17): 47 f(x,f(f(x,y'),f(f(x,y),z))) = f(x,y'). [para(20(a,1),14(a,1,1))].
given #82 (T,wt=13): 445 f(x,f(f(y,z),f(z,x))) = f(z,x). [para(41(a,1),76(a,1,1))].
given #83 (T,wt=13): 1082 f(f(x,y)',f(x',z)) = f(x,y). [para(52(a,1),1070(a,1,2,1,1))].
given #84 (T,wt=13): 1086 f(f(x,y)',f(y',z)) = f(x,y). [para(76(a,1),1070(a,1,2,1,1))].
given #85 (T,wt=13): 1135 f(f(x,y)',f(z,x')) = f(x,y). [para(52(a,1),1073(a,1,2,2,1))].
given #86 (A,wt=17): 51 f(x,f(f(x,y'),f(f(y,x),z))) = f(x,y'). [para(22(a,1),14(a,1,1))].
given #87 (H,wt=14): 1987 f(x',f(y,f(x,z))) = f(x',y'). [para(1172(a,1),51(a,1,2,2)),rewrite([1460(8)])].
given #88 (H,wt=13): 2048 f(x,f(y,f(x',z))) = f(x,y'). [para(220(a,1),1987(a,1,1)),rewrite([220(6)])].
given #89 (H,wt=13): 2228 f(x,f(y,z)') = f(y,f(x,z)'). [back_rewrite(2040),rewrite([2155(5),1626(5),2155(6)])].
given #90 (H,wt=13): 2229 f(x,f(y,z)') = f(z,f(x,y)'). [back_rewrite(2038),rewrite([2155(5),1142(5),2155(6)])].
given #91 (H,wt=13): 2329 f(x,f(y,f(z,x'))) = f(x,y'). [para(4(a,1),2048(a,1,2,2))].
given #92 (H,wt=13): 2330 f(x,f(f(x',y),z)) = f(x,z'). [para(4(a,1),2048(a,1,2))].
given #93 (H,wt=13): 2740 f(x,f(f(y,x'),z)') = f(x,z). [para(52(a,1),2329(a,1,2)),flip(a)].
given #94 (H,wt=14): 2030 f(x',f(f(x,y),z)) = f(x',z'). [para(4(a,1),1987(a,1,2))].
given #95 (H,wt=14): 2478 f(x,f(y,f(x,z)')) = f(x,f(y,z)). [para(2228(a,1),1160(a,1,2)),rewrite([220(7)])].
============================== PROOF =================================
% Proof 3 at 0.72 (+ 0.01) seconds: Sheffer_3.
% Length of proof is 83.
% Level of proof is 26.
% Maximum clause weight is 28.
% Given clauses 95.
3 f(f(f(y,y),x),f(f(z,z),x)) = f(f(x,f(y,z)),f(x,f(y,z))) # label(Sheffer_3) # label(non_clause) # label(goal). [goal].
4 f(x,y) = f(y,x). [assumption].
5 f(f(x,y),f(x,f(y,z))) = x. [assumption].
6 x' = f(x,x). [assumption].
7 f(x,x) = x'. [copy(6),flip(a)].
12 f(f(f(c4,c4),c5),f(f(c6,c6),c5)) != f(f(c5,f(c4,c6)),f(c5,f(c4,c6))) # label(Sheffer_3) # answer(Sheffer_3). [deny(3)].
13 f(f(c5,c4'),f(c5,c6')) != f(c5,f(c4,c6))' # answer(Sheffer_3). [copy(12),rewrite([7(3),4(4),7(7),4(8),7(20)])].
14 f(f(x,y),f(y,f(x,z))) = y. [para(4(a,1),5(a,1,1))].
15 f(f(x,y),f(x,f(z,y))) = x. [para(4(a,1),5(a,1,2,2))].
16 f(f(x,y),f(f(y,z),x)) = x. [para(4(a,1),5(a,1,2))].
18 f(x,f(x,f(x,y))) = f(x,y). [para(5(a,1),5(a,1,2)),rewrite([4(2),4(3)])].
20 f(f(x,y),f(x,y')) = x. [para(7(a,1),5(a,1,2,2))].
22 f(f(x,y),f(y,x')) = y. [para(4(a,1),20(a,1,1))].
23 f(f(x,y),f(y',x)) = x. [para(4(a,1),20(a,1,2))].
32 f(f(x,y'),f(y,x)) = x. [para(22(a,1),4(a,1)),flip(a)].
35 f(x,f(x,f(y,x))) = f(y,x). [para(22(a,1),5(a,1,2)),rewrite([4(2),4(3)])].
36 f(x,f(f(x,y)',f(x,f(y,z)))) = f(x,f(y,z)). [para(5(a,1),22(a,1,1)),rewrite([4(5)])].
38 f(x,f(f(x,y)',f(x,y'))) = f(x,y'). [para(20(a,1),22(a,1,1)),rewrite([4(5)])].
40 f(f(x,f(y,z)),f(y,x)) = x. [para(14(a,1),4(a,1)),flip(a)].
42 f(f(x,y),f(f(x,z),y)) = y. [para(4(a,1),14(a,1,2))].
51 f(x,f(f(x,y'),f(f(y,x),z))) = f(x,y'). [para(22(a,1),14(a,1,1))].
52 f(f(f(x,y),z),f(z,y)) = z. [para(22(a,1),14(a,1,2,2))].
57 f(x,f(f(x,y),f(y,z))) = f(x,y). [para(5(a,1),15(a,1,2)),rewrite([4(4)])].
68 f(x,f(f(x,f(y,z)),f(f(x,z),u))) = f(x,f(y,z)). [para(15(a,1),14(a,1,1))].
76 f(f(x,f(y,z)),f(z,x)) = x. [para(22(a,1),16(a,1,2,1))].
79 f(x,f(f(y,z),f(x,y))) = f(x,y). [para(16(a,1),14(a,1,2)),rewrite([4(4)])].
82 f(f(x,y),f(f(z,x),y)) = y. [para(4(a,1),42(a,1,2,1))].
212 f(x',f(x,y)) = x. [para(18(a,1),5(a,1,2)),rewrite([7(1)])].
218 f(x',f(y,x)) = x. [para(4(a,1),212(a,1,2))].
219 f(x,f(x,y)') = f(x,y). [para(5(a,1),212(a,1,2)),rewrite([4(3)])].
220 x'' = x. [para(7(a,1),212(a,1,2)),rewrite([7(3)])].
223 f(x,f(y,x)') = f(y,x). [para(22(a,1),212(a,1,2)),rewrite([4(3)])].
228 f(x,f(y,x')) = x'. [para(212(a,1),76(a,1,1))].
229 f(x,f(f(x,y),f(z,x'))) = f(x,y). [para(212(a,1),76(a,1,2)),rewrite([4(5)])].
277 f(x,f(f(y,x)',f(x,y'))) = f(x,y'). [para(32(a,1),23(a,1,1))].
334 f(x,f(y,f(x,y))) = x'. [para(40(a,1),68(a,1,2)),rewrite([7(1),4(3)]),flip(a)].
375 f(x,f(y,f(y,x))) = x'. [para(4(a,1),334(a,1,2,2))].
401 f(x,f(f(x,y),f(x,y)')) = x'. [para(219(a,1),334(a,1,2,2)),rewrite([4(4)])].
402 f(x,f(f(y,x),f(y,x)')) = x'. [para(223(a,1),334(a,1,2,2)),rewrite([4(4)])].
410 f(f(x,f(y,z)),f(x,f(y,x))) = f(x,f(y,z))'. [para(40(a,1),334(a,1,2,2)),rewrite([4(4)])].
432 f(f(x,y),f(x,x')) = f(x,y)'. [para(212(a,1),375(a,1,2,2)),rewrite([4(3)])].
434 f(f(x,y),f(y,y')) = f(x,y)'. [para(218(a,1),375(a,1,2,2)),rewrite([4(3)])].
713 f(f(x,y),f(x,f(f(x,y),z))) = f(x,f(f(x,y),z))'. [para(57(a,1),79(a,1,2)),rewrite([4(3),4(6),7(7),4(7),4(9)]),flip(a)].
887 f(x',f(f(x,y),f(x,y)')') = f(f(x,y),f(x,y)'). [para(401(a,1),218(a,1,2)),rewrite([4(7)])].
890 f(f(x,x'),f(f(x,y),f(x,y)')) = f(f(x,y),f(x,y)')'. [para(401(a,1),375(a,1,2,2)),rewrite([4(7)])].
892 f(x',f(f(y,x),f(f(x,z),f(x,z)'))) = f(f(x,z),f(x,z)'). [para(401(a,1),82(a,1,1))].
967 f(x',f(f(y,x),f(y,x)')') = f(f(y,x),f(y,x)'). [para(402(a,1),218(a,1,2)),rewrite([4(7)])].
970 f(f(f(x,y),f(x,y)'),f(y',f(f(x,y),f(x,y)'))) = y'. [para(402(a,1),35(a,1,2,2)),rewrite([4(10),402(16)])].
987 f(x',f(x,y)') = f(x,x'). [para(432(a,1),16(a,1,2)),rewrite([4(3),228(3)])].
997 f(f(x,y),f(x,y)')' = f(x,x')'. [para(432(a,1),375(a,1,2,2)),rewrite([890(7)])].
1007 f(f(x,y),f(x,y)') = f(y',f(x,x')'). [back_rewrite(967),rewrite([997(6)]),flip(a)].
1008 f(x',f(y,y')')' = f(y,y')'. [back_rewrite(890),rewrite([1007(6),228(8),1007(7)]),flip(a)].
1009 f(x',f(y,y')') = f(y,y'). [back_rewrite(887),rewrite([1007(5),1008(7),223(5),1007(6)]),flip(a)].
1017 f(f(x,x'),f(y',f(x,x'))) = y'. [back_rewrite(970),rewrite([1007(4),1009(5),1007(7),1009(8)])].
1029 f(x',f(y,x)') = f(x,x'). [back_rewrite(892),rewrite([1007(6),1009(7),434(5),1007(8),1009(9)])].
1030 f(x,f(y,y')) = x'. [back_rewrite(402),rewrite([1007(4),1009(5)])].
1034 f(f(x,x'),y) = y'. [back_rewrite(1017),rewrite([1030(6),220(4)])].
1053 f(x',f(f(x,x')',f(x',f(f(x,y)',z)))) = f(x',f(f(x,y)',z)). [para(987(a,1),36(a,1,2,1,1))].
1068 f(x',f(f(x,x')',f(x',f(f(y,x)',z)))) = f(x',f(f(y,x)',z)). [para(1029(a,1),36(a,1,2,1,1))].
1069 f(f(x,x')',y) = f(x,x'). [para(1030(a,1),1029(a,1,2,1)),rewrite([220(5),1034(10),220(8)])].
1070 f(x',f(f(y,x)',z)) = x. [back_rewrite(1068),rewrite([1069(10),1030(4),220(2)]),flip(a)].
1071 f(x',f(f(x,y)',z)) = x. [back_rewrite(1053),rewrite([1069(10),1030(4),220(2)]),flip(a)].
1073 f(x',f(y,f(z,x)')) = x. [para(4(a,1),1070(a,1,2))].
1105 f(x',f(y,f(x,z)')) = x. [para(4(a,1),1071(a,1,2))].
1135 f(f(x,y)',f(z,x')) = f(x,y). [para(52(a,1),1073(a,1,2,2,1))].
1139 f(f(x,y)',f(z,y')) = f(x,y). [para(76(a,1),1073(a,1,2,2,1))].
1159 f(x,f(y,x)) = f(x,y'). [back_rewrite(277),rewrite([1135(5)])].
1160 f(x,f(x,y)) = f(x,y'). [back_rewrite(38),rewrite([1139(5)])].
1172 f(f(x,y'),f(x,f(y,z))) = f(x,f(y,z))'. [back_rewrite(410),rewrite([1159(4),4(5)])].
1207 f(f(x,y)',f(f(x,z),y)) = f(y,f(x,z)'). [para(42(a,1),1159(a,1,2)),rewrite([4(3),1159(3),4(8)]),flip(a)].
1415 f(f(x,y)',f(f(y,z),x)) = f(x,f(y,z)'). [para(4(a,1),1207(a,1,1,1))].
1460 f(f(x,y'),f(y,z)') = f(y,z). [para(228(a,1),1207(a,1,1,1)),rewrite([220(2),229(5)]),flip(a)].
1626 f(x,f(y,f(x,z)')') = f(y,f(x,z)'). [para(1105(a,1),22(a,1,1)),rewrite([220(5),4(4),1160(5)])].
1987 f(x',f(y,f(x,z))) = f(x',y'). [para(1172(a,1),51(a,1,2,2)),rewrite([1460(8)])].
2032 f(f(x,y)',f(z,x)) = f(f(x,y)',z'). [para(5(a,1),1987(a,1,2,2))].
2040 f(f(x,y)',f(x,z)') = f(f(x,y)',z). [para(42(a,1),1987(a,1,2)),flip(a)].
2051 f(f(x,y)',f(y,z)') = f(f(x,y)',z). [para(82(a,1),1987(a,1,2)),flip(a)].
2155 f(f(x,y)',z) = f(x,f(y,z)'). [back_rewrite(1415),rewrite([2032(5),2051(5)])].
2228 f(x,f(y,z)') = f(y,f(x,z)'). [back_rewrite(2040),rewrite([2155(5),1626(5),2155(6)])].
2478 f(x,f(y,f(x,z)')) = f(x,f(y,z)). [para(2228(a,1),1160(a,1,2)),rewrite([220(7)])].
3140 f(x,f(y,f(x,z))) = f(x,f(y,z')). [para(1160(a,1),2478(a,1,2,2,1)),rewrite([2478(5)]),flip(a)].
3250 f(f(x,y),f(x,z')) = f(x,f(f(x,y),z))'. [back_rewrite(713),rewrite([3140(5)])].
3311 $F # answer(Sheffer_3). [back_rewrite(13),rewrite([3250(9),4(7),3140(8),220(5),4(4)]),xx(a)].
============================== end of proof ==========================
============================== STATISTICS ============================
Given=95. Generated=19519. Kept=3299. proofs=3.
Usable=58. Sos=1063. Demods=1086. Limbo=61, Disabled=2123. Hints=72.
Kept_by_rule=0, Deleted_by_rule=0.
Forward_subsumed=16217. Back_subsumed=131.
Sos_limit_deleted=0. Sos_displaced=0. Sos_removed=0.
New_demodulators=3094 (1 lex), Back_demodulated=1986. Back_unit_deleted=0.
Demod_attempts=258466. Demod_rewrites=41883.
Res_instance_prunes=0. Para_instance_prunes=0. Basic_paramod_prunes=0.
Nonunit_fsub_feature_tests=0. Nonunit_bsub_feature_tests=0.
Megabytes=2.69.
User_CPU=0.72, System_CPU=0.02, Wall_clock=1.
============================== end of statistics =====================
============================== end of search =========================
THEOREM PROVED
Exiting with 3 proofs.
Process 15846 exit (max_proofs) Wed Feb 25 12:26:19 2009
prover9-manual-2009-02A/LT-82-2-interp.out 0000644 0001750 0001750 00000011450 11151315533 017111 0 ustar mccune mccune ============================== Mace4 =================================
Mace4 (32) version 2009-02A, February 2009.
Process 15848 was started by mccune on cleo,
Wed Feb 25 12:26:19 2009
The command was "/home/mccune/bin/mace4 -N10 -f LT-82-2-interp.in".
============================== end of head ===========================
============================== INPUT =================================
% Reading from file LT-82-2-interp.in
formulas(sos).
x v y = y v x.
(x v y) v z = x v (y v z).
x ^ y = y ^ x.
(x ^ y) ^ z = x ^ (y ^ z).
x ^ (x v y) = x.
x v (x ^ y) = x.
x v 0 = x.
x ^ 1 = x.
end_of_list.
formulas(sos).
end_of_list.
formulas(goals).
x ^ (y v (x ^ z)) = x ^ (y v (z ^ ((x ^ (y v z)) v (y ^ z)))) # label(H2).
end_of_list.
% From the command line: assign(end_size, 10).
============================== end of input ==========================
============================== PROCESS NON-CLAUSAL FORMULAS ==========
% Formulas that are not ordinary clauses:
1 x ^ (y v (x ^ z)) = x ^ (y v (z ^ ((x ^ (y v z)) v (y ^ z)))) # label(H2) # label(non_clause) # label(goal). [goal].
============================== end of process non-clausal formulas ===
============================== CLAUSES FOR SEARCH ====================
formulas(mace4_clauses).
x v y = y v x.
(x v y) v z = x v (y v z).
x ^ y = y ^ x.
(x ^ y) ^ z = x ^ (y ^ z).
x ^ (x v y) = x.
x v (x ^ y) = x.
x v 0 = x.
x ^ 1 = x.
c1 ^ (c2 v (c3 ^ ((c1 ^ (c2 v c3)) v (c2 ^ c3)))) != c1 ^ (c2 v (c1 ^ c3)) # label(H2).
end_of_list.
============================== end of clauses for search =============
% The largest natural number in the input is 1.
============================== DOMAIN SIZE 2 =========================
============================== STATISTICS ============================
For domain size 2.
Current CPU time: 0.00 seconds (total CPU time: 0.01 seconds).
Ground clauses: seen=37, kept=35.
Selections=7, assignments=14, propagations=8, current_models=0.
Rewrite_terms=234, rewrite_bools=42, indexes=13.
Rules_from_neg_clauses=1, cross_offs=1.
============================== end of statistics =====================
============================== DOMAIN SIZE 3 =========================
============================== STATISTICS ============================
For domain size 3.
Current CPU time: 0.00 seconds (total CPU time: 0.01 seconds).
Ground clauses: seen=97, kept=95.
Selections=13, assignments=39, propagations=18, current_models=0.
Rewrite_terms=718, rewrite_bools=121, indexes=50.
Rules_from_neg_clauses=0, cross_offs=5.
============================== end of statistics =====================
============================== DOMAIN SIZE 4 =========================
============================== STATISTICS ============================
For domain size 4.
Current CPU time: 0.00 seconds (total CPU time: 0.01 seconds).
Ground clauses: seen=201, kept=199.
Selections=27, assignments=101, propagations=62, current_models=0.
Rewrite_terms=2553, rewrite_bools=653, indexes=160.
Rules_from_neg_clauses=0, cross_offs=25.
============================== end of statistics =====================
============================== DOMAIN SIZE 5 =========================
============================== STATISTICS ============================
For domain size 5.
Current CPU time: 0.00 seconds (total CPU time: 0.01 seconds).
Ground clauses: seen=361, kept=359.
Selections=49, assignments=225, propagations=221, current_models=0.
Rewrite_terms=8657, rewrite_bools=2568, indexes=538.
Rules_from_neg_clauses=3, cross_offs=158.
============================== end of statistics =====================
============================== DOMAIN SIZE 6 =========================
============================== MODEL =================================
interpretation( 6, [number=1, seconds=0], [
function(c1, [ 2 ]),
function(c2, [ 3 ]),
function(c3, [ 4 ]),
function(^(_,_), [
0, 0, 0, 0, 0, 0,
0, 1, 2, 3, 4, 5,
0, 2, 2, 0, 0, 0,
0, 3, 0, 3, 5, 5,
0, 4, 0, 5, 4, 5,
0, 5, 0, 5, 5, 5 ]),
function(v(_,_), [
0, 1, 2, 3, 4, 5,
1, 1, 1, 1, 1, 1,
2, 1, 2, 1, 1, 1,
3, 1, 1, 3, 1, 3,
4, 1, 1, 1, 4, 4,
5, 1, 1, 3, 4, 5 ])
]).
============================== end of model ==========================
============================== STATISTICS ============================
For domain size 6.
Current CPU time: 0.00 seconds (total CPU time: 0.02 seconds).
Ground clauses: seen=589, kept=587.
Selections=34, assignments=139, propagations=207, current_models=1.
Rewrite_terms=7453, rewrite_bools=2139, indexes=783.
Rules_from_neg_clauses=2, cross_offs=234.
============================== end of statistics =====================
User_CPU=0.02, System_CPU=0.00, Wall_clock=0.
Exiting with 1 model.
Process 15848 exit (max_models) Wed Feb 25 12:26:19 2009
The process finished Wed Feb 25 12:26:19 2009
prover9-manual-2009-02A/ring41.out 0000644 0001750 0001750 00000022647 11151315541 016022 0 ustar mccune mccune ============================== Mace4 =================================
Mace4 (32) version 2009-02A, February 2009.
Process 15849 was started by mccune on cleo,
Wed Feb 25 12:26:19 2009
The command was "/home/mccune/bin/mace4 -f ring41.in".
============================== end of head ===========================
============================== INPUT =================================
% Reading from file ring41.in
assign(iterate,primes).
set(integer_ring).
% set(integer_ring) -> clear(lnh).
formulas(assumptions).
g(x) = M * x.
f(x,y) = (H * x) + (K * y).
f(f(a,b),c) != f(a,f(b,c)).
end_of_list.
formulas(assumptions).
g(f(g(f(y,f(x,z))),f(y,f(f(x,x),g(x))))) = z.
end_of_list.
============================== end of input ==========================
============================== PROCESS NON-CLAUSAL FORMULAS ==========
% Formulas that are not ordinary clauses:
============================== end of process non-clausal formulas ===
============================== CLAUSES FOR SEARCH ====================
formulas(mace4_clauses).
g(x) = M * x.
f(x,y) = (H * x) + (K * y).
f(f(a,b),c) != f(a,f(b,c)).
g(f(g(f(x,f(y,z))),f(x,f(f(y,y),g(y))))) = z.
end_of_list.
============================== end of clauses for search =============
% There are no natural numbers in the input.
============================== DOMAIN SIZE 2 =========================
============================== STATISTICS ============================
For domain size 2.
Current CPU time: 0.00 seconds (total CPU time: 0.01 seconds).
Ground clauses: seen=15, kept=15.
Selections=14, assignments=28, propagations=32, current_models=0.
Rewrite_terms=431, rewrite_bools=47, indexes=32.
Rules_from_neg_clauses=0, cross_offs=0.
============================== end of statistics =====================
============================== DOMAIN SIZE 3 =========================
============================== STATISTICS ============================
For domain size 3.
Current CPU time: 0.00 seconds (total CPU time: 0.01 seconds).
Ground clauses: seen=40, kept=40.
Selections=26, assignments=78, propagations=162, current_models=0.
Rewrite_terms=2493, rewrite_bools=203, indexes=243.
Rules_from_neg_clauses=0, cross_offs=0.
============================== end of statistics =====================
============================== DOMAIN SIZE 5 =========================
============================== STATISTICS ============================
For domain size 5.
Current CPU time: 0.00 seconds (total CPU time: 0.01 seconds).
Ground clauses: seen=156, kept=156.
Selections=62, assignments=310, propagations=1250, current_models=0.
Rewrite_terms=24257, rewrite_bools=1229, indexes=3125.
Rules_from_neg_clauses=0, cross_offs=0.
============================== end of statistics =====================
============================== DOMAIN SIZE 7 =========================
============================== STATISTICS ============================
For domain size 7.
Current CPU time: 0.00 seconds (total CPU time: 0.04 seconds).
Ground clauses: seen=400, kept=400.
Selections=114, assignments=798, propagations=4802, current_models=0.
Rewrite_terms=112588, rewrite_bools=4087, indexes=16807.
Rules_from_neg_clauses=0, cross_offs=0.
============================== end of statistics =====================
============================== DOMAIN SIZE 11 ========================
============================== STATISTICS ============================
For domain size 11.
Current CPU time: 0.00 seconds (total CPU time: 0.21 seconds).
Ground clauses: seen=1464, kept=1464.
Selections=266, assignments=2926, propagations=29282, current_models=0.
Rewrite_terms=923036, rewrite_bools=21251, indexes=161051.
Rules_from_neg_clauses=0, cross_offs=0.
============================== end of statistics =====================
============================== DOMAIN SIZE 13 ========================
============================== STATISTICS ============================
For domain size 13.
Current CPU time: 0.00 seconds (total CPU time: 0.63 seconds).
Ground clauses: seen=2380, kept=2380.
Selections=366, assignments=4758, propagations=57122, current_models=0.
Rewrite_terms=2030641, rewrite_bools=39493, indexes=371293.
Rules_from_neg_clauses=0, cross_offs=0.
============================== end of statistics =====================
============================== DOMAIN SIZE 17 ========================
============================== STATISTICS ============================
For domain size 17.
Current CPU time: 0.00 seconds (total CPU time: 2.50 seconds).
Ground clauses: seen=5220, kept=5220.
Selections=614, assignments=10438, propagations=167042, current_models=0.
Rewrite_terms=7281011, rewrite_bools=108017, indexes=1419857.
Rules_from_neg_clauses=0, cross_offs=0.
============================== end of statistics =====================
============================== DOMAIN SIZE 19 ========================
============================== MODEL =================================
interpretation( 19, [number=1, seconds=5], [
function(H, [17 ]),
function(K, [14 ]),
function(M, [ 7 ]),
function(a, [ 0 ]),
function(b, [ 0 ]),
function(c, [ 1 ]),
function(g(_), [ 0, 7,14, 2, 9,16, 4,11,18, 6,13, 1, 8,15, 3,10,17, 5,12 ]),
function(*(_,_), [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,
0, 2, 4, 6, 8,10,12,14,16,18, 1, 3, 5, 7, 9,11,13,15,17,
0, 3, 6, 9,12,15,18, 2, 5, 8,11,14,17, 1, 4, 7,10,13,16,
0, 4, 8,12,16, 1, 5, 9,13,17, 2, 6,10,14,18, 3, 7,11,15,
0, 5,10,15, 1, 6,11,16, 2, 7,12,17, 3, 8,13,18, 4, 9,14,
0, 6,12,18, 5,11,17, 4,10,16, 3, 9,15, 2, 8,14, 1, 7,13,
0, 7,14, 2, 9,16, 4,11,18, 6,13, 1, 8,15, 3,10,17, 5,12,
0, 8,16, 5,13, 2,10,18, 7,15, 4,12, 1, 9,17, 6,14, 3,11,
0, 9,18, 8,17, 7,16, 6,15, 5,14, 4,13, 3,12, 2,11, 1,10,
0,10, 1,11, 2,12, 3,13, 4,14, 5,15, 6,16, 7,17, 8,18, 9,
0,11, 3,14, 6,17, 9, 1,12, 4,15, 7,18,10, 2,13, 5,16, 8,
0,12, 5,17,10, 3,15, 8, 1,13, 6,18,11, 4,16, 9, 2,14, 7,
0,13, 7, 1,14, 8, 2,15, 9, 3,16,10, 4,17,11, 5,18,12, 6,
0,14, 9, 4,18,13, 8, 3,17,12, 7, 2,16,11, 6, 1,15,10, 5,
0,15,11, 7, 3,18,14,10, 6, 2,17,13, 9, 5, 1,16,12, 8, 4,
0,16,13,10, 7, 4, 1,17,14,11, 8, 5, 2,18,15,12, 9, 6, 3,
0,17,15,13,11, 9, 7, 5, 3, 1,18,16,14,12,10, 8, 6, 4, 2,
0,18,17,16,15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]),
function(+(_,_), [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,
1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18, 0,
2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18, 0, 1,
3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18, 0, 1, 2,
4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18, 0, 1, 2, 3,
5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18, 0, 1, 2, 3, 4,
6, 7, 8, 9,10,11,12,13,14,15,16,17,18, 0, 1, 2, 3, 4, 5,
7, 8, 9,10,11,12,13,14,15,16,17,18, 0, 1, 2, 3, 4, 5, 6,
8, 9,10,11,12,13,14,15,16,17,18, 0, 1, 2, 3, 4, 5, 6, 7,
9,10,11,12,13,14,15,16,17,18, 0, 1, 2, 3, 4, 5, 6, 7, 8,
10,11,12,13,14,15,16,17,18, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
11,12,13,14,15,16,17,18, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,
12,13,14,15,16,17,18, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,
13,14,15,16,17,18, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,
14,15,16,17,18, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,
15,16,17,18, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
16,17,18, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,
17,18, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,
18, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17 ]),
function(f(_,_), [
0,14, 9, 4,18,13, 8, 3,17,12, 7, 2,16,11, 6, 1,15,10, 5,
17,12, 7, 2,16,11, 6, 1,15,10, 5, 0,14, 9, 4,18,13, 8, 3,
15,10, 5, 0,14, 9, 4,18,13, 8, 3,17,12, 7, 2,16,11, 6, 1,
13, 8, 3,17,12, 7, 2,16,11, 6, 1,15,10, 5, 0,14, 9, 4,18,
11, 6, 1,15,10, 5, 0,14, 9, 4,18,13, 8, 3,17,12, 7, 2,16,
9, 4,18,13, 8, 3,17,12, 7, 2,16,11, 6, 1,15,10, 5, 0,14,
7, 2,16,11, 6, 1,15,10, 5, 0,14, 9, 4,18,13, 8, 3,17,12,
5, 0,14, 9, 4,18,13, 8, 3,17,12, 7, 2,16,11, 6, 1,15,10,
3,17,12, 7, 2,16,11, 6, 1,15,10, 5, 0,14, 9, 4,18,13, 8,
1,15,10, 5, 0,14, 9, 4,18,13, 8, 3,17,12, 7, 2,16,11, 6,
18,13, 8, 3,17,12, 7, 2,16,11, 6, 1,15,10, 5, 0,14, 9, 4,
16,11, 6, 1,15,10, 5, 0,14, 9, 4,18,13, 8, 3,17,12, 7, 2,
14, 9, 4,18,13, 8, 3,17,12, 7, 2,16,11, 6, 1,15,10, 5, 0,
12, 7, 2,16,11, 6, 1,15,10, 5, 0,14, 9, 4,18,13, 8, 3,17,
10, 5, 0,14, 9, 4,18,13, 8, 3,17,12, 7, 2,16,11, 6, 1,15,
8, 3,17,12, 7, 2,16,11, 6, 1,15,10, 5, 0,14, 9, 4,18,13,
6, 1,15,10, 5, 0,14, 9, 4,18,13, 8, 3,17,12, 7, 2,16,11,
4,18,13, 8, 3,17,12, 7, 2,16,11, 6, 1,15,10, 5, 0,14, 9,
2,16,11, 6, 1,15,10, 5, 0,14, 9, 4,18,13, 8, 3,17,12, 7 ])
]).
============================== end of model ==========================
============================== STATISTICS ============================
For domain size 19.
Current CPU time: 0.00 seconds (total CPU time: 5.83 seconds).
Ground clauses: seen=7240, kept=7240.
Selections=741, assignments=14010, propagations=243827, current_models=1.
Rewrite_terms=11696989, rewrite_bools=162188, indexes=2318342.
Rules_from_neg_clauses=0, cross_offs=0.
============================== end of statistics =====================
User_CPU=5.83, System_CPU=0.01, Wall_clock=6.
Exiting with 1 model.
Process 15849 exit (max_models) Wed Feb 25 12:26:25 2009
The process finished Wed Feb 25 12:26:25 2009
prover9-manual-2009-02A/RBA-2.in 0000644 0001750 0001750 00000000526 10576540322 015257 0 ustar mccune mccune % This lemma says that if there exists an idempotent
% elememt, then a Robbins algebra is Boolean.
formulas(assumptions).
x + y = y + x.
(x + y) + z = x + (y + z).
((x + y)' + (x + y')')' = x # label(Robbins).
exists c (c + c = c).
end_of_list.
formulas(goals).
(x + y')' + (x' + y')' = y # answer(Huntington).
end_of_list.
prover9-manual-2009-02A/BA4.out 0000644 0001750 0001750 00000000666 11151315545 015265 0 ustar mccune mccune f(f(x,x),f(f(f(y,y),f(z,z)),f(f(y,y),f(z,z)))) = f(f(y,y),f(f(f(x,x),f(z,z)),f(f(x,x),f(z,z)))).
f(f(x,y),f(x,y)) = f(f(f(f(x,x),f(x,x)),f(f(y,y),f(y,y))),f(f(f(x,x),f(x,x)),f(f(y,y),f(y,y)))).
f(f(x,x),f(f(x,x),f(x,x))) = f(f(y,y),f(f(y,y),f(y,y))).
f(f(f(f(x,x),f(f(y,y),f(y,y))),f(f(x,x),f(y,y))),f(f(f(x,x),f(f(y,y),f(y,y))),f(f(x,x),f(y,y)))) = x.
% rewriter BA-Sheffer.demods: rewrote 4 terms with 17 rewrite steps in 0.01 seconds.
prover9-manual-2009-02A/README.run 0000644 0001750 0001750 00000000611 10547023565 015645 0 ustar mccune mccune 1. Update the content of the manual. Check against
/home/mccune/LADR/Changelog
2. Run all of the example jobs for the manual and
check against the old versions
% ./run-and-check /home/mccune/bin
% less checked-jobs/*.diffs
% /bin/rm checked-jobs/*
3. Update the version number of the manual:
% emacs sed.version
% rewrite-files sed.version *.html
% /bin/rm *.bak
prover9-manual-2009-02A/select.html 0000644 0001750 0001750 00000026162 11151021064 016320 0 ustar mccune mccune
Prover9 Manual: Selecting the Given Clause
Prover9 Manual
Version 2009-02A
Selecting the Given Clause
At each iteration of the main loop,
Prover9 selects a given clause from the sos list,
moves it to the usable list, and makes inferences
from it and other clauses in the usable list.
A basic way to select the given clause is to always select the
lightest clause
in sos.
Otter has the ability to mix two methods of selecting
the given clause in a ratio determined by a parameter ---
selecting the lightest clause and selecting the oldest
clause. This method adds a breadth-first component
to the search. See the
pick_given_ratio
parameter below.
Prover9 uses six components in selecting the given clause.
The following six options are used.
The false/true distinction is determined by a set of interpretations.
The default interpretation is that negative clauses are false
and non-negative clauses are true. To use explicit interpretations,
see the section on semantic guidance.
Under the default interpretation, for example, if
age_part = 1,
false_part = 2, and
true_part = 3,
given clauses will be selected in a cycle of size six: one clause
by lowest ID, then two clauses because they are the lightest
negative (i.e., false) clauses, then three clauses because they are the
lightest non-negative (i.e., true) clauses. And so on.
If a clause of required type is not available, that component of
the ratio is simply skipped. For example, with ratio in the
preceding paragraph, if no false clauses are available, the
cycle has size four (one part age, 3 parts true clauses)
until some false clauses become available.
Note that the default value of
hints_part
is INT_MAX. This means that whenever the selection cycle
gets to the
hints_part,
clauses that match hints
will be selected as long as any are available.
When a given clause is printed, its sequence number, the reason
it was selected, its weight, and its ID are also shown as in the following
excerpt.
given #1 (I,wt=7): 9 x v y = y v x. [input].
...
given #18 (T,wt=5): 28 x v x = x. [para(13(a,1),14(a,1,2))].
given #19 (A,wt=11): 18 x ^ (y ^ z) = y ^ (x ^ z). [para(11(a,1),12(a,1,1)),demod(12(2))].
given #20 (F,wt=21): 43 x ^ (((x v y) ^ z) v ((x v z) ^ y)) = (x ^ z) v (x ^ y) # label(false). [para(11(a,1),32(a,1,2,2))].
The selection codes are
A=age, W=weight, F=false, T=true,
H=hints, R=random, and I=input (see flag
input_sos_first).
More selection criteria will likely be added in future
versions of Prover9.
If n ≥ 0, it is used as the seed.
If n = -1, Prover9 selects a seed, based on the value of
the system clock; in this case, Prover9 jobs are not reproducibe.
D. Champeaux.
Sub-problem finder and instance checker, two cooperating modules for
theorem provers.
J. ACM, 33(4):633--657, 1986.
W. McCune.
Otter 3.3 Reference Manual.
Tech. Memo ANL/MCS-TM-263, Mathematics and Computer Science Division,
Argonne National Laboratory, Argonne, IL, August 2003.
W. McCune.
Mace4 Reference Manual and Guide.
Tech. Memo ANL/MCS-TM-264, Mathematics and Computer Science Division,
Argonne National Laboratory, Argonne, IL, August 2003.
R. Veroff.
Using hints to increase the effectiveness of an automated reasoning
program: Case studies.
J. Automated Reasoning, 16(3):223--239, 1996.
R. Veroff.
Solving open questions and other challenge problems using proof
sketches.
J. Automated Reasoning, 27(2):157--174, 2001.
Prover9 has a method of using finite interpretations
to guide the search for a proof; in particular, to
help select the given clause.
To use semantic guidance the user gives one
or more interpretations along with the ordinary
Prover9 input. All clauses (input and derived) that are eligible to be
selected as given clauses are evaluated in the interpretations.
If a clause is false in all of the interpretations, it is
marked as "false" and given the attribute label(false);
if it is true in any of the interpretations, it is marked as "true".
(There is an exception: see the parameter
eval_limit
below.)
If a clause being evaluated contains a symbol that is
not in an interpretation, a warning message is given, and
the clause receives the value "true".
When selecting the given clause,
Prover9 may use the parameters
true_part,and
false_part,
as described on the page
Selecting the Given Clause.
With semantic guidance (explicit interpretations), the
"true_part" and "false_part" refer simply to clauses marked as
"true" and "false" with respect to the interpretations.
Format of Interpretations for Semantic Guidance
The interpretations are finite and must be in the format
produced by Mace4. They must
appear in a list that starts with list(interpretations).
and ends with and_of_list. The following example
is a lattice in terms of the meet and join operations.
The interpretation is the only additional input needed to give
semantic guidance.
The default values of the parameters
age_part,
true_part,
false_part, and
eval_limit,
work well for this job (and many others).
The interpretation does not contain Skolem constants that appear in
the denial, and warning messages are given when Prover9 attempts
to evaluate clauses containing those Skolem constants.
(They receive the value "true".)
One of the input clauses is assigned the attribute
label(false), because it is false in the interpretation.
The "false" given clauses (#12, #13, #17, #18, #22, #23, ...)
are mostly heavier than the "true" given clauses, showing that they
would likely not enter the search at such an early stage without
semantic guidance.
At given clause #138, there are no more false clauses to select;
and then several more are inferred and given near the end of the search,
leading to a proof.
This job takes about 11 seconds. A similar job without
semantic guidance takes about 25 minutes to find a proof.
Advice on Selecting Interpretations
If the conjecture formulates naturally as
theory, hypotheses -> conclusion,
a good first step is to try the smallest model of the theory
in which the conclusion is false.
The preceding example has that form, and
the interpretation used in the that example
can be easily found with the following Mace4 job.
with no obvious hypothesis, one can try to slightly weaken the theory
in some way that relates to the conclusion,
and use a model of the weakened theory in which the conclusion is
false.
Options for Semantic Guidance
Aside from the parameters
true_part,and
false_part,
which may be used regardless of whether semantic guidance is in effect,
there are just two options to control semantic guidance.
Next Section:
Mace4
prover9-manual-2009-02A/references.tex 0000644 0001750 0001750 00000000362 10430710730 017014 0 ustar mccune mccune \documentstyle{article}
\begin{document}
\paragraph{Journal Articles and Book Chapters}
\nocite{otter33,miniscope,mace4,veroff:hints,veroff:sketches}
\bibliographystyle{unsrt}
\bibliography{/home/mccune/papers/bib/master}
\end{document}
prover9-manual-2009-02A/ring41.in 0000644 0001750 0001750 00000002045 10727134455 015622 0 ustar mccune mccune
assign(iterate, primes).
% The following fixes [+,-,*] as the ring of integers (mod domain_size).
set(integer_ring).
formulas(assumptions).
% Assume that f and g have a ring structure.
g(x) = M * x.
f(x,y) = (H * x) + (K * y).
% Denial of associativity.
f(f(a,b),c) != f(a,f(b,c)).
end_of_list.
formulas(assumptions).
% Each of these equations was a candidate for being a single axiom
% for group theory.
%
% We can show that each has a nonassociative model (and therefore
% is not a single axiom) by using ring structures.
%
% The sizes required for these examples range from 11 to 41.
% f(f(g(f(y,g(z))),x),f(f(g(f(z,x)),z),y)) = z. % candidate 1
% f(f(x,f(g(x),z)),f(g(f(f(y,x),g(x))),y)) = z. % candidate 64
% f(f(f(x,x),g(x)),g(f(g(f(y,z)),f(y,x)))) = z. % candidate 30
g(f(g(f(y,f(x,z))),f(y,f(f(x,x),g(x))))) = z. % candidate 107
% g(f(g(f(x,f(y,z))),f(f(f(g(x),x),x),y))) = z. % candidate 60
% f(f(y,g(f(z,y))),f(f(z,g(f(x,g(z)))),x)) = z. % candidate 68
% f(f(x,y),f(y,g(f(f(g(f(g(x),z)),y),y)))) = z. % candidate 11
end_of_list.
prover9-manual-2009-02A/x2.standard 0000644 0001750 0001750 00000000371 11151315541 016226 0 ustar mccune mccune interpretation( 6, [number = 1,seconds = 0], [
function(*(_,_), [0,1,2,3,4,5,1,0,3,2,5,4,2,4,0,5,1,3,3,5,1,4,0,2,4,2,5,0,3,1,5,3,4,1,2,0]),
function('(_), [0,1,2,4,3,5]),
function(e, [0]),
function(c1, [1]),
function(c2, [2])]).
prover9-manual-2009-02A/run-and-check 0000755 0001750 0001750 00000000644 10557700313 016527 0 ustar mccune mccune #!/bin/csh
if ($#argv != 1) then
echo "need 1 arg: bin-directory"
exit(1)
endif
set bin=$1
set dir=checked-jobs
if -e checked-jobs/andrews.out then
/bin/rm checked-jobs/*
endif
set outs=`grep '>' go | sed 's/.*> //'`
/bin/mv $outs checked-jobs
./go $bin
cd checked-jobs
foreach i ($outs)
diff $i ../$i > $i.diffs
if -z $i.diffs /bin/rm $i.diffs
end
echo "See the files $dir/*.diffs"
prover9-manual-2009-02A/syntax.html 0000644 0001750 0001750 00000047203 11151021064 016366 0 ustar mccune mccune
Prover9 Manual: Clauses and Formulas
Prover9 Manual
Version 2009-02A
Clauses and Formulas
The Glossary Page contains definitions
of term,
atomic formula,
literal, clause,
and formula from a logical point of view.
This page contains descriptions of how those kinds of things are parsed
and printed, and we refer to them collectively as objects.
In Otter and in earlier versions of Prover9,
"clauses" and "formulas" were distinct types of object,
and "formulas" could not have free variables.
Now, clauses are a subset of formulas.
Here are the important points about clauses and formulas.
Clauses are a subset of formulas. All input formulas, including clauses,
appear in a list headed by
formulas(list_name).
There is a rule for distinguishing variables from constants,
because clauses and other formulas can have free variables
(variables not bound by quantifiers). The default rule
is that variables start with (lower case) u through z.
For example, in the formula P(a,x), the term
a is a constant, and
x is a variable.
(See also the flag prolog_style_variables.)
Free variables in clauses and formulas are assumed to be universally
quantified at the outermost level.
Prover9's inference rules operate on clauses.
If non-clausal formulas are input,
Prover9 immediately translates them clauses
by NNF,
Skolemization,
and CNF conversions.
Parsing and Printing Objects
The prefix standard form of an object with an n-ary symbol, say f,
at the root is
f( argument_1, ..., argument_n )
Whitespace (spaces, tabs, newline, etc.) is accepted anywhere
except within symbols.
Prover9 will accept any term or formula written
prefix standard form. However formulas and
many terms can be written in more convenient ways, for example,
"a=b | a!=c'" instead of "|(=(a,b),-(=(a,'(c))))".
Prover9 uses a general mechanism in which binary and unary symbols
can have special parsing properties such as "infix",
"infix-right-associated", "postfix". In addition, each of
those symbols has a precedence so that many parentheses
can be omitted. (The mechanism is similar to those used by
most Prolog systems.)
Many symbols have built-in parsing properties
(see the table below),
and the user can declare parsing properties for
other symbols with the "op" command.
Clauses and formulas make extensive use of the built-in
parsing properties for the equality relation and the logic connectives.
Instead of first presenting the general mechanism,
we will present the syntax for formulas
under the assumption of the built-in parsing properties.
The general mechanism is described below in the
section Infix, Prefix, and Postfix Declarations.
Symbols
Symbols include variables, constants, function symbols, predicate symbols,
logic connectives. Symbols do not include parentheses or commas.
Prover9 recognizes several kinds of symbol.
An ordinary symbol is a (maximal) string made from the
characters
a-z, A-Z, 0-9,
$, and _.
The reason for separating ordinary and special symbols is so that
strings like a+b; that is, +(a,b),
can be written without any whitespace around the +.
A symbol cannot have both ordinary and special characters,
for example R+ (unless it is a quoted symbol).
Objects (terms or formulas) are constructed from
symbols, parentheses, and commas.
Overloaded Symbols
In most cases, symbol overloading is not allowed. For example
a symbol cannot be both a function symbol and a predicate symbol,
or both a constant and a binary function symbol. There
are a few exceptions.
The logic connectives can also be used as function or
predicate symbols of the same arity. For example,
- is typically used as unary arithmetic minus
well as for logical negation.
Prover9 is much more strict about overloading symbols than Otter is.
Symbols With Meaning
Several symbols have built-in meaning. These are the equality
symbols (=, !=) and logic connectives
(-, |, &, ->, <-,
<->, all, exists). These
symbols can be changed as described in the section
Redeclaring Built-in Symbols.
(Parentheses, comma, period, and the list construction symbols
cannot be redeclared.)
Any term can be written in prefix standard form, for example,
f(g(x),y) and *('(x),y). If symbols in the
term have parsing/printing properties (either
built-in)
or declared with the op command), the term can be
written in infix/prefix/postfix form with assumed precedence,
for example, x'*y, which represents *('(x),y) under
the built-in parsing/printing properties.
A list notation similar to Prolog's can be used to write
terms that represent lists. Note that the "cons" operator
is ":", instead of "|" as in Prolog.
Term
Standard Prefix Form
What it Is
[]
$nil
the empty list
[a,b,c]
$cons(a,$cons(b,$cons(c,$nil)))
list of three objects
[a:b]
$cons(a,b)
first, rest
[a,b:c]
$cons(a,$cons(b,c))
first, second, rest
Lists are frequently used in Prover9 commands such as the
function_order
command, and they are sometimes also used in clauses and formulas.
Atomic Formulas
Equality is a built-in special case.
The binary predicate symbol =
is usually written as an infix relation.
The binary symbol != is an abbreviation for "not equal";
that is, the formula a!=b stands for -(a=b),
or more precisely, -(=(a,b)).
From the semantics point of view,
the binary predicate symbol =
is the one and only equality symbol for the inference
rules that use equality.
Clauses
The disjunction (OR) symbol is |,
and the negation (NOT) symbol is -.
The disjunction symbol has higher precedence than the equality symbol,
so equations in clauses do not need parentheses. Every clause ends
with a period.
Examples of clauses follow (Prover9 adds some
extra space when printing clauses).
When writing formulas, the built-in parsing declarations
allow many parentheses to be omitted. For example, the following two formulas
are really the same formula.
formulas(sos).
all x all y (p <-> -q | r & -s) .
(all x (all y (p <-> ((-q) | (r & (-s)))))).
end_of_list.
For Prover9 formulas, each quantified variable must have its own
quantifier; Otter allows quantifiers to be omitted in a sequence
of quantified variables with the same quantifier. For example,
Otter allows (all x y z p(x,y,z)), and Prover9 requires
(all x all y all z p(x,y,z)).
Several symbols are understood by Prover9 as having special
parsing properties that determine how terms involving those
symbols can be arranged.
In addition, the user can declare additional symbols to have special
parsing properties.
Parsing Declarations
The "op" command is used to declare parse types and precedences.
op( precedence, type, symbols(s) ). % declare parse type and precedence
1 ≤ precedence ≤ 998.
type is one of
{ infix, infix_left, infix_right, prefix, prefix_paren, postfix, postfix_paren, ordinary }.
symbol(s) is either a symbol or a list of symbols.
Each multi-character special symbol must be enclosed in double quotes.
Prover9 does not allow different symbol types with the same precedence,
for example,
op(325, postfix, ').
op(325, prefix, ~).
This restriction prevents ambiguous strings such as ~x'.
The following table shows an example of each type of parsing
property (and ignores precedence).
Type
Example
Standard Prefix
Comment
infix
a*(b*c)
*(a,*(b,c))
like Prolog's xfx
infix_left
a*b*c
*(*(a,b),c)
like Prolog's yfx
infix_right
a*b*c
*(a,*(b,c))
like Prolog's xfy
prefix
--p
-(-(p))
like Prolog's fy
prefix_paren
-(-p)
-(-(p))
like Prolog's fx
postfix
a''
'('(a))
like Prolog's yf
postfix_paren
(a')'
'('(a))
like Prolog's xf
ordinary
*(a,b)
*(a,b)
takes away parsing properties
Higher precedence means closer to the root of the object,
and lower precedence means the the symbol binds more closely.
For example, assume that the following declarations are in effect.
op(790, infix_right, "|" ). % disjunction in formulas or clauses
op(780, infix_right, "&" ). % conjunction in formulas
Then the string a & b | c is an abbreviation for (a & b) | c.
The built-in parsing declarations are shown in the following box.
The ones with comments have built-in meanings;
the others are for general use as function or predicate symbols.
NOTE: Keep in mind the difference between semantic
properties of symbols (e.g., logic connectives) and
parsing/printing properties of symbols
(e.g., infix with high precedence).
Those two kinds of property are independent
(by default, many symbols have both).
Most of the symbols with built-in meaning can be
changed to other symbols. The symbols that can be
changed are shown in the following table.
Operation
Default Symbol
true
$T
false
$F
negation
-
disjunction
|
conjunction
&
implication
->
backward_implication
<-
equivalence
<->
universal_quantification
all
existential_quantification
exists
equality
=
negated_equality
!=
attribute
#
To change the symbol associated with an operation, one
uses the following command.
redeclare( operation, symbol ). % associate a different symbol with an operation
For example, the following command says that "AND" will be used
for conjunction.
redeclare(conjunction, AND). % change the conjunction symbol to AND.
As with the "op" command, if the new symbol is a
multicharacter special symbol,
it must be enclosed in double quotes, as in the following
example.
redeclare(conjunction, "&&"). % change the conjunction symbol to &&.
When in doubt, quote the symbol, because unnecessary quotes are
ignored in the "redeclare" and "op" commands.
Parsing/Printing Properties and Redeclarations
Many of the default symbols for the built-in operations have
default printing/parsing properties, for example, the default
properties for default conjunction symbol are
op(780, infix_right, "&" ). % conjunction in formulas
When a redeclaration for such an operation occurs, the parsing/printing
properties are copied from the old symbol to the new symbol.
For example, when conjunction is changed to AND, the
following is automatically applied.
op(780, infix_right, AND ).
If the user wishes some other printing/parsing properties for the
new symbol, the appropriate "op" command can be placed
after the "redeclare" command.
Redeclaration Example
The following example shows redeclarations of many of the operations.
Most of the operations can be redeclared repeatedly throughout
the input. The declarations in effect when a formula is read
will be used, ane the ones in effect at the end of the
input will be used for all subsequent output.
An exception: If the operations "equality" or
"negated_equality" are redeclared, it must be done
before any formulas containing those symbols are read.
