twee 2.6.1 → 2.7.1

raw patch · 170 files changed

+5623/−3039 lines, 170 filesdep +asyncdep +binarydep +bytestringdep ~jukeboxdep ~twee-libnew-component:exe:parallel-tweenew-component:exe:twee-lpo

Dependencies added: async, binary, bytestring, hashable, process, tasty, tasty-quickcheck, unix

Dependency ranges changed: jukebox, twee-lib

Files

README.md +2/−2
examples/BOO067-1.p +32/−0
examples/GRP196-1.p +40/−0
examples/GRP666-4.p +63/−0
examples/LAT071-1.p +37/−0
examples/LAT072-1.p +37/−0
examples/LAT073-1.p +37/−0
examples/PUZ037-3-2.p +106/−0
examples/PUZ037-3.p +110/−0
examples/PUZ052-1.p +129/−0
examples/REL038-1.p +14/−0
examples/RNG025-buggy.p +9/−0
examples/RNG035-7.p +12/−0
examples/ROB010-1.p +11/−0
examples/ROB027-1-pretty.p +56/−0
examples/ROB027-1.p +56/−0
examples/ROB033-1.p +10/−0
examples/aim.p +54/−0
examples/append-rev.p +4/−0
examples/cm.p +3/−0
examples/deriv.p +37/−0
examples/diff.p +8/−0
examples/diff2.p +34/−0
examples/distributive_groupoid.p +12/−0
examples/factor.p +44/−0
examples/filter.p +59/−0
examples/gmv.p +74/−0
examples/group.p +14/−0
examples/haken.p +170/−0
examples/loop.p +6/−0
examples/loop2.p +6/−0
examples/lukasiewicz.p +6/−0
examples/minus.p +10/−0
examples/nicomachus.p +36/−0
examples/regexp.p +54/−0
examples/rel.p +32/−0
examples/rel2.p +32/−0
examples/rellat_appendixa.p +27/−0
examples/rellat_appendixb.p +28/−0
examples/rellat_appendixb_easier.p +30/−0
examples/rellat_appendixc.p +30/−0
examples/rellat_theorem34_6.p +32/−0
examples/rellat_theorem34_6a.p +29/−0
examples/rellat_theorem34_6b.p +29/−0
examples/ring.p +9/−0
examples/ring2-cancel.p +9/−0
examples/ring2.p +9/−0
examples/ring3.p +9/−0
examples/ring4.p +9/−0
examples/robbins-easy.p +4/−0
examples/robbins-hints.p +39/−0
examples/robbins.p +4/−0
examples/sam.p +38/−0
examples/semigroup.p +4/−0
examples/sudoku.p +39/−0
examples/sum.p +30/−0
examples/vbool.p +18/−0
examples/veroff-short.p +11/−0
examples/veroff.p +11/−0
examples/winker-easy.p +6/−0
examples/winker.p +6/−0
examples/winker2.p +6/−0
examples/y-easy.p +4/−0
examples/y-encoded.p +5/−0
examples/y.p +3/−0
executable/ParallelMain.hs +78/−0
executable/SequentialMain.hs +235/−86
executable/link.c +12/−0
misc/BestTwee.hs +4/−14
misc/HornProof.hs +1038/−0
misc/Nested.hs +52/−0
misc/NestedOrig.hs +101/−0
misc/Test.hs +0/−334
misc/WhyDoesThisLoopWithHornElimination.hs +1463/−0
misc/static-libstdc++ +0/−24
test/Common.hs +124/−0
test/Index.hs +73/−0
test/Main.hs +21/−0
test/Nest.hs +82/−0
test/Ordering.hs +85/−0
test/Serial.hs +56/−0
test/TermOrder.hs +167/−0
test/Terms.hs +45/−0
tests/BOO067-1.p +0/−32
tests/GRP196-1.p +0/−40
tests/GRP666-4.p +0/−63
tests/KLE125+1.p +0/−47
tests/LAT071-1.p +0/−37
tests/LAT072-1.p +0/−37
tests/LAT073-1.p +0/−37
tests/LAT078-1.p +0/−38
tests/PUZ037-3-2.p +0/−106
tests/PUZ037-3.p +0/−110
tests/PUZ052-1.p +0/−129
tests/REL038-1.p +0/−14
tests/RNG025-buggy.p +0/−9
tests/RNG035-7.p +0/−12
tests/ROB001-1-a.p +0/−42
tests/ROB007-1-a.p +0/−12
tests/ROB007-1-b.p +0/−12
tests/ROB007-1.p +0/−5
tests/ROB010-1.p +0/−11
tests/ROB027-1-inv.p +0/−58
tests/ROB027-1-pretty.p +0/−56
tests/ROB027-1.p +0/−56
tests/ROB033-1.p +0/−10
tests/aim.p +0/−62
tests/aim2.p +0/−64
tests/append-rev.p +0/−4
tests/cm.p +0/−3
tests/deriv.p +0/−37
tests/diff.p +0/−8
tests/diff2.p +0/−34
tests/factor.p +0/−44
tests/filter.p +0/−59
tests/filter2.p +0/−59
tests/gmv.p +0/−74
tests/group.p +0/−14
tests/haken.p +0/−170
tests/loop.p +0/−6
tests/loop2.p +0/−6
tests/lukasiewicz.p +0/−6
tests/lukasiewicz2.p +0/−5
tests/minus.p +0/−10
tests/nicomachus-tptp-2.p +0/−19
tests/nicomachus-tptp.p +0/−20
tests/nicomachus.p +0/−36
tests/nicomachus2.p +0/−36
tests/p.p +0/−11
tests/regexp.p +0/−54
tests/rel.p +0/−32
tests/rel2.p +0/−32
tests/rellat_appendixa.p +0/−27
tests/rellat_appendixb.p +0/−28
tests/rellat_appendixb_easier.p +0/−30
tests/rellat_appendixc.p +0/−30
tests/rellat_theorem34_6.p +0/−32
tests/rellat_theorem34_6a.p +0/−29
tests/rellat_theorem34_6b.p +0/−29
tests/ring.p +0/−9
tests/ring2-cancel.p +0/−9
tests/ring2.p +0/−9
tests/ring3.p +0/−9
tests/ring4.p +0/−9
tests/rob.p +0/−7
tests/rob2.p +0/−7
tests/robbins-easy.p +0/−4
tests/robbins.p +0/−4
tests/sam.p +0/−38
tests/semigroup.p +0/−4
tests/sudoku.p +0/−39
tests/sudoku2.p +0/−44
tests/sudoku3.p +0/−42
tests/sudoku4.p +0/−45
tests/sudoku5.p +0/−42
tests/sum.p +0/−30
tests/union.p +0/−9
tests/union2.p +0/−25
tests/vbool.p +0/−18
tests/veroff-short.p +0/−11
tests/veroff.p +0/−11
tests/winker-easy.p +0/−6
tests/winker.p +0/−6
tests/winker2.p +0/−6
tests/wos.p +0/−6
tests/y-easy.p +0/−4
tests/y-encoded.p +0/−5
tests/y-i.p +0/−4
tests/y.p +0/−3
twee.cabal +53/−31

README.md view

@@ -15,8 +15,8 @@  Afterwards, run `twee nameofproblem.p`. The problem should be in TPTP format (http://www.tptp.org). You can find a few examples in the-`tests` directory. All axioms and conjectures must be equations, but+`examples` directory. All axioms and conjectures must be equations, but you can freely use quantifiers. If it succeeds in proving your problem, twee will print a human-readable proof. -For the official manual, see http://nick8325.github.io/twee.+For the official manual, see https://twee.smallbone.se.

+ examples/BOO067-1.p view

@@ -0,0 +1,32 @@+%--------------------------------------------------------------------------+% File     : BOO067-1 : TPTP v6.3.0. Released v2.6.0.+% Domain   : Boolean Algebra (Ternary)+% Problem  : Ternary Boolean Algebra Single axiom is complete, part 1+% Version  : [MP96] (equality) axioms.+% English  :++% Refs     : [McC98] McCune (1998), Email to G. Sutcliffe+%          : [MP96]  McCune & Padmanabhan (1996), Automated Deduction in Eq+% Source   : [TPTP]+% Names    :++% Status   : Unsatisfiable+% Rating   : 0.42 v6.3.0, 0.35 v6.2.0, 0.29 v6.1.0, 0.31 v6.0.0, 0.48 v5.5.0, 0.47 v5.4.0, 0.33 v5.3.0, 0.25 v5.2.0, 0.29 v5.1.0, 0.33 v5.0.0, 0.29 v4.1.0, 0.18 v4.0.1, 0.36 v4.0.0, 0.38 v3.7.0, 0.11 v3.4.0, 0.12 v3.3.0, 0.21 v3.1.0, 0.33 v2.7.0, 0.27 v2.6.0+% Syntax   : Number of clauses     :    2 (   0 non-Horn;   2 unit;   1 RR)+%            Number of atoms       :    2 (   2 equality)+%            Maximal clause size   :    1 (   1 average)+%            Number of predicates  :    1 (   0 propositional; 2-2 arity)+%            Number of functors    :    7 (   5 constant; 0-3 arity)+%            Number of variables   :    7 (   0 singleton)+%            Maximal term depth    :    5 (   3 average)+% SPC      : CNF_UNS_RFO_PEQ_UEQ++% Comments : A UEQ part of BOO035-1+%--------------------------------------------------------------------------+cnf(single_axiom,axiom,+    ( multiply(multiply(A,inverse(A),B),inverse(multiply(multiply(C,D,E),F,multiply(C,D,G))),multiply(D,multiply(G,F,E),C)) = B )).++cnf(prove_tba_axioms_1,negated_conjecture,+    (  multiply(multiply(d,e,a),b,multiply(d,e,c)) != multiply(d,e,multiply(a,b,c)) )).++%--------------------------------------------------------------------------

+ examples/GRP196-1.p view

@@ -0,0 +1,40 @@+%--------------------------------------------------------------------------+% File     : GRP196-1 : TPTP v7.4.0. Released v2.2.0.+% Domain   : Group Theory (Semigroups)+% Problem  : In semigroups, xyyy=yyyx -> (uy)^9 = u^9v^9.+% Version  : [MP96] (equality) axioms.+% English  :++% Refs     : [McC98] McCune (1998), Email to G. Sutcliffe+%          : [MP96]  McCune & Padmanabhan (1996), Automated Deduction in Eq+%          : [McC95] McCune (1995), Four Challenge Problems in Equational L+% Source   : [McC98]+% Names    : CS-3 [MP96]+%          : Problem B [McC95]++% Status   : Unsatisfiable+% Rating   : 0.88 v7.4.0, 0.91 v7.3.0, 0.89 v7.0.0, 0.95 v6.4.0, 1.00 v4.0.1, 0.93 v4.0.0, 0.92 v3.7.0, 0.89 v3.4.0, 1.00 v3.3.0, 0.93 v3.1.0, 1.00 v2.2.1+% Syntax   : Number of clauses     :    3 (   0 non-Horn;   3 unit;   1 RR)+%            Number of atoms       :    3 (   3 equality)+%            Maximal clause size   :    1 (   1 average)+%            Number of predicates  :    1 (   0 propositional; 2-2 arity)+%            Number of functors    :    3 (   2 constant; 0-2 arity)+%            Number of variables   :    5 (   0 singleton)+%            Maximal term depth    :   18 (   8 average)+% SPC      : CNF_UNS_RFO_PEQ_UEQ++% Comments : The problem was originally posed for cancellative semigroups,+%            Otter does this with a nonstandard representation [MP96].+%--------------------------------------------------------------------------+%----Include semigroups axioms+include('Axioms/GRP008-0.ax').+%--------------------------------------------------------------------------+%----Hypothesis:+cnf(condition,hypothesis,+    ( '*'(X,'*'(Y,'*'(Y,Y))) = '*'(Y,'*'(Y,'*'(Y,X))) )).++%----Denial of conclusion:+cnf(prove_this,negated_conjecture,+    (  '*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,b))))))))))))))))) != '*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(b,'*'(b,'*'(b,'*'(b,'*'(b,'*'(b,'*'(b,'*'(b,b))))))))))))))))) )).++%--------------------------------------------------------------------------

+ examples/GRP666-4.p view

@@ -0,0 +1,63 @@+%------------------------------------------------------------------------------+% File     : GRP666-4 : TPTP v7.2.0. Released v4.0.0.+% Domain   : Group Theory (Quasigroups)+% Problem  : Inverse property A-loops are Moufang+% Version  : Especial.+% English  :++% Refs     : [KKP02] Kinyon et al. (2002), Every Diassociative A-loop is M+%          : [PS08]  Phillips & Stanovsky (2008), Automated Theorem Proving+%          : [Sta08] Stanovsky (2008), Email to G. Sutcliffe+% Source   : [Sta08]+% Names    : KKP02a [PS08]++% Status   : Unsatisfiable+% Rating   : 0.84 v7.1.0, 0.83 v7.0.0, 0.89 v6.3.0, 0.82 v6.2.0, 0.71 v6.1.0, 0.81 v5.5.0, 0.84 v5.4.0, 0.87 v5.3.0, 0.75 v5.2.0, 0.86 v5.1.0, 0.87 v5.0.0, 0.86 v4.1.0, 0.82 v4.0.1, 0.86 v4.0.0+% Syntax   : Number of clauses     :   12 (   0 non-Horn;  12 unit;   1 RR)+%            Number of atoms       :   12 (  12 equality)+%            Maximal clause size   :    1 (   1 average)+%            Number of predicates  :    1 (   0 propositional; 2-2 arity)+%            Number of functors    :    8 (   4 constant; 0-2 arity)+%            Number of variables   :   25 (   0 singleton)+%            Maximal term depth    :    5 (   3 average)+% SPC      : CNF_UNS_RFO_PEQ_UEQ++% Comments :+%------------------------------------------------------------------------------+cnf(c01,axiom,+    ( mult(A,ld(A,B)) = B )).++cnf(c02,axiom,+    ( ld(A,mult(A,B)) = B )).++cnf(c03,axiom,+    ( mult(rd(A,B),B) = A )).++cnf(c04,axiom,+    ( rd(mult(A,B),B) = A )).++cnf(c05,axiom,+    ( mult(A,unit) = A )).++cnf(c06,axiom,+    ( mult(unit,A) = A )).++cnf(c07,axiom,+    ( ld(mult(A,B),mult(A,mult(B,mult(C,D)))) = mult(ld(mult(A,B),mult(A,mult(B,C))),ld(mult(A,B),mult(A,mult(B,D)))) )).++cnf(c08,axiom,+    ( rd(mult(mult(mult(A,B),C),D),mult(C,D)) = mult(rd(mult(mult(A,C),D),mult(C,D)),rd(mult(mult(B,C),D),mult(C,D))) )).++cnf(c09,axiom,+    ( ld(A,mult(mult(B,C),A)) = mult(ld(A,mult(B,A)),ld(A,mult(C,A))) )).++cnf(c10,axiom,+    ( mult(i(A),mult(A,B)) = B )).++cnf(c11,axiom,+    ( mult(mult(A,B),i(B)) = A )).++cnf(goals,negated_conjecture,+    ( mult(mult(a,b),mult(c,a)) != mult(mult(a,mult(b,c)),a) )).++%------------------------------------------------------------------------------

+ examples/LAT071-1.p view

@@ -0,0 +1,37 @@+%--------------------------------------------------------------------------+% File     : LAT071-1 : TPTP v7.2.0. Released v2.6.0.+% Domain   : Lattice Theory (Orthomodularlattices)+% Problem  : Given single axiom OML-21C, prove associativity+% Version  : [MRV03] (equality) axioms.+% English  : Given a single axiom candidate OML-21C for orthomodular lattices+%            (OML) in terms of the Sheffer Stroke, prove a Sheffer stroke form+%            of associativity.++% Refs     : [MRV03] McCune et al. (2003), Sheffer Stroke Bases for Ortholatt+% Source   : [MRV03]+% Names    : OML-21C-associativity [MRV03]++% Status   : Open+% Rating   : 1.00 v2.6.0+% Syntax   : Number of clauses     :    2 (   0 non-Horn;   2 unit;   1 RR)+%            Number of atoms       :    2 (   2 equality)+%            Maximal clause size   :    1 (   1 average)+%            Number of predicates  :    1 (   0 propositional; 2-2 arity)+%            Number of functors    :    4 (   3 constant; 0-2 arity)+%            Number of variables   :    4 (   2 singleton)+%            Maximal term depth    :    6 (   4 average)+% SPC      : CNF_OPN_RFO_PEQ_UEQ++% Comments :+%--------------------------------------------------------------------------+%----Single axiom OML-21C+cnf(oml_21C,axiom,+    ( f(f(B,A),f(f(f(f(B,A),A),f(C,A)),f(f(A,A),D))) = A )).++%----Denial of Sheffer stroke associativity+cnf(associativity,negated_conjecture,+    (  f(a,f(f(b,c),f(b,c))) != f(c,f(f(b,a),f(b,a))) )).++cnf(bonus, axiom, f(A,B)=f(B,A)).++%--------------------------------------------------------------------------

+ examples/LAT072-1.p view

@@ -0,0 +1,37 @@+%--------------------------------------------------------------------------+% File     : LAT072-1 : TPTP v6.3.0. Released v2.6.0.+% Domain   : Lattice Theory (Ortholattices)+% Problem  : Given single axiom OML-23A, prove associativity+% Version  : [MRV03] (equality) axioms.+% English  : Given a single axiom candidate OML-23A for orthomodular lattices+%            (OML) in terms of the Sheffer Stroke, prove a Sheffer stroke form+%            of associativity.++% Refs     : [MRV03] McCune et al. (2003), Sheffer Stroke Bases for Ortholatt+% Source   : [MRV03]+% Names    : OML-23A-associativity [MRV03]++% Status   : Unsatisfiable+% Rating   : 0.95 v6.3.0, 0.94 v6.2.0, 0.93 v6.1.0, 0.94 v6.0.0, 0.95 v5.4.0, 1.00 v2.6.0+% Syntax   : Number of clauses     :    2 (   0 non-Horn;   2 unit;   1 RR)+%            Number of atoms       :    2 (   2 equality)+%            Maximal clause size   :    1 (   1 average)+%            Number of predicates  :    1 (   0 propositional; 2-2 arity)+%            Number of functors    :    4 (   3 constant; 0-2 arity)+%            Number of variables   :    4 (   2 singleton)+%            Maximal term depth    :    7 (   4 average)+% SPC      : CNF_UNS_RFO_PEQ_UEQ++% Comments :+%--------------------------------------------------------------------------+%----Single axiom OML-23A+cnf(oml_23A,axiom,+    ( f(f(f(f(B,A),f(A,C)),D),f(A,f(f(C,f(f(A,A),C)),C))) = A )).++cnf(a, axiom, f(X,Y) = f(Y, X)).++%----Denial of Sheffer stroke associativity+cnf(associativity,negated_conjecture,+    (  f(a,f(f(b,c),f(b,c))) != f(c,f(f(b,a),f(b,a))) )).++%--------------------------------------------------------------------------

+ examples/LAT073-1.p view

@@ -0,0 +1,37 @@+%--------------------------------------------------------------------------+% File     : LAT073-1 : TPTP v7.2.0. Released v2.6.0.+% Domain   : Lattice Theory (Ortholattices)+% Problem  : Given single axiom MOL-23C, prove modularity+% Version  : [MRV03] (equality) axioms.+% English  : Given a single axiom candidate MOL-23C for modular ortholattices+%            (MOL) in terms of the Sheffer Stroke, prove a Sheffer stroke form+%            of modularity.++% Refs     : [MRV03] McCune et al. (2003), Sheffer Stroke Bases for Ortholatt+% Source   : [MRV03]+% Names    : MOL-23C-modularity [MRV03]++% Status   : Open+% Rating   : 1.00 v2.6.0+% Syntax   : Number of clauses     :    2 (   0 non-Horn;   2 unit;   1 RR)+%            Number of atoms       :    2 (   2 equality)+%            Maximal clause size   :    1 (   1 average)+%            Number of predicates  :    1 (   0 propositional; 2-2 arity)+%            Number of functors    :    4 (   3 constant; 0-2 arity)+%            Number of variables   :    4 (   1 singleton)+%            Maximal term depth    :    7 (   4 average)+% SPC      : CNF_OPN_RFO_PEQ_UEQ++% Comments :+%--------------------------------------------------------------------------+%----Single axiom MOL-23C+cnf(mol_23C,axiom,+    ( f(f(f(B,f(A,B)),B),f(A,f(C,f(f(A,B),f(f(C,C),D))))) = A )).++%----Denial of Sheffer stroke modularity+cnf(modularity,negated_conjecture,+    (  f(a,f(b,f(a,f(c,c)))) != f(a,f(c,f(a,f(b,b)))) )).++cnf(bonus, axiom, f(A,B)=f(B,A)).++%--------------------------------------------------------------------------

+ examples/PUZ037-3-2.p view

@@ -0,0 +1,106 @@+%--------------------------------------------------------------------------+% File     : PUZ037-3 : TPTP v7.2.0. Released v2.3.0.+% Domain   : Puzzles+% Problem  : Rubik's Cube+% Version  : [HM98] axioms : Especial.+%            Theorem formulation : Rotation in all three planes.+% English  : Rubik's Cube is a 3x3x3 cube consisting of 27 subcubes with+%            colored faces. The three layers perpendicular to any axis may+%            be rotated independently. The object is to take a scrambled+%            cube and unscramble it so that each side consists entirely+%            of one color(Blue, White, Green, Yellow, Orange, Red).++% Refs     : [HM98]  Huang & Myers (1998), Subgoal Strategies for Solving B+% Source   : [HM98]+% Names    : Rubik's Cube [HM98]++% Status   : Unsatisfiable+% Rating   : 0.20 v7.2.0, 0.22 v7.1.0, 0.14 v6.4.0, 0.17 v6.3.0, 0.25 v6.2.0, 0.12 v6.1.0, 0.00 v5.5.0, 0.20 v5.4.0, 0.33 v5.0.0, 0.50 v4.1.0, 0.60 v3.7.0, 0.50 v3.5.0, 0.33 v3.1.0, 0.44 v2.7.0, 0.50 v2.6.0, 0.44 v2.5.0, 0.75 v2.4.0, 0.67 v2.3.0+% Syntax   : Number of clauses     :   20 (   0 non-Horn;   2 unit;  20 RR)+%            Number of atoms       :   38 (   0 equality)+%            Maximal clause size   :    2 (   2 average)+%            Number of predicates  :    1 (   0 propositional; 54-54 arity)+%            Number of functors    :    6 (   6 constant; 0-0 arity)+%            Number of variables   :  972 (   0 singleton)+%            Maximal term depth    :    1 (   1 average)+% SPC      : CNF_UNS_EPR++% Comments : mzy, mzy, bzy, byx, lzx rotations to solve.+%--------------------------------------------------------------------------+cnf(a, axiom,+    state(b,b,b,b,b,b,b,b,b,r,r,r,g,g,g,o,o,o,y,y,y,r,r,r,g,g,g,o,o,o,y,y,y,r,r,r,g,g,g,o,o,o,y,y,y,w,w,w,w,w,w,w,w,w) !=+    state(b,r,r,w,w,w,y,b,b,g,y,r,b,g,g,o,g,y,w,w,r,g,o,r,b,g,g,o,r,b,y,y,r,g,o,g,o,o,o,y,r,b,y,y,r,w,w,w,b,b,y,w,o,o)).++cnf(txy,axiom,+    (  state(W7,W6,W5,W8,A1,W4,W1,W2,W3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7)+    = state(W1,W8,W7,W2,A1,W6,W3,W4,W5,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7) )).++cnf(mxy,axiom,+    (  state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6)+    = state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6) )).++cnf(bxy,axiom,+    (  state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,W7,W8,W1,W6,D7,W2,W5,W4,W3)+    = state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,W1,W2,W3,W8,D7,W4,W7,W6,W5) )).++cnf(fzy,axiom,+    (  state(A1,A2,A3,A4,A5,A6,V1,U1,Y1,A7,A8,W1,V2,U2,Y2,X1,A9,B1,B2,B3,B4,B5,B6,W2,V3,U3,Y3,X2,B7,B8,B9,C1,C2,C3,C4,W3,V4,U4,Y4,X3,C5,C6,C7,C8,C9,V5,U5,Y5,D1,D2,D3,D4,D5,D6)+    = state(A1,A2,A3,A4,A5,A6,X1,X2,X3,A7,A8,Y1,Y2,Y3,Y4,Y5,A9,B1,B2,B3,B4,B5,B6,U1,U2,U3,U4,U5,B7,B8,B9,C1,C2,C3,C4,V1,V2,V3,V4,V5,C5,C6,C7,C8,C9,W1,W2,W3,D1,D2,D3,D4,D5,D6) )).++cnf(mzy,axiom,+    (  state(A1,A2,A3,Y1,Y2,Y3,A4,A5,A6,A7,X9,A8,A9,B1,B2,B3,X1,B4,B5,B6,B7,B8,X8,B9,C1,C2,C3,C4,X2,C5,C6,C7,C8,C9,X7,D1,D2,D3,D4,D5,X3,D6,D7,D8,D9,E1,E2,E3,X6,X5,X4,E4,E5,E6)+    = state(A1,A2,A3,X1,X2,X3,A4,A5,A6,A7,Y3,A8,A9,B1,B2,B3,X4,B4,B5,B6,B7,B8,Y2,B9,C1,C2,C3,C4,X5,C5,C6,C7,C8,C9,Y1,D1,D2,D3,D4,D5,X6,D6,D7,D8,D9,E1,E2,E3,X9,X8,X7,E4,E5,E6) )).++cnf(bzy,axiom,+    (  state(Y1,Y2,Y3,A1,A2,A3,A4,A5,A6,X9,A7,A8,A9,B1,B2,B3,B4,X1,W1,W8,W7,X8,B5,B6,B7,B8,B9,C1,C2,X2,W2,C3,W6,X7,C4,C5,C6,C7,C8,C9,D1,X3,W3,W4,W5,D2,D3,D4,D5,D6,D7,X6,X5,X4)+    = state(X1,X2,X3,A1,A2,A3,A4,A5,A6,Y3,A7,A8,A9,B1,B2,B3,B4,X4,W3,W2,W1,Y2,B5,B6,B7,B8,B9,C1,C2,X5,W4,C3,W8,Y1,C4,C5,C6,C7,C8,C9,D1,X6,W5,W6,W7,D2,D3,D4,D5,D6,D7,X9,X8,X7) )).++cnf(lzx,axiom,+    (  state(Y1,A1,A2,Y2,A3,A4,Y3,A5,A6,W7,W8,W1,X1,A7,A8,A9,B1,B2,B3,B4,X9,W6,B5,W2,X2,B6,B7,B8,B9,C1,C2,C3,X8,W5,W4,W3,X3,C4,C5,C6,C7,C8,C9,D1,X7,X4,D2,D3,X5,D4,D5,X6,D6,D7)+    = state(X1,A1,A2,X2,A3,A4,X3,A5,A6,W1,W2,W3,X4,A7,A8,A9,B1,B2,B3,B4,Y3,W8,B5,W4,X5,B6,B7,B8,B9,C1,C2,C3,Y2,W7,W6,W5,X6,C4,C5,C6,C7,C8,C9,D1,Y1,X7,D2,D3,X8,D4,D5,X9,D6,D7) )).++cnf(mzx,axiom,+    (  state(A1,Y1,A2,A3,Y2,A4,A5,Y3,A6,A7,A8,A9,B1,X1,B2,B3,B4,B5,B6,X9,B7,B8,B9,C1,C2,X2,C3,C4,C5,C6,C7,X8,C8,C9,D1,D2,D3,X3,D4,D5,D6,D7,D8,X7,D9,E1,X4,E2,E3,X5,E4,E5,X6,E6)+    = state(A1,X1,A2,A3,X2,A4,A5,X3,A6,A7,A8,A9,B1,X4,B2,B3,B4,B5,B6,Y3,B7,B8,B9,C1,C2,X5,C3,C4,C5,C6,C7,Y2,C8,C9,D1,D2,D3,X6,D4,D5,D6,D7,D8,Y1,D9,E1,X7,E2,E3,X8,E4,E5,X9,E6) )).++cnf(rzx,axiom,+    (  state(A1,A2,Y1,A3,A4,Y2,A5,A6,Y3,A7,A8,A9,B1,B2,X1,W1,W8,W7,X9,B3,B4,B5,B6,B7,B8,B9,X2,W2,C1,W6,X8,C2,C3,C4,C5,C6,C7,C8,X3,W3,W4,W5,X7,C9,D1,D2,D3,X4,D4,D5,X5,D6,D7,X6)+    = state(A1,A2,X1,A3,A4,X2,A5,A6,X3,A7,A8,A9,B1,B2,X4,W3,W2,W1,Y3,B3,B4,B5,B6,B7,B8,B9,X5,W4,C1,W8,Y2,C2,C3,C4,C5,C6,C7,C8,X6,W5,W6,W7,Y1,C9,D1,D2,D3,X7,D4,D5,X8,D6,D7,X9) )).++cnf(tyx,axiom,+    (  state(W1,W8,W7,W2,A1,W6,W3,W4,W5,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7)+    = state(W7,W6,W5,W8,A1,W4,W1,W2,W3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7) )).++cnf(myx,axiom,+    (  state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6)+    = state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6) )).++cnf(byx,axiom,+    (  state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,W1,W2,W3,W8,D7,W4,W7,W6,W5)+    = state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,W7,W8,W1,W6,D7,W2,W5,W4,W3) )).++cnf(fyz,axiom,+    (  state(A1,A2,A3,A4,A5,A6,X1,X2,X3,A7,A8,Y1,Y2,Y3,Y4,Y5,A9,B1,B2,B3,B4,B5,B6,U1,U2,U3,U4,U5,B7,B8,B9,C1,C2,C3,C4,V1,V2,V3,V4,V5,C5,C6,C7,C8,C9,W1,W2,W3,D1,D2,D3,D4,D5,D6)+    = state(A1,A2,A3,A4,A5,A6,V1,U1,Y1,A7,A8,W1,V2,U2,Y2,X1,A9,B1,B2,B3,B4,B5,B6,W2,V3,U3,Y3,X2,B7,B8,B9,C1,C2,C3,C4,W3,V4,U4,Y4,X3,C5,C6,C7,C8,C9,V5,U5,Y5,D1,D2,D3,D4,D5,D6) )).++cnf(myz,axiom,+    (  state(A1,A2,A3,X1,X2,X3,A4,A5,A6,A7,Y3,A8,A9,B1,B2,B3,X4,B4,B5,B6,B7,B8,Y2,B9,C1,C2,C3,C4,X5,C5,C6,C7,C8,C9,Y1,D1,D2,D3,D4,D5,X6,D6,D7,D8,D9,E1,E2,E3,X9,X8,X7,E4,E5,E6)+    = state(A1,A2,A3,Y1,Y2,Y3,A4,A5,A6,A7,X9,A8,A9,B1,B2,B3,X1,B4,B5,B6,B7,B8,X8,B9,C1,C2,C3,C4,X2,C5,C6,C7,C8,C9,X7,D1,D2,D3,D4,D5,X3,D6,D7,D8,D9,E1,E2,E3,X6,X5,X4,E4,E5,E6) )).++cnf(byz,axiom,+    (  state(X1,X2,X3,A1,A2,A3,A4,A5,A6,Y3,A7,A8,A9,B1,B2,B3,B4,X4,W3,W2,W1,Y2,B5,B6,B7,B8,B9,C1,C2,X5,W4,C3,W8,Y1,C4,C5,C6,C7,C8,C9,D1,X6,W5,W6,W7,D2,D3,D4,D5,D6,D7,X9,X8,X7)+    = state(Y1,Y2,Y3,A1,A2,A3,A4,A5,A6,X9,A7,A8,A9,B1,B2,B3,B4,X1,W1,W8,W7,X8,B5,B6,B7,B8,B9,C1,C2,X2,W2,C3,W6,X7,C4,C5,C6,C7,C8,C9,D1,X3,W3,W4,W5,D2,D3,D4,D5,D6,D7,X6,X5,X4) )).++cnf(lxz,axiom,+    (  state(X1,A1,A2,X2,A3,A4,X3,A5,A6,W1,W2,W3,X4,A7,A8,A9,B1,B2,B3,B4,Y3,W8,B5,W4,X5,B6,B7,B8,B9,C1,C2,C3,Y2,W7,W6,W5,X6,C4,C5,C6,C7,C8,C9,D1,Y1,X7,D2,D3,X8,D4,D5,X9,D6,D7)+    = state(Y1,A1,A2,Y2,A3,A4,Y3,A5,A6,W7,W8,W1,X1,A7,A8,A9,B1,B2,B3,B4,X9,W6,B5,W2,X2,B6,B7,B8,B9,C1,C2,C3,X8,W5,W4,W3,X3,C4,C5,C6,C7,C8,C9,D1,X7,X4,D2,D3,X5,D4,D5,X6,D6,D7) )).++cnf(mxz,axiom,+    (  state(A1,X1,A2,A3,X2,A4,A5,X3,A6,A7,A8,A9,B1,X4,B2,B3,B4,B5,B6,Y3,B7,B8,B9,C1,C2,X5,C3,C4,C5,C6,C7,Y2,C8,C9,D1,D2,D3,X6,D4,D5,D6,D7,D8,Y1,D9,E1,X7,E2,E3,X8,E4,E5,X9,E6)+    = state(A1,Y1,A2,A3,Y2,A4,A5,Y3,A6,A7,A8,A9,B1,X1,B2,B3,B4,B5,B6,X9,B7,B8,B9,C1,C2,X2,C3,C4,C5,C6,C7,X8,C8,C9,D1,D2,D3,X3,D4,D5,D6,D7,D8,X7,D9,E1,X4,E2,E3,X5,E4,E5,X6,E6) )).++cnf(rxz,axiom,+    (  state(A1,A2,X1,A3,A4,X2,A5,A6,X3,A7,A8,A9,B1,B2,X4,W3,W2,W1,Y3,B3,B4,B5,B6,B7,B8,B9,X5,W4,C1,W8,Y2,C2,C3,C4,C5,C6,C7,C8,X6,W5,W6,W7,Y1,C9,D1,D2,D3,X7,D4,D5,X8,D6,D7,X9)+    = state(A1,A2,Y1,A3,A4,Y2,A5,A6,Y3,A7,A8,A9,B1,B2,X1,W1,W8,W7,X9,B3,B4,B5,B6,B7,B8,B9,X2,W2,C1,W6,X8,C2,C3,C4,C5,C6,C7,C8,X3,W3,W4,W5,X7,C9,D1,D2,D3,X4,D4,D5,X5,D6,D7,X6) )).++%--------------------------------------------------------------------------

+ examples/PUZ037-3.p view

@@ -0,0 +1,110 @@+%--------------------------------------------------------------------------+% File     : PUZ037-3 : TPTP v7.2.0. Released v2.3.0.+% Domain   : Puzzles+% Problem  : Rubik's Cube+% Version  : [HM98] axioms : Especial.+%            Theorem formulation : Rotation in all three planes.+% English  : Rubik's Cube is a 3x3x3 cube consisting of 27 subcubes with+%            colored faces. The three layers perpendicular to any axis may+%            be rotated independently. The object is to take a scrambled+%            cube and unscramble it so that each side consists entirely+%            of one color(Blue, White, Green, Yellow, Orange, Red).++% Refs     : [HM98]  Huang & Myers (1998), Subgoal Strategies for Solving B+% Source   : [HM98]+% Names    : Rubik's Cube [HM98]++% Status   : Unsatisfiable+% Rating   : 0.20 v7.2.0, 0.22 v7.1.0, 0.14 v6.4.0, 0.17 v6.3.0, 0.25 v6.2.0, 0.12 v6.1.0, 0.00 v5.5.0, 0.20 v5.4.0, 0.33 v5.0.0, 0.50 v4.1.0, 0.60 v3.7.0, 0.50 v3.5.0, 0.33 v3.1.0, 0.44 v2.7.0, 0.50 v2.6.0, 0.44 v2.5.0, 0.75 v2.4.0, 0.67 v2.3.0+% Syntax   : Number of clauses     :   20 (   0 non-Horn;   2 unit;  20 RR)+%            Number of atoms       :   38 (   0 equality)+%            Maximal clause size   :    2 (   2 average)+%            Number of predicates  :    1 (   0 propositional; 54-54 arity)+%            Number of functors    :    6 (   6 constant; 0-0 arity)+%            Number of variables   :  972 (   0 singleton)+%            Maximal term depth    :    1 (   1 average)+% SPC      : CNF_UNS_EPR++% Comments : mzy, mzy, bzy, byx, lzx rotations to solve.+%--------------------------------------------------------------------------+cnf(make_like_this,negated_conjecture, lhs != rhs).++cnf(a, axiom, lhs =+    state(b,b,b,b,b,b,b,b,b,r,r,r,g,g,g,o,o,o,y,y,y,r,r,r,g,g,g,o,o,o,y,y,y,r,r,r,g,g,g,o,o,o,y,y,y,w,w,w,w,w,w,w,w,w)).++cnf(b, axiom, rhs =+    state(b,r,r,w,w,w,y,b,b,g,y,r,b,g,g,o,g,y,w,w,r,g,o,r,b,g,g,o,r,b,y,y,r,g,o,g,o,o,o,y,r,b,y,y,r,w,w,w,b,b,y,w,o,o)).++cnf(txy,axiom,+    (  state(W7,W6,W5,W8,A1,W4,W1,W2,W3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7)+    = state(W1,W8,W7,W2,A1,W6,W3,W4,W5,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7) )).++cnf(mxy,axiom,+    (  state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6)+    = state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6) )).++cnf(bxy,axiom,+    (  state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,W7,W8,W1,W6,D7,W2,W5,W4,W3)+    = state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,W1,W2,W3,W8,D7,W4,W7,W6,W5) )).++cnf(fzy,axiom,+    (  state(A1,A2,A3,A4,A5,A6,V1,U1,Y1,A7,A8,W1,V2,U2,Y2,X1,A9,B1,B2,B3,B4,B5,B6,W2,V3,U3,Y3,X2,B7,B8,B9,C1,C2,C3,C4,W3,V4,U4,Y4,X3,C5,C6,C7,C8,C9,V5,U5,Y5,D1,D2,D3,D4,D5,D6)+    = state(A1,A2,A3,A4,A5,A6,X1,X2,X3,A7,A8,Y1,Y2,Y3,Y4,Y5,A9,B1,B2,B3,B4,B5,B6,U1,U2,U3,U4,U5,B7,B8,B9,C1,C2,C3,C4,V1,V2,V3,V4,V5,C5,C6,C7,C8,C9,W1,W2,W3,D1,D2,D3,D4,D5,D6) )).++cnf(mzy,axiom,+    (  state(A1,A2,A3,Y1,Y2,Y3,A4,A5,A6,A7,X9,A8,A9,B1,B2,B3,X1,B4,B5,B6,B7,B8,X8,B9,C1,C2,C3,C4,X2,C5,C6,C7,C8,C9,X7,D1,D2,D3,D4,D5,X3,D6,D7,D8,D9,E1,E2,E3,X6,X5,X4,E4,E5,E6)+    = state(A1,A2,A3,X1,X2,X3,A4,A5,A6,A7,Y3,A8,A9,B1,B2,B3,X4,B4,B5,B6,B7,B8,Y2,B9,C1,C2,C3,C4,X5,C5,C6,C7,C8,C9,Y1,D1,D2,D3,D4,D5,X6,D6,D7,D8,D9,E1,E2,E3,X9,X8,X7,E4,E5,E6) )).++cnf(bzy,axiom,+    (  state(Y1,Y2,Y3,A1,A2,A3,A4,A5,A6,X9,A7,A8,A9,B1,B2,B3,B4,X1,W1,W8,W7,X8,B5,B6,B7,B8,B9,C1,C2,X2,W2,C3,W6,X7,C4,C5,C6,C7,C8,C9,D1,X3,W3,W4,W5,D2,D3,D4,D5,D6,D7,X6,X5,X4)+    = state(X1,X2,X3,A1,A2,A3,A4,A5,A6,Y3,A7,A8,A9,B1,B2,B3,B4,X4,W3,W2,W1,Y2,B5,B6,B7,B8,B9,C1,C2,X5,W4,C3,W8,Y1,C4,C5,C6,C7,C8,C9,D1,X6,W5,W6,W7,D2,D3,D4,D5,D6,D7,X9,X8,X7) )).++cnf(lzx,axiom,+    (  state(Y1,A1,A2,Y2,A3,A4,Y3,A5,A6,W7,W8,W1,X1,A7,A8,A9,B1,B2,B3,B4,X9,W6,B5,W2,X2,B6,B7,B8,B9,C1,C2,C3,X8,W5,W4,W3,X3,C4,C5,C6,C7,C8,C9,D1,X7,X4,D2,D3,X5,D4,D5,X6,D6,D7)+    = state(X1,A1,A2,X2,A3,A4,X3,A5,A6,W1,W2,W3,X4,A7,A8,A9,B1,B2,B3,B4,Y3,W8,B5,W4,X5,B6,B7,B8,B9,C1,C2,C3,Y2,W7,W6,W5,X6,C4,C5,C6,C7,C8,C9,D1,Y1,X7,D2,D3,X8,D4,D5,X9,D6,D7) )).++cnf(mzx,axiom,+    (  state(A1,Y1,A2,A3,Y2,A4,A5,Y3,A6,A7,A8,A9,B1,X1,B2,B3,B4,B5,B6,X9,B7,B8,B9,C1,C2,X2,C3,C4,C5,C6,C7,X8,C8,C9,D1,D2,D3,X3,D4,D5,D6,D7,D8,X7,D9,E1,X4,E2,E3,X5,E4,E5,X6,E6)+    = state(A1,X1,A2,A3,X2,A4,A5,X3,A6,A7,A8,A9,B1,X4,B2,B3,B4,B5,B6,Y3,B7,B8,B9,C1,C2,X5,C3,C4,C5,C6,C7,Y2,C8,C9,D1,D2,D3,X6,D4,D5,D6,D7,D8,Y1,D9,E1,X7,E2,E3,X8,E4,E5,X9,E6) )).++cnf(rzx,axiom,+    (  state(A1,A2,Y1,A3,A4,Y2,A5,A6,Y3,A7,A8,A9,B1,B2,X1,W1,W8,W7,X9,B3,B4,B5,B6,B7,B8,B9,X2,W2,C1,W6,X8,C2,C3,C4,C5,C6,C7,C8,X3,W3,W4,W5,X7,C9,D1,D2,D3,X4,D4,D5,X5,D6,D7,X6)+    = state(A1,A2,X1,A3,A4,X2,A5,A6,X3,A7,A8,A9,B1,B2,X4,W3,W2,W1,Y3,B3,B4,B5,B6,B7,B8,B9,X5,W4,C1,W8,Y2,C2,C3,C4,C5,C6,C7,C8,X6,W5,W6,W7,Y1,C9,D1,D2,D3,X7,D4,D5,X8,D6,D7,X9) )).++cnf(tyx,axiom,+    (  state(W1,W8,W7,W2,A1,W6,W3,W4,W5,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7)+    = state(W7,W6,W5,W8,A1,W4,W1,W2,W3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7) )).++cnf(myx,axiom,+    (  state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6)+    = state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6) )).++cnf(byx,axiom,+    (  state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,W1,W2,W3,W8,D7,W4,W7,W6,W5)+    = state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,W7,W8,W1,W6,D7,W2,W5,W4,W3) )).++cnf(fyz,axiom,+    (  state(A1,A2,A3,A4,A5,A6,X1,X2,X3,A7,A8,Y1,Y2,Y3,Y4,Y5,A9,B1,B2,B3,B4,B5,B6,U1,U2,U3,U4,U5,B7,B8,B9,C1,C2,C3,C4,V1,V2,V3,V4,V5,C5,C6,C7,C8,C9,W1,W2,W3,D1,D2,D3,D4,D5,D6)+    = state(A1,A2,A3,A4,A5,A6,V1,U1,Y1,A7,A8,W1,V2,U2,Y2,X1,A9,B1,B2,B3,B4,B5,B6,W2,V3,U3,Y3,X2,B7,B8,B9,C1,C2,C3,C4,W3,V4,U4,Y4,X3,C5,C6,C7,C8,C9,V5,U5,Y5,D1,D2,D3,D4,D5,D6) )).++cnf(myz,axiom,+    (  state(A1,A2,A3,X1,X2,X3,A4,A5,A6,A7,Y3,A8,A9,B1,B2,B3,X4,B4,B5,B6,B7,B8,Y2,B9,C1,C2,C3,C4,X5,C5,C6,C7,C8,C9,Y1,D1,D2,D3,D4,D5,X6,D6,D7,D8,D9,E1,E2,E3,X9,X8,X7,E4,E5,E6)+    = state(A1,A2,A3,Y1,Y2,Y3,A4,A5,A6,A7,X9,A8,A9,B1,B2,B3,X1,B4,B5,B6,B7,B8,X8,B9,C1,C2,C3,C4,X2,C5,C6,C7,C8,C9,X7,D1,D2,D3,D4,D5,X3,D6,D7,D8,D9,E1,E2,E3,X6,X5,X4,E4,E5,E6) )).++cnf(byz,axiom,+    (  state(X1,X2,X3,A1,A2,A3,A4,A5,A6,Y3,A7,A8,A9,B1,B2,B3,B4,X4,W3,W2,W1,Y2,B5,B6,B7,B8,B9,C1,C2,X5,W4,C3,W8,Y1,C4,C5,C6,C7,C8,C9,D1,X6,W5,W6,W7,D2,D3,D4,D5,D6,D7,X9,X8,X7)+    = state(Y1,Y2,Y3,A1,A2,A3,A4,A5,A6,X9,A7,A8,A9,B1,B2,B3,B4,X1,W1,W8,W7,X8,B5,B6,B7,B8,B9,C1,C2,X2,W2,C3,W6,X7,C4,C5,C6,C7,C8,C9,D1,X3,W3,W4,W5,D2,D3,D4,D5,D6,D7,X6,X5,X4) )).++cnf(lxz,axiom,+    (  state(X1,A1,A2,X2,A3,A4,X3,A5,A6,W1,W2,W3,X4,A7,A8,A9,B1,B2,B3,B4,Y3,W8,B5,W4,X5,B6,B7,B8,B9,C1,C2,C3,Y2,W7,W6,W5,X6,C4,C5,C6,C7,C8,C9,D1,Y1,X7,D2,D3,X8,D4,D5,X9,D6,D7)+    = state(Y1,A1,A2,Y2,A3,A4,Y3,A5,A6,W7,W8,W1,X1,A7,A8,A9,B1,B2,B3,B4,X9,W6,B5,W2,X2,B6,B7,B8,B9,C1,C2,C3,X8,W5,W4,W3,X3,C4,C5,C6,C7,C8,C9,D1,X7,X4,D2,D3,X5,D4,D5,X6,D6,D7) )).++cnf(mxz,axiom,+    (  state(A1,X1,A2,A3,X2,A4,A5,X3,A6,A7,A8,A9,B1,X4,B2,B3,B4,B5,B6,Y3,B7,B8,B9,C1,C2,X5,C3,C4,C5,C6,C7,Y2,C8,C9,D1,D2,D3,X6,D4,D5,D6,D7,D8,Y1,D9,E1,X7,E2,E3,X8,E4,E5,X9,E6)+    = state(A1,Y1,A2,A3,Y2,A4,A5,Y3,A6,A7,A8,A9,B1,X1,B2,B3,B4,B5,B6,X9,B7,B8,B9,C1,C2,X2,C3,C4,C5,C6,C7,X8,C8,C9,D1,D2,D3,X3,D4,D5,D6,D7,D8,X7,D9,E1,X4,E2,E3,X5,E4,E5,X6,E6) )).++cnf(rxz,axiom,+    (  state(A1,A2,X1,A3,A4,X2,A5,A6,X3,A7,A8,A9,B1,B2,X4,W3,W2,W1,Y3,B3,B4,B5,B6,B7,B8,B9,X5,W4,C1,W8,Y2,C2,C3,C4,C5,C6,C7,C8,X6,W5,W6,W7,Y1,C9,D1,D2,D3,X7,D4,D5,X8,D6,D7,X9)+    = state(A1,A2,Y1,A3,A4,Y2,A5,A6,Y3,A7,A8,A9,B1,B2,X1,W1,W8,W7,X9,B3,B4,B5,B6,B7,B8,B9,X2,W2,C1,W6,X8,C2,C3,C4,C5,C6,C7,C8,X3,W3,W4,W5,X7,C9,D1,D2,D3,X4,D4,D5,X5,D6,D7,X6) )).++%--------------------------------------------------------------------------

+ examples/PUZ052-1.p view

@@ -0,0 +1,129 @@+%--------------------------------------------------------------------------+% File     : PUZ052-1 : TPTP v7.2.0. Released v2.7.0.+% Domain   : Puzzles+% Problem  : Rubik's Cube unreachability+% Version  : [HM98] axioms : Especial.+%            Theorem formulation : Rotations in one plane only.+% English  : Rubik's Cube is a 3x3x3 cube consisting of 27 subcubes with+%            colored faces. The three layers perpendicular to any axis may+%            be rotated independently. The object is to take a scrambled+%            cube and unscramble it so that each side consists entirely+%            of one color(Blue, White, Green, Yellow, Orange, Red).+%            The objective here is unreachable: there are 10 b's and only+%            8 r's.++% Refs     : [HM98]  Huang & Myers (1998), Subgoal Strategies for Solving B+%          : [Cla03] Claessen (2003), Email to G. Sutcliffe+% Source   : [Cla03]+% Names    :++% Status   : Satisfiable+% Rating   : 1.00 v2.7.0+% Syntax   : Number of clauses     :   20 (   0 non-Horn;   2 unit;  20 RR)+%            Number of atoms       :   38 (   0 equality)+%            Maximal clause size   :    2 (   2 average)+%            Number of predicates  :    1 (   0 propositional; 54-54 arity)+%            Number of functors    :    6 (   6 constant; 0-0 arity)+%            Number of variables   :  972 (   0 singleton)+%            Maximal term depth    :    1 (   1 average)+% SPC      : CNF_SAT_EPR++% Comments : Replaced one b by an r in make_like_this from PUZ037-1.p+%            Model never found; a domain of size 2 should be enough though.+%--------------------------------------------------------------------------+cnf(make_like_this,negated_conjecture,+    ( state(b,b,b,b,b,b,b,b,b,b,r,r,g,g,g,o,o,o,y,y,y,r,r,r,g,g,g,o,o,o,y,y,y,r,r,r,g,g,g,o,o,o,y,y,y,w,w,w,w,w,w,w,w,w) !=+     state(b,b,b,b,b,b,b,b,b,r,r,r,g,g,g,o,o,o,y,y,y,g,g,g,o,o,o,y,y,y,r,r,r,r,r,r,g,g,g,o,o,o,y,y,y,w,w,w,w,w,w,w,w,w) )).++cnf(txy,axiom,+    ( +state(W7,W6,W5,W8,A1,W4,W1,W2,W3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7) += state(W1,W8,W7,W2,A1,W6,W3,W4,W5,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7) )).++cnf(mxy,axiom,+    ( +state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6) +=+    state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6) )).++cnf(bxy,axiom,+    ( state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,W7,W8,W1,W6,D7,W2,W5,W4,W3)+    = +state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,W1,W2,W3,W8,D7,W4,W7,W6,W5) )).++cnf(fzy,axiom,+    ( state(A1,A2,A3,A4,A5,A6,V1,U1,Y1,A7,A8,W1,V2,U2,Y2,X1,A9,B1,B2,B3,B4,B5,B6,W2,V3,U3,Y3,X2,B7,B8,B9,C1,C2,C3,C4,W3,V4,U4,Y4,X3,C5,C6,C7,C8,C9,V5,U5,Y5,D1,D2,D3,D4,D5,D6)+    = +state(A1,A2,A3,A4,A5,A6,X1,X2,X3,A7,A8,Y1,Y2,Y3,Y4,Y5,A9,B1,B2,B3,B4,B5,B6,U1,U2,U3,U4,U5,B7,B8,B9,C1,C2,C3,C4,V1,V2,V3,V4,V5,C5,C6,C7,C8,C9,W1,W2,W3,D1,D2,D3,D4,D5,D6) )).++cnf(mzy,axiom,+    ( state(A1,A2,A3,Y1,Y2,Y3,A4,A5,A6,A7,X9,A8,A9,B1,B2,B3,X1,B4,B5,B6,B7,B8,X8,B9,C1,C2,C3,C4,X2,C5,C6,C7,C8,C9,X7,D1,D2,D3,D4,D5,X3,D6,D7,D8,D9,E1,E2,E3,X6,X5,X4,E4,E5,E6)+    = +state(A1,A2,A3,X1,X2,X3,A4,A5,A6,A7,Y3,A8,A9,B1,B2,B3,X4,B4,B5,B6,B7,B8,Y2,B9,C1,C2,C3,C4,X5,C5,C6,C7,C8,C9,Y1,D1,D2,D3,D4,D5,X6,D6,D7,D8,D9,E1,E2,E3,X9,X8,X7,E4,E5,E6) )).++cnf(bzy,axiom,+    ( state(Y1,Y2,Y3,A1,A2,A3,A4,A5,A6,X9,A7,A8,A9,B1,B2,B3,B4,X1,W1,W8,W7,X8,B5,B6,B7,B8,B9,C1,C2,X2,W2,C3,W6,X7,C4,C5,C6,C7,C8,C9,D1,X3,W3,W4,W5,D2,D3,D4,D5,D6,D7,X6,X5,X4)+    = +state(X1,X2,X3,A1,A2,A3,A4,A5,A6,Y3,A7,A8,A9,B1,B2,B3,B4,X4,W3,W2,W1,Y2,B5,B6,B7,B8,B9,C1,C2,X5,W4,C3,W8,Y1,C4,C5,C6,C7,C8,C9,D1,X6,W5,W6,W7,D2,D3,D4,D5,D6,D7,X9,X8,X7) )).++cnf(lzx,axiom,+    ( state(Y1,A1,A2,Y2,A3,A4,Y3,A5,A6,W7,W8,W1,X1,A7,A8,A9,B1,B2,B3,B4,X9,W6,B5,W2,X2,B6,B7,B8,B9,C1,C2,C3,X8,W5,W4,W3,X3,C4,C5,C6,C7,C8,C9,D1,X7,X4,D2,D3,X5,D4,D5,X6,D6,D7)+    = +state(X1,A1,A2,X2,A3,A4,X3,A5,A6,W1,W2,W3,X4,A7,A8,A9,B1,B2,B3,B4,Y3,W8,B5,W4,X5,B6,B7,B8,B9,C1,C2,C3,Y2,W7,W6,W5,X6,C4,C5,C6,C7,C8,C9,D1,Y1,X7,D2,D3,X8,D4,D5,X9,D6,D7) )).++cnf(mzx,axiom,+    ( state(A1,Y1,A2,A3,Y2,A4,A5,Y3,A6,A7,A8,A9,B1,X1,B2,B3,B4,B5,B6,X9,B7,B8,B9,C1,C2,X2,C3,C4,C5,C6,C7,X8,C8,C9,D1,D2,D3,X3,D4,D5,D6,D7,D8,X7,D9,E1,X4,E2,E3,X5,E4,E5,X6,E6)+    = +state(A1,X1,A2,A3,X2,A4,A5,X3,A6,A7,A8,A9,B1,X4,B2,B3,B4,B5,B6,Y3,B7,B8,B9,C1,C2,X5,C3,C4,C5,C6,C7,Y2,C8,C9,D1,D2,D3,X6,D4,D5,D6,D7,D8,Y1,D9,E1,X7,E2,E3,X8,E4,E5,X9,E6) )).++cnf(rzx,axiom,+    ( state(A1,A2,Y1,A3,A4,Y2,A5,A6,Y3,A7,A8,A9,B1,B2,X1,W1,W8,W7,X9,B3,B4,B5,B6,B7,B8,B9,X2,W2,C1,W6,X8,C2,C3,C4,C5,C6,C7,C8,X3,W3,W4,W5,X7,C9,D1,D2,D3,X4,D4,D5,X5,D6,D7,X6)+    = +state(A1,A2,X1,A3,A4,X2,A5,A6,X3,A7,A8,A9,B1,B2,X4,W3,W2,W1,Y3,B3,B4,B5,B6,B7,B8,B9,X5,W4,C1,W8,Y2,C2,C3,C4,C5,C6,C7,C8,X6,W5,W6,W7,Y1,C9,D1,D2,D3,X7,D4,D5,X8,D6,D7,X9) )).++cnf(tyx,axiom,+    ( state(W1,W8,W7,W2,A1,W6,W3,W4,W5,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7)+    = +state(W7,W6,W5,W8,A1,W4,W1,W2,W3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7) )).++cnf(myx,axiom,+    ( state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6)+    = +state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6) )).++cnf(byx,axiom,+    ( state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,W1,W2,W3,W8,D7,W4,W7,W6,W5)+    = +state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,W7,W8,W1,W6,D7,W2,W5,W4,W3) )).++cnf(fyz,axiom,+    ( state(A1,A2,A3,A4,A5,A6,X1,X2,X3,A7,A8,Y1,Y2,Y3,Y4,Y5,A9,B1,B2,B3,B4,B5,B6,U1,U2,U3,U4,U5,B7,B8,B9,C1,C2,C3,C4,V1,V2,V3,V4,V5,C5,C6,C7,C8,C9,W1,W2,W3,D1,D2,D3,D4,D5,D6)+    = +state(A1,A2,A3,A4,A5,A6,V1,U1,Y1,A7,A8,W1,V2,U2,Y2,X1,A9,B1,B2,B3,B4,B5,B6,W2,V3,U3,Y3,X2,B7,B8,B9,C1,C2,C3,C4,W3,V4,U4,Y4,X3,C5,C6,C7,C8,C9,V5,U5,Y5,D1,D2,D3,D4,D5,D6) )).++cnf(myz,axiom,+    ( state(A1,A2,A3,X1,X2,X3,A4,A5,A6,A7,Y3,A8,A9,B1,B2,B3,X4,B4,B5,B6,B7,B8,Y2,B9,C1,C2,C3,C4,X5,C5,C6,C7,C8,C9,Y1,D1,D2,D3,D4,D5,X6,D6,D7,D8,D9,E1,E2,E3,X9,X8,X7,E4,E5,E6)+    = +state(A1,A2,A3,Y1,Y2,Y3,A4,A5,A6,A7,X9,A8,A9,B1,B2,B3,X1,B4,B5,B6,B7,B8,X8,B9,C1,C2,C3,C4,X2,C5,C6,C7,C8,C9,X7,D1,D2,D3,D4,D5,X3,D6,D7,D8,D9,E1,E2,E3,X6,X5,X4,E4,E5,E6) )).++cnf(byz,axiom,+    ( state(X1,X2,X3,A1,A2,A3,A4,A5,A6,Y3,A7,A8,A9,B1,B2,B3,B4,X4,W3,W2,W1,Y2,B5,B6,B7,B8,B9,C1,C2,X5,W4,C3,W8,Y1,C4,C5,C6,C7,C8,C9,D1,X6,W5,W6,W7,D2,D3,D4,D5,D6,D7,X9,X8,X7)+    = +state(Y1,Y2,Y3,A1,A2,A3,A4,A5,A6,X9,A7,A8,A9,B1,B2,B3,B4,X1,W1,W8,W7,X8,B5,B6,B7,B8,B9,C1,C2,X2,W2,C3,W6,X7,C4,C5,C6,C7,C8,C9,D1,X3,W3,W4,W5,D2,D3,D4,D5,D6,D7,X6,X5,X4) )).++cnf(lxz,axiom,+    ( state(X1,A1,A2,X2,A3,A4,X3,A5,A6,W1,W2,W3,X4,A7,A8,A9,B1,B2,B3,B4,Y3,W8,B5,W4,X5,B6,B7,B8,B9,C1,C2,C3,Y2,W7,W6,W5,X6,C4,C5,C6,C7,C8,C9,D1,Y1,X7,D2,D3,X8,D4,D5,X9,D6,D7)+    = +state(Y1,A1,A2,Y2,A3,A4,Y3,A5,A6,W7,W8,W1,X1,A7,A8,A9,B1,B2,B3,B4,X9,W6,B5,W2,X2,B6,B7,B8,B9,C1,C2,C3,X8,W5,W4,W3,X3,C4,C5,C6,C7,C8,C9,D1,X7,X4,D2,D3,X5,D4,D5,X6,D6,D7) )).++cnf(mxz,axiom,+    ( state(A1,X1,A2,A3,X2,A4,A5,X3,A6,A7,A8,A9,B1,X4,B2,B3,B4,B5,B6,Y3,B7,B8,B9,C1,C2,X5,C3,C4,C5,C6,C7,Y2,C8,C9,D1,D2,D3,X6,D4,D5,D6,D7,D8,Y1,D9,E1,X7,E2,E3,X8,E4,E5,X9,E6)+    = +state(A1,Y1,A2,A3,Y2,A4,A5,Y3,A6,A7,A8,A9,B1,X1,B2,B3,B4,B5,B6,X9,B7,B8,B9,C1,C2,X2,C3,C4,C5,C6,C7,X8,C8,C9,D1,D2,D3,X3,D4,D5,D6,D7,D8,X7,D9,E1,X4,E2,E3,X5,E4,E5,X6,E6) )).++cnf(rxz,axiom,+    ( state(A1,A2,X1,A3,A4,X2,A5,A6,X3,A7,A8,A9,B1,B2,X4,W3,W2,W1,Y3,B3,B4,B5,B6,B7,B8,B9,X5,W4,C1,W8,Y2,C2,C3,C4,C5,C6,C7,C8,X6,W5,W6,W7,Y1,C9,D1,D2,D3,X7,D4,D5,X8,D6,D7,X9)+    = +state(A1,A2,Y1,A3,A4,Y2,A5,A6,Y3,A7,A8,A9,B1,B2,X1,W1,W8,W7,X9,B3,B4,B5,B6,B7,B8,B9,X2,W2,C1,W6,X8,C2,C3,C4,C5,C6,C7,C8,X3,W3,W4,W5,X7,C9,D1,D2,D3,X4,D4,D5,X5,D6,D7,X6) )).++%--------------------------------------------------------------------------

+ examples/REL038-1.p view

@@ -0,0 +1,14 @@+cnf(maddux1_join_commutativity_1, axiom, join(A, B)=join(B, A)).+cnf(maddux2_join_associativity_2, axiom, join(A, join(B, C))=join(join(A, B), C)).+cnf(maddux3_a_kind_of_de_Morgan_3, axiom, A=join(complement(join(complement(A), complement(B))), complement(join(complement(A), B)))).+cnf(maddux4_definiton_of_meet_4, axiom, meet(A, B)=complement(join(complement(A), complement(B)))).+cnf(composition_associativity_5, axiom, composition(A, composition(B, C))=composition(composition(A, B), C)).+cnf(composition_identity_6, axiom, composition(A, one)=A).+cnf(composition_distributivity_7, axiom, composition(join(A, B), C)=join(composition(A, C), composition(B, C))).+cnf(converse_idempotence_8, axiom, converse(converse(A))=A).+cnf(converse_additivity_9, axiom, converse(join(A, B))=join(converse(A), converse(B))).+cnf(converse_multiplicativity_10, axiom, converse(composition(A, B))=composition(converse(B), converse(A))).+cnf(converse_cancellativity_11, axiom, join(composition(converse(A), complement(composition(A, B))), complement(B))=complement(B)).+cnf(def_top_12, axiom, top=join(A, complement(A))).+cnf(def_zero_13, axiom, zero=meet(A, complement(A))).+cnf(goals_14, negated_conjecture, join(meet(composition(sk1, sk2), sk3), meet(composition(sk1, meet(sk2, composition(converse(sk1), sk3))), sk3))!=meet(composition(sk1, meet(sk2, composition(converse(sk1), sk3))), sk3)).

+ examples/RNG025-buggy.p view

@@ -0,0 +1,9 @@+% SPASS solves this instantly, Twee takes ages!+cnf(axiom, axiom, multiply(U,add(V,W))=add(multiply(U,V),multiply(U,W))).+cnf(axiom, axiom, add(U,additive_inverse(add(additive_inverse(V),U)))=V).+cnf(axiom, axiom, add(U,additive_inverse(add(V,add(W,U))))=additive_inverse(add(V,W))).+cnf(axiom, axiom, add(additive_inverse(U),V)=additive_inverse(add(U,additive_inverse(V)))).+cnf(axiom, axiom, multiply(multiply(U,V),W)=add(associator(U,V,W),multiply(U,multiply(V,W)))).+cnf(axiom, axiom, additive_inverse(add(multiply(U,multiply(V,W)),add(multiply(U,multiply(X,W)),additive_inverse(add(multiply(multiply(U,V),W),multiply(multiply(U,X),W))))))=associator(U,add(V,X),W)).++cnf(conjecture, conjecture, add(associator(U,V,W),associator(U,X,W))=associator(U,add(V,X),W)).

+ examples/RNG035-7.p view

@@ -0,0 +1,12 @@+cnf(left_additive_identity, axiom, add(additive_identity, X)=X).+cnf(right_additive_identity, axiom, add(X, additive_identity)=X).+cnf(left_additive_inverse, axiom, add(additive_inverse(X), X)=additive_identity).+cnf(right_additive_inverse, axiom, add(X, additive_inverse(X))=additive_identity).+cnf(associativity_for_addition, axiom, add(X, add(Y, Z))=add(add(X, Y), Z)).+cnf(commutativity_for_addition, axiom, add(X, Y)=add(Y, X)).+cnf(associativity_for_multiplication, axiom, multiply(X, multiply(Y, Z))=multiply(multiply(X, Y), Z)).+cnf(distribute1, axiom, multiply(X, add(Y, Z))=add(multiply(X, Y), multiply(X, Z))).+cnf(distribute2, axiom, multiply(add(X, Y), Z)=add(multiply(X, Z), multiply(Y, Z))).+cnf(x_fourthed_is_x, hypothesis, multiply(X, multiply(X, multiply(X, X)))=X).+cnf(a_times_b_is_c, negated_conjecture, multiply(a, b)=c).+cnf(prove_commutativity, negated_conjecture, multiply(b, a)!=c).

+ examples/ROB010-1.p view

@@ -0,0 +1,11 @@+cnf(condition,hypothesis,+    ( negate(add(a,negate(b))) = c )).++cnf(prove_result,negated_conjecture,+    (  negate(add(c,negate(add(b,a)))) != a )).++cnf(commutativity_of_add,axiom,+    ( add(X,Y) = add(Y,X) )).++cnf(robbins_axiom,axiom,+    ( negate(add(negate(add(X,Y)),negate(add(X,negate(Y))))) = X )).

+ examples/ROB027-1-pretty.p view

@@ -0,0 +1,56 @@+%--------------------------------------------------------------------------+% File     : ROB027-1 : TPTP v6.3.0. Released v1.2.0.+% Domain   : Robbins Algebra+% Problem  : -(-c) = c => Boolean+% Version  : [Win90] (equality) axioms.+%            Theorem formulation : Denies Huntington's axiom.+% English  : If there are elements c and d such that c+d=d, then the+%            algebra is Boolean.++% Refs     : [HMT71] Henkin et al. (1971), Cylindrical Algebras+%          : [Win90] Winker (1990), Robbins Algebra: Conditions that make a+%          : [Wos94] Wos (1994), Two Challenge Problems+% Source   : [Wos94]+% Names    : - [Wos94]++% Status   : Open+% Rating   : 1.00 v2.0.0+% Syntax   : Number of clauses     :    5 (   0 non-Horn;   5 unit;   2 RR)+%            Number of atoms       :    5 (   5 equality)+%            Maximal clause size   :    1 (   1 average)+%            Number of predicates  :    1 (   0 propositional; 2-2 arity)+%            Number of functors    :    5 (   3 constant; 0-2 arity)+%            Number of variables   :    7 (   0 singleton)+%            Maximal term depth    :    6 (   3 average)+% SPC      : CNF_UNK_UEQ++% Comments : Commutativity, associativity, and Huntington's axiom+%            axiomatize Boolean algebra.+%--------------------------------------------------------------------------+%----Include axioms for Robbins algebra+%--------------------------------------------------------------------------+cnf(commutativity_of_add,axiom,+    ( '+'(X,Y) = '+'(Y,X) )).++cnf(associativity_of_add,axiom,+    ( '+'('+'(X,Y),Z) = '+'(X,'+'(Y,Z)) )).++cnf(robbins_axiom,axiom,+    ( '-'('+'('-'('+'(X,Y)),'-'('+'(X,'-'(Y))))) = X )).++%--------------------------------------------------------------------------+%--------------------------------------------------------------------------+cnf(double_negation,hypothesis,+    ( '-'('-'(c)) = c )).++cnf(prove_huntingtons_axiom,negated_conjecture,+    '+'('-'('+'(a,'-'(b))),'-'('+'('-'(a),'-'(b)))) != b).++%--------------------------------------------------------------------------+%----Definition of g+cnf(sos04,axiom,(+    g(A) = '-'('+'(A,'-'(A))) )).++%----Definition of h+cnf(sos05,axiom,(+    h(A) = '+'(A,'+'(A,'+'(A,'-'('+'(A,'-'(A)))))))).

+ examples/ROB027-1.p view

@@ -0,0 +1,56 @@+%--------------------------------------------------------------------------+% File     : ROB027-1 : TPTP v6.3.0. Released v1.2.0.+% Domain   : Robbins Algebra+% Problem  : -(-c) = c => Boolean+% Version  : [Win90] (equality) axioms.+%            Theorem formulation : Denies Huntington's axiom.+% English  : If there are elements c and d such that c+d=d, then the+%            algebra is Boolean.++% Refs     : [HMT71] Henkin et al. (1971), Cylindrical Algebras+%          : [Win90] Winker (1990), Robbins Algebra: Conditions that make a+%          : [Wos94] Wos (1994), Two Challenge Problems+% Source   : [Wos94]+% Names    : - [Wos94]++% Status   : Open+% Rating   : 1.00 v2.0.0+% Syntax   : Number of clauses     :    5 (   0 non-Horn;   5 unit;   2 RR)+%            Number of atoms       :    5 (   5 equality)+%            Maximal clause size   :    1 (   1 average)+%            Number of predicates  :    1 (   0 propositional; 2-2 arity)+%            Number of functors    :    5 (   3 constant; 0-2 arity)+%            Number of variables   :    7 (   0 singleton)+%            Maximal term depth    :    6 (   3 average)+% SPC      : CNF_UNK_UEQ++% Comments : Commutativity, associativity, and Huntington's axiom+%            axiomatize Boolean algebra.+%--------------------------------------------------------------------------+%----Include axioms for Robbins algebra+%--------------------------------------------------------------------------+cnf(commutativity_of_add,axiom,+    ( add(X,Y) = add(Y,X) )).++cnf(associativity_of_add,axiom,+    ( add(add(X,Y),Z) = add(X,add(Y,Z)) )).++cnf(robbins_axiom,axiom,+    ( negate(add(negate(add(X,Y)),negate(add(X,negate(Y))))) = X )).++%--------------------------------------------------------------------------+%--------------------------------------------------------------------------+cnf(double_negation,hypothesis,+    ( negate(negate(c)) = c )).++cnf(prove_huntingtons_axiom,negated_conjecture,+    add(negate(add(a,negate(b))),negate(add(negate(a),negate(b)))) != b).++%--------------------------------------------------------------------------+%----Definition of g+cnf(sos04,axiom,(+    g(A) = negate(add(A,negate(A))) )).++%----Definition of h+cnf(sos05,axiom,(+    h(A) = add(A,add(A,add(A,negate(add(A,negate(A)))))))).

+ examples/ROB033-1.p view

@@ -0,0 +1,10 @@+cnf(commutativity_of_add, axiom, add(X, Y)=add(Y, X)).+cnf(associativity_of_add, axiom,+    add(add(X, Y), Z)=add(X, add(Y, Z))).+cnf(robbins_axiom, axiom,+    negate(add(negate(add(X, Y)), negate(add(X, negate(Y)))))=X).+cnf(sos04, axiom, g(A)=negate(add(A, negate(A)))).+cnf(sos05, axiom, h(A)=add(A, add(A, add(A, g(A))))).+cnf(goals, negated_conjecture,+    add(negate(add(x0, negate(x1))),+        negate(add(negate(x0), negate(x1))))!=x1).

+ examples/aim.p view

@@ -0,0 +1,54 @@+cnf(left_ident, axiom,+  '1' * X = X).+cnf(right_ident, axiom,+  X * '1' = X).+cnf(left_division_1, axiom,+  X \ (X * Y) = Y).+cnf(left_division_2, axiom,+  X * (X \ Y) = Y).+cnf(right_division_1, axiom,+  (X * Y) / Y = X).+cnf(right_division_2, axiom,+  (X / Y) * Y = X).+cnf(associator, axiom,+  (X * (Y * Z)) \ ((X * Y) * Z) = a(X,Y,Z)).+cnf(commutator, axiom,+  (X * Y) \ (Y * X) = k(Y,X)).+cnf(l, axiom,+  (Y * X) \ (Y * (X * U)) = l(U,X,Y)).+cnf(r, axiom,+  ((U * X) * Y) / (X * Y) = r(U,X,Y)).+cnf(t, axiom,+  X \ (U * X) = t(U,X)).+cnf(abelian_inner_mapping_1, axiom,+  t(t(U,X),Y) = t(t(U,Y),X)).+cnf(abelian_inner_mapping_2, axiom,+  t(l(U,X,Y),Z) = l(t(U,Z),X,Y)).+cnf(abelian_inner_mapping_3, axiom,+  t(r(U,X,Y),Z) = r(t(U,Z),X,Y)).+cnf(abelian_inner_mapping_4, axiom,+  l(r(U,X,Y),Z,W) = r(l(U,Z,W),X,Y)).+cnf(abelian_inner_mapping_5, axiom,+  l(l(U,X,Y),Z,W) = l(l(U,Z,W),X,Y)).+cnf(abelian_inner_mapping_6, axiom,+  r(r(U,X,Y),Z,W) = r(r(U,Z,W),X,Y)).++% aK (or "single-a") goals+cnf(ka, conjecture,+  k(a(x,y,z),u) = '1').+cnf(aK1, conjecture,+  a(k(x,y),z,u) = '1').+cnf(aK2, conjecture,+  a(x,k(y,z),u) = '1').+cnf(aK3, conjecture,+  a(x,y,k(z,u)) = '1').++% aa (or "double-a") goals+cnf(aa1, conjecture,+  a(a(x,y,z),u,w) = '1').+cnf(aa2, conjecture,+  a(x,a(y,z,u),w) = '1').+cnf(aa3, conjecture,+  a(x,y,a(z,u,w)) = '1').++cnf(bonus, axiom, (X * (Y / X)) \ X = Y \ (Y / (Y / X))).

+ examples/append-rev.p view

@@ -0,0 +1,4 @@+cnf(rev_rev, axiom, rev(rev(X)) = X).+cnf(app_assoc, axiom, X ++ (Y ++ Z) = (X ++ Y) ++ Z).+cnf(rev_app, axiom, rev(X) ++ rev(Y) = rev(Y ++ X)).+fof(conjecture, conjecture, ![A,B]: A ++ rev(B) = rev(B ++ rev(A))).

+ examples/cm.p view

@@ -0,0 +1,3 @@+fof(a, axiom, ![X, Y]: plus(X, Y)=plus(Y, X)).+fof(a, axiom, ![X, Y, Z]: plus(plus(X, Y), Z)=plus(X, plus(Z, Y))).+fof(a, axiom, a!=b).

+ examples/deriv.p view

@@ -0,0 +1,37 @@+% Axioms about arithmetic.++cnf('commutativity of +', axiom,+    X + Y = Y + X).+cnf('associativity of +', axiom,+    X + (Y + Z) = (X + Y) + Z).+cnf('commutativity of *', axiom,+    X * Y = Y * X).+cnf('associativity of *', axiom,+    X * (Y * Z) = (X * Y) * Z).+cnf('plus 0', axiom,+    '0' + X = X).+cnf('times 0', axiom,+    '0' * X = '0').+cnf('times 1', axiom,+    '1' * X = X).+cnf('distributivity', axiom,+    X * (Y + Z) = (X * Y) + (X * Z)).+cnf('minus', axiom,+    X + -X = '0').+cnf('derivative of 0', axiom,+    d('0') = '0').+cnf('derivative of 1', axiom,+    d('1') = '0').+cnf('derivative of x', axiom,+    d(x) = '1').+cnf('derivative of +', axiom,+    d(T+U) = d(T) + d(U)).+cnf('derivative of *', axiom,+    d(T*U) = (T*d(U)) + (U*d(T))).+cnf('derivative of sin', axiom,+    d(sin(T)) = cos(T) * d(T)).+cnf('derivative of cos', axiom,+    d(cos(T)) = -(sin(T)*d(T))).++fof(goal, conjecture,+    ?[T]: d(T) = x*cos(x)).

+ examples/diff.p view

@@ -0,0 +1,8 @@+cnf('x\\(y\\x)=x', axiom,+    X \ (Y \ X) = X).+cnf('x\\(x\\y)=y\\(y\\x)', axiom,+    X \ (X \ Y) = Y \ (Y \ X)).+cnf('(x\\y)\\z=(x\\z)\\(y\\z)', axiom,+    (X \ Y) \ Z = (X \ Z) \ (Y \ Z)).+cnf(conjecture, conjecture,+    (a \ c) \ b = (a \ b) \ c).

+ examples/diff2.p view

@@ -0,0 +1,34 @@+cnf('x\\(y\\x)=x', axiom,+    X \ (Y \ X) = X).+cnf('x\\(x\\y)=y\\(y\\x)', axiom,+    X \ (X \ Y) = Y \ (Y \ X)).+cnf('(x\\y)\\z=(x\\z)\\(y\\z)', axiom,+    (X \ Y) \ Z = (X \ Z) \ (Y \ Z)).++cnf(empty, axiom,+    X \ empty = X).++cnf(equals, conjecture,+    (X \ Y = empty & Y \ X = empty) => X = Y).++cnf(union, axiom,+    X \ union(Y, Z) = (X \ Y) \ Z).++cnf(union, conjecture,+    union(a,b) = union(b,a)).+cnf(union, conjecture,+    union(a,a) = a).+cnf(union, conjecture,+    union(a,union(b,c)) = union(union(a,b),c)).++cnf(intersection, axiom,+    intersection(X, Y) = X \ (X \ Y)).++cnf(intersection, conjecture,+    intersection(a,b) = intersection(b,a)).+cnf(intersection, conjecture,+    intersection(a,a) = a).+cnf(intersection, conjecture,+    intersection(a,intersection(b,c)) = intersection(intersection(a,b),c)).+cnf(intersection, conjecture,+    intersection(X, Y) = union(X,Y) \ union(X \ Y, Y \ X)).

+ examples/distributive_groupoid.p view

@@ -0,0 +1,12 @@+% Mitschke, "Every distributive groupoid is trimedial".+% Twee's proof of this is much uglier than the paper's proof.++cnf(distributivity, axiom,+    X . (Y . Z) = (X . Y) . (X . Z)).+cnf(distributivity, axiom,+    (X . Y) . Z = (X . Z) . (Y . Z)).+fof(conjecture, conjecture,+    (a . b) . (c . a) = (a . c) . (b . a)). ++%fof(lemma6, conjecture, ![X, Y, Z]: ((X . Y) . (Z . X)) . ((X . Z) . (Y . X)) = (X . Y) . (Z . X)).+

+ examples/factor.p view

@@ -0,0 +1,44 @@+% Axioms about arithmetic.++cnf('commutativity_of_plus', axiom,+    X + Y = Y + X).+cnf('associativity_of_plus', axiom,+    X + (Y + Z) = (X + Y) + Z).+cnf('commutativity_of_times', axiom,+    X * Y = Y * X).+cnf('associativity_of_times', axiom,+    X * (Y * Z) = (X * Y) * Z).+cnf('plus_zero', axiom,+    '0' + X = X).+cnf('times_zero', axiom,+    '0' * X = '0').+cnf('times_one', axiom,+    '1' * X = X).+cnf('distributivity', axiom,+    X * (Y + Z) = (X * Y) + (X * Z)).+cnf('minus', axiom,+    X + -X = '0').++cnf(two, axiom, two = '1'+'1').+cnf(three, axiom, three = '1'+two).+cnf(four, axiom, four = '1'+three).+cnf(five, axiom, five = '1'+four).+cnf(six, axiom, six = '1'+five).+cnf(seven, axiom, seven = '1'+six).+cnf(eight, axiom, eight = '1'+seven).+cnf(nine, axiom, nine = '1'+eight).+cnf(minus_six, axiom, minus_four = -four).+cnf(minus_six, axiom, minus_six = -six).++fof(factoring, conjecture,+    ?[A,B,C]: ![X]:+      (X*(X*X)) + ((minus_six*(X*X)) + ((nine*X) + minus_four)) = ((X ++      -'1')*((X + -'1') * (X + -four)))).++fof(factoring, conjecture,+    ?[A,B,C]: ![X]:+    (X*(X*X)) ++    (-(('1'+('1'+('1'+('1'+('1'+'1')))))*(X*X)) ++     ((('1'+('1'+('1'+('1'+('1'+('1'+('1'+('1'+'1'))))))))*X) ++     -('1'+('1'+('1'+'1'))))) =+    (X + -A)*((X + -B)*(X + -C))).

+ examples/filter.p view

@@ -0,0 +1,59 @@+fof('associativity of ∘', axiom,+    ![F, G, H]:+    F ∘ (G ∘ H) = (F ∘ G) ∘ H).++fof('∘ identity', axiom,+    ![F]:+    id ∘ F = F).++fof('∘ identity', axiom,+    ![F]:+    F ∘ id = F).++fof('map functor', axiom,+    ![F, G]:+    map(F) ∘ map(G) = map(F ∘ G)).++fof('map functor', axiom,+    map(id) = id).++fof('naturality of concat', axiom,+    ![F]:+    map(F) ∘ concat = concat ∘ map(map(F))).++fof('defn filter', axiom,+    ![P]:+    filter(P) = concat ∘ map(test(P))).++% test(P) = \x -> if P(x) then [x] else []++%fof('test property', axiom,+%    ![P, F]:+%    test(P) ∘ F =+%    map(F) ∘ test(P ∘ F)).++fof('map/filter', conjecture,+    ![P, F]:+    filter(P) ∘ map(F) = map(F) ∘ filter(P ∘ F)).+++% cond(P, F, G) = \x -> if P(x) then F(x) else G(x)++fof('test defn', axiom,+    ![P]:+    test(P) = cond(P, unit, nil)).+fof('cond ∘', axiom,+    ![F, P, G, H]:+    F ∘ cond(P, G, H) = cond(P, F ∘ G, F ∘ H)).+fof('cond ∘', axiom,+    ![F, P, G, H]:+    cond(P, G, H) ∘ F = cond(P ∘ F, G ∘ F, H ∘ F)).+fof('nil', axiom,+    ![F]:+    nil ∘ F = nil).+fof('nil', axiom,+    ![F]:+    map(F) ∘ nil = nil).+fof('unit', axiom,+    ![F]:+    map(F) ∘ unit = unit ∘ F).

+ examples/gmv.p view

@@ -0,0 +1,74 @@+cnf('Associativity-∧', axiom,+    (X ∧ Y) ∧ Z = X ∧ (Y ∧ Z)).   +cnf('Associativity-∨', axiom,+    (X ∨ Y) ∨ Z = X ∨ (Y ∨ Z)).+cnf('Idempotence-∧', axiom,+    X ∧ X = X).+cnf('Idempotence-∨', axiom,+    X ∨ X = X).+cnf('Commutativity-∧', axiom,+    X ∧ Y = Y ∧ X).+cnf('Commutativity-∨', axiom,+    X ∨ Y = Y ∨ X).+cnf('Absorption a', axiom,+    (X ∧ Y) ∨ X = X).+cnf('Absorption b', axiom,+    (X ∨ Y) ∧ X = X).++cnf('Residual a', axiom,+    (X * ((X \ Z) ∧ Y)) ∨ Z = Z).+cnf('Residual b', axiom,+    ((Y ∧ (Z / X)) * X) ∨ Z = Z).+cnf('Residual c', axiom,+    (X \ ((X * Y) ∨ Z)) ∧ Y = Y).+cnf('Residual d', axiom,+    (((Y * X) ∨ Z) / X) ∧ Y = Y).++cnf('Associativity-* (fusion)', axiom,+    (X * Y) * Z = X * (Y * Z)).+cnf('Left monoid unit', axiom,+    '1' * X = X).+cnf('Right monoid unit', axiom,+    X * '1' = X).++cnf('GMV a', axiom,+    X ∨ Y = X / ((X ∨ Y) \ X)).+cnf('GMV b', axiom,+    X ∨ Y = (X / (X ∨ Y)) \ X).++cnf('Definition-@', axiom,+    X @ Y = (X * (X \ '1')) * ((Y \ '1') \ '1')).++cnf('Goal 1', conjecture,+    x @ x = x).+cnf('Goal 2', conjecture,+    (x @ y) @ z = x @ z).+cnf('Goal 3', conjecture,+    x @ (y @ z) = x @ z).+  +cnf('Goal 4', conjecture,+    (x ∧ y) @ (z ∧ u) = (x @ z) ∧ (y @ u)).+cnf('Goal 5', conjecture,+    (x ∨ y) @ (z ∨ u) = (x @ z) ∨ (y @ u)).+cnf('Goal 6', conjecture,+    (x \ y) @ (z \ u) = (x @ z) \ (y @ u)).+cnf('Goal 7', conjecture,+    (x / y) @ (z / u) = (x @ z) / (y @ u)).+  +cnf('Goal 8', conjecture,+    (x * (x \ '1')) @ '1' = x * (x \ '1')).+cnf('Goal 9', conjecture,+    '1' @ (x * (x \ '1')) = '1').+cnf('Goal 10', conjecture,+    (x \ '1') @ '1' = '1').+cnf('Goal 11', conjecture,+    '1' @ (x \ '1') = x \ '1').+  +cnf('Goal 12', conjecture,+    (x / (y \ x)) @ (x ∨ y) = x ∨ y).+cnf('Goal 13', conjecture,+    ((x / y) \ x) @ (x ∨ y) = x ∨ y).+cnf('Goal 14', conjecture,+    (x ∨ y) @ (x / (y \ x)) = x / (y \ x)).+cnf('Goal 15', conjecture,+    (x ∨ y) @ ((x / y) \ x) = (x / y) \ x).

+ examples/group.p view

@@ -0,0 +1,14 @@+cnf(associativity, axiom,+    X + (Y + Z) = (X + Y) + Z).+cnf(plus_zero, axiom,+    '0' + X = X).+cnf(plus_zero, axiom,+    X + '0' = X).+cnf(minus_left, axiom,+    (-X) + X = '0').+cnf(minus_right, axiom,+    X + (-X) = '0').+cnf(assumption, assumption,+    a + b = a).+cnf(goal, conjecture,+    b = '0').

+ examples/haken.p view

@@ -0,0 +1,170 @@+cnf(a, conjecture, a1 = a2 & a2 = a3 & a3 = a4 & a4 = a5 & a5 = a6 &+a6 = a7 & a7 = a8 & a8 = a9 & a9 = a10 & a10 = a11 & a11 = a12 & a12 =+a13 & a13 = a14 & a14 = a15 & a15 = a16 & a16 = a17 & a17 = a18 & a18+= a19 & a19 = a20 & a20 = a21 & a20 = a22 & a21 = a23 & a23 = a24 &+a24 = a25 & a25 = a26 & a26 = a27 & a27 = a28 & a28 = a29 & a29 = a30+& a30 = a31 & a31 = a32 & a32 = a33 & a33 = a34 & a34 = a35 & a35 =+a36 & a36 = a37 & a37 = a38 & a38 = a39 & a39 = a40 & a40 = a41 & a41+= a42 & a42 = a43 & a43 = a44 & a44 = a45 & a45 = a46 & a46 = a47 &+a47 = a48 & a48 = a49 & a49 = a50 & a50 = a51 & a51 = a52 & a52 = a53+& a53 = a54 & a54 = a55 & a55 = a56 & a56 = a57 & a57 = a58 & a58 =+a59 & a59 = a60 & a60 = a61 & a61 = a62 & a62 = a63 & a63 = a64 & a64+= a65 & a65 = a66 & a66 = a67 & a67 = a68 & a68 = a69 & a69 = a70 &+a70 = a71 & a71 = a72 & a72 = a73 & a73 = a74 & a74 = a75 & a75 = a76+& a76 = a77 & a77 = a78 & a78 = a79 & a79 = a80 & a80 = a81 & a81 =+a82 & a82 = a83 & a83 = a84 & a84 = a85 & a85 = a86 & a86 = a87 & a87+= a88 & a88 = a89 & a89 = a90 & a90 = a91 & a91 = a92 & a92 = a93 &+a93 = a94 & a94 = a95 & a95 = a96 & a96 = a97 & a97 = a98 & a98 = a99+& a99 = a100 & a100 = a101 & a101 = a102 & a102 = a103 & a103 = a104 &+a104 = a105 & a105 = a106 & a106 = a107 & a107 = a108 & a108 = a109 &+a109 = a110 & a110 = a111 & a111 = a112 & a112 = a113 & a113 = a114 &+a114 = a115 & a115 = a116 & a116 = a117 & a117 = a118 & a118 = a119 &+a119 = a120 & a120 = a121 & a121 = a122 & a122 = a123 & a123 = a124 &+a124 = a125 & a125 = a126 & a126 = a127 & a127 = a128 & a128 = a129 &+a129 = a130 & a130 = a131 & a131 = a132 & a132 = a133 & a133 = a134 &+a134 = a135 & a135 = a136 & a136 = a137 & a137 = a138 & a138 = a139 &+a139 = a140 & a140 = a141).+cnf(a, axiom, '*'(X, X) = X).+cnf(a, axiom, '*'('*'(X,Y),Y) = X).+cnf(a, axiom, '*'('*'(X,Y),Z) = '*'('*'(X, Z), '*'(Y, Z))).+cnf(a, axiom, a2 = '*'(a1, a42)).+cnf(a, axiom, a3 = '*'(a2, a41)).+cnf(a, axiom, a4 = '*'(a3, a14)).+cnf(a, axiom, a5 = '*'(a4, a39)).+cnf(a, axiom, a6 = '*'(a5, a136)).+cnf(a, axiom, a7 = '*'(a6, a52)).+cnf(a, axiom, a8 = '*'(a7, a17)).+cnf(a, axiom, a9 = '*'(a8, a56)).+cnf(a, axiom, a10 = '*'(a9, a134)).+cnf(a, axiom, a11 = '*'(a10, a37)).+cnf(a, axiom, a12 = '*'(a11, a21)).+cnf(a, axiom, a13 = '*'(a12, a23)).+cnf(a, axiom, a14 = '*'(a13, a32)).+cnf(a, axiom, a15 = '*'(a14, a53)).+cnf(a, axiom, a16 = '*'(a15, a136)).+cnf(a, axiom, a17 = '*'(a16, a29)).+cnf(a, axiom, a18 = '*'(a17, a133)).+cnf(a, axiom, a19 = '*'(a18, a58)).+cnf(a, axiom, a20 = '*'(a19, a26)).+cnf(a, axiom, a21 = '*'(a20, a35)).+cnf(a, axiom, a22 = '*'(a21, a141)).+cnf(a, axiom, a23 = '*'(a22, a45)).+cnf(a, axiom, a24 = '*'(a23, a35)).+cnf(a, axiom, a25 = '*'(a24, a49)).+cnf(a, axiom, a26 = '*'(a25, a138)).+cnf(a, axiom, a27 = '*'(a26, a8)).+cnf(a, axiom, a28 = '*'(a27, a37)).+cnf(a, axiom, a29 = '*'(a28, a17)).+cnf(a, axiom, a30 = '*'(a29, a14)).+cnf(a, axiom, a31 = '*'(a30, a5)).+cnf(a, axiom, a32 = '*'(a31, a39)).+cnf(a, axiom, a33 = '*'(a32, a13)).+cnf(a, axiom, a34 = '*'(a33, a131)).+cnf(a, axiom, a35 = '*'(a34, a60)).+cnf(a, axiom, a36 = '*'(a35, a139)).+cnf(a, axiom, a37 = '*'(a36, a47)).+cnf(a, axiom, a38 = '*'(a37, a17)).+cnf(a, axiom, a39 = '*'(a38, a7)).+cnf(a, axiom, a40 = '*'(a39, a4)).+cnf(a, axiom, a41 = '*'(a40, a14)).+cnf(a, axiom, a42 = '*'(a41, a2)).+cnf(a, axiom, a43 = '*'(a42, a62)).+cnf(a, axiom, a44 = '*'(a43, a128)).+cnf(a, axiom, a45 = '*'(a44, a23)).+cnf(a, axiom, a46 = '*'(a45, a141)).+cnf(a, axiom, a47 = '*'(a46, a11)).+cnf(a, axiom, a48 = '*'(a47, a20)).+cnf(a, axiom, a49 = '*'(a48, a138)).+cnf(a, axiom, a50 = '*'(a49, a131)).+cnf(a, axiom, a51 = '*'(a50, a59)).+cnf(a, axiom, a52 = '*'(a51, a39)).+cnf(a, axiom, a53 = '*'(a52, a136)).+cnf(a, axiom, a54 = '*'(a53, a29)).+cnf(a, axiom, a55 = '*'(a54, a135)).+cnf(a, axiom, a56 = '*'(a55, a37)).+cnf(a, axiom, a57 = '*'(a56, a134)).+cnf(a, axiom, a58 = '*'(a57, a26)).+cnf(a, axiom, a59 = '*'(a58, a138)).+cnf(a, axiom, a60 = '*'(a59, a131)).+cnf(a, axiom, a61 = '*'(a60, a13)).+cnf(a, axiom, a62 = '*'(a61, a1)).+cnf(a, axiom, a63 = '*'(a62, a96)).+cnf(a, axiom, a64 = '*'(a63, a127)).+cnf(a, axiom, a65 = '*'(a64, a41)).+cnf(a, axiom, a66 = '*'(a65, a2)).+cnf(a, axiom, a67 = '*'(a66, a92)).+cnf(a, axiom, a68 = '*'(a67, a98)).+cnf(a, axiom, a69 = '*'(a68, a32)).+cnf(a, axiom, a70 = '*'(a69, a13)).+cnf(a, axiom, a71 = '*'(a70, a118)).+cnf(a, axiom, a72 = '*'(a71, a109)).+cnf(a, axiom, a73 = '*'(a72, a82)).+cnf(a, axiom, a74 = '*'(a73, a32)).+cnf(a, axiom, a75 = '*'(a74, a14)).+cnf(a, axiom, a76 = '*'(a75, a68)).+cnf(a, axiom, a77 = '*'(a76, a114)).+cnf(a, axiom, a78 = '*'(a77, a13)).+cnf(a, axiom, a79 = '*'(a78, a33)).+cnf(a, axiom, a80 = '*'(a79, a119)).+cnf(a, axiom, a81 = '*'(a80, a70)).+cnf(a, axiom, a82 = '*'(a81, a109)).+cnf(a, axiom, a83 = '*'(a82, a118)).+cnf(a, axiom, a84 = '*'(a83, a39)).+cnf(a, axiom, a85 = '*'(a84, a5)).+cnf(a, axiom, a86 = '*'(a85, a30)).+cnf(a, axiom, a87 = '*'(a86, a104)).+cnf(a, axiom, a88 = '*'(a87, a4)).+cnf(a, axiom, a89 = '*'(a88, a14)).+cnf(a, axiom, a90 = '*'(a89, a41)).+cnf(a, axiom, a91 = '*'(a90, a100)).+cnf(a, axiom, a92 = '*'(a91, a124)).+cnf(a, axiom, a93 = '*'(a92, a2)).+cnf(a, axiom, a94 = '*'(a93, a41)).+cnf(a, axiom, a95 = '*'(a94, a127)).+cnf(a, axiom, a96 = '*'(a95, a64)).+cnf(a, axiom, a97 = '*'(a96, a42)).+cnf(a, axiom, a98 = '*'(a97, a1)).+cnf(a, axiom, a99 = '*'(a98, a92)).+cnf(a, axiom, a100 = '*'(a99, a124)).+cnf(a, axiom, a101 = '*'(a100, a14)).+cnf(a, axiom, a102 = '*'(a101, a40)).+cnf(a, axiom, a103 = '*'(a102, a4)).+cnf(a, axiom, a104 = '*'(a103, a87)).+cnf(a, axiom, a105 = '*'(a104, a30)).+cnf(a, axiom, a106 = '*'(a105, a5)).+cnf(a, axiom, a107 = '*'(a106, a84)).+cnf(a, axiom, a108 = '*'(a107, a39)).+cnf(a, axiom, a109 = '*'(a108, a118)).+cnf(a, axiom, a110 = '*'(a109, a70)).+cnf(a, axiom, a111 = '*'(a110, a119)).+cnf(a, axiom, a112 = '*'(a111, a79)).+cnf(a, axiom, a113 = '*'(a112, a33)).+cnf(a, axiom, a114 = '*'(a113, a13)).+cnf(a, axiom, a115 = '*'(a114, a68)).+cnf(a, axiom, a116 = '*'(a115, a14)).+cnf(a, axiom, a117 = '*'(a116, a74)).+cnf(a, axiom, a118 = '*'(a117, a32)).+cnf(a, axiom, a119 = '*'(a118, a70)).+cnf(a, axiom, a120 = '*'(a119, a13)).+cnf(a, axiom, a121 = '*'(a120, a32)).+cnf(a, axiom, a122 = '*'(a121, a68)).+cnf(a, axiom, a123 = '*'(a122, a115)).+cnf(a, axiom, a124 = '*'(a123, a75)).+cnf(a, axiom, a125 = '*'(a124, a2)).+cnf(a, axiom, a126 = '*'(a125, a65)).+cnf(a, axiom, a127 = '*'(a126, a41)).+cnf(a, axiom, a128 = '*'(a127, a96)).+cnf(a, axiom, a129 = '*'(a128, a62)).+cnf(a, axiom, a130 = '*'(a129, a1)).+cnf(a, axiom, a131 = '*'(a130, a13)).+cnf(a, axiom, a132 = '*'(a131, a138)).+cnf(a, axiom, a133 = '*'(a132, a58)).+cnf(a, axiom, a134 = '*'(a133, a26)).+cnf(a, axiom, a135 = '*'(a134, a37)).+cnf(a, axiom, a136 = '*'(a135, a29)).+cnf(a, axiom, a137 = '*'(a136, a39)).+cnf(a, axiom, a138 = '*'(a137, a51)).+cnf(a, axiom, a139 = '*'(a138, a20)).+cnf(a, axiom, a140 = '*'(a139, a47)).+cnf(a, axiom, a141 = '*'(a140, a11)).+cnf(a, axiom, a1 = '*'(a141, a23)).

+ examples/loop.p view

@@ -0,0 +1,6 @@+cnf(mult_ld, axiom, X * (X \ Y) = Y).+cnf(ld_mult, axiom, X \ (X * Y) = Y).+cnf(mult_rd, axiom, (X / Y) * Y = X).+cnf(rd_mult, axiom, (X * Y) / Y = X).+cnf(moufang, axiom, X * (Y * (X * Z)) = ((X * Y) * X) * Z).+cnf(conjecture, conjecture, a \ a = a / a).

+ examples/loop2.p view

@@ -0,0 +1,6 @@+cnf('*-\\', axiom, X * (X \ Y) = Y).+cnf('\\-*', axiom, X \ (X * Y) = Y).+cnf('*-/', axiom, (X / Y) * Y = X).+cnf('/-*', axiom, (X * Y) / Y = X).+cnf(moufang, axiom, X * (Y * (X * Z)) = ((X * Y) * X) * Z).+cnf(conjecture, conjecture, a * (b / b) = a).

+ examples/lukasiewicz.p view

@@ -0,0 +1,6 @@+cnf(imp_true, axiom, implies(true, X) = X).+cnf(imp_compose, axiom, implies(implies(X, Y), implies(implies(Y, Z), implies(X, Z))) = true).+cnf(imp_not, axiom, implies(implies(not(X), not(Y)), implies(Y, X)) = true).+cnf(imp_switch, axiom, implies(implies(X, Y), Y) = implies(implies(Y, X), X)).+cnf(or_def, axiom, or(X, Y) = implies(not(X), Y)).+cnf(conjecture, negated_conjecture, or(a,or(b,c)) != or(or(a,b),c)).

+ examples/minus.p view

@@ -0,0 +1,10 @@+cnf(plus_zero, axiom,+    '0' + X = X).+cnf(plus_zero, axiom,+    X + '0' = X).+cnf(minus_minus, axiom,+    - -X = X).+cnf(minus_plus, axiom,+    -(X + Y) = -X + -Y).+cnf(goal, conjecture,+    -'0' = '0').

+ examples/nicomachus.p view

@@ -0,0 +1,36 @@+cnf(plus_comm, axiom,+    X + Y = Y + X).+cnf(plus_assoc, axiom,+    X + (Y + Z) = (X + Y) + Z).+cnf(times_comm, axiom,+    X * Y = Y * X).+cnf(times_assoc, axiom,+    X * (Y * Z) = (X * Y) * Z).+cnf(plus_zero, axiom,+    X + zero = X).+cnf(times_zero, axiom,+    X * zero = zero).+cnf(times_one, axiom,+    X * one = X).+cnf(distr, axiom,+    X * (Y + Z) = (X * Y) + (X * Z)).+cnf(distr, axiom,+    (X + Y) * Z = (X * Z) + (Y * Z)).+cnf(plus_s, axiom,+    s(X) + Y = s(X+Y)).+cnf(times_s, axiom,+    s(X)*Y = Y + (X*Y)).+cnf(sum_zero, axiom,+    sum(zero) = zero).+cnf(sum_s, axiom,+    sum(s(N)) = s(N) + sum(N)).+cnf(cubes_zero, axiom,+    cubes(zero) = zero).+cnf(cubes_s, axiom,+    cubes(s(N)) = (s(N) * (s(N) * s(N))) + cubes(N)).+cnf(plus_sum, axiom,+    sum(N) + sum(N) = N * s(N)).+cnf(ih, axiom,+    sum(a) * sum(a) = cubes(a)).+cnf(conjecture, conjecture,+    sum(s(a)) * sum(s(a)) = cubes(s(a))).

+ examples/regexp.p view

@@ -0,0 +1,54 @@+%% and, or+cnf(def, axiom, and(true,B) = B).+cnf(def, axiom, and(false,B) = false).+cnf(def, axiom, and(X,Y) = and(Y,X)).++cnf(def, axiom, or(true,B) = true).+cnf(def, axiom, or(false,B) = B).+cnf(def, axiom, or(X,Y) = or(Y,X)).++%% eq+cnf(def, axiom, eq(X,X) = true).+cnf(def, axiom, eq(X,Y) = eq(Y,X)).+cnf(def, axiom, eq(a,b) = false).+cnf(def, axiom, eq(a,c) = false).+cnf(def, axiom, eq(b,c) = false).++%% haseps+cnf(def, axiom, haseps(atom(A)) = false).+cnf(def, axiom, haseps(zero) = false).+cnf(def, axiom, haseps(eps) = true).+cnf(def, axiom, haseps(plus(P,Q)) = or(haseps(P),haseps(Q))).+cnf(def, axiom, haseps(seq(P,Q)) = and(haseps(P),haseps(Q))).+cnf(def, axiom, haseps(star(P)) = true).++%% step+cnf(def, axiom, step(atom(A),A) = eps).+cnf(def, axiom, eq(A,B) = false => step(atom(A),B) = zero).+cnf(def, axiom, step(zero,B) = zero).+cnf(def, axiom, step(eps,B) = zero).+cnf(def, axiom, step(plus(P,Q),B) = plus(step(P,B),step(Q,B))).+cnf(def, axiom, haseps(P) = true => step(seq(P,Q),B) = plus(seq(step(P,B),Q),step(Q,B))).+cnf(def, axiom, haseps(P) = false => step(seq(P,Q),B) = plus(seq(step(P,B),Q),zero)).+cnf(def, axiom, step(star(P),B) = seq(step(P,B),star(P))).++%% rec+cnf(def, axiom, rec(P,nil) = haseps(P)).+cnf(def, axiom, rec(P,cons(A,As)) = rec(step(P,A),As)).++%% question+cnf(hypothesis, axiom, rec(seq(P,Q), As) = rec(seq(Q,P), As)).+cnf(goal, axiom, true != false).++%cnf(a, axiom, atom(A) != zero & atom(A) != eps & atom(A) != plus(P, Q) & atom(A) != seq(P, Q) & atom(A) != star(P)).+%cnf(a, axiom, zero != eps & zero != plus(P, Q) & zero != seq(P, Q) & zero != star(P)).+%cnf(a, axiom, eps != plus(P, Q) & eps != seq(P, Q) & eps != star(P)).+%cnf(a, axiom, plus(P, Q) != seq(P, Q) & plus(P, Q) != star(P)).+%cnf(a, axiom, seq(P, Q) != star(P)).+%cnf(a, axiom, un_atom(atom(A)) = A).+%cnf(a, axiom, un_plus_1(plus(P, Q)) = P).+%cnf(a, axiom, un_plus_2(plus(P, Q)) = Q).+%cnf(a, axiom, un_seq_1(seq(P, Q)) = P).+%cnf(a, axiom, un_seq_2(seq(P, Q)) = Q).+%cnf(a, axiom, un_star(star(P)) = P).+%cnf(a, axiom, a != b & b != c & a != c).

+ examples/rel.p view

@@ -0,0 +1,32 @@+tff(type, type, '_⁻¹' : $i > $i).+tff(type, type, '_⁻' : $i > $i).++cnf('commutativity of ∨', axiom,+    A ∨ B = B ∨ A).+cnf('associativity of ∨', axiom,+    A ∨ (B ∨ C) = (A ∨ B) ∨ C).+cnf('a kind of de Morgan', axiom,+    (A⁻ ∨ B⁻)⁻ ∨ (A⁻ ∨ B)⁻ = A).+cnf('definition of ∧', axiom,+    A ∧ B = (A⁻ ∨ B⁻)⁻).+cnf('associativity of ;', axiom,+    A ; (B ; C) = (A ; B) ; C).+cnf('identity for ;', axiom,+    A ; '1' = A).+cnf('distributivity of ; over ∨', axiom,+    (A ∨ B) ; C = (A ; C) ∨ (B ; C)).+cnf('involution of ⁻¹', axiom,+    A⁻¹ ⁻¹ = A).+cnf('additivity of ⁻¹', axiom,+    (A ∨ B)⁻¹ = A⁻¹ ∨ B⁻¹).+cnf('multiplicativity of ⁻¹', axiom,+    (A ; B)⁻¹ = B⁻¹ ; A⁻¹).+cnf('cancellativity of ⁻', axiom,+    (A⁻¹ ; (A ; B)⁻) ∨ B⁻ = B⁻).+cnf('definition of top', axiom,+    top = A ∨ A⁻).+cnf('definition of zero', axiom,+    zero = A ∧ A⁻).+cnf(goal, conjecture,+    (r1 ; (r2 ∧ r3)) ∨ ((r1 ; r2) ∧ (r1 ; r3)) =+    (r1 ; r2) ∧ (r1 ; r3)).

+ examples/rel2.p view

@@ -0,0 +1,32 @@+tff(type, type, '_⁻¹' : $i > $i).+tff(type, type, '_⁻' : $i > $i).++cnf('commutativity of ∨', axiom,+    A ∨ B = B ∨ A).+cnf('associativity of ∨', axiom,+    A ∨ (B ∨ C) = (A ∨ B) ∨ C).+cnf('a kind of de Morgan', axiom,+    (A⁻ ∨ B⁻)⁻ ∨ (A⁻ ∨ B)⁻ = A).+cnf('definition of ∧', axiom,+    A ∧ B = (A⁻ ∨ B⁻)⁻).+cnf('associativity of ;', axiom,+    A ; (B ; C) = (A ; B) ; C).+cnf('identity for ;', axiom,+    A ; '1' = A).+cnf('distributivity of ; over ∨', axiom,+    (A ∨ B) ; C = (A ; C) ∨ (B ; C)).+cnf('involution of ⁻¹', axiom,+    A⁻¹ ⁻¹ = A).+cnf('additivity of ⁻¹', axiom,+    (A ∨ B)⁻¹ = A⁻¹ ∨ B⁻¹).+cnf('multiplicativity of ⁻¹', axiom,+    (A ; B)⁻¹ = B⁻¹ ; A⁻¹).+cnf('cancellativity of ⁻', axiom,+    (A⁻¹ ; (A ; B)⁻) ∨ B⁻ = B⁻).+cnf('definition of top', axiom,+    top = A ∨ A⁻).+cnf('definition of zero', axiom,+    zero = A ∧ A⁻).+cnf(goal, conjecture,+    ((r1 ; r2) ∧ r3) ∨ ((r1; (r2 ∧ (r1⁻¹ ; r3))) ∧ r3) =+    (r1 ; (r2 ∧ (r1⁻¹ ; r3))) ∧ r3).

+ examples/rellat_appendixa.p view

@@ -0,0 +1,27 @@+% http://www.dcs.bbk.ac.uk/~szabolcs/rellat-jlamp-second-submission-2.pdf+% appendix a. theorem 3.4, clause 7.+cnf(commutativity, axiom,+    X ∧ Y = Y ∧ X).+cnf(associativity, axiom,+    X ∧ (Y ∧ Z) = (X ∧ Y) ∧ Z).+cnf(commutativity, axiom,+    X ∨ Y = Y ∨ X).+cnf(associativity, axiom,+    X ∨ (Y ∨ Z) = (X ∨ Y) ∨ Z).+cnf(absorption, axiom,+    X ∨ (X ∧ Y) = X).+cnf(absorption, axiom,+    X ∧ (X ∨ Y) = X).+cnf(definition_of_upme, axiom,+    upme(X,Y,Z) = X ∧ (Y ∨ Z)).+cnf(definition_of_lome, axiom,+    lome(X,Y,Z) = (X ∧ Y) ∨ (X ∧ Z)).+cnf(definition_of_upjo, axiom,+    upjo(X,Y,Z) = (X ∨ Y) ∧ (X ∨ Z)).+cnf(definition_of_lojo, axiom,+    lojo(X,Y,Z) = X ∨ (Y ∧ Z)).++fof(conjecture, conjecture,+    (![X1, Y1, W]:+    upme(a ∧ X1,Y1,W) ∨ (Y1 ∧ W) = (((a ∧ X1) ∧ Y1) ∨ W) ∧ (((a ∧ X1) ∧ W) ∨ Y1)) =>+    upme(a ∧ z1,z2,z3) = lome(a ∧ z1,z2,z3)).

+ examples/rellat_appendixb.p view

@@ -0,0 +1,28 @@+% http://www.dcs.bbk.ac.uk/~szabolcs/rellat-jlamp-second-submission-2.pdf+% appendix b. theorem 3.4, clause 8.+cnf(commutativity, axiom,+    X ∧ Y = Y ∧ X).+cnf(associativity, axiom,+    X ∧ (Y ∧ Z) = (X ∧ Y) ∧ Z).+cnf(commutativity, axiom,+    X ∨ Y = Y ∨ X).+cnf(associativity, axiom,+    X ∨ (Y ∨ Z) = (X ∨ Y) ∨ Z).+cnf(absorption, axiom,+    X ∨ (X ∧ Y) = X).+cnf(absorption, axiom,+    X ∧ (X ∨ Y) = X).+cnf(definition_of_upme, axiom,+    upme(X,Y,Z) = X ∧ (Y ∨ Z)).+cnf(definition_of_lome, axiom,+    lome(X,Y,Z) = (X ∧ Y) ∨ (X ∧ Z)).+cnf(definition_of_upjo, axiom,+    upjo(X,Y,Z) = (X ∨ Y) ∧ (X ∨ Z)).+cnf(definition_of_lojo, axiom,+    lojo(X,Y,Z) = X ∨ (Y ∧ Z)).+cnf(rh1, axiom,+    upme(a ∧ X1,Y1,Z1) ∨ (Y1 ∧ Z1) = (((a ∧ X1) ∧ Y1) ∨ Z1) ∧ (((a ∧ X1) ∧ Z1) ∨ Y1)).+cnf(rh2, axiom,+    upme(X,Y,Z) = upme(X,Y,a ∧ Z) ∨ upme(X,Z,a ∧ Y)).+fof(conjecture, conjecture,+    upme(a,x2,y2) = upme(a,x2,z2) => upme(x2,y2,z2) = lome(x2,y2,z2)).

+ examples/rellat_appendixb_easier.p view

@@ -0,0 +1,30 @@+% http://www.dcs.bbk.ac.uk/~szabolcs/rellat-jlamp-second-submission-2.pdf+% appendix b. theorem 3.4, clause 8, assuming axiom rl1.+cnf(commutativity, axiom,+    X ∧ Y = Y ∧ X).+cnf(associativity, axiom,+    X ∧ (Y ∧ Z) = (X ∧ Y) ∧ Z).+cnf(commutativity, axiom,+    X ∨ Y = Y ∨ X).+cnf(associativity, axiom,+    X ∨ (Y ∨ Z) = (X ∨ Y) ∨ Z).+cnf(absorption, axiom,+    X ∨ (X ∧ Y) = X).+cnf(absorption, axiom,+    X ∧ (X ∨ Y) = X).+cnf(definition_of_upme, axiom,+    upme(X,Y,Z) = X ∧ (Y ∨ Z)).+cnf(definition_of_lome, axiom,+    lome(X,Y,Z) = (X ∧ Y) ∨ (X ∧ Z)).+cnf(definition_of_upjo, axiom,+    upjo(X,Y,Z) = (X ∨ Y) ∧ (X ∨ Z)).+cnf(definition_of_lojo, axiom,+    lojo(X,Y,Z) = X ∨ (Y ∧ Z)).+cnf(rh1, axiom,+    upme(a ∧ X1,Y1,Z1) ∨ (Y1 ∧ Z1) = (((a ∧ X1) ∧ Y1) ∨ Z1) ∧ (((a ∧ X1) ∧ Z1) ∨ Y1)).+cnf(rh2, axiom,+    upme(X,Y,Z) = upme(X,Y,a ∧ Z) ∨ upme(X,Z,a ∧ Y)).+cnf(rl1, axiom,+    lome(X,Y,Z) = upme(X,upme(Y,X,Z),upme(Z,X,Y))).+fof(conjecture, conjecture,+    upme(a,x2,y2) = upme(a,x2,z2) => upme(x2,y2,z2) = lome(x2,y2,z2)).

+ examples/rellat_appendixc.p view

@@ -0,0 +1,30 @@+% http://www.dcs.bbk.ac.uk/~szabolcs/rellat-jlamp-second-submission-2.pdf+% appendix c. theorem 3.4, clause 9.+cnf(commutativity, axiom,+    X ∧ Y = Y ∧ X).+cnf(associativity, axiom,+    X ∧ (Y ∧ Z) = (X ∧ Y) ∧ Z).+cnf(commutativity, axiom,+    X ∨ Y = Y ∨ X).+cnf(associativity, axiom,+    X ∨ (Y ∨ Z) = (X ∨ Y) ∨ Z).+cnf(absorption, axiom,+    X ∨ (X ∧ Y) = X).+cnf(absorption, axiom,+    X ∧ (X ∨ Y) = X).+cnf(definition_of_upme, axiom,+    upme(X,Y,Z) = X ∧ (Y ∨ Z)).+cnf(definition_of_lome, axiom,+    lome(X,Y,Z) = (X ∧ Y) ∨ (X ∧ Z)).+cnf(definition_of_upjo, axiom,+    upjo(X,Y,Z) = (X ∨ Y) ∧ (X ∨ Z)).+cnf(definition_of_lojo, axiom,+    lojo(X,Y,Z) = X ∨ (Y ∧ Z)).+cnf(upme_property_1, axiom,+    upme(a ∧ X1,Y1,Z1) ∨ (Y1 ∧ Z1) = (((a ∧ X1) ∧ Y1) ∨ Z1) ∧ (((a ∧ X1) ∧ Z1) ∨ Y1)).+cnf(upme_property_2, axiom,+    upme(X,Y,Z) = upme(X,Y,a ∧ Z) ∨ upme(X,Z,a ∧ Y)).+fof(conjecture, conjecture,+    (upme(a,x2,y2) = upme(a,x2,z2) &+     upme(a,x2,y2) = upme(a,y2,z2)) =>+    upjo(x2,y2,z2) = lojo(x2,y2,z2)).

+ examples/rellat_theorem34_6.p view

@@ -0,0 +1,32 @@+% http://www.dcs.bbk.ac.uk/~szabolcs/rellat-jlamp-second-submission-2.pdf+% theorem 3.4, clause 6.+cnf(commutativity, axiom,+    X ∧ Y = Y ∧ X).+cnf(associativity, axiom,+    X ∧ (Y ∧ Z) = (X ∧ Y) ∧ Z).+cnf(commutativity, axiom,+    X ∨ Y = Y ∨ X).+cnf(associativity, axiom,+    X ∨ (Y ∨ Z) = (X ∨ Y) ∨ Z).+cnf(absorption, axiom,+    X ∨ (X ∧ Y) = X).+cnf(absorption, axiom,+    X ∧ (X ∨ Y) = X).+cnf(definition_of_upme, axiom,+    upme(X,Y,Z) = X ∧ (Y ∨ Z)).+cnf(definition_of_lome, axiom,+    lome(X,Y,Z) = (X ∧ Y) ∨ (X ∧ Z)).+cnf(definition_of_upjo, axiom,+    upjo(X,Y,Z) = (X ∨ Y) ∧ (X ∨ Z)).+cnf(definition_of_lojo, axiom,+    lojo(X,Y,Z) = X ∨ (Y ∧ Z)).+cnf(eq1, axiom,+    upme(a ∧ Z1,Z2,Z3) = lome(a ∧ Z1,Z2,Z3)).+cnf(qu2, axiom,+    upme(a,X2,Y2) = upme(a,X2,Z2) => upme(X2,Y2,Z2) = lome(X2,Y2,Z2)).+fof(rl1, conjecture,+    lome(x,y,z) =+    (x∧(y∧(x∨z)))∨(z∧(x∨y))).+%fof(rl2, conjecture,+%    t∧(((x∨y)∧(x∨z))∨((u∨w)∧(u∨v))) =+%    (t∧(((x∨y)∧(x∨z))∨(u∨(w∧v))))∨(t∧(((u∨w)∧(u∨v))∨(x∨(y∧z))))).

+ examples/rellat_theorem34_6a.p view

@@ -0,0 +1,29 @@+% http://www.dcs.bbk.ac.uk/~szabolcs/rellat-jlamp-second-submission-2.pdf+% theorem 3.4, clause 6.+cnf(commutativity, axiom,+    X ∧ Y = Y ∧ X).+cnf(associativity, axiom,+    X ∧ (Y ∧ Z) = (X ∧ Y) ∧ Z).+cnf(commutativity, axiom,+    X ∨ Y = Y ∨ X).+cnf(associativity, axiom,+    X ∨ (Y ∨ Z) = (X ∨ Y) ∨ Z).+cnf(absorption, axiom,+    X ∨ (X ∧ Y) = X).+cnf(absorption, axiom,+    X ∧ (X ∨ Y) = X).+cnf(definition_of_upme, axiom,+    upme(X,Y,Z) = X ∧ (Y ∨ Z)).+cnf(definition_of_lome, axiom,+    lome(X,Y,Z) = (X ∧ Y) ∨ (X ∧ Z)).+cnf(definition_of_upjo, axiom,+    upjo(X,Y,Z) = (X ∨ Y) ∧ (X ∨ Z)).+cnf(definition_of_lojo, axiom,+    lojo(X,Y,Z) = X ∨ (Y ∧ Z)).+cnf(eq1, axiom,+    upme(a ∧ Z1,Z2,Z3) = lome(a ∧ Z1,Z2,Z3)).+cnf(qu2, axiom,+    upme(a,X2,Y2) = upme(a,X2,Z2) => upme(X2,Y2,Z2) = lome(X2,Y2,Z2)).+fof(rl1, conjecture,+    lome(x,y,z) =+    x∧((y∧(x∨z))∨(z∧(x∨y)))).

+ examples/rellat_theorem34_6b.p view

@@ -0,0 +1,29 @@+% http://www.dcs.bbk.ac.uk/~szabolcs/rellat-jlamp-second-submission-2.pdf+% theorem 3.4, clause 6.+cnf(commutativity, axiom,+    X ∧ Y = Y ∧ X).+cnf(associativity, axiom,+    X ∧ (Y ∧ Z) = (X ∧ Y) ∧ Z).+cnf(commutativity, axiom,+    X ∨ Y = Y ∨ X).+cnf(associativity, axiom,+    X ∨ (Y ∨ Z) = (X ∨ Y) ∨ Z).+cnf(absorption, axiom,+    X ∨ (X ∧ Y) = X).+cnf(absorption, axiom,+    X ∧ (X ∨ Y) = X).+cnf(definition_of_upme, axiom,+    upme(X,Y,Z) = X ∧ (Y ∨ Z)).+cnf(definition_of_lome, axiom,+    lome(X,Y,Z) = (X ∧ Y) ∨ (X ∧ Z)).+cnf(definition_of_upjo, axiom,+    upjo(X,Y,Z) = (X ∨ Y) ∧ (X ∨ Z)).+cnf(definition_of_lojo, axiom,+    lojo(X,Y,Z) = X ∨ (Y ∧ Z)).+cnf(eq1, axiom,+    upme(a ∧ Z1,Z2,Z3) = lome(a ∧ Z1,Z2,Z3)).+cnf(qu2, axiom,+    upme(a,X2,Y2) = upme(a,X2,Z2) => upme(X2,Y2,Z2) = lome(X2,Y2,Z2)).+fof(rl2, conjecture,+    t∧(((x∨y)∧(x∨z))∨((u∨w)∧(u∨v))) =+    (t∧(((x∨y)∧(x∨z))∨(u∨(w∧v))))∨(t∧(((u∨w)∧(u∨v))∨(x∨(y∧z))))).

+ examples/ring.p view

@@ -0,0 +1,9 @@+cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(plus_zero, axiom, '+'('0', X) = X).+cnf(plus_inv, axiom, '+'(X, '-'(X)) = '0').+cnf(times_assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).+cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).+cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).+cnf(cube, axiom, X = '*'(X, '*'(X, X))).+cnf(conjecture, negated_conjecture, '*'(a, b) != '*'(b, a)).

+ examples/ring2-cancel.p view

@@ -0,0 +1,9 @@+cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(plus_zero, axiom, '+'('0', X) = X).+cnf(plus_inv, axiom, '+'(X, '-'(X)) = '0').+cnf(times_assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).+cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).+cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).+cnf(power_six, axiom, X = '*'(X, '*'(X, '*'(X, '*'(X, '*'(X, X)))))).+cnf(conjecture, negated_conjecture, '+'(x, x) != '0').

+ examples/ring2.p view

@@ -0,0 +1,9 @@+cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(plus_zero, axiom, '+'('0', X) = X).+cnf(plus_inv, axiom, '+'(X, '-'(X)) = '0').+cnf(times_assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).+cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).+cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).+cnf(power_six, axiom, X = '*'(X, '*'(X, '*'(X, '*'(X, '*'(X, X)))))).+cnf(conjecture, negated_conjecture, '*'(a, b) != '*'(b, a)).

+ examples/ring3.p view

@@ -0,0 +1,9 @@+cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(plus_zero, axiom, '+'('0', X) = X).+cnf(plus_neg, axiom, '+'(X, '-'(X)) = '0').+cnf(times_assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).+cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).+cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).+cnf(power_four, axiom, X = '*'(X, '*'(X, '*'(X, X)))).+cnf(conjecture, negated_conjecture, '*'(a, b) != '*'(b, a)).

+ examples/ring4.p view

@@ -0,0 +1,9 @@+cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(plus_zero, axiom, '+'('0', X) = X).+cnf(plus_inv, axiom, '+'(X, '-'(X)) = '0').+cnf(times_ssoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).+cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).+cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).+cnf(power_five, axiom, X = '*'(X, '*'(X, '*'(X, '*'(X, X))))).+cnf(conjecture, negated_conjecture, '*'(a, b) != '*'(b, a)).

+ examples/robbins-easy.p view

@@ -0,0 +1,4 @@+cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(funny, axiom, '+'('-'('+'('-'(X), Y)), '-'('+'('-'(X), '-'(Y)))) = X).+cnf(conjecture, negated_conjecture, '-'('+'('-'('+'(a, b)), '-'('+'(a, '-'(b))))) != a).

+ examples/robbins-hints.p view

@@ -0,0 +1,39 @@+%------------------------------------------------------------------------------+% File     : ROB001-1 : TPTP v9.3.0. Released v1.0.0.+% Domain   : Robbins Algebra+% Problem  : Is every Robbins algebra Boolean?+% Version  : [Win90] (equality) axioms.+% English  :++% Refs     : [HMT71] Henkin et al. (1971), Cylindrical Algebras+%          : [Win90] Winker (1990), Robbins Algebra: Conditions that make a+% Source   : [TPTP]+% Names    :++% Status   : Unsatisfiable+% Rating   : 1.00 v2.0.0+% Syntax   : Number of clauses     :    4 (   4 unt;   0 nHn;   1 RR)+%            Number of literals    :    4 (   4 equ;   1 neg)+%            Maximal clause size   :    1 (   1 avg)+%            Maximal term depth    :    6 (   2 avg)+%            Number of predicates  :    1 (   0 usr;   0 prp; 2-2 aty)+%            Number of functors    :    4 (   4 usr;   2 con; 0-2 aty)+%            Number of variables   :    7 (   0 sgn)+% SPC      : CNF_UNS_RFO_PEQ_UEQ++% Comments : Commutativity, associativity, and Huntington's axiom axiomatize +%            Boolean algebra.+%------------------------------------------------------------------------------+%----Include axioms for Robbins algebra+include('Axioms/ROB001-0.ax').+%------------------------------------------------------------------------------+cnf(prove_huntingtons_axiom,negated_conjecture,+    add(negate(add(a,negate(b))),negate(add(negate(a),negate(b)))) != b ).++%----Definition of g+cnf(sos04,axiom,(+    $hint(negate(add(A,negate(A)))) )).++%----Definition of h+cnf(sos05,axiom,(+    h(A) = add(A,add(A,add(A,negate(add(A,negate(A)))))))).

+ examples/robbins.p view

@@ -0,0 +1,4 @@+cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(funny, axiom, '-'('+'('-'('+'(X, Y)), '-'('+'(X, '-'(Y))))) = X).+cnf(conjecture, negated_conjecture, '-'('-'(a)) != a).

+ examples/sam.p view

@@ -0,0 +1,38 @@+cnf(f_assoc, axiom,+    meet(X,meet(Y,Z)) = meet(meet(X,Y),Z)).+cnf(f_comm, axiom,+    meet(X,Y) = meet(Y,X)).+cnf(f_idem, axiom,+    meet(X,X) = X).+cnf(g_assoc, axiom,+    join(X,join(Y,Z)) = join(join(X,Y),Z)).+cnf(g_comm, axiom,+    join(X,Y) = join(Y,X)).+cnf(g_idem, axiom,+    join(X,X) = X).++cnf(ax31, axiom,+    meet(X, join(X,Y)) = X).+cnf(ax32, axiom,+    meet(zero, X) = zero).+cnf(ax33, axiom,+    join(zero, X) = X).+cnf(ax34, axiom,+    join(X, meet(X, Y)) = X).+cnf(ax35, axiom,+    meet(one, X) = X).+cnf(ax36, axiom,+    join(one, X) = one).+cnf(ax37, axiom,+    meet(X,Z) = X =>+    meet(join(X,Y),Z) = join(X,meet(Y,Z))).++cnf(comp, definition,+    comp(X,Y) <=> (meet(X,Y) = zero & join(X,Y) = one)).++cnf(premise1, assumption,+    comp(a, join(c,d))).+cnf(premise2, assumption,+    comp(b, join(c,d))).+cnf(goal, conjecture,+    meet(join(a,meet(b,c)),join(a,meet(b,d)))=a).

+ examples/semigroup.p view

@@ -0,0 +1,4 @@+cnf(assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).+cnf(two_three, axiom, '*'(X, X) = '*'(X, '*'(X, X))).+cnf(twiddle, axiom, '*'('*'(X, X), Y) = '*'(Y, '*'(X, X))).+cnf(conjecture, negated_conjecture, '*'('*'(a, b), '*'(a, b)) != '*'('*'(a, a), '*'(b, b))).

+ examples/sudoku.p view

@@ -0,0 +1,39 @@+cnf('associativity of ∘', axiom,+    F ∘ (G ∘ H) = (F ∘ G) ∘ H).++cnf('∘ identity', axiom,+    id ∘ F = F).++cnf('∘ identity', axiom,+    F ∘ id = F).++cnf('map functor', axiom,+    map(F) ∘ map(G) = map(F ∘ G)).++cnf('map functor', axiom,+    map(id) = id).++cnf('defn pruneBy', axiom,+    pruneBy(F) = F ∘ (map(pruneRow) ∘ F)).++cnf('defn expand', axiom,+    expand = product ∘ map(product)).++cnf('expand after boxs', axiom,+    expand ∘ boxs = map(boxs) ∘ expand).++cnf('filter with boxs', axiom,+    filter (P ∘ boxs) = map(boxs) ∘ (filter(P) ∘ map(boxs))).++cnf('boxs involution', axiom,+    boxs ∘ boxs = id).++cnf('filter after product', axiom,+    filter(all(P)) ∘ product = product ∘ map(filter(P))).++cnf('law of pruneRow', axiom,+    filter(nodups) ∘ (product ∘ pruneRow) = filter(nodups) ∘ product).++cnf('conjecture', conjecture,+    filter(all(nodups) ∘ boxs) ∘ (expand ∘ pruneBy(boxs)) =+    filter(all(nodups) ∘ boxs) ∘ expand).

+ examples/sum.p view

@@ -0,0 +1,30 @@+cnf(plus_comm, axiom,+    X + Y = Y + X).+cnf(plus_assoc, axiom,+    X + (Y + Z) = (X + Y) + Z).+cnf(times_comm, axiom,+    X * Y = Y * X).+cnf(times_assoc, axiom,+    X * (Y * Z) = (X * Y) * Z).+cnf(plus_zero, axiom,+    X + zero = X).+cnf(times_zero, axiom,+    X * zero = zero).+cnf(times_one, axiom,+    X * one = X).+cnf(distr, axiom,+    X * (Y + Z) = (X * Y) + (X * Z)).+cnf(distr, axiom,+    (X + Y) * Z = (X * Z) + (Y * Z)).+cnf(plus_s, axiom,+    s(X) + Y = s(X+Y)).+cnf(times_s, axiom,+    s(X)*Y = Y + (X*Y)).+cnf(sum_zero, axiom,+    sum(zero) = zero).+cnf(sum_s, axiom,+    sum(s(N)) = s(N) + sum(N)).+cnf(ih, axiom,+    sum(a) + sum(a) = a * s(a)).+cnf(conjecture, conjecture,+    sum(s(a)) + sum(s(a)) = s(a) * s(s(a))).

+ examples/vbool.p view

@@ -0,0 +1,18 @@+fof(associativity, axiom,+    ![X, Y, Z]:+    X ⊕ (Y ⊕ Z) = (X ⊕ Y) ⊕ Z).++fof(commutativity, axiom,+    ![X, Y]:+    X ⊕ Y = Y ⊕ X).++fof(idempotence, axiom,+    ![X]:+    X ⊕ X = X).++fof(non_injectivity, conjecture,+    ![A, B]: ?[X]: A ⊕ X = B ⊕ X).++% Examples:+% plus is commutative, associative, and injective, but not idempotent+% max is idempotent, commutative, and associativity, but not injective

+ examples/veroff-short.p view

@@ -0,0 +1,11 @@+cnf(majority, axiom,+    f(X,X,Y) = X).+cnf('2a', axiom,+    f(X,Y,Z) = f(Z,X,Y)).+cnf('2b', axiom,+    f(X,Y,Z) = f(X,Z,Y)).+cnf(associativity, axiom,+    f(f(X,W,Y),W,Z) = f(X,W,f(Y,W,Z))).++cnf(dist_long, conjecture,+    f(f(x,y,z),u,w) = f(x,f(y,u,w),f(z,u,w))).

+ examples/veroff.p view

@@ -0,0 +1,11 @@+cnf(majority, axiom,+    f(X,X,Y) = X).+cnf('2a', axiom,+    f(X,Y,Z) = f(Z,X,Y)).+cnf('2b', axiom,+    f(X,Y,Z) = f(X,Z,Y)).+cnf(associativity, axiom,+    f(f(X,W,Y),W,Z) = f(X,W,f(Y,W,Z))).++cnf(dist_long, conjecture,+    f(f(x,y,z),u,w) = f(f(x,u,w),f(y,u,w),f(z,u,w))).

+ examples/winker-easy.p view

@@ -0,0 +1,6 @@+% Needs case split on X < c.+cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(idem, axiom, '+'(X, X) = X).+cnf(funny, axiom, '-'('+'('-'('+'(X, Y)), '-'('+'(X, '-'(Y))))) = X).+cnf(conjecture, negated_conjecture, '+'('-'('+'('-'(a), b)), '-'('+'('-'(a), '-'(b)))) != a).

+ examples/winker.p view

@@ -0,0 +1,6 @@+% Needs case split on X < c.+cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(idem_c, axiom, '+'(c, c) = c).+cnf(funny, axiom, '-'('+'('-'('+'(X, Y)), '-'('+'(X, '-'(Y))))) = X).+cnf(conjecture, negated_conjecture, '+'('-'('+'('-'(a), b)), '-'('+'('-'(a), '-'(b)))) != a).

+ examples/winker2.p view

@@ -0,0 +1,6 @@+% Needs case split on X < c.+cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(plus_c_d, axiom, '+'(c, d) = c).+cnf(funny, axiom, '-'('+'('-'('+'(X, Y)), '-'('+'(X, '-'(Y))))) = X).+cnf(conjecture, negated_conjecture, '+'('-'('+'('-'(a), b)), '-'('+'('-'(a), '-'(b)))) != a).

+ examples/y-easy.p view

@@ -0,0 +1,4 @@+fof(k_def, axiom, ![X, Y]: (k @ X) @ Y = X).+fof(s_def, axiom, ![X, Y, Z]: ((s @ X) @ Y) @ Z = (X @ Z) @ (Y @ Z)).+fof(i_def, axiom, ![X]: i @ X = X).+fof(conjecture, conjecture, ?[Y]: ![F]: Y @ F = F @ (Y @ F)).

+ examples/y-encoded.p view

@@ -0,0 +1,5 @@+cnf(ifeq_axiom, axiom, ifeq(A, A, B, C)=B).+cnf(k_def, axiom, '@'('@'(k, X), Y)=X).+cnf(s_def, axiom, '@'('@'('@'(s, X), Y), Z)='@'('@'(X, Z), '@'(Y, Z))).+cnf(conjecture, negated_conjecture, ifeq('@'(Y, f(Y)), '@'(f(Y), '@'(Y, f(Y))), a, b)=b).+cnf(goal, negated_conjecture, a!=b).

+ examples/y.p view

@@ -0,0 +1,3 @@+fof(k_def, axiom, ![X, Y]: (k @ X) @ Y = X).+fof(s_def, axiom, ![X, Y, Z]: ((s @ X) @ Y) @ Z = (X @ Z) @ (Y @ Z)).+fof(conjecture, conjecture, ?[Y]: ![F]: Y @ F = F @ (Y @ F)).

+ executable/ParallelMain.hs view

@@ -0,0 +1,78 @@+{-# LANGUAGE ForeignFunctionInterface #-}+import System.IO+import Control.Concurrent.Async hiding (link)+import System.Posix+import System.Environment+import qualified SequentialMain+import Control.Monad++foreign import ccall "link_to_parent" link :: CPid -> IO ()++raceMany :: [IO a] -> IO a+raceMany [x] = x+raceMany (x:xs) = do+  result <- race x (raceMany xs)+  case result of+    Left res  -> return res+    Right res -> return res++raceStdout :: [(String, IO ())] -> IO ()+raceStdout xs = do+  action <- raceMany (map waitForStdout xs)+  action+  where+    end = "*** END OF OUTPUT"+    waitForStdout (args, p) = do+      (fdIn, fdOut) <- createPipe+      pid <- getProcessID+      forkProcess $ do+        link (fromIntegral pid)+        dupTo fdOut stdOutput+        hSetBuffering stdout LineBuffering+        p+        putStrLn end++      hIn <- fdToHandle fdIn+      hSetBuffering hIn LineBuffering+      line <- hGetLine hIn+      return $ do+        putStrLn ("Command-line arguments: " ++ args)+        putStrLn ""+        putStrLn line+        let+          loop = do+            line <- hGetLine hIn+            unless (line == end) $ do+              putStrLn line+              loop+        loop++variants :: FilePath -> [[String]]+{-+variants =+  map words+  ["--lhs-weight 1 --flip-ordering --normalise-queue-percent 10 --cp-renormalise-threshold 10 --complete-subsets --ground-joining-incomplete-limit 15",+   "--no-flatten-goal --ground-joining-incomplete-limit 15 --ground-connectedness --normalise-queue-percent 10 --cp-renormalise-threshold 10",+   "--flatten --complete-subsets",+   "--lhs-weight 9 --flip-ordering --complete-subsets --normalise-queue-percent 10 --cp-renormalise-threshold 10",+   "--ground-connectedness --complete-subsets",+   "--flip-ordering --lhs-weight 1 --depth-weight 60 --distributivity-heuristic --ground-joining-limit 15",+   "--set-join --lhs-weight 1 --no-flatten-goal --complete-subsets --goal-heuristic",+   "--no-kbo-weight0-unary --kbo-weight0 --no-flatten-goal"]+  -- "--random-mode --random-mode-goal-directed --no-flatten-goal --no-connectedness --no-ground-joining"]+-}+variants stitch =+  map words+  ["--lhs-weight 1 --flip-ordering --normalise-queue-percent 10 --cp-renormalise-threshold 10 --complete-subsets --ground-joining-incomplete-limit 15 --flatten-every 2",+   "--no-flatten-goal",+   "--stitch " ++ stitch ++ " --hint-skel-cost 0 --hint-skel-factor 0.5",+   "--lhs-weight 9 --flip-ordering --complete-subsets --normalise-queue-percent 10 --cp-renormalise-threshold 10",+   "--flatten --complete-subsets",+   "--flatten-regeneralise",+   "--stitch " ++ stitch ++ " --hint-skel-cost 0 --hint-skel-factor 0.5 --no-flatten-goal",+   "--lhs-weight 1 --flip-ordering --normalise-queue-percent 10 --cp-renormalise-threshold 10 --complete-subsets --ground-joining-incomplete-limit 15 --flatten-regeneralise"]++main = do+  hSetBuffering stdout LineBuffering+  (n:stitch:args) <- getArgs+  raceStdout [(unwords variant, withArgs (args ++ variant) SequentialMain.main) | variant <- take (read n) (variants stitch)]

executable/SequentialMain.hs view

@@ -1,12 +1,13 @@-{-# LANGUAGE CPP, RecordWildCards, FlexibleInstances, PatternGuards, DeriveAnyClass, RankNTypes, ApplicativeDo #-}+{-# LANGUAGE CPP, RecordWildCards, FlexibleInstances, PatternGuards, DeriveAnyClass, RankNTypes, ApplicativeDo, DeriveGeneric #-} {-# OPTIONS_GHC -flate-specialise #-}-module SequentialMain(main) where+module SequentialMain(main, Constant(..)) where  import Control.Monad import Data.Char import Data.Either import Twee hiding (message) import Twee.Base hiding (char, lookup, vars, ground)+--import qualified Twee.Base as Twee import Twee.Rule(lhs, rhs, unorient) import Twee.Equation import qualified Twee.Proof as Proof@@ -15,13 +16,18 @@ import Twee.Utils import qualified Twee.CP as CP import Data.Ord+import Data.Map(Map) import qualified Data.Map.Strict as Map import qualified Twee.KBO as KBO+#ifdef USE_LPO+import qualified Twee.LPO as LPO+#endif import Data.List.Split import Data.List import Data.Maybe import Jukebox.Options import Jukebox.Toolbox+import qualified Jukebox.Name as Jukebox import Jukebox.Name hiding (lhs, rhs, label) import qualified Jukebox.Form as Jukebox import Jukebox.Form hiding ((:=:), Var, Symbolic(..), Term, Axiom, size, Subst, subst)@@ -36,6 +42,13 @@ import System.Console.ANSI import Data.Symbol import Twee.Profile+import GHC.Generics+import Data.Hashable+import Data.Binary.Sharing+import qualified Data.ByteString.Lazy as BS+import System.Process+import qualified Jukebox.TPTP.Parse.Core as TPTP+import qualified Jukebox.TPTP.ParseSnippet as Snippet  data MainFlags =   MainFlags {@@ -46,11 +59,13 @@     flags_explain_encoding :: Bool,     flags_flip_ordering :: Bool,     flags_give_up_on_saturation :: Bool,+    flags_hint_goals :: Bool,     flags_flatten_goals :: Bool,     flags_flatten_nonground :: Bool,     flags_flatten_goals_lightly :: Bool,     flags_flatten_all :: Bool,     flags_flatten_regeneralise :: Bool,+    flags_flatten_every :: Int,     flags_eliminate :: [String],     flags_backwards_goal :: Int,     flags_flatten_backwards_goal :: Int,@@ -58,7 +73,11 @@     flags_distributivity_heuristic :: Bool,     flags_kbo_weight0 :: Bool,     flags_kbo_weight0_unary :: Bool,-    flags_goal_heuristic :: Bool }+    flags_goal_heuristic :: Bool,+    flags_funweight :: Float,+    flags_dump_proof :: Maybe FilePath,+    flags_dump_state :: Maybe FilePath,+    flags_stitch :: Maybe FilePath }  parseMainFlags :: OptionParser MainFlags parseMainFlags = do@@ -102,6 +121,10 @@     expert $     inGroup "Output options" $     bool "give-up-on-saturation" ["Report SZS status GiveUp rather than Unsatisfiable on saturation (off by default)."] False+  flags_hint_goals <-+    expert $+    inGroup "Completion heuristics" $+    bool "hint-goal" ["Add hints representing goal terms (off by default)."] False   flags_flatten_goals <-     expert $     inGroup "Completion heuristics" $@@ -118,6 +141,10 @@     expert $     inGroup "Completion heuristics" $     bool "flatten" ["Flatten all clauses by adding new axioms (off by default)."] False+  flags_flatten_every <-+    expert $+    inGroup "Completion heuristics" $+    flag "flatten-every" ["Flatten only every nth subterm (default = 1)."] 1 argNum   flags_flatten_regeneralise <-     expert $     inGroup "Completion heuristics" $@@ -151,6 +178,28 @@        "distinct variables. The term f must not otherwise appear in the problem!",        "This is not checked."]       (splitOn "," <$> arg "<axioms>" "expected a list of axiom names" Just)+  flags_funweight <-+    expert $+    inGroup "Critical pair weighting heuristics" $+    flag "fun-weight" ["Weight given to function symbols"] 1 argNum+  flags_dump_proof <-+    expert $+    inGroup "Debugging options" $+    flag "dump-proof"+      ["Dump a binary proof to this file (off by default)."]+      Nothing (Just <$> argFile)+  flags_dump_state <-+    expert $+    inGroup "Debugging options" $+    flag "dump-state"+      ["Dump prover state to this file on termination (off by default)."]+      Nothing (Just <$> argFile)+  flags_stitch <-+    expert $+    inGroup "Critical pair weighting heuristics" $+    flag "stitch"+      ["Path to 'stitch' tool for discovering abstractions (disabled by default)."]+      Nothing (Just <$> argFile)    return MainFlags{..} @@ -208,7 +257,7 @@     bool "complete-subsets"       ["Identify and exploit complete subsets of the axioms in joining (off by default)."]       False-  let cfg_score_cp = undefined -- filled in later, in runTwee+  let cfg_hint_func i x = Intern.intern (Hint i x)    cfg_join <- do     cfg_ground_join <-@@ -352,6 +401,7 @@     expert $     inGroup "Output options" $     bool "print-score" ["Print score of each generated rule (off by default)."] False+  cfg_cp_config <- parseCPConfig    return Config{..}   where@@ -371,10 +421,6 @@     expert $     inGroup "Critical pair weighting heuristics" $     defaultFlag "rhs-weight" "Weight given to RHS of critical pair" CP.cfg_rhsweight argNum-  cfg_funweight <--    expert $-    inGroup "Critical pair weighting heuristics" $-    defaultFlag "fun-weight" "Weight given to function symbols" CP.cfg_funweight argNum   cfg_varweight <-     expert $     inGroup "Critical pair weighting heuristics" $@@ -391,10 +437,6 @@     expert $     inGroup "Critical pair weighting heuristics" $     defaultFlag "dup-factor" "Size factor of duplicate subterms" CP.cfg_dupfactor argNum-  cfg_resonance <--    expert $-    inGroup "Critical pair weighting heuristics" $-    bool "resonance" ["Interpret hints as resonators by only allowing substitutions which map variables to variables (off by default)."] False   return CP.Config{..}   where     defaultFlag name desc field parser =@@ -412,31 +454,44 @@ data Constant =   Minimal |   Skolem Int |+  Hint Int Float |   Constant {-    con_prec   :: {-# UNPACK #-} !Precedence,-    con_id     :: {-# UNPACK #-} !Jukebox.Function,-    con_arity  :: {-# UNPACK #-} !Int,-    con_size   :: !Integer,-    con_weight :: !Integer,-    con_bonus  :: !Bool }-  deriving (Eq, Ord)+    con_prec    :: {-# UNPACK #-} !Precedence,+    con_id      :: {-# UNPACK #-} !Int,+    con_name    :: !String,+    con_arity   :: {-# UNPACK #-} !Int,+    con_label   :: !(Maybe String),+    con_size    :: !Integer,+    con_weight  :: !Integer,+    con_fweight :: {-# UNPACK #-} !Float,+    con_bonus   :: !Bool }+  deriving (Eq, Ord, Generic, Hashable, Binary)  data Precedence = Precedence !Bool !Bool !Bool !(Maybe Int) !Int-  deriving (Eq, Ord)+  deriving (Eq, Ord, Generic, Hashable, Binary)  instance KBO.Sized Constant where   size Minimal = 1   size Skolem{} = 1+  size Hint{} = 1   size Constant{..} = con_size-instance KBO.Weighted Constant where+instance KBO.ArgWeighted Constant where   argWeight Minimal = 1   argWeight Skolem{} = 1+  argWeight Hint{} = 1   argWeight Constant{..} = con_weight +instance Weighted Constant where+  weight Minimal = 1+  weight (Skolem _) = 1+  weight (Hint _ x) = x+  weight Constant{..} = con_fweight+ instance Pretty Constant where   pPrint Minimal = text "?"   pPrint (Skolem n) = text ("sk" ++ show n)-  pPrint Constant{..} = text (removePostfix (base con_id))+  pPrint (Hint n _) = text ("hint" ++ show n)+  pPrint Constant{..} = text (removePostfix con_name)     where       removePostfix ('_':x:xs) | con_arity == 1 = x:xs       removePostfix xs = xs@@ -444,10 +499,11 @@ instance PrettyTerm Constant where   termStyle Minimal = uncurried   termStyle Skolem{} = uncurried+  termStyle Hint{} = uncurried   termStyle Constant{..}-    | hasLabel "type_tag" con_id = invisible-    | "_" `isPrefixOf` base con_id && con_arity == 1 = postfix-    | any isAlphaNum (base con_id) = uncurried+    | con_label == Just "type_tag" = invisible+    | "_" `isPrefixOf` con_name && con_arity == 1 = postfix+    | any isAlphaNum con_name = uncurried     | otherwise =       case con_arity of         1 -> prefix@@ -458,25 +514,31 @@   minimal = Sym Minimal   skolem = Sym . Skolem +#ifdef USE_LPO instance Ordered Constant where+  lessEq t u = LPO.lessEq t u+  lessIn model t u = LPO.lessIn model t u+  lessEqSkolem t u = LPO.lessEqSkolem t u+#else+instance Ordered Constant where   lessEq t u = KBO.lessEq t u   lessIn model t u = KBO.lessIn model t u   lessEqSkolem t u = KBO.lessEqSkolem t u+#endif  instance EqualsBonus Constant where   hasEqualsBonus Minimal = False   hasEqualsBonus Skolem{} = False+  hasEqualsBonus Hint{} = False   hasEqualsBonus c = con_bonus c-  isEquals Minimal = False-  isEquals Skolem{} = False-  isEquals c = SequentialMain.isEquals (con_id c)-  isTrue Minimal = False-  isTrue Skolem{} = False-  isTrue c = SequentialMain.isTrue (con_id c)-  isFalse Minimal = False-  isFalse Skolem{} = False-  isFalse c = SequentialMain.isFalse (con_id c) +  isEquals Constant{..} = con_label == Just "equals" && con_arity == 2+  isEquals _ = False+  isTrue Constant{..} = con_label == Just "true" && con_arity == 0+  isTrue _ = False+  isFalse Constant{..} = con_label == Just "false" && con_arity == 0+  isFalse _ = False+ data TweeContext =   TweeContext {     ctx_var     :: Jukebox.Variable,@@ -484,7 +546,9 @@     ctx_true    :: Jukebox.Function,     ctx_false   :: Jukebox.Function,     ctx_equals  :: Jukebox.Function,-    ctx_type    :: Type }+    ctx_type    :: Type,+    ctx_funs    :: Map Int Jukebox.Function,+    ctx_ids     :: Map Jukebox.Function Int }  -- Convert back and forth between Twee and Jukebox. tweeConstant :: MainFlags -> HornFlags -> TweeContext -> Precedence -> Jukebox.Function -> Constant@@ -493,15 +557,18 @@   | otherwise =     Constant {       con_prec = prec,-      con_id = fun,+      con_id = Map.findWithDefault (error (show (fun, ctx_ids))) fun ctx_ids,+      con_name = base (name fun),+      con_label = Jukebox.label (name fun),       con_arity = Jukebox.arity fun,       con_size = if flags_kbo_weight0 && Jukebox.arity fun >= 2 then 0 else if flags_kbo_weight0_unary && isInv then 0 else 1,       con_weight = 1,+      con_fweight = flags_funweight,       con_bonus = bonus fun }   where     bonus fun =       (isIfeq fun && encoding flags /= Asymmetric2) ||-      SequentialMain.isEquals fun+      (Jukebox.label (name fun) == Just "equals" && Jukebox.arity fun == 2)     isInv =       case prec of         Precedence _ x _ _ _ -> x@@ -514,27 +581,15 @@ isIfeq fun =   hasLabel "ifeq" (name fun) -isEquals :: Jukebox.Function -> Bool-isEquals fun =-  hasLabel "equals" (name fun) && Jukebox.arity fun == 2--isTrue :: Jukebox.Function -> Bool-isTrue fun =-  hasLabel "true" (name fun) && Jukebox.arity fun == 0--isFalse :: Jukebox.Function -> Bool-isFalse fun =-  hasLabel "false" (name fun) && Jukebox.arity fun == 0- jukeboxFunction :: TweeContext -> Constant -> Jukebox.Function-jukeboxFunction _ Constant{..} = con_id+jukeboxFunction TweeContext{..} Constant{..} = Map.findWithDefault undefined con_id ctx_funs jukeboxFunction TweeContext{..} Minimal = ctx_minimal -tweeTerm :: MainFlags -> HornFlags -> TweeContext -> (Jukebox.Function -> Precedence) -> Jukebox.Term -> Term Constant-tweeTerm flags horn ctx prec t = build (tm t)+tweeTerm :: MainFlags -> HornFlags -> TweeContext -> (Jukebox.Variable -> Int) -> (Jukebox.Function -> Precedence) -> Jukebox.Term -> Term Constant+tweeTerm flags horn ctx varNum prec t = build (tm t)   where-    tm (Jukebox.Var (x ::: _)) =-      var (V (Intern.symId (Intern.intern x)))+    tm (Jukebox.Var x) =+      var (V (varNum x))     tm (f :@: ts) =       app (Sym (tweeConstant flags horn ctx (prec f) f)) (map tm ts) @@ -560,18 +615,22 @@   false   <- newFunction (withLabel "false" (name "false")) [] ty   equals  <- newFunction (withLabel "equals" (name "equals")) [ty, ty] ty +  let allFuns = usort $ [minimal, true, false, equals] ++ Jukebox.functions (hints, prob)+   return TweeContext {     ctx_var = var,     ctx_minimal = minimal,     ctx_true = true,     ctx_false = false,     ctx_equals = equals,-    ctx_type = ty }+    ctx_type = ty,+    ctx_funs = Map.fromList (zip [0..] allFuns),+    ctx_ids = Map.fromList (zip allFuns [0..]) } -flattenGoals :: Int -> Bool -> Bool -> Bool -> [Jukebox.Term] -> Problem Clause -> Problem Clause-flattenGoals backwardsGoal flattenNonGround flattenAll full hints prob =+flattenGoals :: Int -> Bool -> Bool -> Bool -> Int -> [Jukebox.Term] -> Problem Clause -> Problem Clause+flattenGoals backwardsGoal flattenNonGround flattenAll full depthMod hints prob =   run (hints, prob) $ \(_, prob) -> do-    let ts = usort $ extraTerms prob+    let ts = filter depthOk $ usort $ extraTerms prob     cs <- mapM define ts     return (prob ++ cs)   where@@ -593,6 +652,10 @@     isVar (Jukebox.Var _) = True     isVar _ = False +    depthOk t = depthMod == 1 || depth t `mod` depthMod == 0+    depth (_f :@: ts) = 1 + maximum (0:map depth ts)+    depth _ = 1+     define (f :@: ts) = do       name <- newName f       let vs  = Jukebox.vars ts@@ -613,6 +676,24 @@         ground u,         v <- backwards (n-1) cs u ] +hintGoals :: Problem Clause -> Problem Clause+hintGoals prob =+  prob ++ map define extraTerms+  where+    extraTerms = usort (concatMap input prob)+    input Input{what = Clause (Bind _ [Neg (x Jukebox.:=: y)])} =+      term x ++ term y+    input _ = []++    term t@(_f :@: ts) = t:concatMap term ts+    term _ = []++    define t =+      Input{ident = Nothing, tag = "flattening", kind = Jukebox.Ax Definition, what = c, source = Unknown}+      where+        c = clause [Pos (Tru (hint :@: [t]))]+        hint = name "$hint" ::: FunType [Jukebox.typ t] O+ addDistributivityHeuristic :: [Jukebox.Term] -> Problem Clause -> Problem Clause addDistributivityHeuristic hints prob =   run (hints, prob) $ \(_, prob) -> do@@ -739,19 +820,18 @@       return $ Left (pre inp (Jukebox.Var ctx_var, ctx_minimal :@: []))     identify inp = Left inp -runTwee :: GlobalFlags -> TSTPFlags -> HornFlags -> [String] -> Config Constant -> CP.Config -> MainFlags -> (IO () -> IO ()) -> [Jukebox.Term] -> Problem Clause -> IO Answer-runTwee globals (TSTPFlags tstp) horn precedence config0 cpConfig flags@MainFlags{..} later hints obligs = {-# SCC runTwee #-} do+runTwee :: GlobalFlags -> TSTPFlags -> HornFlags -> [String] -> Config Constant -> MainFlags -> (IO () -> IO ()) -> [Jukebox.Term] -> Problem Clause -> IO Answer+runTwee globals (TSTPFlags tstp) horn precedence config0 flags@MainFlags{..} later hints obligs = {-# SCC runTwee #-} do   let     -- Encode whatever needs encoding in the problem     obligs1-      | flags_flatten_goals_lightly = flattenGoals flags_flatten_backwards_goal flags_flatten_nonground False False hints obligs-      | flags_flatten_all = flattenGoals flags_flatten_backwards_goal flags_flatten_nonground True True hints obligs-      | flags_flatten_goals = flattenGoals flags_flatten_backwards_goal flags_flatten_nonground False True hints obligs+      | flags_flatten_goals_lightly = flattenGoals flags_flatten_backwards_goal flags_flatten_nonground False False flags_flatten_every hints obligs+      | flags_flatten_all = flattenGoals flags_flatten_backwards_goal flags_flatten_nonground True True flags_flatten_every hints obligs+      | flags_flatten_goals = flattenGoals flags_flatten_backwards_goal flags_flatten_nonground False True flags_flatten_every hints obligs       | otherwise = obligs     obligs2       | flags_distributivity_heuristic = addDistributivityHeuristic hints obligs1       | otherwise = obligs1-    ctx = makeContext hints obligs2     lowercaseSkolem x       | hasLabel "skolem" x =         withRenamer x $ \s i ->@@ -759,7 +839,9 @@             Renaming xss xs ->               Renaming (map (map toLower) xss) (map toLower xs)       | otherwise = x-    (hints', prob) = prettyNames (mapName lowercaseSkolem (hints, addNarrowing flags_equals_transformation ctx obligs2))+    (hints', prettyObligs) = prettyNames (mapName lowercaseSkolem (hints, obligs2))+    ctx = makeContext hints' prettyObligs+    prob = addNarrowing flags_equals_transformation ctx prettyObligs    (unsortedAxioms0, goals0) <-     case identifyProblem ctx prob of@@ -776,20 +858,38 @@     prec c =       Precedence         (isType c)+#ifdef USE_LPO+        ((hasLabel "equals" c && Jukebox.arity c == 2) || isIfeq c)+#else         (Just c == maxUnary)-        (isNothing (elemIndex (base c) precedence))+#endif+        (isJust (elemIndex (base c) precedence))         (fmap negate (elemIndex (base c) precedence))         (maybeNegate (Map.findWithDefault 0 c funOccs))     maybeNegate = if flags_flip_ordering then negate else id     funOccs = funsOcc prob+#ifndef USE_LPO     maxUnary =       case filter (\(f, _) -> arity f == 1 && not (isType f)) (Map.toList funOccs) of         [] -> Nothing         xs -> Just (fst (maximumBy (comparing snd) xs))+#endif      -- Translate everything to Twee.-    toTerm t = tweeTerm flags horn ctx prec t-    toEquation (t, u) = canonicalise (toTerm t :=: toTerm u)+    toTerm var t = tweeTerm flags horn ctx var prec t+    varNums :: Jukebox.Symbolic a => a -> Jukebox.Variable -> Int+    varNums t = \x -> Map.findWithDefault undefined x ids+      where+        xs = usort (vars t)+        ids = Map.fromList (zip xs [0..])+    toEquation (t, u) =+      toTerm var t :=: toTerm var u+      where+        var = varNums (t, u)+    equationVars (t, u) =+      Map.fromList [(V n, base (name x)) | x <- vars (t, u), let n = var x]+      where+        var = varNums (t, u)      axiomCompare ax1 ax2       | isEquality ax1' && not (isEquality ax2') = GT@@ -807,7 +907,7 @@       [ goal n pre_name (toEquation pre_eqn)       | (n, PreEquation{..}) <- zip [1..] goals0 ]     axioms =-      [ Axiom n pre_name (toEquation pre_eqn)+      [ Axiom n pre_name (Just (equationVars pre_eqn)) (toEquation pre_eqn)       | (n, PreEquation{..}) <- zip [1..] axioms0 ]     defs =       [ axiom@@ -818,27 +918,29 @@    -- Compute CP scoring heuristic   let+    {-     goalNests = nests (map goal_eqn goals)     goalOccs = occs (map goal_eqn goals)     score depth hints eqn       | flags_goal_heuristic =-        CP.score cpConfig depth hints eqn *+        scoreCP cpConfig depth hints eqn *         product           [ pos (IntMap.findWithDefault 0 f eqnNests - IntMap.findWithDefault 0 f goalNests) *             pos (IntMap.findWithDefault 0 f eqnOccs - IntMap.findWithDefault 0 f goalOccs)           | f <- IntMap.keys eqnNests ] -- skip constants       | otherwise = -        CP.score cpConfig depth hints eqn+        scoreCP cpConfig depth hints eqn       where         eqnNests = nests eqn         eqnOccs = occs eqn          pos :: Int -> Float         pos n = if n <= 0 then 1 else fromIntegral n+1-    config = config0 { cfg_score_cp = score, cfg_eliminate_axioms = if flags_flatten_regeneralise then defs else [] }+    -}+    config = config0 { cfg_eliminate_axioms = if flags_flatten_regeneralise then defs else [] }    let-    withHints = foldl' (addHint config) (initialState config) (map toTerm hints')+    withHints = foldl' (addHint config) (initialState config) [toTerm (varNums h) h | h <- hints']     withGoals = foldl' (addGoal config) withHints goals     withAxioms = foldl' (addAxiom config) withGoals axioms     withBackwardsGoal = foldn rewriteGoalsBackwards withAxioms flags_backwards_goal@@ -908,16 +1010,53 @@   forM_ axioms $ \Axiom{..} ->     say $ show $ nest 2 $       describeEquation "Axiom"-        (show axiom_number) (Just axiom_name) axiom_eqn+        (show axiom_number) (Just axiom_name) axiom_vars axiom_eqn   forM_ goals $ \Goal{..} ->     say $ show $ nest 2 $       describeEquation "Goal"-        (show goal_number) (Just goal_name) goal_eqn+        (show goal_number) (Just goal_name) Nothing goal_eqn   line -  state <- complete output config withBackwardsGoal+  state <-+    case flags_stitch of+      Nothing -> do+        complete output config withBackwardsGoal+      Just stitch -> do+        let+          (timeout, final_timeout) =+            case cfg_max_time config of+              Just time -> (time / 5, Just (time * 4 / 5))+              Nothing -> (30, Nothing)+        intermediate <- complete output config{cfg_max_time = Just timeout} withBackwardsGoal+        let+          score rule =+            (KBO.size (lhs rule), lhs rule,+             KBO.size (rhs rule), rhs rule)+          actives =+            sortBy (comparing (score . active_rule)) $+            IntMap.elems (st_active_set intermediate)+          pres = present (cfg_proof_presentation config){cfg_all_lemmas = True} (map active_proof actives) []+          proofStr = show (pPrintPresentation (cfg_proof_presentation config){cfg_use_colour = False} pres)+        line+        say "Running Stitch..."+        hintsStrs <- lines <$> readProcess stitch [] proofStr+        let toTerm' t = toTerm (varNums t) t+        let parseTerm str = toTerm' (Snippet.giveProblem prob (Snippet.form (TPTP.term TPTP.NoQuantification Map.empty)) str)+        let hints = map parseTerm hintsStrs+        mapM_ (say . show . pPrint) hints+        let config' = config{cfg_max_time = final_timeout}+        complete output config' $+          interreduce config' $+          simplifyQueue config' $+          foldl' (addHint config') intermediate hints+   line +  case flags_dump_state of+    Nothing -> return ()+    Just dumpStateFile ->+      BS.writeFile dumpStateFile (encode state)+   when (solved state && flags_proof) $ later $ do     let       cfg_present@@ -927,6 +1066,11 @@           cfg_proof_presentation config       pres = present cfg_present [] $ map (eliminateDefinitionsFromGoal defs) $ solutions state +    case flags_dump_proof of+      Nothing -> return ()+      Just dumpProofFile ->+        BS.writeFile dumpProofFile (encode pres)+     sayTrace ""     forM_ (pres_axioms pres) $ \p ->       sayTrace $ show $@@ -954,8 +1098,8 @@             Just inp -> go inp            where             go Input{source = Unknown} = []-            go Input{source = Inference _ _ inps} = concatMap (go . inputValue) inps-            go inp@Input{source = FromFile _ _} = [inp]+            go Input{source = Inference _ _ _ inps} = concatMap (go . inputValue) inps+            go inp@Input{source = FromFile _ _ _} = [inp]        when flags_explain_encoding $ do         putStrLn "Take the following subset of the input axioms:"@@ -982,6 +1126,11 @@       putStrLn ""        when (tstp && flags_formal_proof) $ do+      forM_ (pres_goals pres) $ \ProvedGoal{..} ->+        unless (pg_witness_hint == emptySubst) $ do+          let varName x = fromJust (Map.lookup x (fromJust pg_vars))+          let answer = intercalate ", " [varName x ++ "->" ++ prettyShow t | (x, t) <- substToList pg_witness_hint]+          putStrLn $ "% SZS answers Tuple [[" ++ answer ++ "]|_] for " ++ pg_name       putStrLn "% SZS output start CNFRefutation"       print $ pPrintProof $         presentToJukebox ctx (curry toEquation)@@ -1117,7 +1266,7 @@           -- Check if this looks like the correct clause;           -- if not, try its ancestors.           find inp | ok inp = [inp]-          find Input{source = Inference _ _ inps} =+          find Input{source = Inference _ _ _ inps} =             concatMap (find . inputValue) inps           find _ = [] @@ -1137,9 +1286,9 @@   stampM (intern "twee") . join . parseCommandLineWithExtraArgs     ["--no-conjunctive-conjectures", "--no-split"] #ifdef VERSION_twee-    "Twee, an equational theorem prover" . version ("twee version " ++ VERSION_twee) $+    "Twee, the wonderful equation engine" . version ("twee version " ++ VERSION_twee) $ #else-    "Twee, an equational theorem prover" . version "twee development version" $+    "Twee, the wonderful equation engine" . version "twee development version" $ #endif       globalFlags *> parseMainFlags *>       -- hack: get --quiet and --no-proof options to appear before --tstp@@ -1150,7 +1299,6 @@            (combine <$>              expert hornToUnitBox <*>              parseConfig <*>-             parseCPConfig <*>              parseMainFlags <*>              (toFormulasBox =>>=               expert (toFof <$> clausifyBox <*> pure (tags True)) =>>=@@ -1161,8 +1309,9 @@     getHint Input{what = Clause (Bind _ [Pos (Tru (hint :@: [t]))])}       | base (name hint) == "$hint" = Left t     getHint c = Right c-    combine horn config cpConfig main encode prove later prob0 = do-      let (hints, nonHints) = partitionEithers (map getHint prob0)+    combine horn config main encode prove later prob0 = do+      let prob1 = if flags_hint_goals main then hintGoals prob0 else prob0+      let (hints, nonHints) = partitionEithers (map getHint prob1)       res <- horn nonHints       case res of         Left ans -> return ans@@ -1171,6 +1320,6 @@             isUnitEquality [Pos (_ Jukebox.:=: _)] = True             isUnitEquality [Neg (_ Jukebox.:=: _)] = True             isUnitEquality _ = False-            isUnit = all isUnitEquality (map (toLiterals . what) prob0)+            isUnit = all isUnitEquality (map (toLiterals . what) prob1)             main' = if isUnit then main{flags_explain_encoding = False} else main{flags_formal_proof = False}-          encode prob >>= prove config cpConfig main' later hints+          encode prob >>= prove config main' later hints

+ executable/link.c view

@@ -0,0 +1,12 @@+#include <sys/prctl.h>+#include <sys/signal.h>+#include <stdlib.h>+#include <unistd.h>++void link_to_parent(pid_t parent) {+    prctl(PR_SET_PDEATHSIG, SIGTERM);++    pid_t ppid = getppid();+    if (ppid != parent)+        exit(1);+}

misc/BestTwee.hs view

@@ -14,15 +14,6 @@ import Data.Map(Map) import Data.FileEmbed -solvedInTime :: NominalDiffTime -> FilePath -> String -> IO Bool-solvedInTime timeLimit dir prob = do-  let-    stdout = dir </> prob ++ ".p.stdout"-    stderr = dir </> prob ++ ".p.stderr"-  outTime <- getModificationTime stdout-  errTime <- getModificationTime stderr-  return (diffUTCTime outTime errTime <= timeLimit)- notE :: [(String, Double)] notE = filter (\(x, _) -> '+' `notElem` x) [   ("GRP702+1", 0.06), ("GRP715+1", 0.06), ("GRP660+2", 0.12), ("GRP660+3", 0.12),@@ -54,10 +45,12 @@ ratings :: Map String Double ratings =   Map.fromList-    [ (name, read rating)+    [ (strip ".p" name, read rating)     | [name, rating] <- map words (lines input)]   where     input = $(embedStringFile "ratings")+    strip suf str+      | suf `isSuffixOf` str = take (length str - length suf) str  problemBonus :: (Int, Int, Int, Int, Int, Int) -> String -> Int problemBonus (b0, b1, b2, b3, b4, b5) p =@@ -90,15 +83,12 @@    ("rating 1", (0, 0, 0, 0, 0, 1))]  readResults ok = do-  filenames <- glob "/home/nick/twee-out/*/times"+  filenames <- glob "results/*/times"   fmap (filter (\(x, _) -> x `notElem` banned)) $ forM filenames $ \filename -> do     let name = takeFileName (takeDirectory filename)     let unpack xs = (takeBaseName name, read time :: Double) where [name, time] = words xs     solved <- filter (ok . fst) . map unpack . lines <$> readFile filename     let solvedInTime t = [name | (name, time) <- solved, time < t]---    fast <- filterM (solvedInTime 120 directory) solved---    med  <- filterM (solvedInTime 240 directory) solved---    slow <- filterM (solvedInTime 600 directory) solved     let fast = solvedInTime 120     let med  = solvedInTime 210     let slow = solvedInTime (1/0)

+ misc/HornProof.hs view

@@ -0,0 +1,1038 @@+-- | Proofs of Horn formulas. Modelled on Twee.Proof.+{-# LANGUAGE OverloadedStrings, DeriveAnyClass #-}+module Twee.Proof.Horn(+  -- * Constructing proofs+  Proof, Derivation(..), Axiom(..),+  certify, equation, derivation,+  -- ** Smart constructors for derivations+  lemma, autoSubst, simpleLemma, axiom, symm, trans, cong, congPath,++  -- * Analysing proofs+  simplify, steps, stepTerms, usedLemmas, usedAxioms, usedLemmasAndSubsts, usedAxiomsAndSubsts,+  groundAxiomsAndSubsts, eliminateDefinitions, eliminateDefinitionsFromGoal,+  simplifyProof, generaliseProof,++  -- * Pretty-printing proofs+  Config(..), defaultConfig, Presentation(..),+  ProvedGoal(..), provedGoal, checkProvedGoal,+  pPrintPresentation, present, describeEquation) where++import Twee.Base hiding (invisible)+import Twee.Equation+import Twee.Utils+import qualified Twee.Index as Index+import Control.Monad+import Data.Maybe+import Data.List hiding (singleton)+import Data.Ord+import qualified Data.Set as Set+import Data.Set(Set)+import qualified Data.Map.Strict as Map+import Data.Map(Map)+import qualified Data.IntMap.Strict as IntMap+import Control.Monad.Trans.State.Strict+import Data.Graph+import Twee.Profile+import qualified Data.Binary.Sharing as Binary+import Data.Binary.Sharing(Binary, Shared(..))+import GHC.Generics+import Data.Hashable+import qualified Twee.Proof as Eq++----------------------------------------------------------------------+-- Equational proofs. Only valid proofs can be constructed.+----------------------------------------------------------------------++-- | A checked proof. Construct using 'certify'.+data Proof f =+  Proof {+    context    :: !(Set (Equation f)),+    equation   :: !(Equation f),+    derivation :: !(Derivation f) }+  deriving Show++-- | An unchecked proof.+data Derivation f =+    -- | Apply an existing rule (with proof!) to the root of a term+    UseLemma {-# UNPACK #-} !(Proof f) !(Subst f)+    -- | Apply an axiom to the root of a term+  | UseAxiom {-# UNPACK #-} !(Axiom f) !(Subst f)+    -- Using from the context.+  | UseContext !(Equation f)+    -- | Reflexivity. @'Refl' t@ proves @t = t@.+  | Refl !(Term f)+    -- | Symmetry+  | Symm !(Derivation f)+    -- | Transivitity+  | Trans !(Derivation f) !(Derivation f)+    -- | Congruence.+    -- Parallel, i.e., takes a function symbol and one derivation for each+    -- argument of that function.+  | Cong {-# UNPACK #-} !(Sym f) ![Derivation f]+    -- | Resolution.+  | Resolve !(Derivation f) !(Derivation f)+  deriving (Eq, Show, Generic, Hashable)++--  | An axiom, which comes without proof.+data Axiom f =+  Axiom {+    -- | The number of the axiom.+    -- Has no semantic meaning; for convenience only.+    axiom_number :: {-# UNPACK #-} !Int,+    -- | A description of the axiom.+    -- Has no semantic meaning; for convenience only.+    axiom_name :: !String,+    axiom_context :: !(Set (Equation f)),+    -- | The equation which the axiom asserts.+    axiom_eqn :: !(Equation f) }+  deriving (Eq, Ord, Show, Generic, Hashable)++-- | Checks a 'Derivation' and, if it is correct, returns a+-- certified 'Proof'.+--+-- If the 'Derivation' is incorrect, throws an exception.++-- This is the trusted core of the module.+{-# INLINEABLE certify #-}+certify :: Derivation f -> Proof f+certify p =+  stamp "certify proof" $+  case check p of+    Nothing -> error "Invalid proof created!"+    Just (ctx, eqn) -> Proof ctx eqn p+  where+    check (UseLemma proof sub) =+      return (Set.map (subst sub) (context proof), subst sub (equation proof))+    check (UseAxiom Axiom{..} sub) =+      return (Set.map (subst sub) axiom_context, subst sub axiom_eqn)+    check (UseContext eqn) =+      return (Set.singleton eqn, eqn)+    check (Refl t) =+      return (Set.empty, t :=: t)+    check (Symm p) = do+      (ctx, t :=: u) <- check p+      return (ctx, u :=: t)+    check (Trans p q) = do+      (ctx1, t :=: u1) <- check p+      (ctx2, u2 :=: v) <- check q+      guard (u1 == u2)+      return (Set.union ctx1 ctx2, t :=: v)+    check (Cong f ps) = do+      (ctxs, eqns) <- unzip <$> mapM check ps+      return+        (Set.unions ctxs,+         build (app f (map eqn_lhs eqns)) :=:+         build (app f (map eqn_rhs eqns)))+    check (Resolve p q) = do+      (ctx1, eqn1) <- check p+      (ctx2, eqn2) <- check q+      guard (eqn1 `Set.member` ctx2)+      return (Set.union ctx1 (Set.delete eqn1 ctx2), eqn2)++----------------------------------------------------------------------+-- Everything below this point need not be trusted, since all proof+-- construction goes through the "certify" function.+--+-- N.B.: For this reason, the code below must never directly invoke+-- the Proof constructor!+----------------------------------------------------------------------++-- Typeclass instances.+instance Eq (Proof f) where+  x == y = compare x y == EQ+instance Ord (Proof f) where+  -- Don't look at the proof itself, to prevent exponential blowup+  -- when a proof contains UseLemma+  compare = comparing (\p -> (context p, equation p))+instance Hashable (Proof f) where+  hashWithSalt s p = hashWithSalt s (context p, equation p)++instance Symbolic (Derivation f) where+  type ConstantOf (Derivation f) = f+  termsDL (UseLemma _ sub) = termsDL sub+  termsDL (UseAxiom _ sub) = termsDL sub+  termsDL (UseContext eq) = termsDL eq+  termsDL (Refl t) = termsDL t+  termsDL (Symm p) = termsDL p+  termsDL (Trans p q) = termsDL p `mplus` termsDL q+  termsDL (Cong _ ps) = termsDL ps+  termsDL (Resolve p q) = termsDL p `mplus` termsDL q++  subst_ sub (UseLemma lemma s) = UseLemma lemma (subst_ sub s)+  subst_ sub (UseAxiom axiom s) = UseAxiom axiom (subst_ sub s)+  subst_ sub (UseContext eq) = UseContext (subst_ sub eq)+  subst_ sub (Refl t) = Refl (subst_ sub t)+  subst_ sub (Symm p) = Symm (subst_ sub p)+  subst_ sub (Trans p q) = Trans (subst_ sub p) (subst_ sub q)+  subst_ sub (Cong f ps) = Cong f (subst_ sub ps)+  subst_ sub (Resolve p q) = Resolve (subst_ sub p) (subst_ sub q)++{-+instance Function f => Pretty (Proof f) where+  pPrint = pPrintLemma defaultConfig (prettyShow . axiom_number) (prettyShow . equation)+instance (Intern f, PrettyTerm f) => Pretty (Derivation f) where+  pPrint (UseLemma lemma sub) =+    text "subst" <#> pPrintTuple [text "lemma" <+> pPrint (equation lemma), pPrint sub]+  pPrint (UseAxiom axiom sub) =+    text "subst" <#> pPrintTuple [pPrint axiom, pPrint sub]+  pPrint (Refl t) =+    text "refl" <#> pPrintTuple [pPrint t]+  pPrint (Symm p) =+    text "symm" <#> pPrintTuple [pPrint p]+  pPrint (Trans p q) =+    text "trans" <#> pPrintTuple [pPrint p, pPrint q]+  pPrint (Cong f ps) =+    text "cong" <#> pPrintTuple (pPrint f:map pPrint ps)++instance (Intern f, PrettyTerm f) => Pretty (Axiom f) where+  pPrint Axiom{..} =+    text "axiom" <#>+    pPrintTuple [pPrint axiom_number, text axiom_name, pPrint axiom_eqn]++instance (Intern f, Binary f) => Binary (Axiom f) where+  put Axiom{..} = Binary.put (Shared (axiom_number, axiom_name, axiom_eqn))+  get = do+    Shared (num, name, eqn) <- Binary.get+    return (Axiom num name eqn)++instance (Intern f, Binary f) => Binary (Proof f) where+  put = Binary.put . Shared . derivation+  get = certify . getShared <$> Binary.get++foldLemmas :: (Intern f, PrettyTerm f) => (Map (Proof f) a -> Derivation f -> a) -> [Derivation f] -> Map (Proof f) a+foldLemmas op ds =+  execState (mapM_ foldGoal ds) Map.empty+  where+    foldGoal p = mapM_ foldLemma (usedLemmas p)+    foldLemma p = do+      m <- get+      case Map.lookup p m of+        Just x -> return x+        Nothing -> do+          mapM_ foldLemma (usedLemmas (derivation p))+          m <- get+          case Map.lookup p m of+            Just x  -> return x+            Nothing -> do+              let x = op m (derivation p)+              put (Map.insert p x m)+              return x++mapLemmas :: Function f => (Derivation f -> Derivation f) -> [Derivation f] -> [Derivation f]+mapLemmas f ds = map (derivation . op lem) ds+  where+    op lem = certify . f . unfoldLemmas (\pf -> Just (simpleLemma (lem Map.! pf)))+    lem = foldLemmas op ds++allLemmas :: Function f => [Derivation f] -> [Proof f]+allLemmas ds =+  reverse [p | (_, p, _) <- map vertex (topSort graph)]+  where+    used = foldLemmas (\_ p -> usedLemmas p) ds+    (graph, vertex, _) =+      graphFromEdges+        [((), p, ps) | (p, ps) <- Map.toList used]++unfoldLemmas :: Minimal f => (Proof f -> Maybe (Derivation f)) -> Derivation f -> Derivation f+unfoldLemmas lem p@(UseLemma q sub) =+  case lem q of+    Nothing -> p+    Just r ->+      -- Get rid of any variables that are not bound by sub+      -- (e.g., ones which only occur internally in q)+      subst sub (eraseExcept (substDomain sub) r)+unfoldLemmas lem (Symm p) = symm (unfoldLemmas lem p)+unfoldLemmas lem (Trans p q) = trans (unfoldLemmas lem p) (unfoldLemmas lem q)+unfoldLemmas lem (Cong f ps) = cong f (map (unfoldLemmas lem) ps)+unfoldLemmas _ p = p++lemma :: Proof f -> Subst f -> Derivation f+lemma p sub = UseLemma p sub++simpleLemma :: Function f => Proof f -> Derivation f+simpleLemma p =+  UseLemma p (autoSubst (equation p))++axiom :: Axiom f -> Derivation f+axiom ax@Axiom{..} =+  UseAxiom ax (autoSubst axiom_eqn)++autoSubst :: Equation f -> Subst f+autoSubst eqn =+  fromJust $+  listToSubst [(x, build (var x)) | x <- vars eqn]++symm :: Derivation f -> Derivation f+symm (Refl t) = Refl t+symm (Symm p) = p+symm (Trans p q) = trans (symm q) (symm p)+symm (Cong f ps) = cong f (map symm ps)+symm p = Symm p++trans :: Derivation f -> Derivation f -> Derivation f+trans Refl{} p = p+trans p Refl{} = p+trans (Trans p q) r =+  -- Right-associate uses of transitivity.+  -- p cannot be a Trans (if it was created with the smart+  -- constructors) but q could be.+  Trans p (trans q r)+trans p q = Trans p q++cong :: Sym f -> [Derivation f] -> Derivation f+cong f ps =+  case sequence (map unRefl ps) of+    Nothing -> Cong f ps+    Just ts -> Refl (build (app f ts))+  where+    unRefl (Refl t) = Just t+    unRefl _ = Nothing++-- Transform a proof so that each step uses exactly one axiom+-- or lemma. The proof will have the following form afterwards:+--   * Trans only occurs at the outermost level and is right-associated+--   * Each Cong has exactly one non-Refl argument (no parallel rewriting)+--   * Symm only occurs innermost, i.e., next to UseLemma or UseAxiom+--   * Refl only occurs as an argument to Cong, or outermost if the+--     whole proof is a single reflexivity step+flattenDerivation :: Function f => Derivation f -> Derivation f+flattenDerivation p =+  fromSteps (equation (certify p)) (steps p)++-- | Simplify a derivation so that:+--   * Symm occurs innermost+--   * Trans is right-associated+--   * Each Cong has at least one non-Refl argument+--   * Refl is not used unnecessarily+simplify :: Function f => Derivation f -> Derivation f+simplify (Symm p) = symm (simplify p)+simplify (Trans p q) = trans (simplify p) (simplify q)+simplify (Cong f ps) = cong f (map simplify ps)+simplify p+  | t == u = Refl t+  | otherwise = p+  where+    t :=: u = equation (certify p)++-- | Transform a derivation into a list of single steps.+--   Each step has the following form:+--     * Trans does not occur+--     * Symm only occurs innermost, i.e., next to UseLemma or UseAxiom+--     * Each Cong has exactly one non-Refl argument (no parallel rewriting)+--     * Refl only occurs as an argument to Cong+steps :: Function f => Derivation f -> [Derivation f]+steps = steps1 . simplify+  where+    steps1 p@UseAxiom{} = [p]+    steps1 p@UseLemma{} = [p]+    steps1 (Refl _) = []+    steps1 (Symm p) = map symm (reverse (steps1 p))+    steps1 (Trans p q) = steps1 p ++ steps1 q+    steps1 p@(Cong f qs) =+      concat [ map (inside i) (steps1 q) | (i, q) <- zip [0..] qs ]+      where+        App _ ts :=: App _ us = equation (certify p)+        inside i p =+          Cong f $+            map Refl (take i (unpack us)) +++            [p] +++            map Refl (drop (i+1) (unpack ts))++-- | Convert a list of steps (plus the equation it is proving)+-- back to a derivation.+fromSteps :: Equation f -> [Derivation f] -> Derivation f+fromSteps (t :=: _) [] = Refl t+fromSteps _ ps = foldr1 Trans ps++-- | Given a derivation, compute which terms it goes through.+stepTerms :: Function f => Derivation f -> [Term f]+stepTerms p =+  case steps p of+    [] -> [eqn_lhs (equation (certify p))]+    s:ss ->+      eqn_lhs (equation (certify s)):+      map (eqn_rhs . equation . certify) (s:ss)++-- | Find peak terms in a derivation.+peakTerms :: Function f => Derivation f -> [Term f]+peakTerms = peaks . stepTerms+  where+    peaks [] = []+    peaks [t] = [t]+    peaks (t:u:ts)+      | lessEq t u = peaks (u:ts)+      | lessEq u t = peaks (t:ts)+      | otherwise = t:peaks (u:ts)+      -- TODO do more carefully?+      -- handle this case t --> v <-- u where e.g. t <= u (should still be counted as a peak perhaps)++-- | Find all lemmas which are used in a derivation.+usedLemmas :: Derivation f -> [Proof f]+usedLemmas p = map fst (usedLemmasAndSubsts p)++-- | Find all lemmas which are used in a derivation,+-- together with the substitutions used.+usedLemmasAndSubsts :: Derivation f -> [(Proof f, Subst f)]+usedLemmasAndSubsts p = lem p []+  where+    lem (UseLemma p sub) = ((p, sub):)+    lem (Symm p) = lem p+    lem (Trans p q) = lem p . lem q+    lem (Cong _ ps) = foldr (.) id (map lem ps)+    lem _ = id++-- | Find all axioms which are used in a derivation.+usedAxioms :: Derivation f -> [Axiom f]+usedAxioms p = map fst (usedAxiomsAndSubsts p)++-- | Find all axioms which are used in a derivation,+-- together with the substitutions used.+usedAxiomsAndSubsts :: Derivation f -> [(Axiom f, Subst f)]+usedAxiomsAndSubsts p = ax p []+  where+    ax (UseAxiom axiom sub) = ((axiom, sub):)+    ax (Symm p) = ax p+    ax (Trans p q) = ax p . ax q+    ax (Cong _ ps) = foldr (.) id (map ax ps)+    ax _ = id++-- | Find all ground instances of axioms which are used in the+-- expanded form of a derivation (no lemmas).+groundAxiomsAndSubsts :: Function f => Derivation f -> Map (Axiom f) (Set (Subst f))+groundAxiomsAndSubsts p = ax lem p+  where+    lem = foldLemmas ax [p]++    ax _ (UseAxiom axiom sub) =+      Map.singleton axiom (Set.singleton sub)+    ax lem (UseLemma lemma sub) =+      Map.map (Set.map substAndErase) (lem Map.! lemma)+      where+        substAndErase sub' =+          eraseExcept (vars sub) (subst sub sub')+    ax lem (Symm p) = ax lem p+    ax lem (Trans p q) = Map.unionWith Set.union (ax lem p) (ax lem q)+    ax lem (Cong _ ps) = Map.unionsWith Set.union (map (ax lem) ps)+    ax _ _ = Map.empty++eliminateDefinitionsFromGoal :: Function f => [Axiom f] -> ProvedGoal f -> ProvedGoal f+eliminateDefinitionsFromGoal axioms pg =+  pg {+    pg_proof = certify (eliminateDefinitions axioms (derivation (pg_proof pg))) }++eliminateDefinitions :: Function f => [Axiom f] -> Derivation f -> Derivation f+eliminateDefinitions [] p = p+eliminateDefinitions axioms p = head (mapLemmas elim [p])+  where+    elim (UseAxiom axiom sub)+      | axiom `Set.member` axSet =+        Refl (term (subst sub (eqn_rhs (axiom_eqn axiom))))+      | otherwise = UseAxiom axiom (elimSubst sub)+    elim (UseLemma lemma sub) =+      UseLemma lemma (elimSubst sub)+    elim (Refl t) = Refl (term t)+    elim (Symm p) = Symm (elim p)+    elim (Trans p q) = Trans (elim p) (elim q)+    elim (Cong f ps) =+      case find (build (app f (map var vs))) of+        Nothing -> Cong f (map elim ps)+        Just (rhs, Subst sub) ->+          let proof (Cons (Var (V x)) Nil) = qs !! x in+          replace (proof <$> sub) rhs+      where+        vs = map V [0..length ps-1]+        qs = map (simpleLemma . certify . elim) ps -- avoid duplicating proofs of ts++    elimSubst (Subst sub) = Subst (singleton <$> term <$> unsingleton <$> sub)+      where+        unsingleton (Cons t Nil) = t++    term = build . term'+    term' (Var x) = var x+    term' t@(App f ts) =+      case find t of+        Nothing -> app f (map term' (unpack ts))+        Just (rhs, sub) ->+          term' (subst sub rhs)++    find t =+      listToMaybe $ do+        (_, UseAxiom Axiom{axiom_eqn = l :=: r} _) <- Index.matches t idx+        let Just sub = match l t+        return (r, sub)++    replace sub (Var (V x)) =+      IntMap.findWithDefault undefined x sub+    replace sub (App f ts) =+      cong f (map (replace sub) (unpack ts))++    axSet = Set.fromList axioms+    idx = Index.fromList [(eqn_lhs (axiom_eqn ax), axiom ax) | ax <- axioms]++-- | Applies a derivation at a particular path in a term.+congPath :: [Int] -> Term f -> Derivation f -> Derivation f+congPath [] _ p = p+congPath (n:ns) (App f t) p | n <= length ts =+  cong f $+    map Refl (take n ts) +++    [congPath ns (ts !! n) p] +++    map Refl (drop (n+1) ts)+  where+    ts = unpack t+congPath _ _ _ = error "bad path"++----------------------------------------------------------------------+-- Pretty-printing of proofs.+----------------------------------------------------------------------++-- | Options for proof presentation.+data Config f =+  Config {+    -- | Never inline lemmas.+    cfg_all_lemmas :: !Bool,+    -- | Inline all lemmas.+    cfg_no_lemmas :: !Bool,+    -- | Make the proof ground.+    cfg_ground_proof :: !Bool,+    -- | Print out explicit substitutions.+    cfg_show_instances :: !Bool,+    -- | Print out proofs in colour.+    cfg_use_colour :: !Bool,+    -- | Print out which instances of some axioms were used.+    cfg_show_uses_of_axioms :: Axiom f -> Bool,+    -- | Print out peaks of each lemma.+    cfg_show_peaks :: !Bool,+    -- | Eliminate $equals from the proofs.+    cfg_eliminate_existentials_coding :: !Bool,+    -- | Show which subterm is rewritten.+    cfg_show_subterms :: !Bool }++-- | The default configuration.+defaultConfig :: Config f+defaultConfig =+  Config {+    cfg_all_lemmas = False,+    cfg_no_lemmas = False,+    cfg_ground_proof = False,+    cfg_show_instances = False,+    cfg_use_colour = False,+    cfg_show_uses_of_axioms = const False,+    cfg_show_peaks = False,+    cfg_eliminate_existentials_coding = True,+    cfg_show_subterms = False }++-- | A proof, with all axioms and lemmas explicitly listed.+data Presentation f =+  Presentation {+    -- | The used axioms.+    pres_axioms :: [Axiom f],+    -- | The used lemmas.+    pres_lemmas :: [Proof f],+    -- | The goals proved.+    pres_goals  :: [ProvedGoal f] }+  deriving (Show, Generic, Binary)++-- Note: only the pg_proof field should be trusted!+-- The remaining fields are for information only.+data ProvedGoal f =+  ProvedGoal {+    pg_number  :: Int,+    pg_name    :: String,+    pg_proof   :: Proof f,++    -- Extra fields for existentially-quantified goals, giving the original goal+    -- and the existential witness. These fields are not verified. If you want+    -- to check them, use checkProvedGoal.+    --+    -- In general, subst pg_witness_hint pg_goal_hint == equation pg_proof.+    -- For non-existential goals, pg_goal_hint == equation pg_proof+    -- and pg_witness_hint is the empty substitution.+    pg_goal_hint    :: Equation f,+    pg_witness_hint :: Subst f }+  deriving (Show, Generic, Binary)++-- | Construct a @ProvedGoal@.+provedGoal :: Int -> String -> Proof f -> ProvedGoal f+provedGoal number name proof =+  ProvedGoal {+    pg_number = number,+    pg_name = name,+    pg_proof = proof,+    pg_goal_hint = equation proof,+    pg_witness_hint = emptySubst }++-- | Check that pg_goal/pg_witness match up with pg_proof.+checkProvedGoal :: Function f => ProvedGoal f -> ProvedGoal f+checkProvedGoal pg@ProvedGoal{..}+  | subst pg_witness_hint pg_goal_hint == equation pg_proof =+    pg+  | otherwise =+    error $ show $+      text "Invalid ProvedGoal!" $$+      text "Claims to prove" <+> pPrint pg_goal_hint $$+      text "with witness" <+> pPrint pg_witness_hint <#> text "," $$+      text "but actually proves" <+> pPrint (equation pg_proof)++instance Function f => Pretty (Presentation f) where+  pPrint = pPrintPresentation defaultConfig++-- | Simplify and present a proof.+present :: Function f => Config f -> [Proof f] -> [ProvedGoal f] -> Presentation f+present config@Config{..} extraLemmas goals =+  Presentation axioms lemmas goals'+  where+    ps =+      mapLemmas flattenDerivation $+      simplifyProof config $ map (derivation . pg_proof) goals++    goals' =+      [ decodeGoal config (goal{pg_proof = certify p})+      | (goal, p) <- zip goals ps ]++    axioms = usort $+      concatMap (usedAxioms . derivation . pg_proof) goals' +++      concatMap (usedAxioms . derivation) lemmas++    lemmas = allLemmas (map simpleLemma extraLemmas ++ map (derivation . pg_proof) goals')++groundProof :: Function f => [Derivation f] -> [Derivation f]+groundProof ds+  | all (isGround . equation) (allLemmas ds) = ds+  | otherwise = groundProof (mapLemmas f ds)+  where+    f (UseLemma lemma sub) =+      simpleLemma $ certify $+      eraseExcept (vars sub) $+      subst sub $+      derivation lemma+    f p@UseAxiom{} = p+    f p@Refl{} = p+    f (Symm p) = Symm (f p)+    f (Trans p q) = Trans (f p) (f q)+    f (Cong fun ps) = Cong fun (map f ps)++simplifyProof :: Function f => Config f -> [Derivation f] -> [Derivation f]+simplifyProof config@Config{..} goals =+  canonicaliseLemmas (fixpointOn key simp' (fixpointOn key simp goals))+  where+    simpCore =+      (inlineUsedOnceLemmas `onlyIf` not cfg_all_lemmas) .+      inlineTrivialLemmas config .+      tightenProof++    simp = simpCore . generaliseProof True+    -- generaliseProof undoes the effect of groundProof!+    -- But we still want to run generaliseProof first, to simplify the proof+    simp' = (simpCore . groundProof) `onlyIf` cfg_ground_proof++    key ds =+      (ds, [(equation p, derivation p) | p <- allLemmas ds])++    pass `onlyIf` True = pass+    _    `onlyIf` False = id++simplificationPass ::+  Function f =>+  -- A transformation on lemmas+  (Map (Proof f) (Derivation f) -> Proof f -> Derivation f) ->+  -- A transformation on goals+  (Map (Proof f) (Derivation f) -> Derivation f -> Derivation f) ->+  [Derivation f] -> [Derivation f]+simplificationPass lemma goal p = map (op goal lem) p+  where+    lem = foldLemmas (op (\lem -> lemma lem . certify)) p+    op f lem p =+      f lem (unfoldLemmas (\lemma -> Just (lem Map.! lemma)) p)++inlineTrivialLemmas :: Function f => Config f -> [Derivation f] -> [Derivation f]+inlineTrivialLemmas Config{..} =+  -- A lemma is trivial if one of the following holds:+  --   * It only has one step+  --   * It is subsumed by an earlier lemma+  --   * It has to do with $equals (for printing of the goal proof)+  --   * The option cfg_no_lemmas is true+  simplificationPass inlineTrivial (const id)+  where+    inlineTrivial lem p+      | shouldInline p = derivation p+      | (q:_) <- subsuming lem (equation p) = q+      | otherwise = simpleLemma p++    shouldInline p =+      cfg_no_lemmas ||+      length (filter (not . invisible) (map (equation . certify) (steps (derivation p)))) <= 1 ||+      (cfg_eliminate_existentials_coding &&+        (any (isJust . decodeEquality) [eqn_lhs (equation p), eqn_rhs (equation p)] ||+         any isFalseTerm [eqn_lhs (equation p), eqn_rhs (equation p)] ||+         any isTrueTerm [eqn_lhs (equation p), eqn_rhs (equation p)]))++    subsuming lem (t :=: u) =+      subsuming1 lem (t :=: u) +++      map symm (subsuming1 lem (u :=: t))+    subsuming1 lem eq =+      [ subst sub d+      | (q, d) <- Map.toList lem,+        sub <- maybeToList (matchEquation (equation q) eq) ]++inlineUsedOnceLemmas :: Function f => [Derivation f] -> [Derivation f]+inlineUsedOnceLemmas ds =+  -- Inline any lemma that's only used once in the proof+  simplificationPass (const inlineOnce) (const id) ds+  where+    uses = Map.unionsWith (+) $+      map countUses ds ++ Map.elems (foldLemmas (const countUses) ds)++    countUses p =+      Map.fromListWith (+) (zip (usedLemmas p) (repeat (1 :: Int)))++    inlineOnce p+      | usedOnce p = derivation p+      | otherwise = simpleLemma p+      where+        usedOnce p =+          case Map.lookup p uses of+            Just 1 -> True+            _ -> False++tightenProof :: Function f => [Derivation f] -> [Derivation f]+tightenProof = mapLemmas tightenLemma+  where+    tightenLemma p =+      fromSteps eq (map fst (fixpointOn length (tightenSteps eq) (zip ps eqs)))+      where+        eq = equation (certify p)+        ps = steps p+        eqs = map (equation . certify) ps++    tightenSteps eq steps = head (cands ++ [steps])+      where+        -- Look for a segment of ps which can be removed, in the+        -- sense that the terms at both ends of the segment are+        -- unifiable without altering eq.+        cands =+          [ subst sub (before ++ after)+          | (before, mid1) <- splits steps,+            -- 'reverse' means we start with big segments.+            (mid@(_:_), after) <- reverse (splits mid1),+            let t :=: _ = snd (head mid)+                _ :=: u = snd (last mid),+            sub <- maybeToList (unify t u),+            subst sub eq == eq ] +++          [ subst sub before+          | (before, after@(_:_)) <- splits steps,+            let t :=: _ = snd (head after)+                _ :=: u = snd (last after),+            sub <- maybeToList (match t u),+            subst sub (eqn_lhs eq) == eqn_lhs eq ] +++          [ subst sub after+          | (before@(_:_), after) <- reverse (splits steps),+            let t :=: _ = snd (head before)+                _ :=: u = snd (last before),+            sub <- maybeToList (match u t),+            subst sub (eqn_rhs eq) == eqn_rhs eq ]++generaliseProof :: Function f => Bool -> [Derivation f] -> [Derivation f]+generaliseProof instGoal =+  simplificationPass (const generaliseLemma) (const generaliseGoal)+  where+    generaliseLemma p = lemma (certify q) sub+      where+        (q, sub) = generalise p+    generaliseGoal p = if instGoal then subst sub q else q+      where+        (q, sub) = generalise (certify p)++    generalise p = (q, sub)+      where+        eq = equation p+        n = freshVar eq+        qs = evalState (mapM generaliseStep (steps (derivation p))) n+        Just sub1 = unifyMany (stepsConstraints qs)+        q = canonicalise (fromSteps eq (subst sub1 qs))+        Just sub = matchEquation (equation (certify q)) eq++    generaliseStep (UseAxiom axiom _) =+      freshen (vars (axiom_eqn axiom)) (UseAxiom axiom)+    generaliseStep (UseLemma lemma _) =+      freshen (vars (equation lemma)) (UseLemma lemma)+    generaliseStep (Refl _) = do+      n <- get+      put (n+1)+      return (Refl (build (var (V n))))+    generaliseStep (Symm p) =+      Symm <$> generaliseStep p+    generaliseStep (Trans p q) =+      liftM2 Trans (generaliseStep p) (generaliseStep q)+    generaliseStep (Cong f ps) = do+      q <- cong f <$> mapM generaliseStep ps+      case q of+        Refl{} -> generaliseStep q+        _ -> return q++    freshen xs f = do+      n <- get+      put (n + length xs)+      let Just sub = listToSubst [(x, build (var (V i))) | (x, i) <- zip (usort xs) [n..]]+      return (f sub)++    stepsConstraints ps = zipWith combine eqs (tail eqs)+      where+        eqs = map (equation . certify) ps+        combine (_ :=: t) (u :=: _) = (t, u)++canonicaliseLemmas :: Function f => [Derivation f] -> [Derivation f]+canonicaliseLemmas =+  simplificationPass (const canonicaliseLemma) (const canonicalise)+  where+    -- Present the equation left-to-right, and with variables+    -- named canonically+    canonicaliseLemma p+      | u `lessEqSkolem` t = canon (derivation p)+      | otherwise = symm (canon (symm (derivation p)))+      where+        t :=: u = equation p+        -- This ensures that we also renumber variables in the derivation that+        -- do not occur in the equation, but that variables in the equation+        -- get priority.+        symbolic p = (equation p, derivation p)+        before = symbolic p+        after = canonicalise (symbolic p)+        Just sub1 = matchManyList (terms before) (terms after)+        Just sub2 = matchManyList (terms after) (terms before)+        canon p = subst sub2 (simpleLemma (certify (subst sub1 p)))++invisible :: Function f => Equation f -> Bool+invisible (t :=: u) = show (pPrint t) == show (pPrint u)++-- Pretty-print the proof of a single lemma.+pPrintLemma :: Function f => Config f -> (Axiom f -> String) -> (Proof f -> String) -> Proof f -> Doc+pPrintLemma Config{..} axiomNum lemmaNum p+  | null qs = text "Reflexivity."+  | equation (certify (fromSteps (equation p) qs)) == equation p =+    vcat (zipWith pp hl qs) $$ ppTerm (HighlightedTerm [] Nothing) (eqn_rhs (equation p))+  | otherwise = error "lemma changed by pretty-printing!"+  where+    qs = steps (derivation p)+    hl = map highlightStep qs+    peaks = Set.fromList (peakTerms (derivation p))++    pp _ p | invisible (equation (certify p)) = pPrintEmpty+    pp h p =+      ppTerm (HighlightedTerm [green | cfg_use_colour] (Just h)) (eqn_lhs (equation (certify p))) $$+      text "=" <+> highlight [bold | cfg_use_colour] (text "{" <+> ((text "by" <+> ppStep p) $$ if cfg_show_subterms then subtermInfo else pPrintEmpty) <+> text "}")+      where+        subtermInfo =+          (text "from" <+> pPrint t) $$+          (text "to" <+> pPrint u)+        t :=: u = rewrittenSubterms p++    highlightStep UseAxiom{} = []+    highlightStep UseLemma{} = []+    highlightStep (Symm p) = highlightStep p+    highlightStep (Cong _ ps) = i:highlightStep p+      where+        [(i, p)] = filter (not . isRefl . snd) (zip [0..] ps)++    rewrittenSubterms (Symm p) = u :=: t+      where+        t :=: u = rewrittenSubterms p+    rewrittenSubterms (Cong _ ps) = rewrittenSubterms p+      where+        [p] = filter (not . isRefl) ps+    rewrittenSubterms p = equation (certify p)++    ppTerm decorate t = text "  " <#> pPrint (decorate t) <+> (if cfg_show_peaks && t `Set.member` peaks then text "(peak)" else pPrintEmpty)++    ppStep = pp True+      where+        pp dir (UseAxiom axiom@Axiom{..} sub) =+          text "axiom" <+> text (axiomNum axiom) <+> parens (text axiom_name) <+> ppDir dir <#> showSubst sub+        pp dir (UseLemma lemma sub) =+          text "lemma" <+> text (lemmaNum lemma) <+> ppDir dir <#> showSubst sub+        pp dir (Symm p) =+          pp (not dir) p+        pp dir (Cong _ ps) = pp dir p+          where+            [p] = filter (not . isRefl) ps++    ppDir True = pPrintEmpty+    ppDir False = text "R->L"++    showSubst sub+      | cfg_show_instances && not (null (substToList sub)) =+        text " with " <#> pPrintSubst sub+      | otherwise = pPrintEmpty++    isRefl Refl{} = True+    isRefl _ = False++-- Pretty-print a substitution.+pPrintSubst :: Function f => Subst f -> Doc+pPrintSubst sub =+  fsep (punctuate comma+    [ pPrint x <+> text "->" <+> pPrint t+    | (x, t) <- substToList sub ])++-- | Print a presented proof.+pPrintPresentation :: forall f. Function f => Config f -> Presentation f -> Doc+pPrintPresentation config (Presentation axioms lemmas goals) =+  vcat $ intersperse (text "") $+    vcat [ describeEquation "Axiom" (axiomNum axiom) (Just name) eqn $$+           ppAxiomUses axiom+         | axiom@(Axiom _ name eqn) <- axioms,+           not (invisible eqn) ]:+    [ pp "Lemma" (lemmaNum p) Nothing (equation p) emptySubst p+    | p <- lemmas,+      not (invisible (equation p)) ] +++    [ pp "Goal" (show num) (Just pg_name) pg_goal_hint pg_witness_hint pg_proof+    | (num, ProvedGoal{..}) <- zip [1..] goals ]+  where+    pp kind n mname eqn witness p =+      describeEquation kind n mname eqn $$+      ppWitness witness $$+      text "Proof:" $$+      pPrintLemma config axiomNum lemmaNum p++    axiomNums = Map.fromList (zip axioms [1..])+    lemmaNums = Map.fromList (zip lemmas [length axioms+1..])+    axiomNum x = show (fromJust (Map.lookup x axiomNums))+    lemmaNum x = show (fromJust (Map.lookup x lemmaNums))++    ppWitness sub+      | sub == emptySubst = pPrintEmpty+      | otherwise =+          vcat [+            text "The goal is true when:",+            nest 2 $ vcat+              [ pPrint x <+> text "=" <+> pPrint t+              | (x, t) <- substToList sub ],+            if minimal `elem` funs sub then+              text "where" <+> doubleQuotes (pPrint (minimal :: Sym f)) <+>+              text "stands for an arbitrary term of your choice."+            else pPrintEmpty,+            text ""]++    ppAxiomUses axiom+      | cfg_show_uses_of_axioms config axiom && not (null uses) =+        text "Used with:" $$+        nest 2 (vcat+          [ pPrint i <#> text "." <+> pPrintSubst sub+          | (i, sub) <- zip [1 :: Int ..] uses ])+      | otherwise = pPrintEmpty+      where+        uses = Set.toList (axiomUses axiom)++    axiomUses axiom = Map.findWithDefault Set.empty axiom usesMap+    usesMap =+      Map.unionsWith Set.union+        [ Map.map (Set.delete emptySubst . Set.map ground)+            (groundAxiomsAndSubsts p)+        | goal <- goals,+          let p = derivation (pg_proof goal) ]++-- | Format an equation nicely.+--+-- Used both here and in the main file.+describeEquation ::+  Function f =>+  String -> String -> Maybe String -> Equation f -> Doc+describeEquation kind num mname eqn =+  text kind <+> text num <#>+  (case mname of+     Nothing -> text ""+     Just name -> text (" (" ++ name ++ ")")) <#>+  text ":" <+> pPrint eqn <#> text "."++----------------------------------------------------------------------+-- Making proofs of existential goals more readable.+----------------------------------------------------------------------++-- The idea: the only axioms which mention $equals, $true and $false+-- are:+--   * $equals(x,x) = $true  (reflexivity)+--   * $equals(t,u) = $false (conjecture)+-- This implies that a proof $true = $false must have the following+-- structure, if we expand out all lemmas:+--   $true = $equals(s,s) = ... = $equals(t,u) = $false.+--+-- The substitution in the last step $equals(t,u) = $false is in fact the+-- witness to the existential.+--+-- Furthermore, we can make it so that the inner "..." doesn't use the $equals+-- axioms. If it does, one of the "..." steps results in either $true or $false,+-- and we can chop off everything before the $true or after the $false.+--+-- Once we have done that, every proof step in the "..." must be a congruence+-- step of the shape+--   $equals(t, u) = $equals(v, w).+-- This is because there are no other axioms which mention $equals. Hence we can+-- split the proof of $equals(s,s) = $equals(t,u) into separate proofs of s=t+-- and s=u.+--+-- What we have got out is:+--   * the witness to the existential+--   * a proof that both sides of the conjecture are equal+-- and we can present that to the user.++-- Tries to transform a proof of $true = $false into a proof of+-- the original existentially-quantified formula.+decodeGoal :: Function f => Config f -> ProvedGoal f -> ProvedGoal f+decodeGoal config pg =+  case maybeDecodeGoal config pg of+    Nothing -> pg+    Just (name, witness, goal, deriv) ->+      checkProvedGoal $+      pg {+        pg_name = name,+        pg_proof = certify deriv,+        pg_goal_hint = goal,+        pg_witness_hint = witness }++maybeDecodeGoal :: forall f. Function f =>+  Config f -> ProvedGoal f -> Maybe (String, Subst f, Equation f, Derivation f)+maybeDecodeGoal Config{..} ProvedGoal{..}+  | not cfg_eliminate_existentials_coding = Nothing+  --  N.B. presentWithGoals takes care of expanding any lemma which mentions+  --  $equals, and flattening the proof.+  | isFalseTerm u = extract (steps deriv)+    -- Orient the equation so that $false is the RHS.+  | isFalseTerm t = extract (steps (symm deriv))+  | otherwise = Nothing+  where+    t :=: u = equation pg_proof+    deriv = derivation pg_proof++    -- Detect $true = $equals(t, t).+    decodeReflexivity :: Derivation f -> Maybe (Term f)+    decodeReflexivity (Symm (UseAxiom Axiom{..} sub)) = do+      guard (isTrueTerm (eqn_rhs axiom_eqn))+      (t, u) <- decodeEquality (eqn_lhs axiom_eqn)+      guard (t == u)+      return (subst sub t)+    decodeReflexivity _ = Nothing++    -- Detect $equals(t, u) = $false.+    decodeConjecture :: Derivation f -> Maybe (String, Equation f, Subst f)+    decodeConjecture (UseAxiom Axiom{..} sub) = do+      guard (isFalseTerm (eqn_rhs axiom_eqn))+      (t, u) <- decodeEquality (eqn_lhs axiom_eqn)+      return (axiom_name, t :=: u, sub)+    decodeConjecture _ = Nothing++    extract (p:ps) = do+      -- Start by finding $true = $equals(t,u).+      t <- decodeReflexivity p+      cont (Refl t) (Refl t) ps+    extract [] = Nothing++    cont p1 p2 (p:ps)+      | Just t <- decodeReflexivity p =+        cont (Refl t) (Refl t) ps+      | Just (name, eqn, sub) <- decodeConjecture p =+        -- If p1: s=t and p2: s=u+        -- then symm p1 `trans` p2: t=u.+        return (name, sub, eqn, symm p1 `trans` p2)+      | Cong eq [p1', p2'] <- p, isEquals eq =+        cont (p1 `trans` p1') (p2 `trans` p2') ps+    cont _ _ _ = Nothing+-}

+ misc/Nested.hs view

@@ -0,0 +1,52 @@+{-# LANGUAGE TypeFamilies, BangPatterns, PatternSynonyms, ViewPatterns #-}+module Twee.Term.Nested where++import qualified Twee.Term as Flat+import qualified Twee.Term.Core as Flat+import Twee.Term(Var, Fun, Build(..))++data Term f =+    Flat {-# UNPACK #-} !(Flat.Term f)+  | VarTerm {-# UNPACK #-} !Var+  | AppTerm {-# UNPACK #-} !(Fun f) ![Term f]++instance Build (Term f) where+  type BuildFun (Term f) = f+  builder (Flat t) = builder t+  builder (VarTerm x) = Flat.var x+  builder (AppTerm f ts) = Flat.app f (builder ts)++len :: Term f -> Int+len t = aux 0 [t] []+  where+    aux !_ !_ !_ | False = undefined+    aux n [] [] = n+    aux n [] (ts:tss) = aux n ts tss+    aux n (Flat t:ts) tss = aux (n+Flat.len t) ts tss+    aux n (VarTerm _:ts) tss = aux (n+1) ts tss+    aux n (AppTerm _ ts:us) tss = aux (n+1) ts (us:tss)++flatten :: Term f -> Flat.Term f+flatten t =+  case Flat.buildTermList (len t) (builder t) of+    Flat.Cons u Flat.Nil -> u++pattern Var :: Var -> Term f+pattern Var x <- (patVar -> Just x)+  where+    Var x = VarTerm x++pattern App :: Fun f -> [Term f] -> Term f+pattern App f ts <- (patApp -> Just (f, ts))+  where+    App f ts = AppTerm f ts++patVar :: Term f -> Maybe Var+patVar (VarTerm x) = Just x+patVar (Flat (Flat.Var x)) = Just x+patVar _ = Nothing++patApp :: Term f -> Maybe (Fun f, [Term f])+patApp (AppTerm f ts) = Just (f, ts)+patApp (Flat (Flat.App f ts)) = Just (f, map Flat (Flat.unpack ts))+patApp _ = Nothing

+ misc/NestedOrig.hs view

@@ -0,0 +1,101 @@+{-# LANGUAGE TypeFamilies, BangPatterns, PatternSynonyms, ViewPatterns #-}+module Twee.Term.Nested where++import qualified Twee.Term as Flat+import qualified Twee.Term.Core as Flat+import Twee.Term(Var, Fun, Build(..))++data TermList f =+    Nil+  | AppendTerm (Term f) (TermList f)+  | AppendFlatList {-# UNPACK #-} !(Flat.TermList f) (TermList f) -- first argument must be non-empty++flatList :: Flat.TermList f -> TermList f+flatList Flat.Nil = Nil+flatList t = AppendFlatList t Nil++(+++) :: TermList f -> TermList f -> TermList f+Nil +++ ts = ts+AppendTerm t ts +++ us = AppendTerm t (ts +++ us)+AppendFlatList t ts +++ us = AppendFlatList t (ts +++ us)++data Term f =+    Flat {-# UNPACK #-} !(Flat.Term f)+  | VarTerm {-# UNPACK #-} !Var+  | AppTerm {-# UNPACK #-} !(Fun f) (TermList f)++singleton :: Term f -> TermList f+singleton t = AppendTerm t Nil++instance Build (TermList f) where+  type BuildFun (TermList f) = f+  builder Nil = mempty+  builder (AppendTerm t us) = builder t `mappend` builder us+  builder (AppendFlatList ts us) = builder ts `mappend` builder us++instance Build (Term f) where+  type BuildFun (Term f) = f+  builder (Flat t) = builder t+  builder (VarTerm x) = Flat.var x+  builder (AppTerm f ts) = Flat.app f (builder ts)++lenList :: TermList f -> Int+lenList t = aux 0 [t]+  where+    aux !_ !_ | False = undefined+    aux n [] = n+    aux n (Nil:ts) = aux n ts+    aux n (AppendFlatList t u:ts) = aux (n+Flat.lenList t) (u:ts)+    aux n (AppendTerm (Flat t) u:ts) = aux (n+Flat.len t) (u:ts)+    aux n (AppendTerm VarTerm{} u:ts) = aux (n+1) (u:ts)+    aux n (AppendTerm (AppTerm f t) u:ts) = aux (n+1) (t:u:ts)++len :: Term f -> Int+len t = lenList (singleton t)++flattenList :: TermList f -> Flat.TermList f+flattenList t = Flat.buildTermList (lenList t) (builder t)++flatten :: Term f -> Flat.Term f+flatten t =+  case Flat.buildTermList (len t) (builder (singleton t)) of+    Flat.Cons u Flat.Nil -> u++toTerm :: TermList f -> Term f+toTerm (AppendFlatList t Nil)+  | Flat.Cons u Flat.Nil <- t = Flat u+toTerm (AppendTerm t Nil) = t+toTerm _ = error "toTerm: not a singleton term"++patHead :: TermList f -> Maybe (Term f, TermList f, TermList f)+patHead Nil = Nothing+patHead (AppendFlatList t ts) =+  let (t, us, vs) = Flat.unsafePatHead (Flat.singleton t) in+  Just (Flat t, AppendFlatList us ts, AppendFlatList vs ts) +patHead (AppendTerm t@VarTerm{} ts) =+  Just (t, ts, ts)+patHead (AppendTerm t@(AppTerm f ts) us) =+  Just (t, us, ts +++ us)++pattern ConsSym :: Term f -> TermList f -> TermList f -> TermList f+pattern ConsSym{hd, tl, rest} <- (patHead -> Just (hd, tl, rest))++pattern Var :: Var -> Term f+pattern Var x <- (patVar -> Just x)+  where+    Var x = VarTerm x++patVar :: Term f -> Maybe Var+patVar (VarTerm x) = Just x+patVar (Flat (Flat.Var x)) = Just x+patVar _ = Nothing++patApp :: Term f -> Maybe (Fun f, TermList f)+patApp (AppTerm f ts) = Just (f, ts)+patApp (Flat (Flat.App f ts)) = Just (f, flatList ts)+patApp _ = Nothing++pattern App :: Fun f -> TermList f -> Term f+pattern App f ts <- (patApp -> Just (f, ts))+  where+    App f ts = AppTerm f ts

− misc/Test.hs

@@ -1,334 +0,0 @@-{-# LANGUAGE TemplateHaskell, FlexibleInstances, FlexibleContexts, UndecidableInstances, StandaloneDeriving, ScopedTypeVariables, TupleSections, DeriveGeneric, DerivingVia, DeriveAnyClass #-}-module Main where--import Twee.Constraints-import Twee.Term hiding (subst, canonicalise, F)-import Twee.Term.Core hiding (F)-import Test.QuickCheck hiding (Function, Fun)-import Test.QuickCheck.All-import Twee.Pretty-import Twee.CP-import Twee.Proof-import qualified Twee.KBO as Ord-import Text.PrettyPrint-import Twee.Base hiding (F)-import Twee.Rule-import Twee.Equation-import Control.Monad-import qualified Data.Map as Map-import Data.Maybe-import Data.Ord-import Data.List hiding (singleton)-import Data.Typeable-import qualified Twee.Index as Index-import Data.Int-import GHC.Generics-import Twee.Utils-import qualified Data.IntMap as M-import qualified Twee.Index as Index--data Func = F Int Integer deriving (Eq, Ord, Show, Labelled)--instance Pretty Func where-  pPrint (F 3 _) = text "a"-  pPrint (F 4 _) = text "b"-  pPrint (F 5 _) = text "zero"-  pPrint (F 6 _) = text "plus"-  pPrint (F 7 _) = text "times"-  pPrint (F f _) = text "f" <#> int f-instance PrettyTerm Func-instance Arbitrary (Subst Func) where-  arbitrary = fmap fromJust (fmap listToSubst (liftM2 zip (fmap nub arbitrary) (infiniteListOf arbitrary)))-instance Arbitrary Func where-  arbitrary = F <$> choose (0, 2) <*> choose (1, 3)-instance Minimal Func where-  minimal = fun (F 0 1)-instance Ord.Sized Func where size (F _ n) = n-instance Ord.Weighted Func where argWeight _ = 1-class Arity f where-  arity :: f -> Int-instance Arity Func where-  arity (F 0 _) = 0-  arity (F 1 _) = 1-  arity (F 2 _) = 2-  arity (F 3 _) = 0 -- a-  arity (F 4 _) = 0 -- b-  arity (F 5 _) = 0 -- zero-  arity (F 6 _) = 2 -- plus-  arity (F 7 _) = 2 -- times-instance EqualsBonus Func--instance Arbitrary Var where arbitrary = fmap V (choose (0, 3))-instance (Labelled f, Ord f, Typeable f, Arbitrary f, Arity f) => Arbitrary (Fun f) where-  arbitrary = fmap fun arbitrary--instance (Labelled f, Ord f, Typeable f, Arbitrary f, Arity f) => Arbitrary (Term f) where-  arbitrary =-    sized $ \n ->-      oneof $-        [ build <$> var <$> arbitrary ] ++-        [ do { f <- arbitrary; build <$> app (fun f) <$> vectorOf (arity f) (resize ((n-1) `div` arity f) arbitrary :: Gen (Term f)) } | n > 0 ]-  shrink (App f ts0) =-    ts ++ (build <$> app f <$> shrinkOne ts)-    where-      ts = unpack ts0-      shrinkOne [] = []-      shrinkOne (x:xs) =-        [ y:xs | y <- shrink x ] ++-        [ x:ys | ys <- shrinkOne xs ]-  shrink _ = []--instance (Labelled f, Ord f, Typeable f, Arbitrary f, Arity f) => Arbitrary (TermList f) where-  arbitrary = buildList <$> listOf (arbitrary :: Gen (Term f))-  shrink = map buildList . shrink . unpack--data Pair f = Pair (Term f) (Term f) deriving Show--instance (Labelled f, Ord f, Typeable f, Arbitrary f, Arity f) => Arbitrary (Pair f) where-  arbitrary = liftM2 Pair arbitrary arbitrary-  shrink (Pair x y) =-    [ Pair x' y  | x' <- shrink x ] ++-    [ Pair x y'  | y' <- shrink y ] ++-    [ Pair x' y' | x' <- shrink x, y' <- shrink y ]--instance (Labelled f, Ord f, Typeable f, Arbitrary f, Arity f) => Arbitrary (Equation f) where-  arbitrary = do-    Pair t u <- arbitrary-    return (t :=: u)-  shrink (t :=: u) = [t' :=: u' | Pair t' u' <- shrink (Pair t u)]--instance Ordered Func where-  lessIn = Ord.lessIn-  lessEq = Ord.lessEq-  lessEqSkolem = Ord.lessEqSkolem--instance Function f => Arbitrary (Model f) where-  arbitrary = fmap (modelFromOrder . map Variable . nub) arbitrary-  shrink = weakenModel--{--prop_1 :: Model Func -> Pair Func -> Subst Func -> Property-prop_1 model (Pair t u) sub =-  counterexample ("Model: " ++ prettyShow model) $-  counterexample ("Subst: " ++ prettyShow sub) $-  conjoin $ do-    let cp = CriticalPair (t :=: u) 0 Nothing (axiom (Axiom 0 "dummy" (t :=: u)))-    r@(Rule _ t' u') <- map orient (map cp_eqn (split cp))-    return $-      counterexample ("LHS:   " ++ prettyShow t') $-      counterexample ("RHS:   " ++ prettyShow u') $-      counterexample ("Rule:  " ++ prettyShow r) $-      counterexample ("Inst:  " ++ prettyShow (Rule Oriented (subst sub t') (subst sub u'))) $-      counterexample ("Res:   " ++ show (lessIn model (subst sub u') (subst sub t'))) $-      not (reducesInModel model r sub) || isJust (lessIn model (subst sub u') (subst sub t'))--}--prop_2 :: Model Func -> Pair Func -> Bool-prop_2 model (Pair t u) =-  not (lessIn model t u == Just Strict && isJust (lessIn model u t))--prop_3 :: Pair Func -> Bool-prop_3 (Pair t u) =-  not (lessThan t u && lessEq u t)--prop_4 :: Pair Func -> Property-prop_4 (Pair t u) =-  t /= u ==> -  not (lessEq t u && lessEq u t)--prop_5 :: Term Func -> Property-prop_5 t =-  lessEq t t .&&. not (lessThan t t)--prop_paths :: Term Func -> Property-prop_paths t =-  forAllShrink (choose (0, len t-1)) shrink $ \n ->-    counterexample (show (positionToPath t n)) $-    pathToPosition t (positionToPath t n) === n--prop_index :: [Term Func] -> Term Func -> Property-prop_index ts u =-  counterexample (show ts') $-  counterexample (show idx) $-  sort (catMaybes [fmap (,t) (match t u) | t <- ts']) ===-  sort (Index.matches u idx)-  where-    idx = foldr (\t -> Index.insert t t) Index.empty ts-    ts' = map canonicalise ts--newtype Terms f = Terms [Term f] deriving Show-instance (Labelled f, Ord f, Typeable f, Arbitrary f, Arity f) => Arbitrary (Terms f) where-  arbitrary = Terms <$> arbitrary-  shrink (Terms ts) =-    map Terms $-      filter (/= ts) $-      shrink ts ++ [canonicalise ts] ++ shrinkList (return . canonicalise) ts--newtype IndexOps f = IndexOps [IndexOp f] deriving Show-data IndexOp f = Add (Term f) | Delete (Term f) deriving Show--instance (Labelled f, Ord f, Typeable f, Arbitrary f, Arity f) => Arbitrary (IndexOps f) where-  arbitrary =-    sized $ \n -> IndexOps <$> take n <$> arbOps []-    where-      arbOps ts =-        frequency $-          [(2, do { t <- arbitrary; ops <- arbOps (t:ts); return (Add t:ops) })] ++-          [(1, do { t <- elements ts; ops <- arbOps (delete t ts); return (Delete t:ops) }) | not (null ts)]-  shrink (IndexOps ops) =-    IndexOps <$> shrinkList shr ops-    where-      shr (Add t) = Add <$> shrink t-      shr (Delete t) = Delete <$> shrink t---prop_index_invariant :: IndexOps Func -> Property-prop_index_invariant (IndexOps ops) =-  flip (foldr (counterexample . show)) idxs $-  property $ Index.invariant (last idxs)-  where-    idxs = scanl (\idx op -> applyIndex op idx) Index.empty ops-    applyIndex (Add t) = Index.insert t t-    applyIndex (Delete t) = Index.delete t t--deriving instance Eq Symbol-deriving instance Generic Symbol--instance Arbitrary Symbol where-  arbitrary =-    Symbol <$>-      arbitrary <*>-      fmap getLarge arbitrary <*>-      (fmap (fromIntegral . getLarge) (arbitrary :: Gen (Large Int32)) `suchThat` (> 0) `suchThat` (< 2^31))-  shrink s =-    filter ok (genericShrink s)-    where-      ok s = Twee.Term.Core.size s > 0--prop_symbol_1 :: Symbol -> Property-prop_symbol_1 s =-  withMaxSuccess 100000 $-  counterexample ("fun/index/size = " ++ show (isFun s, index s, Twee.Term.Core.size s)) $-  counterexample ("n = " ++ show (fromSymbol s)) $-  toSymbol (fromSymbol s) === twiddle s-  where-    twiddle s =-      s { index = fromIntegral (fromIntegral (index s) :: Int32) }--prop_symbol_2 :: Int64 -> Property-prop_symbol_2 n =-  withMaxSuccess 100000 $-  fromSymbol (toSymbol n) === n--prop_canonorder :: Equation Func -> Property-prop_canonorder eqn@(t :=: u) =-  let vs = usort (vars eqn) in-  forAll (shuffle vs) $ \ws swap (NonNegative n) ->-    let-      Just sub = listToSubst (zip vs [build (var (V (w + n))) | V w <- ws])-      eqn' = subst sub (if swap then u :=: t else t :=: u)-    in-      canonicalise (order eqn) === canonicalise (order eqn')--prop_canonorder2 :: Equation Func -> Equation Func -> Bool-prop_canonorder2 eqn1 eqn2 =-  eqn1 `simplerThan` eqn2 || eqn2 `simplerThan` eqn1 || order eqn1 == order eqn2--prop_canonorder3 :: Equation Func -> Property-prop_canonorder3 eq =-  let eq' = order eq in-  counterexample (show eq) $-  Ord.size (eqn_lhs eq') >= Ord.size (eqn_rhs eq')----t :: Term Func---t = build (app (fun (F 0)) [app (fun (F 1)) [var (V 0), var (V 1)], var (V 2)])---- Define 'nest' from Fuchs "The application of goal-oriented heuristics...",--- then refine it to a more efficient version-nestf :: Func -> Term Func -> Int-nestf f _ | arity f == 0 = 0-nestf f t = hnest (fun f) t 0 0-  where-    hnest _ (Var _) c a = max c a-    hnest _ (App _ Empty) c a = max c a-    hnest f (App g ts) c a-      | f == g = maximum [hnest f t (c+1) a | t <- unpack ts]-      | otherwise = maximum [hnest f t 0 (max c a) | t <- unpack ts]---- a simpler version, to illustrate the meaning-nestf1 :: Func -> Term Func -> Int-nestf1 f t = hnest (fun f) t 0-  where-    hnest _ (Var _) c = c-    hnest _ (App _ Empty) c = c-    hnest f (App g ts) c-      | f == g = maximum [hnest f t (c+1) | t <- unpack ts]-      | otherwise = max c (maximum [hnest f t 0 | t <- unpack ts])---- a more efficient version-nestf2 :: Func -> Term Func -> Int-nestf2 f t = hnest (fun f) (singleton t) 0 0-  where-    hnest _ Empty c a = max c a-    hnest f (Cons (Var _) ts) c a = hnest f ts c a-    hnest f (Cons (App _ Empty) ts) c a = hnest f ts c a-    hnest f (Cons (App g ts) us) c a-      | f == g = -        let a' = hnest f ts (c+1) a-        in hnest f us c a'-      | otherwise =-        let a' = hnest f ts 0 a-        in hnest f us c a'---- a version that does all function symbols at once-nestf3 :: Term Func -> M.IntMap Int-nestf3 t = hnest 0 0 M.empty (singleton t)-  where-    hnest f c as Empty = M.insertWith max f c as-    hnest f c as (Cons (Var _) ts) = hnest f c as ts-    hnest f c as (Cons (App _ Empty) ts) = hnest f c as ts-    hnest f c as (Cons (App g ts) us) =-      let as' = hnest (fun_id g) (if f == fun_id g then c+1 else 1) as ts-      in hnest f c as' us--prop_nest_1 :: Func -> Term Func -> Property-prop_nest_1 f t = withMaxSuccess 1000000 $ nestf f t === nestf1 f t--prop_nest_2 :: Func -> Term Func -> Property-prop_nest_2 f t = withMaxSuccess 1000000 $ nestf f t === nestf2 f t--prop_nest_3 :: Func -> Term Func -> Property-prop_nest_3 f t =-  withMaxSuccess 1000000 $-    nestf f t === M.findWithDefault 0 (fun_id (fun f)) (nestf3 t)--prop_nests :: Func -> TermList Func -> Property-prop_nests f ts =-  withMaxSuccess 1000000 $-    maximum (0:map (nestf f) (unpack ts)) ===-    M.findWithDefault 0 (fun_id (fun f)) (nests ts)--return []-main = $forAllProperties (quickCheckWithResult stdArgs { maxSuccess = 1000000 })--a = con (fun (F 3 1))-b = con (fun (F 4 2))-zero = con (fun (F 5 1))-plus t u = app (fun (F 6 1)) [t, u]-times t u = app (fun (F 7 1)) [t, u]-x = var (V 0)-y = var (V 1)--axioms = [-  build (plus x y) ==== plus y x,-  times zero x ==== zero,-  plus x zero ==== x ]-  where-    t ==== u = build t :=: build u--rules = [orient eq (certify (axiom (Axiom 0 "axiom" eq))) | eq <- axioms]--theIndex = Index.fromList [(lhs r, r) | r <- rules]--term = build (plus (times zero a) b)-strat = anywhere1 (basic (rewrite reduces theIndex))

+ misc/WhyDoesThisLoopWithHornElimination.hs view

@@ -0,0 +1,1463 @@+{-# LANGUAGE CPP, RecordWildCards, FlexibleInstances, PatternGuards, DeriveAnyClass, RankNTypes, ApplicativeDo, DeriveGeneric #-}+{-# OPTIONS_GHC -flate-specialise #-}+module SequentialMain(main, Constant(..)) where++import Control.Monad+import Data.Char+import Data.Either+import Twee hiding (message)+import Twee.Base hiding (char, lookup, vars, ground)+--import qualified Twee.Base as Twee+import Twee.Rule(lhs, rhs, unorient)+import Twee.Equation+import qualified Twee.Proof as Proof+import Twee.Proof hiding (Config, defaultConfig)+import qualified Twee.Join as Join+import Twee.Utils+import qualified Twee.CP as CP+import Data.Ord+import Data.Map(Map)+import qualified Data.Map as Map+import qualified Twee.KBO as KBO+#ifdef USE_LPO+import qualified Twee.LPO as LPO+#endif+import Data.List.Split+import Data.List+import Data.Maybe+import Jukebox.Options+import Jukebox.Toolbox+import qualified Jukebox.Name as Jukebox+import Jukebox.Name hiding (lhs, rhs, label)+import qualified Jukebox.Form as Jukebox+import Jukebox.Form hiding ((:=:), Var, Symbolic(..), Term, Axiom, size, Subst, subst)+import Jukebox.Tools.EncodeTypes+import Jukebox.TPTP.Print+import Jukebox.Tools.HornToUnit+import qualified Data.IntMap.Strict as IntMap+import System.IO+import System.Exit+import qualified Data.Set as Set+import qualified Data.Intern as Intern+import System.Console.ANSI+import Data.Symbol+import Twee.Profile+import GHC.Generics+import Data.Hashable+import Data.Binary.Sharing+import qualified Data.ByteString.Lazy as BS+import System.Process+import qualified Jukebox.TPTP.Parse.Core as TPTP+import qualified Jukebox.TPTP.ParseSnippet as Snippet+import Debug.Trace++data MainFlags =+  MainFlags {+    flags_proof :: Bool,+    flags_proof_on_saturation :: Bool,+    flags_trace :: Maybe (String, String),+    flags_formal_proof :: Bool,+    flags_explain_encoding :: Bool,+    flags_flip_ordering :: Bool,+    flags_give_up_on_saturation :: Bool,+    flags_hint_goals :: Bool,+    flags_flatten_goals :: Bool,+    flags_flatten_nonground :: Bool,+    flags_flatten_goals_lightly :: Bool,+    flags_flatten_all :: Bool,+    flags_flatten_regeneralise :: Bool,+    flags_flatten_every :: Int,+    flags_eliminate :: [String],+    flags_backwards_goal :: Int,+    flags_flatten_backwards_goal :: Int,+    flags_equals_transformation :: Bool,+    flags_distributivity_heuristic :: Bool,+    flags_kbo_weight0 :: Bool,+    flags_kbo_weight0_unary :: Bool,+    flags_goal_heuristic :: Bool,+    flags_funweight :: Float,+    flags_dump_proof :: Maybe FilePath,+    flags_dump_state :: Maybe FilePath,+    flags_stitch :: Maybe FilePath }++parseMainFlags :: OptionParser MainFlags+parseMainFlags = do+  let argModule = arg "<module>" "expected a Prolog module name" Just+  flags_proof <-+    inGroup "Output options" $+    bool "proof" ["Produce proofs (on by default)."]+    True+  flags_proof_on_saturation <-+    expert $+    inGroup "Output options" $+    bool "proof-on-saturation" ["Produce proofs of all rewrite rules on saturation (off by default)."]+    False+  flags_trace <-+    expert $+    inGroup "Output options" $+    flag "trace"+      ["Write a Prolog-format execution trace to this file (off by default)."]+      Nothing ((\x y -> Just (x, y)) <$> argFile <*> argModule)+  flags_formal_proof <-+    expert $+    inGroup "Output options" $+    bool "formal-proof" ["Print proof as formal TSTP derivation (requires --tstp; off by default)."] False+  flags_explain_encoding <-+    expert $+    inGroup "Output options" $+    bool "explain-encoding" ["In CASC mode, explain the conditional encoding (off by default)."] False+  flags_flip_ordering <-+    expert $+    inGroup "Term order options" $+    bool "flip-ordering" ["Make more common function symbols smaller (off by default)."] False+  flags_kbo_weight0 <-+    expert $+    inGroup "Term order options" $+    bool "kbo-weight0" ["Give functions of arity >= 2 a weight of 0."] False+  flags_kbo_weight0_unary <-+    expert $+    inGroup "Term order options" $+    bool "kbo-weight0-unary" ["Give one function of arity 1 a weight of 0."] True+  flags_give_up_on_saturation <-+    expert $+    inGroup "Output options" $+    bool "give-up-on-saturation" ["Report SZS status GiveUp rather than Unsatisfiable on saturation (off by default)."] False+  flags_hint_goals <-+    expert $+    inGroup "Completion heuristics" $+    bool "hint-goal" ["Add hints representing goal terms (off by default)."] False+  flags_flatten_goals <-+    expert $+    inGroup "Completion heuristics" $+    bool "flatten-goal" ["Flatten goal by adding new axioms (on by default)."] True+  flags_flatten_nonground <-+    expert $+    inGroup "Completion heuristics" $+    bool "flatten-nonground" ["Flatten even non-ground clauses (off by default)."] False+  flags_flatten_goals_lightly <-+    expert $+    inGroup "Completion heuristics" $+    bool "flatten-goal-lightly" ["Flatten goal non-recursively by adding new axioms (off by default)."] False+  flags_flatten_all <-+    expert $+    inGroup "Completion heuristics" $+    bool "flatten" ["Flatten all clauses by adding new axioms (off by default)."] False+  flags_flatten_every <-+    expert $+    inGroup "Completion heuristics" $+    flag "flatten-every" ["Flatten only every nth subterm (default = 1)."] 1 argNum+  flags_flatten_regeneralise <-+    expert $+    inGroup "Completion heuristics" $+    bool "flatten-regeneralise" ["Regeneralise rules involving flattened goal terms (off by default)."] False+  flags_backwards_goal <-+    expert $+    inGroup "Completion heuristics" $+    flag "backwards-goal" ["Try rewriting backwards from the goal this many times (0 by default)."] 0 argNum+  flags_flatten_backwards_goal <-+    expert $+    inGroup "Completion heuristics" $+    flag "flatten-backwards-goal" ["Try rewriting backwards from the goal this many times when flattening (0 by default)."] 0 argNum+  flags_equals_transformation <-+    expert $+    inGroup "Completion heuristics" $+    bool "equals-transformation" ["Apply the 'equals transformation' even to ground goals (off by default)."] False+  flags_distributivity_heuristic <-+    expert $+    inGroup "Completion heuristics" $+    bool "distributivity-heuristic" ["Treat distributive operators specially (off by default)."] False+  flags_goal_heuristic <-+    expert $+    inGroup "Completion heuristics" $+    bool "goal-heuristic" ["Use the CP weighting heuristic from Anantharaman and Andrianarievelo (off by default)."] False+  flags_eliminate <-+    inGroup "Proof presentation" $+    concat <$>+    manyFlags "eliminate"+      ["Treat these axioms as definitions and eliminate them from the proof.",+       "The axiom must have the shape f(x1...xn) = t, where x1...xn are",+       "distinct variables. The term f must not otherwise appear in the problem!",+       "This is not checked."]+      (splitOn "," <$> arg "<axioms>" "expected a list of axiom names" Just)+  flags_funweight <-+    expert $+    inGroup "Critical pair weighting heuristics" $+    flag "fun-weight" ["Weight given to function symbols"] 1 argNum+  flags_dump_proof <-+    expert $+    inGroup "Debugging options" $+    flag "dump-proof"+      ["Dump a binary proof to this file (off by default)."]+      Nothing (Just <$> argFile)+  flags_dump_state <-+    expert $+    inGroup "Debugging options" $+    flag "dump-state"+      ["Dump prover state to this file on termination (off by default)."]+      Nothing (Just <$> argFile)+  flags_stitch <-+    expert $+    inGroup "Critical pair weighting heuristics" $+    flag "stitch"+      ["Path to 'stitch' tool for discovering abstractions (disabled by default)."]+      Nothing (Just <$> argFile)++  return MainFlags{..}++parseConfig :: OptionParser (Config Constant)+parseConfig = do+  cfg_accept_term <-+    let checkSize n t = KBO.size (t :: Term Constant) <= n in+    inGroup "Resource limits" $+    flag "max-term-size" ["Discard rewrite rules whose left-hand side is bigger than this limit (unlimited by default)."] Nothing (Just <$> checkSize <$> argNum)+  cfg_max_critical_pairs <-+    inGroup "Resource limits" $+    flag "max-cps" ["Give up after considering this many critical pairs (unlimited by default)."] maxBound argNum+  cfg_max_cp_depth <-+    inGroup "Resource limits" $+    flag "max-cp-depth" ["Only consider critical pairs up to this depth (unlimited by default)."] maxBound argNum+  cfg_max_rules <-+    inGroup "Resource limits" $+    flag "max-rules" ["Give up after generating this many rules (unlimited by default)."] maxBound argNum+  cfg_max_time <-+    inGroup "Resource limits" $+    flag "max-time" ["Give up after running for this long in seconds (unlimited by default)."] Nothing (Just <$> argNum)+  cfg_simplify <-+    expert $+    inGroup "Completion heuristics" $+    bool "simplify"+      ["Simplify rewrite rules with respect to one another (on by default)."]+      True+  cfg_renormalise_percent <-+    expert $+    inGroup "Completion heuristics" $+    defaultFlag "normalise-queue-percent" "Percent of time spent renormalising queued critical pairs" cfg_renormalise_percent argNum+  cfg_cp_sample_size <-+    expert $+    inGroup "Completion heuristics" $+    defaultFlag "cp-sample-size" "Size of random CP sample used to trigger renormalisation" cfg_cp_sample_size argNum+  cfg_renormalise_threshold <-+    expert $+    inGroup "Completion heuristics" $+    defaultFlag "cp-renormalise-threshold" "Trigger renormalisation when this percentage of CPs can be simplified" cfg_renormalise_threshold argNum+  cfg_set_join_goals <-+    expert $+    inGroup "Critical pair joining heuristics" $+    bool "set-join-goals"+      ["Compute all normal forms when joining goal terms (on by default)."]+      True+  cfg_always_simplify <-+    expert $+    inGroup "Debugging options" $+    bool "always-simplify"+      ["Interreduce rules after every step."]+      False+  cfg_complete_subsets <-+    expert $+    inGroup "Critical pair joining heuristics" $+    bool "complete-subsets"+      ["Identify and exploit complete subsets of the axioms in joining (off by default)."]+      False+  let cfg_hint_func i x = Intern.intern (Hint i x)++  cfg_join <- do+    cfg_ground_join <-+      expert $+      inGroup "Critical pair joining heuristics" $+      bool "ground-joining"+        ["Test terms for ground joinability (on by default)."]+        True+    cfg_use_connectedness_standalone <-+      expert $+      inGroup "Critical pair joining heuristics" $+      bool "connectedness"+        ["Test terms for subconnectedness, as a separate check (on by default)."]+        True+    cfg_use_connectedness_in_ground_joining <-+      expert $+      inGroup "Critical pair joining heuristics" $+      bool "ground-connectedness"+        ["Test terms for subconnectedness, as part of ground joinability testing (off by default)."]+        False+    cfg_set_join <-+      expert $+      inGroup "Critical pair joining heuristics" $+      bool "set-join"+        ["Compute all normal forms when joining critical pairs (off by default)."]+        False+    cfg_ground_join_limit <-+      inGroup "Critical pair joining heuristics" $+      flag "ground-joining-limit" ["Assume not ground joinable after considering this many orderings (unlimited by default)."] maxBound argNum+    cfg_ground_join_incomplete_limit <-+      inGroup "Critical pair joining heuristics" $+      flag "ground-joining-incomplete-limit" ["Assume ground joinable after considering this many orderings (unlimited by default)."] maxBound argNum+    return Join.Config{..}++  cfg_proof_presentation <- do+    cfg_all_lemmas <-+      inGroup "Proof presentation" $+      bool "all-lemmas"+        ["Produce a proof with one lemma for each critical pair (off by default)."]+        False+    cfg_no_lemmas <-+      inGroup "Proof presentation" $+      bool "no-lemmas"+        ["Produce a proof with no lemmas (off by default).",+         "May lead to exponentially large proofs."]+        False+    cfg_ground_proof <-+      inGroup "Proof presentation" $+      bool "ground-proof"+        ["Produce a ground proof (off by default).",+         "May lead to exponentially large proofs."]+        False+    cfg_show_instances <-+      inGroup "Proof presentation" $+      bool "show-instances"+        ["Show which instance of a lemma or axiom each rewrite step uses (off by default)."]+        False+    cfg_use_colour <-+      let+        colourFlag =+          inGroup "Proof presentation" $+          primFlag "(no-)colour"+            ["Produce output in colour (on by default if writing output to a terminal)."]+            (`elem` map fst colourFlags)+            (\_ y -> return y)+            Nothing+            (pure (`lookup` colourFlags))+        colourFlags = [("--colour", True), ("--no-colour", False),+                       ("--color", True), ("--no-color", False)]+        colourSupported =+          liftM2 (&&) (hSupportsANSIColor stdout)+            (return (setSGRCode [] /= "")) -- Check for Windows terminal not supporting ANSI+      in fromMaybe <$> io colourSupported <*> colourFlag++    cfg_show_uses_of_axioms <-+      let interpret xss ax = axiom_name ax `elem` xss || "all" `elem` xss in+      inGroup "Proof presentation" $+      interpret <$>+      concat <$>+      manyFlags "show-uses-of"+        ["Show which instances of the given axioms were needed (none by default).",+         "Separate multiple axiom names with commas.",+         "Use --show-uses-of all to show uses of all axioms."]+        (splitOn "," <$> arg "<axioms>" "expected a list of axiom names" Just)++    cfg_show_peaks <-+      inGroup "Proof presentation" $+      bool "show-peaks"+        ["Show peak terms in a proof (off by default)."]+        False+    cfg_eliminate_existentials_coding <-+      inGroup "Proof presentation" $+      bool "eliminate-existentials-coding"+        ["Eliminate $equals from proofs (on by default)."]+        True+    cfg_show_subterms <-+      inGroup "Proof presentation" $+      bool "show-subterms"+        ["Show which subterm is rewritten at each step (off by default)."]+        False++    return Proof.Config{..}++  let cfg_eliminate_axioms = [] -- filled in later++  cfg_random_mode <-+    expert $+    inGroup "Completion heuristics" $+    bool "random-mode"+      ["Use random testing to find suitable CPs (doesn't work yet!) (off by default)."]+      False+  cfg_random_mode_goal_directed <-+    expert $+    inGroup "Completion heuristics" $+    bool "random-mode-goal-directed"+      ["Use goal-direction in --random-mode (off by default)."]+      False+  cfg_random_mode_simple <-+    expert $+    inGroup "Completion heuristics" $+    bool "random-mode-simple"+      ["Use simple version of --random-mode (off by default)."]+      False+  cfg_random_mode_best_of <-+    inGroup "Completion heuristics" $+    defaultFlag "random-mode-best-of" "Generate this many critical pairs at a time and pick the best one" cfg_random_mode_best_of argNum+  cfg_always_complete <-+    inGroup "Input and clausifier options" $+    bool "complete"+      ["Don't stop until the rewrite system is confluent"]+      False+  cfg_hint_skel_cost <-+    expert $+    inGroup "Critical pair weighting heuristics" $+    defaultFlag "hint-skel-cost" "Size of hint skeletons" cfg_hint_skel_cost argNum+  cfg_hint_skel_factor <-+    expert $+    inGroup "Critical pair weighting heuristics" $+    defaultFlag "hint-skel-factor" "Size factor of hint skeletons" cfg_hint_skel_factor argNum+  cfg_print_score <-+    expert $+    inGroup "Output options" $+    bool "print-score" ["Print score of each generated rule (off by default)."] False+  cfg_cp_config <- parseCPConfig++  return Config{..}+  where+    defaultFlag :: Show a => String -> String -> (Config Constant -> a) -> ArgParser a -> OptionParser a+    defaultFlag name desc field parser =+      flag name [desc ++ " (" ++ show def ++ " by default)."] def parser+      where+        def = field defaultConfig++parseCPConfig :: OptionParser CP.Config+parseCPConfig = do+  cfg_lhsweight <-+    expert $+    inGroup "Critical pair weighting heuristics" $+    defaultFlag "lhs-weight" "Weight given to LHS of critical pair" CP.cfg_lhsweight argNum+  cfg_rhsweight <-+    expert $+    inGroup "Critical pair weighting heuristics" $+    defaultFlag "rhs-weight" "Weight given to RHS of critical pair" CP.cfg_rhsweight argNum+  cfg_varweight <-+    expert $+    inGroup "Critical pair weighting heuristics" $+    defaultFlag "var-weight" "Weight given to variable symbols" CP.cfg_varweight argNum+  cfg_depthweight <-+    expert $+    inGroup "Critical pair weighting heuristics" $+    defaultFlag "depth-weight" "Weight given to critical pair depth" CP.cfg_depthweight argNum+  cfg_dupcost <-+    expert $+    inGroup "Critical pair weighting heuristics" $+    defaultFlag "dup-cost" "Cost of duplicate subterms" CP.cfg_dupcost argNum+  cfg_dupfactor <-+    expert $+    inGroup "Critical pair weighting heuristics" $+    defaultFlag "dup-factor" "Size factor of duplicate subterms" CP.cfg_dupfactor argNum+  return CP.Config{..}+  where+    defaultFlag name desc field parser =+      flag name [desc ++ " (" ++ show def ++ " by default)."] def parser+      where+        def = field CP.defaultConfig++parsePrecedence :: OptionParser [String]+parsePrecedence =+  expert $+  inGroup "Term order options" $+  fmap (splitOn ",")+  (flag "precedence" ["List of functions in descending order of precedence."] [] (arg "<function>" "expected a function name" Just))++data Constant =+  Minimal |+  Skolem Int |+  Hint Int Float |+  Constant {+    con_prec    :: {-# UNPACK #-} !Precedence,+    con_id      :: {-# UNPACK #-} !Int,+    con_name    :: !String,+    con_arity   :: {-# UNPACK #-} !Int,+    con_label   :: !(Maybe String),+    con_size    :: !Integer,+    con_weight  :: !Integer,+    con_fweight :: {-# UNPACK #-} !Float,+    con_bonus   :: !Bool }+  deriving (Eq, Ord, Generic, Hashable, Binary)++data Precedence = Precedence !Bool !Bool !Bool !(Maybe Int) !Int+  deriving (Eq, Ord, Generic, Hashable, Binary)++instance KBO.Sized Constant where+  size Minimal = 1+  size Skolem{} = 1+  size Hint{} = 1+  size Constant{..} = con_size+instance KBO.ArgWeighted Constant where+  argWeight Minimal = 1+  argWeight Skolem{} = 1+  argWeight Hint{} = 1+  argWeight Constant{..} = con_weight++instance Weighted Constant where+  weight Minimal = 1+  weight (Skolem _) = 1+  weight (Hint _ x) = x+  weight Constant{..} = con_fweight++instance Pretty Constant where+  pPrint Minimal = text "?"+  pPrint (Skolem n) = text ("sk" ++ show n)+  pPrint (Hint n _) = text ("hint" ++ show n)+  pPrint Constant{..} = text (removePostfix con_name)+    where+      removePostfix ('_':x:xs) | con_arity == 1 = x:xs+      removePostfix xs = xs++instance PrettyTerm Constant where+  termStyle Minimal = uncurried+  termStyle Skolem{} = uncurried+  termStyle Hint{} = uncurried+  termStyle Constant{..}+    | con_label == Just "type_tag" = invisible+    | "_" `isPrefixOf` con_name && con_arity == 1 = postfix+    | any isAlphaNum con_name = uncurried+    | otherwise =+      case con_arity of+        1 -> prefix+        2 -> infixStyle 5+        _ -> uncurried++instance Minimal Constant where+  minimal = Sym Minimal+  skolem = Sym . Skolem++#ifdef USE_LPO+instance Ordered Constant where+  lessEq t u = LPO.lessEq t u+  lessIn model t u = LPO.lessIn model t u+  lessEqSkolem t u = LPO.lessEqSkolem t u+#else+instance Ordered Constant where+  lessEq t u = KBO.lessEq t u+  lessIn model t u = KBO.lessIn model t u+  lessEqSkolem t u = KBO.lessEqSkolem t u+#endif++instance EqualsBonus Constant where+  hasEqualsBonus Minimal = False+  hasEqualsBonus Skolem{} = False+  hasEqualsBonus Hint{} = False+  hasEqualsBonus c = con_bonus c++  isEquals Constant{..} = con_label == Just "equals" && con_arity == 2+  isEquals _ = False+  isTrue Constant{..} = con_label == Just "true" && con_arity == 0+  isTrue _ = False+  isFalse Constant{..} = con_label == Just "false" && con_arity == 0+  isFalse _ = False++data TweeContext =+  TweeContext {+    ctx_var     :: Jukebox.Variable,+    ctx_minimal :: Jukebox.Function,+    ctx_true    :: Jukebox.Function,+    ctx_false   :: Jukebox.Function,+    ctx_equals  :: Jukebox.Function,+    ctx_type    :: Type,+    ctx_funs    :: Map Int Jukebox.Function,+    ctx_ids     :: Map Jukebox.Function Int }++-- Convert back and forth between Twee and Jukebox.+tweeConstant :: MainFlags -> HornFlags -> TweeContext -> Precedence -> Jukebox.Function -> Constant+tweeConstant MainFlags{..} flags TweeContext{..} prec fun+  | fun == ctx_minimal = Minimal+  | otherwise =+    Constant {+      con_prec = prec,+      con_id = Map.findWithDefault (error (show (fun, ctx_ids))) fun ctx_ids,+      con_name = base (name fun),+      con_label = Jukebox.label (name fun),+      con_arity = Jukebox.arity fun,+      con_size = if flags_kbo_weight0 && Jukebox.arity fun >= 2 then 0 else if flags_kbo_weight0_unary && isInv then 0 else 1,+      con_weight = 1,+      con_fweight = flags_funweight,+      con_bonus = bonus fun }+  where+    bonus fun =+      (isIfeq fun && encoding flags /= Asymmetric2) ||+      (Jukebox.label (name fun) == Just "equals" && Jukebox.arity fun == 2)+    isInv =+      case prec of+        Precedence _ x _ _ _ -> x++isType :: Jukebox.Function -> Bool+isType fun =+  hasLabel "type_tag" (name fun) && Jukebox.arity fun == 1++isIfeq :: Jukebox.Function -> Bool+isIfeq fun =+  hasLabel "ifeq" (name fun)++jukeboxFunction :: TweeContext -> Constant -> Jukebox.Function+jukeboxFunction TweeContext{..} Constant{..} = Map.findWithDefault undefined con_id ctx_funs+jukeboxFunction TweeContext{..} Minimal = ctx_minimal++tweeTerm :: MainFlags -> HornFlags -> TweeContext -> (Jukebox.Variable -> Int) -> (Jukebox.Function -> Precedence) -> Jukebox.Term -> Term Constant+tweeTerm flags horn ctx varNum prec t = build (tm t)+  where+    tm (Jukebox.Var x) =+      var (V (varNum x))+    tm (f :@: ts) =+      app (Sym (tweeConstant flags horn ctx (prec f) f)) (map tm ts)++jukeboxTerm :: TweeContext -> Term Constant -> Jukebox.Term+jukeboxTerm TweeContext{..} (Var (V x)) =+  Jukebox.Var (Unique (fromIntegral x) (intern "X") Nothing defaultRenamer ::: ctx_type)+jukeboxTerm ctx@TweeContext{..} (App (Sym f) t) =+  jukeboxFunction ctx f :@: map (jukeboxTerm ctx) ts+  where+    ts = unpack t++makeContext :: [Jukebox.Term] -> Problem Clause -> TweeContext+makeContext hints prob = run (hints, prob) $ \(_, prob) -> do+  let+    ty =+      case types' prob of+        []   -> indType+        [ty] -> ty++  var     <- newSymbol "X" ty+  minimal <- newFunction (withLabel "minimal" (name "constant")) [] ty+  true    <- newFunction (withLabel "true" (name "true")) [] ty+  false   <- newFunction (withLabel "false" (name "false")) [] ty+  equals  <- newFunction (withLabel "equals" (name "equals")) [ty, ty] ty++  let allFuns = usort $ [minimal, true, false, equals] ++ Jukebox.functions (hints, prob)++  return TweeContext {+    ctx_var = var,+    ctx_minimal = minimal,+    ctx_true = true,+    ctx_false = false,+    ctx_equals = equals,+    ctx_type = ty,+    ctx_funs = Map.fromList (zip [0..] allFuns),+    ctx_ids = Map.fromList (zip allFuns [0..]) }++flattenGoals :: Int -> Bool -> Bool -> Bool -> Int -> [Jukebox.Term] -> Problem Clause -> Problem Clause+flattenGoals backwardsGoal flattenNonGround flattenAll full depthMod hints prob =+  run (hints, prob) $ \(_, prob) -> do+    let ts = usort $ extraTerms prob+    cs <- mapM define ts+    return (prob ++ cs)+  where+    extraTerms prob = concatMap (input prob) prob+    input prob Input{what = Clause (Bind _ [Neg (x Jukebox.:=: y)])} =+      concatMap term (backwards backwardsGoal prob x) +++      concatMap term (backwards backwardsGoal prob y)+    input _ Input{what = Clause (Bind _ [Pos (x Jukebox.:=: y)])}+      | flattenAll = term x ++ term y+    input _ _ = []++    term t@(_f :@: ts) =+      [ t+      | ground t || flattenNonGround,+        not (all isVar ts) || usort ts /= sort ts ] +++      if full then concatMap term ts else []+    term _ = []++    isVar (Jukebox.Var _) = True+    isVar _ = False++    depthOk t = depthMod == 1 || depth t `mod` depthMod == 0+    depth (_f :@: ts) = 1 + maximum (0:map depth ts)+    depth _ = 1++    define (f :@: ts) = do+      name <- newName f+      let vs  = Jukebox.vars ts+          g = name ::: FunType (map typ vs) (typ f)+          c = clause [Pos (g :@: map Jukebox.Var vs Jukebox.:=: f :@: ts)]+      return Input{ident = Nothing, tag = "flattening", kind = Jukebox.Ax Definition,+                   what = c, source = Unknown }++    backwards 0 _ t = [t]+    backwards n cs t =+      t:+      [ v+      | Input{what = Clause (Bind _ [Pos (x0 Jukebox.:=: y0)])} <- cs,+        (x, y) <- [(x0, y0), (y0, x0)],+        (s, k) <- contexts t,+        sub <- maybeToList (Jukebox.match x s),+        let u = k (Jukebox.subst sub y),+        ground u,+        v <- backwards (n-1) cs u ]++hintGoals :: Problem Clause -> Problem Clause+hintGoals prob =+  prob ++ map define extraTerms+  where+    extraTerms = usort (concatMap input prob)+    input Input{what = Clause (Bind _ [Neg (x Jukebox.:=: y)])} =+      term x ++ term y+    input _ = []++    term t@(_f :@: ts) = t:concatMap term ts+    term _ = []++    define t =+      Input{ident = Nothing, tag = "flattening", kind = Jukebox.Ax Definition, what = c, source = Unknown}+      where+        c = clause [Pos (Tru (hint :@: [t]))]+        hint = name "$hint" ::: FunType [Jukebox.typ t] O++addDistributivityHeuristic :: [Jukebox.Term] -> Problem Clause -> Problem Clause+addDistributivityHeuristic hints prob =+  run (hints, prob) $ \(_, prob) -> do+    cs <- mapM add prob+    return (prob ++ catMaybes cs)++  where+    add Input{what = Clause (Bind _ [Pos (t Jukebox.:=: u)])} =+      case checkDistributivity t u `mplus` checkDistributivity u t of+        Just (f, g, ty) -> do+          name <- newName (base f ++ "_" ++ base g)+          x <- Jukebox.Var <$> newSymbol "X" ty+          y <- Jukebox.Var <$> newSymbol "Y" ty+          z <- Jukebox.Var <$> newSymbol "Z" ty+          Just <$> define name (g :@: [f :@: [x, y], z])+        _ -> return Nothing+    add _ = return Nothing++    checkDistributivity+      (f1 :@: [Jukebox.Var x1, g1 :@: [Jukebox.Var y1, Jukebox.Var z1]])+      (g2 :@: [f2 :@: [Jukebox.Var x2, Jukebox.Var y2],+               f3 :@: [Jukebox.Var x3, Jukebox.Var z2]])+      | f1 == f2 && f2 == f3 && g1 == g2 &&+        x1 == x2 && x2 == x3 && y1 == y2 && z1 == z2 =+        Just (f1, g1, Jukebox.typ x1)+      +    checkDistributivity+      (f1 :@: [g1 :@: [Jukebox.Var x1, Jukebox.Var y1], Jukebox.Var z1])+      (g2 :@: [f2 :@: [Jukebox.Var x2, Jukebox.Var z2],+       f3 :@: [Jukebox.Var y2, Jukebox.Var z3]])+      | f1 == f2 && f2 == f3 && g1 == g2 &&+        x1 == x2 && y1 == y2 && z1 == z2 && z2 == z3 =+        Just (f1, g1, Jukebox.typ x1)+    checkDistributivity _ _ = Nothing++    define name t = do+      let vs  = Jukebox.vars t+          g = name ::: FunType (map typ vs) (typ t)+          c = clause [Pos (g :@: map Jukebox.Var vs Jukebox.:=: t)]+      return Input{ident = Nothing, tag = "distributivity_heuristic", kind = Jukebox.Ax Definition,+                   what = c, source = Unknown }++-- Encode existentials so that all goals are ground.+addNarrowing :: Bool -> TweeContext -> Problem Clause -> Problem Clause+addNarrowing alwaysNarrow TweeContext{..} prob =+  unchanged ++ equalityClauses+  where+    prob' = [inp { ident = Just (variant "addNarrowing" [i :: Int]) } | (i, inp) <- zip [0..] prob]++    (unchanged, nonGroundGoals) = partitionEithers (map f prob')+      where+        f inp@Input{what = Clause (Bind _ [Neg (x Jukebox.:=: y)])}+          | not (ground x) || not (ground y) || alwaysNarrow =+            Right (inp, (x, y))+        f inp = Left inp++    equalityClauses+      | null nonGroundGoals = []+      | otherwise =+        -- Turn a != b & c != d & ...+        -- into eq(a,b)=false & eq(c,d)=false & eq(X,X)=true & true!=false (esa)+        -- and then extract the individual components (thm)+        let+          equalityLiterals =+            -- true != false+            ("true_equals_false", Neg ((ctx_true :@:) [] Jukebox.:=: (ctx_false :@: []))):+            -- eq(X,X)=true+            ("reflexivity", Pos (ctx_equals :@: [Jukebox.Var ctx_var, Jukebox.Var ctx_var] Jukebox.:=: (ctx_true :@: []))):+            -- [eq(a,b)=false, eq(c,d)=false, ...]+            [ (tag, Pos (ctx_equals :@: [x, y] Jukebox.:=: (ctx_false :@: [])))+            | (Input{tag = tag}, (x, y)) <- nonGroundGoals ]++          -- Equisatisfiable to the input clauses+          justification =+            Input {+              ident = Just (name "addNarrowing2"),+              tag  = "new_negated_conjecture",+              kind = Jukebox.Ax NegatedConjecture,+              what =+                let form = And (map (Literal . snd) equalityLiterals) in+                ForAll (Bind (Set.fromList (vars form)) form),+              source =+                inference "encode_existential" "esa"+                  (map (fmap toForm . fst) nonGroundGoals) }++          input tag form i =+            Input {+              ident = Just (variant "addNarrowing3" [i :: Int]),+              tag = tag,+              kind = Jukebox.Ax NegatedConjecture,+              what = clause [form],+              source =+                inference "split_conjunct" "thm" [justification] }++        in [input tag form i | ((tag, form), i) <- zip equalityLiterals [0..]]++data PreEquation =+  PreEquation {+    pre_name :: String,+    pre_form :: Input Form,+    pre_eqn  :: (Jukebox.Term, Jukebox.Term) }++-- Split the problem into axioms and ground goals.+identifyProblem ::+  TweeContext -> Problem Clause -> Either (Input Clause) ([PreEquation], [PreEquation])+identifyProblem TweeContext{..} prob =+  fmap partitionEithers (mapM identify prob)++  where+    pre inp x =+      PreEquation {+        pre_name = tag inp,+        pre_form = fmap toForm inp,+        pre_eqn = x }++    identify inp@Input{what = Clause (Bind _ [Pos (t Jukebox.:=: u)])} =+      return $ Left (pre inp (t, u))+    identify inp@Input{what = Clause (Bind _ [Neg (t Jukebox.:=: u)])}+      | ground t && ground u =+        return $ Right (pre inp (t, u))+    identify inp@Input{what = Clause (Bind _ [])} =+      -- The empty clause can appear after clausification if+      -- the conjecture was trivial+      return $ Left (pre inp (Jukebox.Var ctx_var, ctx_minimal :@: []))+    identify inp = Left inp++runTwee :: GlobalFlags -> TSTPFlags -> HornFlags -> [String] -> Config Constant -> MainFlags -> (IO () -> IO ()) -> [Jukebox.Term] -> Problem Clause -> IO Answer+runTwee globals (TSTPFlags tstp) horn precedence config0 flags@MainFlags{..} later hints obligs = {-# SCC runTwee #-} do+  let+    -- Encode whatever needs encoding in the problem+    obligs1+      | flags_flatten_goals_lightly = flattenGoals flags_flatten_backwards_goal flags_flatten_nonground False False flags_flatten_every hints obligs+      | flags_flatten_all = flattenGoals flags_flatten_backwards_goal flags_flatten_nonground True True flags_flatten_every hints obligs+      | flags_flatten_goals = flattenGoals flags_flatten_backwards_goal flags_flatten_nonground False True flags_flatten_every hints obligs+      | otherwise = obligs+    obligs2+      | flags_distributivity_heuristic = addDistributivityHeuristic hints obligs1+      | otherwise = obligs1+    lowercaseSkolem x+      | hasLabel "skolem" x =+        withRenamer x $ \s i ->+          case defaultRenamer s i of+            Renaming xss xs ->+              Renaming (map (map toLower) xss) (map toLower xs)+      | otherwise = x+    (hints', prettyObligs) = prettyNames (mapName lowercaseSkolem (hints, obligs2))+    ctx = makeContext hints' prettyObligs+    prob = addNarrowing flags_equals_transformation ctx prettyObligs++  (unsortedAxioms0, goals0) <-+    case identifyProblem ctx prob of+      Left inp -> do+        mapM_ (hPutStrLn stderr) [+          "The problem contains the following clause, which is not a unit equality:",+          indent (show (pPrintClauses [inp])),+          "Twee only handles unit equality problems."]+        exitWith (ExitFailure 1)+      Right x -> return x++  let+    -- Work out a precedence for function symbols+    prec c =+      Precedence+        (isType c)+#ifdef USE_LPO+        ((hasLabel "equals" c && Jukebox.arity c == 2) || isIfeq c)+#else+        (Just c == maxUnary)+#endif+        (isJust (elemIndex (base c) precedence))+        (fmap negate (elemIndex (base c) precedence))+        (maybeNegate (Map.findWithDefault 0 c funOccs))+    maybeNegate = if flags_flip_ordering then negate else id+    funOccs = funsOcc prob+#ifndef USE_LPO+    maxUnary =+      case filter (\(f, _) -> arity f == 1 && not (isType f)) (Map.toList funOccs) of+        [] -> Nothing+        xs -> Just (fst (maximumBy (comparing snd) xs))+#endif++    -- Translate everything to Twee.+    toTerm var t = tweeTerm flags horn ctx var prec t+    toTerm' t = toTerm (varNums t) t+    varNums :: Jukebox.Symbolic a => a -> Jukebox.Variable -> Int+    varNums t = \x -> Map.findWithDefault undefined x ids+      where+        xs = usort (vars t)+        ids = Map.fromList (zip xs [0..])+    toEquation (t, u) =+      canonicalise (toTerm var t :=: toTerm var u)+      where+        var = varNums (t, u)++    axiomCompare ax1 ax2+      | isEquality ax1' && not (isEquality ax2') = GT+      | isEquality ax2' && not (isEquality ax1') = LT+      | ax1' `simplerThan` ax2' = LT+      | ax2' `simplerThan` ax1' = GT+      | otherwise = EQ+      where+        ax1' = toEquation (pre_eqn ax1)+        ax2' = toEquation (pre_eqn ax2)+        isEquality ax = isJust (decodeEquality (eqn_lhs ax)) || isJust (decodeEquality (eqn_rhs ax))+    axioms0 = sortBy axiomCompare unsortedAxioms0++    goals =+      [ goal n pre_name (toEquation pre_eqn)+      | (n, PreEquation{..}) <- zip [1..] goals0 ]+    axioms =+      [ Axiom n pre_name (toEquation pre_eqn)+      | (n, PreEquation{..}) <- zip [1..] axioms0 ]+    defs =+      [ axiom+      | (axiom, PreEquation{..}) <- zip axioms axioms0,+        isDefinition pre_form ]+    isDefinition Input{source = Unknown} = True+    isDefinition inp = tag inp `elem` flags_eliminate++  -- Compute CP scoring heuristic+  let+    {-+    goalNests = nests (map goal_eqn goals)+    goalOccs = occs (map goal_eqn goals)+    score depth hints eqn+      | flags_goal_heuristic =+        scoreCP cpConfig depth hints eqn *+        product+          [ pos (IntMap.findWithDefault 0 f eqnNests - IntMap.findWithDefault 0 f goalNests) *+            pos (IntMap.findWithDefault 0 f eqnOccs - IntMap.findWithDefault 0 f goalOccs)+          | f <- IntMap.keys eqnNests ] -- skip constants+      | otherwise = +        scoreCP cpConfig depth hints eqn+      where+        eqnNests = nests eqn+        eqnOccs = occs eqn++        pos :: Int -> Float+        pos n = if n <= 0 then 1 else fromIntegral n+1+    -}+    config = config0 { cfg_eliminate_axioms = if flags_flatten_regeneralise then defs else [] }++  let+    withHints = foldl' (addHint config) (initialState config) [toTerm (varNums h) h | h <- hints']+    withGoals = foldl' (addGoal config) withHints goals+    withAxioms = foldl' (addAxiom config) withGoals axioms+    withBackwardsGoal = foldn rewriteGoalsBackwards withAxioms flags_backwards_goal++  -- Set up tracing.+  sayTrace <-+    case flags_trace of+      Nothing -> return $ \_ -> return ()+      Just (file, mod) -> do+        h <- openFile file WriteMode+        hSetBuffering h LineBuffering+        let put msg = hPutStrLn h msg+        put $ ":- module(" ++ mod ++ ", [step/1, lemma/1, axiom/1, goal/1])."+        put ":- discontiguous(step/1)."+        put ":- discontiguous(lemma/1)."+        put ":- discontiguous(axiom/1)."+        put ":- discontiguous(goal/1)."+        put ":- style_check(-singleton)."+        return $ \msg -> hPutStrLn h msg+  +  let+    say msg = unless (quiet globals) (putStrLn msg)+    line = say ""+    output = Output {+      output_message = \msg -> do+        say (prettyShow msg)+        sayTrace (show (traceMsg msg)) }++    traceMsg (NewActive _ active) =+      step "add" [traceActive active]+    traceMsg (NewEquation eqn) =+      step "hard" [traceEqn eqn]+    traceMsg (DeleteActive active) =+      step "delete" [traceActive active]+    traceMsg SimplifyQueue =+      step "simplify_queue" []+    traceMsg Interreduce =+      step "interreduce" []+    traceMsg (Status n) =+      step "status" [pPrint n]++    traceActive Active{active_top = Nothing, ..} =+      traceApp "rule" [pPrint active_id, traceEqn (unorient active_rule)]+    traceActive Active{active_top = Just top, ..} =+      traceApp "rule" [pPrint active_id, traceEqn (unorient active_rule), traceEqn lemma1, traceEqn lemma2]+      where+        (lemma1, lemma2) =+          find (steps (derivation active_proof))+        find (s1:s2:_)+          | eqn_rhs (equation (certify s1)) == top && eqn_lhs (equation (certify s2)) == top =+            (lemmaOf s1, lemmaOf s2)+        find (_:xs) = find xs+        lemmaOf s =+          case (usedLemmas s, usedAxioms s) of+            ([p], []) -> equation p+            ([], [ax]) -> axiom_eqn ax++    traceEqn (t :=: u) =+      pPrintPrec prettyNormal 6 t <+> text "=" <+> pPrintPrec prettyNormal 6 u+    traceApp f xs =+      pPrintTerm uncurried prettyNormal 0 (text f) xs++    step :: String -> [Doc] -> Doc+    step f xs = traceApp "step" [traceApp f xs] <#> text "."++  say "Here is the input problem:"+  forM_ axioms $ \Axiom{..} ->+    say $ show $ nest 2 $+      describeEquation "Axiom"+        (show axiom_number) (Just axiom_name) axiom_eqn+  forM_ goals $ \Goal{..} ->+    say $ show $ nest 2 $+      describeEquation "Goal"+        (show goal_number) (Just goal_name) goal_eqn+  line++  state <-+    case flags_stitch of+      Nothing -> do+        complete output config withBackwardsGoal+      Just stitch -> do+        let+          (timeout, final_timeout) =+            case cfg_max_time config of+              Just time -> (time / 5, Just (time * 4 / 5))+              Nothing -> (30, Nothing)+        intermediate <- complete output config{cfg_max_time = Just timeout} withBackwardsGoal+        let+          score rule =+            (KBO.size (lhs rule), lhs rule,+             KBO.size (rhs rule), rhs rule)+          actives =+            sortBy (comparing (score . active_rule)) $+            IntMap.elems (st_active_set intermediate)+          pres = present (cfg_proof_presentation config){cfg_all_lemmas = True} (map active_proof actives) []+          proofStr = show (pPrintPresentation (cfg_proof_presentation config){cfg_use_colour = False} pres)+        line+        say "Running Stitch..."+        hintsStrs <- lines <$> readProcess stitch [] proofStr+        let parseTerm str = toTerm' (Snippet.giveProblem prob (Snippet.form (TPTP.term TPTP.NoQuantification Map.empty)) str)+        let hints = map parseTerm hintsStrs+        mapM_ (say . show . pPrint) hints+        let config' = config{cfg_max_time = final_timeout}+        complete output config' $+          interreduce config' $+          simplifyQueue config' $+          foldl' (addHint config') intermediate hints++  line++  case flags_dump_state of+    Nothing -> return ()+    Just dumpStateFile ->+      BS.writeFile dumpStateFile (encode state)++  when (solved state && flags_proof) $ later $ do+    let+      cfg_present+        | tstp && flags_formal_proof =+          (cfg_proof_presentation config){cfg_all_lemmas = True}+        | otherwise =+          cfg_proof_presentation config+      pres = present cfg_present [] $ map (eliminateDefinitionsFromGoal defs) $ solutions state++    case flags_dump_proof of+      Nothing -> return ()+      Just dumpProofFile ->+        BS.writeFile dumpProofFile (encode pres)++    sayTrace ""+    forM_ (pres_axioms pres) $ \p ->+      sayTrace $ show $+        traceApp "axiom" [traceEqn (axiom_eqn p)] <#> text "."+    forM_ (pres_lemmas pres) $ \p ->+      sayTrace $ show $+        traceApp "lemma" [traceEqn (equation p)] <#> text "."+    forM_ (pres_goals pres) $ \p ->+      sayTrace $ show $+        traceApp "goal" [traceEqn (pg_goal_hint p)] <#> text "."++    when (tstp && not flags_formal_proof) $ do+      putStrLn "% SZS output start Proof"+      let+        axiomForms =+          Map.fromList+            (zip (map axiom_number axioms) (map pre_form axioms0))+        goalForms =+          Map.fromList+            (zip (map goal_number goals) (map pre_form goals0))++        findSource forms n =+          case Map.lookup n forms of+            Nothing -> []+            Just inp -> go inp+           where+            go Input{source = Unknown} = []+            go Input{source = Inference _ _ _ inps} = concatMap (go . inputValue) inps+            go inp@Input{source = FromFile _ _} = [inp]++      when flags_explain_encoding $ do+        putStrLn "Take the following subset of the input axioms:"+        mapM_ putStrLn $ map ("  " ++) $ lines $ showProblem $+          usortBy (comparing show) $+            (pres_axioms pres >>= findSource axiomForms . axiom_number) +++            (pres_goals pres >>= findSource goalForms . pg_number)++        putStrLn ""+        putStrLn "Now clausify the problem and encode Horn clauses using encoding 3 of"+        putStrLn "http://www.cse.chalmers.se/~nicsma/papers/horn.pdf."+        putStrLn "We repeatedly replace C & s=t => u=v by the two clauses:"+        putStrLn "  fresh(y, y, x1...xn) = u"+        putStrLn "  C => fresh(s, t, x1...xn) = v"+        putStrLn "where fresh is a fresh function symbol and x1..xn are the free"+        putStrLn "variables of u and v."+        putStrLn "A predicate p(X) is encoded as p(X)=true (this is sound, because the"+        putStrLn "input problem has no model of domain size 1)."+        putStrLn ""+        putStrLn "The encoding turns the above axioms into the following unit equations and goals:"+        putStrLn ""+      print $ pPrintPresentation (cfg_proof_presentation config) pres+      putStrLn "% SZS output end Proof"+      putStrLn ""+  +    when (tstp && flags_formal_proof) $ do+      putStrLn "% SZS output start CNFRefutation"+      print $ pPrintProof $+        presentToJukebox ctx toTerm' (curry toEquation)+          (zip (map axiom_number axioms) (map pre_form axioms0))+          (zip (map goal_number goals) (map pre_form goals0))+          pres+      putStrLn "% SZS output end CNFRefutation"+      putStrLn ""++    unless tstp $ do+      putStrLn "The conjecture is true! Here is a proof."+      putStrLn ""+      print $ pPrintPresentation (cfg_proof_presentation config) pres+      putStrLn ""++  when (not (quiet globals) && not (solved state)) $ later $ do+    let+      state' = interreduce config state+      score rule =+        (KBO.size (lhs rule), lhs rule,+         KBO.size (rhs rule), rhs rule)+      actives =+        sortBy (comparing (score . active_rule)) $+        IntMap.elems (st_active_set state')++    when (tstp && configIsComplete config) $ do+      putStrLn "% SZS output start Saturation"+      print $ pPrintProof $+        map pre_form axioms0 +++        map pre_form goals0 +++        [ Input Nothing "rule" (Jukebox.Ax Jukebox.Axiom) Unknown $+            toForm $ clause+              [Pos (jukeboxTerm ctx (lhs rule) Jukebox.:=: jukeboxTerm ctx (rhs rule))]+        | rule <- rules state ]+      putStrLn "% SZS output end Saturation"+      putStrLn ""++    if configIsComplete config then do+      putStrLn "Ran out of critical pairs. This means the conjecture is not true."+    else do+      putStrLn "Gave up on reaching the given resource limit."+    putStrLn "Here is the final rewrite system:"+    forM_ actives $ \active ->+      putStrLn ("  " ++ prettyShow (canonicalise (active_rule active)))+    putStrLn ""+    +    when flags_proof_on_saturation $ do+      let pres = present (cfg_proof_presentation config) (map active_proof actives) []+      print $ pPrintPresentation (cfg_proof_presentation config) pres++  return $+    if solved state then Unsat Unsatisfiable Nothing+    else if configIsComplete config && not (dropNonHorn horn) && not flags_give_up_on_saturation then Sat Satisfiable Nothing+    else NoAnswer GaveUp++data HornClause = HornClause [Equation Constant] (Equation Constant) deriving Eq+instance Pretty HornClause where+  pPrint (HornClause lhs rhs) = pPrint lhs <#> text "=>" <#> pPrint rhs+data ClauseProof = ClauseProof (Maybe Name) HornClause InputSource+instance Pretty ClauseProof where+  pPrint (ClauseProof _ cl _) = pPrint cl+type ConjunctiveProof = [ClauseProof] -- first proof is "main" clause++jukeboxClause :: TweeContext -> [Equation Constant] -> Equation Constant -> Form+jukeboxClause ctx lhs rhs =+  toForm $ clause $ map (Neg . eqn) lhs ++ [Pos (eqn rhs)]+  where+    eqn (t :=: u) = jukeboxTerm ctx t Jukebox.:=: jukeboxTerm ctx u++toInput :: TweeContext -> ClauseProof -> Input Form+toInput ctx (ClauseProof ident (HornClause lhs rhs) pf) =+  Input {+    ident = ident,+    tag = "step",+    kind = Jukebox.Ax Jukebox.Axiom,+    what = jukeboxClause ctx lhs rhs,+    source = pf }++toInput' :: TweeContext -> ConjunctiveProof -> Input Form+toInput' ctx pf =+  Input {+    ident = Nothing,+    tag = "conjunction",+    kind = Jukebox.Ax Jukebox.Axiom,+    what = And (map what inps),+    source = inference "conjunction" "thm" inps }+  where+    inps = map (toInput ctx) pf++findProof :: TweeContext -> ConjunctiveProof -> HornClause -> Maybe InputSource+findProof ctx pf c =+  trace ("finding " ++ prettyShow c) $+  trace ("in " ++ prettyShow pf) $+  listToMaybe $+    [inf | ClauseProof _ c' inf <- pf, c == c'] +++    [inference "rewriting" "thm" (map (toInput ctx) [p1, p2]) | p1@(ClauseProof _ c1 _) <- pf, p2@(ClauseProof _ c2 _) <- pf, rewrites c1 c2 c]+  where+    rewrites (HornClause lhs (t :=: u)) (HornClause [] (u' :=: v)) (HornClause lhs' (t' :=: v'))+      | lhs == lhs' && t == t' && u == u' && v == v' = True+    rewrites _ _ _ = False++clauseSets :: Equation Constant -> [(Equation Constant, [HornClause])]+clauseSets (t :=: u) = do+  (t', cs1) <- splits t+  (u', cs2) <- splits u+  return (t' :=: u', cs1 ++ cs2)+  where+    splits t@Var{} = [(t, [])]+    splits (App (Sym Constant{con_label = Just "ifeq"}) ts) =+      let [t, u, v, w] = unpack ts in+        [(v, [HornClause [] (t :=: u)]), (w, [HornClause [t :=: u] (v :=: w)])]+    splits (App f ts) =+      [ (build (app f (map fst ss)), concatMap snd ss) | ss <- mapM splits (unpack ts) ]++-- TODO don't go back and forth between Twee terms and Jukebox terms the whole time+axiomProof :: (Jukebox.Term -> Term Constant) -> (Jukebox.Term -> Jukebox.Term -> Equation Constant) -> Input Form -> ConjunctiveProof+axiomProof toTerm toEquation Input{source = Inference _ "clausify" _ [c]} =+  axiomProof toTerm toEquation (inputValue c)+axiomProof toTerm toEquation Input{source = Inference _ "type_encoding" _ [c]} =+  axiomProof toTerm toEquation (inputValue c)+axiomProof toTerm toEquation inp@Input{source = Inference _ "ifeq_elim" _ _} =+  case toClause (what inp) of+    Just (Clause (Bind _ [Pos (lhs Jukebox.:=: rhs)])) ->+      trace ("eliminator: " ++ show (lhs, rhs)) $+      trace (prettyShow (toEquation lhs rhs)) $+      let App (Sym Constant{con_label = Just "ifeq"}) ts :=: y'@Var{} = toEquation lhs rhs+          [x@Var{}, x'@Var{}, y@Var{}, z@Var{}] | trace (prettyShow (x, x', y, z)) $ x == x' && y == y' = unpack ts+      in [reflexivity y, reflexivity x]+axiomProof toTerm toEquation inp@Input{source = Inference _ "ifeq_intro" _ [c]} =+  case toClause (what inp) of+    Just (Clause (Bind _ [Pos (lhs Jukebox.:=: rhs)]))+      | App (Sym Constant{con_label = Just "ifeq"}) ts :=: w' <- traceShow (lhs, rhs) $ toEquation lhs rhs ->+        let [t, u, v, w] | w == w' = unpack ts+        in [reflexivity w, ClauseProof Nothing (HornClause [t :=: u] (v :=: w)) (source (inputValue c))]+    _ -> axiomProof toTerm toEquation (inputValue c)+axiomProof _ toEquation inp =+  case toClause (what inp) of+    Just (Clause (Bind _ [Pos (t Jukebox.:=: u)])) ->+      [ClauseProof (ident inp) (HornClause [] (toEquation t u)) (source inp)]++reflexivity :: Term Constant -> ClauseProof+reflexivity t =+  ClauseProof Nothing (HornClause [] (t :=: t)) (inference "reflexivity" "thm" [])++congruence :: Sym Constant -> [Term Constant] -> [Term Constant] -> ConjunctiveProof -> ConjunctiveProof+congruence f ts us (ClauseProof _ (HornClause lhs (t :=: u)) inf:pfs) =+  ClauseProof Nothing (HornClause lhs (cong t :=: cong u)) inf:pfs+  where+    cong t = build (app f (ts ++ [t] ++ us))++symmetry :: ConjunctiveProof -> ConjunctiveProof+symmetry (ClauseProof _ (HornClause lhs (t :=: u)) inf:pfs) =+  ClauseProof Nothing (HornClause lhs (u :=: t)) inf:pfs++-- TODO we are erasing idents everywhere, maybe labelProof shsould instead convert each one to an Input Form and wrap it in a ClauseProof+substitute :: Subst Constant -> ConjunctiveProof -> ConjunctiveProof+substitute sub pfs = [ClauseProof Nothing (HornClause (subst sub lhs) (subst sub rhs)) inf | ClauseProof _ (HornClause lhs rhs) inf <- pfs]++labelProof :: Name -> ConjunctiveProof -> ConjunctiveProof+labelProof ident pf = [ClauseProof (Just (variant ident [i])) c inf | (i, ClauseProof _ c inf) <- zip [0 :: Int ..] pf]++-- Transform a proof presentation into a Jukebox proof.+presentToJukebox ::+  TweeContext ->+  (Jukebox.Term -> Term Constant) ->+  (Jukebox.Term -> Jukebox.Term -> Equation Constant) ->+  -- Axioms, indexed by axiom number.+  [(Int, Input Form)] ->+  -- N.B. the formula here proves the negated goal.+  [(Int, Input Form)] ->+  Presentation Constant ->+  Problem Form+presentToJukebox ctx toTerm toEquation axioms goals Presentation{..} =+  [ Input {+      ident = Nothing,+      tag = pg_name,+      kind = Jukebox.Ax Jukebox.Axiom,+      what = false,+      source =+        inference "resolution" "thm"+          [-- A proof of t != u+           existentialHack pg_goal_hint (fromJust (lookup pg_number goals)),+           -- A proof of t = u+           toInput ctx (the (fromJust (Map.lookup pg_number goal_proofs)))] }+  | ProvedGoal{..} <- pres_goals ]++  where+    axiom_proofs =+      Map.fromList+        [ (axiom_number, labelProof (ident axiom_number) (axiomProof toTerm toEquation $! traceShowId (fromJust (lookup axiom_number axioms))))+        | Axiom{..} <- pres_axioms ]+      where+        ident i = variant "axiom" [i]++    lemma_proofs =+      Map.fromList [(p, labelProof (ident i) (tstp p)) | (i, p) <- zip [0..] pres_lemmas]+      where+        ident i = variant "lemma" [i :: Int]++    goal_proofs =+      Map.fromList [(pg_number, tstp pg_proof) | ProvedGoal{..} <- pres_goals]++    the [x] = x++    tstp :: Proof Constant -> ConjunctiveProof+    tstp p = snd (foldl1 combine (map step' (steps (derivation p))))++    combine :: (Equation Constant, ConjunctiveProof) -> (Equation Constant, ConjunctiveProof) -> (Equation Constant, ConjunctiveProof)+    combine (lhs1 :=: rhs1, p1) (lhs2 :=: rhs2, p2) =+      -- TODO try all possible values of clauseSets (lhs1 :=: rhs2), see if we can match up+      -- main one should either be rewriting wrt main one,+      -- or clash resolvable by resolution+      case [pf | (eqn, cs) <- clauseSets (lhs1 :=: rhs2), pf <- maybeToList (mapM find (HornClause [] eqn:cs))] of+        (pf:_) ->+          case pf of+            ClauseProof _ (HornClause [] eqn) _:_ | eqn == (lhs1 :=: rhs2) -> (lhs1 :=: rhs2, pf)+            _ -> error ("failed proof from:\n" ++ prettyShow (lhs1 :=: rhs1, p1) ++ "\nand\n" ++ prettyShow (lhs2 :=: rhs2, p2) ++ "\nto get\n" ++ prettyShow pf)+        _ -> error ("can't combine:\n" ++ prettyShow (lhs1 :=: rhs1, p1) ++ "\nand\n" ++ prettyShow (lhs2 :=: rhs2, p2) ++ "\nwith\n" ++ prettyShow (clauseSets (lhs1 :=: rhs2)))+      where+        find c = ClauseProof Nothing c <$> findProof ctx (p1 ++ p2) c++    step' p =+      case pf of+        ClauseProof _ (HornClause [] eqn') _:_ | eqn' `elem` map fst (clauseSets eqn) -> (eqn, pf)+        _ -> error ("failed step:\n" ++ prettyShow (eqn, p) ++ "\nresulting in:\n" ++ prettyShow pf)+      where+        eqn = equation (certify p)+        pf = step p++    step :: Derivation Constant -> ConjunctiveProof+    step (Symm p) = symmetry (step p)+    step (Cong f ps) =+      case span isRefl ps of+        (qs, r:rs) | all isRefl rs ->+          congruence f (map unRefl qs) (map unRefl rs) (step r)+      where+        isRefl Refl{} = True+        isRefl _ = False+        unRefl (Refl t) = t+    step (UseAxiom Axiom{..} sub) =+      substitute sub (fromJust (Map.lookup axiom_number axiom_proofs))+    step (UseLemma lemma sub) =+      substitute sub (fromJust (Map.lookup lemma lemma_proofs))+{-+    deriv :: Derivation Constant -> Input Form+    deriv p =+      Input {+        ident = Nothing,+        tag = "step",+        kind = Jukebox.Ax Jukebox.Axiom,+        what = jukeboxEquation (equation (certify p)),+        source =+          inference name "thm" sources }+      where+        (name, sources) = unpack p++    unpack :: Derivation Constant -> (String, [Input Form])+    unpack (Refl _) = ("reflexivity", [])+    unpack (Symm p) = ("symmetry", [deriv p])+    unpack (Trans p q) = ("transitivity", [deriv p, deriv q])+    unpack (Cong _ ps) = ("congruence", [deriv p | p <- ps, let t :=: u = equation (certify p), t /= u])+    unpack (UseAxiom Axiom{..} _) =+      ("substitution", [toInput' ctx (fromJust (Map.lookup axiom_number axiom_proofs))])+    unpack (UseLemma lemma _) =+      ("substitution", [fromJust (Map.lookup lemma lemma_proofs)])++    jukeboxEquation :: Equation Constant -> Form+    jukeboxEquation (t :=: u) =+      toForm $ clause [Pos (jukeboxTerm ctx t Jukebox.:=: jukeboxTerm ctx u)]+-}+    -- An ugly hack: since Twee.Proof decodes $true = $false into a+    -- proof of the existentially quantified goal, we need to do the+    -- same decoding at the Jukebox level.+    existentialHack eqn input =+      case find input of+        [] -> error $ "bug in TSTP output: can't fix up decoded existential"+        (inp:_) -> inp+        where+          -- Check if this looks like the correct clause;+          -- if not, try its ancestors.+          find inp | ok inp = [inp]+          find Input{source = Inference _ _ _ inps} =+            concatMap (find . inputValue) inps+          find _ = []++          ok inp =+            case toClause (what inp) of+              Nothing -> False+              Just (Clause (Bind _ [Neg (t' Jukebox.:=: u')])) ->+                let+                  eqn' = toEquation t' u'+                  ts = buildList [eqn_lhs eqn, eqn_rhs eqn]+                  us = buildList [eqn_lhs eqn', eqn_rhs eqn']+                in+                  isJust (matchList ts us) && isJust (matchList us ts)++main = do+  hSetBuffering stdout LineBuffering+  stampM (intern "twee") . join . parseCommandLineWithExtraArgs+    ["--no-conjunctive-conjectures", "--no-split"]+#ifdef VERSION_twee+    "Twee, the wonderful equation engine" . version ("twee version " ++ VERSION_twee) $+#else+    "Twee, the wonderful equation engine" . version "twee development version" $+#endif+      globalFlags *> parseMainFlags *>+      -- hack: get --quiet and --no-proof options to appear before --tstp+      forAllFilesBox <*>+        (readProblemBox =>>=+         expert clausifyBox =>>=+         forAllConjecturesBox <*>+           (combine <$>+             expert hornToUnitBox <*>+             parseConfig <*>+             parseMainFlags <*>+             (toFormulasBox =>>=+              expert (toFof <$> clausifyBox <*> pure (tags True)) =>>=+              expert clausifyBox =>>= expert oneConjectureBox) <*>+             (runTwee <$> globalFlags <*> tstpFlags <*> expert hornFlags <*> parsePrecedence)))+  profile+  where+    getHint Input{what = Clause (Bind _ [Pos (Tru (hint :@: [t]))])}+      | base (name hint) == "$hint" = Left t+    getHint c = Right c+    combine horn config main encode prove later prob0 = do+      let prob1 = if flags_hint_goals main then hintGoals prob0 else prob0+      let (hints, nonHints) = partitionEithers (map getHint prob1)+      res <- horn nonHints+      case res of+        Left ans -> return ans+        Right prob -> do+          let+            isUnitEquality [Pos (_ Jukebox.:=: _)] = True+            isUnitEquality [Neg (_ Jukebox.:=: _)] = True+            isUnitEquality _ = False+            isUnit = all isUnitEquality (map (toLiterals . what) prob1)+            main' = if isUnit then main{flags_explain_encoding = False} else main -- {flags_formal_proof = False}+          encode prob >>= prove config main' later hints

− misc/static-libstdc++

@@ -1,24 +0,0 @@-#!/bin/zsh-typeset -a args--process() {-    for arg in $*; do-        case $arg in-            \"*\")-                process $(echo $arg | cut -c2- | rev | cut -c2- | rev)-                ;;-            @*)-                process $(cat $(echo $arg | cut -c2-))-                ;;-            -lstdc++ | -fuse-ld=gold)-                ;;-            *)-                args+=$arg-                ;;-        esac-    done-}--process $*--exec g++ -static-libgcc -static-libstdc++ $args

+ test/Common.hs view

@@ -0,0 +1,124 @@+-- Common code used by the rest of the tests.++{-# LANGUAGE FlexibleInstances, ScopedTypeVariables, DeriveGeneric, DeriveAnyClass #-}+module Common where++import Data.Intern+import Twee.Base+import Twee.Constraints+import Twee.Equation+import Twee.Utils+import qualified Twee.KBO as KBO+import Control.Monad+import Data.Hashable+import Data.List+import Data.Maybe+import Data.Typeable+import GHC.Generics+import Test.QuickCheck hiding (Function)+import Text.Printf+import Data.Binary.Sharing++data Func = Min | Skolem Int | F Int Integer deriving (Eq, Ord, Generic, Hashable, Binary)++instance Show Func where+  show Min = "m"+  show (Skolem n) = printf "sk%d" n+  show (F x y) = printf "f%d_%d" x y++instance Pretty Func where+  pPrint Min = text "m"+  pPrint (Skolem m) = text "sk" <#> int m+  pPrint (F 3 _) = text "a"+  pPrint (F 4 _) = text "b"+  pPrint (F 5 _) = text "zero"+  pPrint (F 6 _) = text "plus"+  pPrint (F 7 _) = text "times"+  pPrint (F f _) = text "f" <#> int f+instance PrettyTerm Func+instance Arbitrary (Subst Func) where+  arbitrary = fmap fromJust (fmap listToSubst (liftM2 zip (fmap nub arbitrary) (infiniteListOf arbitrary)))+instance Arbitrary Func where+  arbitrary =+    frequency+      [(10, F <$> choose (0, 2) <*> choose (1, 3)),+       (2, Skolem <$> choose (0, 2)),+       (1, return Min)]+instance Minimal Func where+  minimal = intern Min+  skolem n = intern (Skolem n)+instance KBO.Sized Func where+  size (F _ n) = n+  size _ = 1+instance Weighted Func where+  weight (F _ n) = fromIntegral n+  weight _ = 1+instance KBO.ArgWeighted Func where argWeight _ = 1+class Arity f where+  arity :: f -> Int+instance Arity Func where+  arity (F 0 _) = 0+  arity (F 1 _) = 1+  arity (F 2 _) = 2+  arity (F 3 _) = 0 -- a+  arity (F 4 _) = 0 -- b+  arity (F 5 _) = 0 -- zero+  arity (F 6 _) = 2 -- plus+  arity (F 7 _) = 2 -- times+  arity _ = 0+instance EqualsBonus Func++instance Arbitrary Var where arbitrary = fmap V (choose (0, 3))+instance (Hashable f, Eq f, Typeable f, Arbitrary f, Arity f) => Arbitrary (Sym f) where+  arbitrary = fmap intern arbitrary++instance (Hashable f, Eq f, Typeable f, Arbitrary f, Arity f) => Arbitrary (Term f) where+  arbitrary =+    sized $ \n ->+      oneof $+        [ build <$> var <$> arbitrary ] +++        [ do { f <- arbitrary; build <$> app (Sym f) <$> vectorOf (arity f) (resize ((n-1) `div` arity f) arbitrary :: Gen (Term f)) } | n > 0 ]+  shrink (App f ts0) =+    ts ++ (build <$> app f <$> shrinkOne ts)+    where+      ts = unpack ts0+      shrinkOne [] = []+      shrinkOne (x:xs) =+        [ y:xs | y <- shrink x ] +++        [ x:ys | ys <- shrinkOne xs ]+  shrink _ = []++instance (Hashable f, Eq f, Typeable f, Arbitrary f, Arity f) => Arbitrary (TermList f) where+  arbitrary = buildList <$> listOf (arbitrary :: Gen (Term f))+  shrink = map buildList . shrink . unpack++data Pair f = Pair (Term f) (Term f) deriving Show++instance (Hashable f, Eq f, Typeable f, Arbitrary f, Arity f) => Arbitrary (Pair f) where+  arbitrary = liftM2 Pair arbitrary arbitrary+  shrink (Pair x y) =+    [ Pair x' y  | x' <- shrink x ] +++    [ Pair x y'  | y' <- shrink y ] +++    [ Pair x' y' | x' <- shrink x, y' <- shrink y ]++instance (Hashable f, Eq f, Typeable f, Arbitrary f, Arity f) => Arbitrary (Equation f) where+  arbitrary = do+    Pair t u <- arbitrary+    return (t :=: u)+  shrink (t :=: u) = [t' :=: u' | Pair t' u' <- shrink (Pair t u)]++instance Ordered Func where+  lessIn = KBO.lessIn+  lessEq = KBO.lessEq+  lessEqSkolem = KBO.lessEqSkolem++instance Function f => Arbitrary (Model f) where+  arbitrary = fmap (modelFromOrder . map Variable . nub) arbitrary+  shrink = weakenModel++genSubst :: [Var] -> Gen (Subst Func)+genSubst xs = do+  let xs' = usort xs+  ts <- sequence [arbitrary | _ <- xs']+  let Just sub = listToSubst (zip xs' ts)+  return sub

+ test/Index.hs view

@@ -0,0 +1,73 @@+-- Tests for the term index.++{-# LANGUAGE TupleSections #-}+module Index(tests) where++import Common+import Twee.Base+import Twee.Index(Index)+import qualified Twee.Index as Index+import Data.Hashable+import Data.List+import Data.Maybe+import Data.Typeable+import Test.Tasty+import Test.Tasty.QuickCheck+import Data.Binary.Sharing++newtype IndexOps f = IndexOps [IndexOp f] deriving Show+data IndexOp f = Add (Term f) | Delete (Term f) deriving Show++instance (Hashable f, Eq f, Typeable f, Arbitrary f, Arity f) => Arbitrary (IndexOps f) where+  arbitrary =+    sized $ \n -> IndexOps <$> take n <$> arbOps []+    where+      arbOps ts =+        frequency $+          [(2, do { t <- arbitrary; ops <- arbOps (t:ts); return (Add t:ops) })] +++          [(1, do { t <- elements ts; ops <- arbOps (delete t ts); return (Delete t:ops) }) | not (null ts)]+  shrink (IndexOps ops) =+    IndexOps <$> shrinkList shr ops+    where+      shr (Add t) = Add <$> shrink t+      shr (Delete t) = Delete <$> shrink t++prop_index_insert :: [Term Func] -> Term Func -> Property+prop_index_insert ts u =+  counterexample (show ts') $+  counterexample (show idx) $+  sort (catMaybes [fmap (,t) (match t u) | t <- ts']) ===+  sort (Index.matches u idx)+  where+    idx = foldr (\t -> Index.insert t t) Index.empty ts+    ts' = map canonicalise ts++prop_index_invariant :: IndexOps Func -> Property+prop_index_invariant (IndexOps ops) =+  flip (foldr (counterexample . show)) idxs $+  property $ Index.invariant (last idxs)+  where+    idxs = scanl (\idx op -> applyIndex op idx) Index.empty ops+    applyIndex (Add t) = Index.insert t t+    applyIndex (Delete t) = Index.delete t t++prop_index_serialise :: [Term Func] -> Property+prop_index_serialise ts =+  counterexample (show idx) $+  counterexample (show serial) $+  counterexample (show idx') $+  Index.elems idx === Index.elems idx' .&&.+  serial === encode idx'+  where+    idx, idx' :: Index Func (Term Func)+    idx = foldr (\t -> Index.insert t t) Index.empty ts+    serial = encode idx+    idx' = decode serial++tests :: TestTree+tests =+  localOption (QuickCheckTests 100000) $+  testGroup "Term indexing"+    [testProperty "Invariant holds" prop_index_invariant,+     testProperty "Inserted terms are found" prop_index_insert,+     testProperty "Serialisation round trip" prop_index_serialise]

+ test/Main.hs view

@@ -0,0 +1,21 @@+module Main where++import qualified Index+import qualified Nest+import qualified Ordering+import qualified Serial+import qualified TermOrder+import qualified Terms+import Test.Tasty++tests :: TestTree+tests =+  testGroup "Twee tests"+    [Terms.tests,+    TermOrder.tests,+    Ordering.tests,+    Index.tests,+    Nest.tests,+    Serial.tests]++main = defaultMain tests

+ test/Nest.hs view

@@ -0,0 +1,82 @@+-- Tests for the 'nests' function.++module Nest(tests) where++import Common+import Data.Intern+import Twee.Base+import Test.Tasty+import Test.Tasty.QuickCheck+import qualified Data.IntMap as M++-- Define 'nest' from Fuchs "The application of goal-oriented heuristics...",+-- then refine it to a more efficient version+nestf :: Func -> Term Func -> Int+nestf f _ | arity f == 0 = 0+nestf f t = hnest (Sym f) t 0 0+  where+    hnest _ (Var _) c a = max c a+    hnest _ (App _ Nil) c a = max c a+    hnest f (App g ts) c a+      | f == g = maximum [hnest f t (c+1) a | t <- unpack ts]+      | otherwise = maximum [hnest f t 0 (max c a) | t <- unpack ts]++-- a simpler version, to illustrate the meaning+nestf1 :: Func -> Term Func -> Int+nestf1 f t = hnest (Sym f) t 0+  where+    hnest _ (Var _) c = c+    hnest _ (App _ Nil) c = c+    hnest f (App g ts) c+      | f == g = maximum [hnest f t (c+1) | t <- unpack ts]+      | otherwise = max c (maximum [hnest f t 0 | t <- unpack ts])++-- a more efficient version+nestf2 :: Func -> Term Func -> Int+nestf2 f t = hnest (Sym f) (singleton t) 0 0+  where+    hnest _ Nil c a = max c a+    hnest f (Cons (Var _) ts) c a = hnest f ts c a+    hnest f (Cons (App _ Nil) ts) c a = hnest f ts c a+    hnest f (Cons (App g ts) us) c a+      | f == g =+        let a' = hnest f ts (c+1) a+        in hnest f us c a'+      | otherwise =+        let a' = hnest f ts 0 a+        in hnest f us c a'++-- a version that does all function symbols at once+nestf3 :: Term Func -> M.IntMap Int+nestf3 t = hnest 0 0 M.empty (singleton t)+  where+    hnest f c as Nil = M.insertWith max f c as+    hnest f c as (Cons (Var _) ts) = hnest f c as ts+    hnest f c as (Cons (App _ Nil) ts) = hnest f c as ts+    hnest f c as (Cons (App g ts) us) =+      let as' = hnest (symId g) (if f == symId g then c+1 else 1) as ts+      in hnest f c as' us++prop_nest_1 :: Func -> Term Func -> Property+prop_nest_1 f t = nestf f t === nestf1 f t++prop_nest_2 :: Func -> Term Func -> Property+prop_nest_2 f t = nestf f t === nestf2 f t++prop_nest_3 :: Func -> Term Func -> Property+prop_nest_3 f t =+  nestf f t === M.findWithDefault 0 (symId (Sym f)) (nestf3 t)++prop_nests :: Func -> TermList Func -> Property+prop_nests f ts =+  maximum (0:map (nestf f) (unpack ts)) ===+  M.findWithDefault 0 (symId (Sym f)) (nests ts)++tests :: TestTree+tests =+  localOption (QuickCheckTests 100000) $+  testGroup "Nest function" [+    testProperty "nestf1 is correct" prop_nest_1,+    testProperty "nestf2 is correct" prop_nest_2,+    testProperty "nestf3 is correct" prop_nest_3,+    testProperty "nests is correct" prop_nests]

+ test/Ordering.hs view

@@ -0,0 +1,85 @@+-- Tests for equation and rule ordering.++module Ordering(tests) where++import Common+import Test.QuickCheck hiding (Function, Fun)+import Twee.Base+import Twee.Constraints+import Twee.Equation+import Twee.Utils+import Twee.Rule+import Twee.CP+import Twee.Proof+import qualified Twee.KBO as KBO+import Data.Maybe+import Test.Tasty+import Test.Tasty.QuickCheck++-- TODO: this only checks for the default order (KBO)+-- But very similar things are covered in TermOrder.hs.+prop_reducesWith_correct :: Model Func -> Pair Func -> Subst Func -> Property+prop_reducesWith_correct model (Pair t u) sub =+  counterexample ("Model: " ++ prettyShow model) $+  counterexample ("Subst: " ++ prettyShow sub) $+  conjoin $ do+    let cp = CriticalPair (t :=: u) Nothing (axiom (Axiom 0 "dummy" Nothing (t :=: u)))+    r@Rule{lhs = t', rhs = u'} <- map (flip orient (certify (cp_proof cp))) (map cp_eqn (split cp))+    return $+      counterexample ("LHS:   " ++ prettyShow t') $+      counterexample ("RHS:   " ++ prettyShow u') $+      counterexample ("Rule:  " ++ prettyShow r) $+      counterexample ("Inst:  " ++ prettyShow (subst sub r)) $+      counterexample ("Res:   " ++ show (lessIn model (subst sub u') (subst sub t'))) $+      not (reducesInModel model r sub) || isJust (lessIn model (subst sub u') (subst sub t'))++prop_simplerThan_irreflexive :: Equation Func -> Bool+prop_simplerThan_irreflexive eq =+  not (eq `simplerThan` eq)++prop_simplerThan_antisymmetric :: Equation Func -> Equation Func -> Property+prop_simplerThan_antisymmetric eq1 eq2 =+  eq1 `simplerThan` eq2 ==> not (eq2 `simplerThan` eq1)++prop_order_simplerThan :: Equation Func -> Equation Func -> Bool+prop_order_simplerThan eq1 eq2 =+  eq1 `simplerThan` eq2 || eq2 `simplerThan` eq1 || order eq1 == order eq2++prop_order_swap :: Equation Func -> Property+prop_order_swap (t :=: u) =+  order (t :=: u) === order (u :=: t)++prop_order_rearrange :: Equation Func -> Property+prop_order_rearrange eq@(t :=: u) =+  let vs = usort (vars eq) in+  forAll (shuffle vs) $ \ws swap (NonNegative n) ->+    let+      Just sub = listToSubst (zip vs [build (var (V (w + n))) | V w <- ws])+      eq' = subst sub (if swap then u :=: t else t :=: u)+    in+      canonicalise (order eq) === canonicalise (order eq')++prop_order_size :: Equation Func -> Property+prop_order_size eq =+  let eq' = order eq in+  counterexample (show eq) $+  KBO.size (eqn_lhs eq') >= KBO.size (eqn_rhs eq')++prop_order_erase :: Equation Func -> Property+prop_order_erase eq =+  let eq' = order eq in+  counterexample (show eq) $+  eqn_rhs (ground eq') `lessEqSkolem` eqn_lhs (ground eq')++tests :: TestTree+tests =+  localOption (QuickCheckTests 100000) $+  testGroup "Equation ordering" [+    testProperty "reducesWith respects KBO" prop_reducesWith_correct,+    testProperty "simplerThan irreflexive" prop_simplerThan_irreflexive,+    testProperty "simplerThan antisymmetric" prop_simplerThan_antisymmetric,+    testProperty "order/simplerThan trichotomogy" prop_order_simplerThan,+    testProperty "order invariant under swap" prop_order_swap,+    testProperty "order invariant under rearrangement" prop_order_rearrange,+    testProperty "order respects size" prop_order_size,+    testProperty "order respects term order of erased terms" prop_order_erase ]

+ test/Serial.hs view

@@ -0,0 +1,56 @@+-- Tests for serialisation.++{-# LANGUAGE DeriveGeneric, DeriveAnyClass, StandaloneDeriving #-}+module Serial(tests) where++import Test.Tasty+import Test.Tasty.QuickCheck+import Data.Binary.Sharing+import Data.Intern+import GHC.Generics+import Data.Hashable+import qualified Data.ByteString.Lazy as BS+import Data.Int++data Tree = Leaf Int8 | Node Tree Tree | SharedNode (Shared Tree) | SymNode (Sym Tree)+  deriving (Eq, Show, Generic, Binary)+instance Hashable Tree where+  hashWithSalt s (Leaf x) = hashWithSalt s (0 :: Int, x)  +  hashWithSalt s (Node t u) = hashWithSalt s (1 :: Int, t, u)+  hashWithSalt s (SharedNode (Shared t)) = hashWithSalt s (2 :: Int, t)+  hashWithSalt s (SymNode (Sym t)) = hashWithSalt s (2 :: Int, t)++instance Arbitrary Tree where+  arbitrary = sized arb+    where+      arb n =+        frequency [+          (1, Leaf <$> arbitrary),+          (n, Node <$> arb (n `div` 2) <*> arb (n `div` 2)),+          (n, SharedNode . Shared <$> arb (n-1)),+          (n, SymNode . Sym <$> arb (n-1)) ]++  shrink (Leaf n) = Leaf <$> shrink n+  shrink (Node t u) =+    [t, u] +++    [Node t' u' | (t', u') <- shrink (t, u)]+  shrink (SharedNode (Shared t)) =+    [t] ++ map (SharedNode . Shared) (shrink t)+  shrink (SymNode (Sym t)) =+    [t] ++ map (SymNode . Sym) (shrink t)++{-# NOINLINE prop_tree_serialise #-}+prop_tree_serialise :: Tree -> Property+prop_tree_serialise t =+  counterexample (show (BS.unpack serial)) $+  counterexample (show t') $+  t === t'+  where+    serial = encode t+    t' = decode serial++tests :: TestTree+tests =+  localOption (QuickCheckTests 10000) $+  testGroup "Serialisation" [+     testProperty "Tree serialisation round trip" prop_tree_serialise]

+ test/TermOrder.hs view

@@ -0,0 +1,167 @@+-- Tests for KBO and LPO.++{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE RecordWildCards #-}+{-# LANGUAGE TypeFamilies #-}+module TermOrder(tests) where++import Common+import Twee.Base+import Twee.Constraints hiding (funs)+import Twee.Utils+import qualified Twee.KBO as KBO+import qualified Twee.LPO as LPO+import Data.Function+import Data.List+import Data.Maybe+import Test.Tasty+import Test.Tasty.QuickCheck hiding (Function, subterms)++data TermOrder f =+  TermOrder {+    to_lessEq :: Term f -> Term f -> Bool,+    to_lessIn :: Model f -> Term f -> Term f -> Maybe Strictness,+    to_lessEqSkolem :: Term f -> Term f -> Bool }++kbo :: (Function f, KBO.Sized f, KBO.ArgWeighted f) => TermOrder f+kbo =+   TermOrder {+     to_lessEq = KBO.lessEq,+     to_lessIn = KBO.lessIn,+     to_lessEqSkolem = KBO.lessEqSkolem }++lpo :: Function f => TermOrder f+lpo =+   TermOrder {+     to_lessEq = LPO.lessEq,+     to_lessIn = LPO.lessIn,+     to_lessEqSkolem = LPO.lessEqSkolem }++type OrderGen = forall prop. Testable prop => ((Term Func -> Term Func -> Bool) -> prop) -> Property++prop_subterm_reduces :: OrderGen -> Term Func -> Property+prop_subterm_reduces withLessEq t =+  withLessEq $ \lessEq ->+    conjoin [lessEq u t | u <- subterms t]++prop_erase_reduces :: OrderGen -> Term Func -> [Var] -> Property+prop_erase_reduces withLessEq t xs =+  withLessEq $ \lessEq ->+    erase xs t `lessEq` t++prop_antisymmetric :: OrderGen -> Pair Func -> Property+prop_antisymmetric withLessEq (Pair t u) =+  t /= u ==>+  withLessEq $ \lessEq ->+    not (lessEq t u && lessEq u t)++prop_reflexive :: OrderGen -> Term Func -> Property+prop_reflexive withLessEq t =+  withLessEq $ \lessEq ->+    lessEq t t++prop_total :: OrderGen -> Pair Func -> Property+prop_total withLessEq (Pair t u) =+  withLessEq $ \lessEq ->+    lessEq (ground t) (ground u) || lessEq (ground u) (ground t)++prop_skolem_correct :: TermOrder Func -> Pair Func -> Property+prop_skolem_correct TermOrder{..} (Pair t u) =+  skolemFree t && skolemFree u ==>+  to_lessEqSkolem t u === to_lessEq (skolemise t) (skolemise u)+  where+    skolemFree t = all (not . isSkolem) (funs t)+    isSkolem (Sym (Skolem _)) = True+    isSkolem _ = False++prop_lessIn_trivial :: TermOrder Func -> Pair Func -> Property+prop_lessIn_trivial TermOrder{..} (Pair t u) =+  to_lessIn (modelFromOrder []) t u === lessEq' t u+  where+    lessEq' t u+      | to_lessEq t u = Just (if isJust (unify t u) then Nonstrict else Strict)+      | otherwise = Nothing++prop_lessIn_antisymmetric :: TermOrder Func -> Model Func -> Pair Func -> Bool+prop_lessIn_antisymmetric TermOrder{..} model (Pair t u) =+  not (to_lessIn model t u == Just Strict && isJust (to_lessIn model u t))++prop_lessIn_nonstrict :: TermOrder Func -> Model Func -> Pair Func -> Property+prop_lessIn_nonstrict TermOrder{..} model (Pair t u) =+  to_lessIn model t u == Just Nonstrict ==>+  isJust (unify t u)++prop_lessIn_permutation :: TermOrder Func -> Term Func -> Property+prop_lessIn_permutation TermOrder{..} t =+  let vs = nub (vars t) in+  forAll (shuffle vs) $ \ws ->+    let Just sub = listToSubst [(v, build (var w)) | (v, w) <- zip vs ws]+        u = subst sub t+        model = modelFromOrder (map Variable vs)+        weaken m = [m' | m' <- weakenModel m, and [varInModel m' v | v <- vs]]+        allModels = fixpoint (usort . concatMap weaken) [model] in+    conjoin [counterexample (prettyShow m) (isJust (to_lessIn m t u)) | m <- allModels]++prop_lessIn_instance :: TermOrder Func -> Pair Func -> Property+prop_lessIn_instance TermOrder{..} (Pair t u) =+  not (to_lessEq t u) && not (to_lessEq u t) ==>+  let vs = usort (vars t ++ vars u) in+  forAll (ground <$> genSubst vs) $ \sub ->+    case (to_lessEq (subst sub t) (subst sub u), to_lessEq (subst sub u) (subst sub t)) of+      (False, False) ->+        error "partial on ground terms"+      (True, True) ->+        counterexample "Equal terms" $+        subst sub t === subst sub u+      (True, False) ->+        counterexample "t < u" $+        property $ isNothing (to_lessIn (modelFromSubst sub) u t)+      (False, True) ->+        counterexample "t > u" $+        property $ isNothing (to_lessIn (modelFromSubst sub) t u)+  where+    modelFromSubst =+      modelFromOrder' . map (map (Variable . fst)) . groupBy ((==) `on` snd) . sortBy ord . substToList+    ord (_, t) (_, u) =+      case (to_lessEq t u, to_lessEq u t) of+        (False, False) -> error "partial on ground terms"+        (False, True)  -> GT+        (True,  False) -> LT+        (True,  True)  -> if t == u then EQ else error "not antisymmetric"++prop_lpo_basic :: Pair Func -> Property+prop_lpo_basic (Pair t u) =+  minimal `notElem` funs t ==>+  LPO.lessEq t u === LPO.lessEqBasic t u++lessEqTests :: OrderGen -> [TestTree]+lessEqTests withLessEq = [+  testProperty "Order respects subterms" (prop_subterm_reduces withLessEq),+  testProperty "Order respects erasure" (prop_erase_reduces withLessEq),+  testProperty "Order is antisymmetric" (prop_antisymmetric withLessEq),+  testProperty "Order is reflexive" (prop_reflexive withLessEq),+  testProperty "Order is total on ground terms" (prop_total withLessEq)]++orderTests :: TermOrder Func -> [TestTree]+orderTests order@TermOrder{..} = [+  testGroup "Basic order" (lessEqTests (\p -> property (p to_lessEq))),+  testGroup "Skolemised order" $+    lessEqTests (\p -> property (p to_lessEqSkolem)) +++    [testProperty "Order agrees with basic order" (prop_skolem_correct order)],+  testGroup "Model-based order" $+    lessEqTests (\p ->+      property $ \model -> p (\t u -> isJust (to_lessIn model t u))) +++    [testProperty "Order is correct with empty model" (prop_lessIn_trivial order),+     testProperty "Order is correct with permutations" (prop_lessIn_permutation order),+     testProperty "Order only gives non-strict when necessary" (prop_lessIn_nonstrict order),+     testProperty "Order is strongly antisymmetric" (prop_lessIn_antisymmetric order),+     testProperty "Order is sound" (prop_lessIn_instance order)]]++tests :: TestTree+tests =+  localOption (QuickCheckTests 100000) $+  testGroup "Term ordering"+    [testGroup "KBO" (orderTests kbo),+     testGroup "LPO" $+       [testProperty "Basic order agrees with simple implementation" prop_lpo_basic] +++       orderTests lpo]

+ test/Terms.hs view

@@ -0,0 +1,45 @@+-- Tests for basic term functionality.++{-# LANGUAGE StandaloneDeriving, DeriveGeneric #-}+module Terms(tests) where++import Common+import Twee.Base+import Twee.Term.Core+import Data.Int+import GHC.Generics+import Test.Tasty+import Test.Tasty.QuickCheck++deriving instance Eq Symbol+deriving instance Generic Symbol++instance Arbitrary Symbol where+  arbitrary =+    Symbol <$>+      arbitrary <*>+      fmap getLarge arbitrary <*>+      (fmap (fromIntegral . getLarge) (arbitrary :: Gen (Large Int32)) `suchThat` (> 0) `suchThat` (< 2^31))+  shrink s =+    filter ok (genericShrink s)+    where+      ok s = Twee.Term.Core.size s > 0++prop_paths :: Term Func -> Property+prop_paths t =+  forAllShrink (choose (0, len t-1)) shrink $ \n ->+    counterexample (show (positionToPath t n)) $+    pathToPosition t (positionToPath t n) === n+  -- implies x = positionToPath t n ==> positionToPath t (pathToPosition t x) == x++prop_symbol :: Int64 -> Property+prop_symbol n =+  fromSymbol (toSymbol n) === n+  -- implies x = toSymbol n ==> toSymbol (fromSymbol x) == x++tests :: TestTree+tests =+  localOption (QuickCheckTests 100000) $+  testGroup "Terms" [+    testProperty "Paths to positions round trip" prop_paths,+    testProperty "Symbols to Int64 round trip" prop_symbol]

− tests/BOO067-1.p

@@ -1,32 +0,0 @@-%---------------------------------------------------------------------------% File     : BOO067-1 : TPTP v6.3.0. Released v2.6.0.-% Domain   : Boolean Algebra (Ternary)-% Problem  : Ternary Boolean Algebra Single axiom is complete, part 1-% Version  : [MP96] (equality) axioms.-% English  :--% Refs     : [McC98] McCune (1998), Email to G. Sutcliffe-%          : [MP96]  McCune & Padmanabhan (1996), Automated Deduction in Eq-% Source   : [TPTP]-% Names    :--% Status   : Unsatisfiable-% Rating   : 0.42 v6.3.0, 0.35 v6.2.0, 0.29 v6.1.0, 0.31 v6.0.0, 0.48 v5.5.0, 0.47 v5.4.0, 0.33 v5.3.0, 0.25 v5.2.0, 0.29 v5.1.0, 0.33 v5.0.0, 0.29 v4.1.0, 0.18 v4.0.1, 0.36 v4.0.0, 0.38 v3.7.0, 0.11 v3.4.0, 0.12 v3.3.0, 0.21 v3.1.0, 0.33 v2.7.0, 0.27 v2.6.0-% Syntax   : Number of clauses     :    2 (   0 non-Horn;   2 unit;   1 RR)-%            Number of atoms       :    2 (   2 equality)-%            Maximal clause size   :    1 (   1 average)-%            Number of predicates  :    1 (   0 propositional; 2-2 arity)-%            Number of functors    :    7 (   5 constant; 0-3 arity)-%            Number of variables   :    7 (   0 singleton)-%            Maximal term depth    :    5 (   3 average)-% SPC      : CNF_UNS_RFO_PEQ_UEQ--% Comments : A UEQ part of BOO035-1-%---------------------------------------------------------------------------cnf(single_axiom,axiom,-    ( multiply(multiply(A,inverse(A),B),inverse(multiply(multiply(C,D,E),F,multiply(C,D,G))),multiply(D,multiply(G,F,E),C)) = B )).--cnf(prove_tba_axioms_1,negated_conjecture,-    (  multiply(multiply(d,e,a),b,multiply(d,e,c)) != multiply(d,e,multiply(a,b,c)) )).--%--------------------------------------------------------------------------

− tests/GRP196-1.p

@@ -1,40 +0,0 @@-%---------------------------------------------------------------------------% File     : GRP196-1 : TPTP v7.4.0. Released v2.2.0.-% Domain   : Group Theory (Semigroups)-% Problem  : In semigroups, xyyy=yyyx -> (uy)^9 = u^9v^9.-% Version  : [MP96] (equality) axioms.-% English  :--% Refs     : [McC98] McCune (1998), Email to G. Sutcliffe-%          : [MP96]  McCune & Padmanabhan (1996), Automated Deduction in Eq-%          : [McC95] McCune (1995), Four Challenge Problems in Equational L-% Source   : [McC98]-% Names    : CS-3 [MP96]-%          : Problem B [McC95]--% Status   : Unsatisfiable-% Rating   : 0.88 v7.4.0, 0.91 v7.3.0, 0.89 v7.0.0, 0.95 v6.4.0, 1.00 v4.0.1, 0.93 v4.0.0, 0.92 v3.7.0, 0.89 v3.4.0, 1.00 v3.3.0, 0.93 v3.1.0, 1.00 v2.2.1-% Syntax   : Number of clauses     :    3 (   0 non-Horn;   3 unit;   1 RR)-%            Number of atoms       :    3 (   3 equality)-%            Maximal clause size   :    1 (   1 average)-%            Number of predicates  :    1 (   0 propositional; 2-2 arity)-%            Number of functors    :    3 (   2 constant; 0-2 arity)-%            Number of variables   :    5 (   0 singleton)-%            Maximal term depth    :   18 (   8 average)-% SPC      : CNF_UNS_RFO_PEQ_UEQ--% Comments : The problem was originally posed for cancellative semigroups,-%            Otter does this with a nonstandard representation [MP96].-%---------------------------------------------------------------------------%----Include semigroups axioms-include('Axioms/GRP008-0.ax').-%---------------------------------------------------------------------------%----Hypothesis:-cnf(condition,hypothesis,-    ( '*'(X,'*'(Y,'*'(Y,Y))) = '*'(Y,'*'(Y,'*'(Y,X))) )).--%----Denial of conclusion:-cnf(prove_this,negated_conjecture,-    (  '*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,b))))))))))))))))) != '*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(b,'*'(b,'*'(b,'*'(b,'*'(b,'*'(b,'*'(b,'*'(b,b))))))))))))))))) )).--%--------------------------------------------------------------------------

− tests/GRP666-4.p

@@ -1,63 +0,0 @@-%-------------------------------------------------------------------------------% File     : GRP666-4 : TPTP v7.2.0. Released v4.0.0.-% Domain   : Group Theory (Quasigroups)-% Problem  : Inverse property A-loops are Moufang-% Version  : Especial.-% English  :--% Refs     : [KKP02] Kinyon et al. (2002), Every Diassociative A-loop is M-%          : [PS08]  Phillips & Stanovsky (2008), Automated Theorem Proving-%          : [Sta08] Stanovsky (2008), Email to G. Sutcliffe-% Source   : [Sta08]-% Names    : KKP02a [PS08]--% Status   : Unsatisfiable-% Rating   : 0.84 v7.1.0, 0.83 v7.0.0, 0.89 v6.3.0, 0.82 v6.2.0, 0.71 v6.1.0, 0.81 v5.5.0, 0.84 v5.4.0, 0.87 v5.3.0, 0.75 v5.2.0, 0.86 v5.1.0, 0.87 v5.0.0, 0.86 v4.1.0, 0.82 v4.0.1, 0.86 v4.0.0-% Syntax   : Number of clauses     :   12 (   0 non-Horn;  12 unit;   1 RR)-%            Number of atoms       :   12 (  12 equality)-%            Maximal clause size   :    1 (   1 average)-%            Number of predicates  :    1 (   0 propositional; 2-2 arity)-%            Number of functors    :    8 (   4 constant; 0-2 arity)-%            Number of variables   :   25 (   0 singleton)-%            Maximal term depth    :    5 (   3 average)-% SPC      : CNF_UNS_RFO_PEQ_UEQ--% Comments :-%-------------------------------------------------------------------------------cnf(c01,axiom,-    ( mult(A,ld(A,B)) = B )).--cnf(c02,axiom,-    ( ld(A,mult(A,B)) = B )).--cnf(c03,axiom,-    ( mult(rd(A,B),B) = A )).--cnf(c04,axiom,-    ( rd(mult(A,B),B) = A )).--cnf(c05,axiom,-    ( mult(A,unit) = A )).--cnf(c06,axiom,-    ( mult(unit,A) = A )).--cnf(c07,axiom,-    ( ld(mult(A,B),mult(A,mult(B,mult(C,D)))) = mult(ld(mult(A,B),mult(A,mult(B,C))),ld(mult(A,B),mult(A,mult(B,D)))) )).--cnf(c08,axiom,-    ( rd(mult(mult(mult(A,B),C),D),mult(C,D)) = mult(rd(mult(mult(A,C),D),mult(C,D)),rd(mult(mult(B,C),D),mult(C,D))) )).--cnf(c09,axiom,-    ( ld(A,mult(mult(B,C),A)) = mult(ld(A,mult(B,A)),ld(A,mult(C,A))) )).--cnf(c10,axiom,-    ( mult(i(A),mult(A,B)) = B )).--cnf(c11,axiom,-    ( mult(mult(A,B),i(B)) = A )).--cnf(goals,negated_conjecture,-    ( mult(mult(a,b),mult(c,a)) != mult(mult(a,mult(b,c)),a) )).--%------------------------------------------------------------------------------

− tests/KLE125+1.p

@@ -1,47 +0,0 @@-%-------------------------------------------------------------------------------% File     : KLE125+1 : TPTP v9.0.0. Released v4.0.0.-% Domain   : Kleene Algebra (Modal with Divergence)-% Problem  : Quasicommutation theorem-% Version  : [Hoe08] axioms.-% English  : If x quasicommutes over y, then x+y terminates if x and y-%            individually do.--% Refs     : [BD86]  Bachmair & Dershowitz (1986), Commutation, Transformat-%          : [Str07] Struth (2007), Reasoning Automatically about Terminati-%          : [Hoe08] Hoefner (2008), Email to G. Sutcliffe-% Source   : [Hoe08]-% Names    :--% Status   : Theorem-% Rating   : 1.00 v4.0.0-% Syntax   : Number of formulae    :   29 (  26 unt;   0 def)-%            Number of atoms       :   33 (  32 equ)-%            Maximal formula atoms :    3 (   1 avg)-%            Number of connectives :    4 (   0   ~;   0   |;   0   &)-%                                         (   2 <=>;   2  =>;   0  <=;   0 <~>)-%            Maximal formula depth :    5 (   3 avg)-%            Maximal term depth    :    6 (   2 avg)-%            Number of predicates  :    2 (   1 usr;   0 prp; 2-2 aty)-%            Number of functors    :   16 (  16 usr;   2 con; 0-2 aty)-%            Number of variables   :   49 (  49   !;   0   ?)-% SPC      : FOF_THM_RFO_SEQ--% Comments : An abstract version of a theorem in [BD86].-%          : Equational encoding-%-------------------------------------------------------------------------------%---Include axioms for modal Kleene algebra with divergence-include('Axioms/KLE001+0.ax').-%---Include axioms for Boolean domain/codomain-include('Axioms/KLE001+4.ax').-%---Include axioms for diamond and boxes-include('Axioms/KLE001+6.ax').-%---Include axioms for divergence-include('Axioms/KLE001+7.ax').-%-------------------------------------------------------------------------------fof(goals,conjecture,-    ! [X0,X1] :-      ( addition(multiplication(X0,X1),multiplication(X1,star(addition(X1,X0)))) = multiplication(X1,star(addition(X1,X0)))-     => ( divergence(addition(X1,X0)) = zero-      <= addition(divergence(X1),divergence(X0)) = zero ) ) ).--%------------------------------------------------------------------------------

− tests/LAT071-1.p

@@ -1,37 +0,0 @@-%---------------------------------------------------------------------------% File     : LAT071-1 : TPTP v7.2.0. Released v2.6.0.-% Domain   : Lattice Theory (Orthomodularlattices)-% Problem  : Given single axiom OML-21C, prove associativity-% Version  : [MRV03] (equality) axioms.-% English  : Given a single axiom candidate OML-21C for orthomodular lattices-%            (OML) in terms of the Sheffer Stroke, prove a Sheffer stroke form-%            of associativity.--% Refs     : [MRV03] McCune et al. (2003), Sheffer Stroke Bases for Ortholatt-% Source   : [MRV03]-% Names    : OML-21C-associativity [MRV03]--% Status   : Open-% Rating   : 1.00 v2.6.0-% Syntax   : Number of clauses     :    2 (   0 non-Horn;   2 unit;   1 RR)-%            Number of atoms       :    2 (   2 equality)-%            Maximal clause size   :    1 (   1 average)-%            Number of predicates  :    1 (   0 propositional; 2-2 arity)-%            Number of functors    :    4 (   3 constant; 0-2 arity)-%            Number of variables   :    4 (   2 singleton)-%            Maximal term depth    :    6 (   4 average)-% SPC      : CNF_OPN_RFO_PEQ_UEQ--% Comments :-%---------------------------------------------------------------------------%----Single axiom OML-21C-cnf(oml_21C,axiom,-    ( f(f(B,A),f(f(f(f(B,A),A),f(C,A)),f(f(A,A),D))) = A )).--%----Denial of Sheffer stroke associativity-cnf(associativity,negated_conjecture,-    (  f(a,f(f(b,c),f(b,c))) != f(c,f(f(b,a),f(b,a))) )).--cnf(bonus, axiom, f(A,B)=f(B,A)).--%--------------------------------------------------------------------------

− tests/LAT072-1.p

@@ -1,37 +0,0 @@-%---------------------------------------------------------------------------% File     : LAT072-1 : TPTP v6.3.0. Released v2.6.0.-% Domain   : Lattice Theory (Ortholattices)-% Problem  : Given single axiom OML-23A, prove associativity-% Version  : [MRV03] (equality) axioms.-% English  : Given a single axiom candidate OML-23A for orthomodular lattices-%            (OML) in terms of the Sheffer Stroke, prove a Sheffer stroke form-%            of associativity.--% Refs     : [MRV03] McCune et al. (2003), Sheffer Stroke Bases for Ortholatt-% Source   : [MRV03]-% Names    : OML-23A-associativity [MRV03]--% Status   : Unsatisfiable-% Rating   : 0.95 v6.3.0, 0.94 v6.2.0, 0.93 v6.1.0, 0.94 v6.0.0, 0.95 v5.4.0, 1.00 v2.6.0-% Syntax   : Number of clauses     :    2 (   0 non-Horn;   2 unit;   1 RR)-%            Number of atoms       :    2 (   2 equality)-%            Maximal clause size   :    1 (   1 average)-%            Number of predicates  :    1 (   0 propositional; 2-2 arity)-%            Number of functors    :    4 (   3 constant; 0-2 arity)-%            Number of variables   :    4 (   2 singleton)-%            Maximal term depth    :    7 (   4 average)-% SPC      : CNF_UNS_RFO_PEQ_UEQ--% Comments :-%---------------------------------------------------------------------------%----Single axiom OML-23A-cnf(oml_23A,axiom,-    ( f(f(f(f(B,A),f(A,C)),D),f(A,f(f(C,f(f(A,A),C)),C))) = A )).--cnf(a, axiom, f(X,Y) = f(Y, X)).--%----Denial of Sheffer stroke associativity-cnf(associativity,negated_conjecture,-    (  f(a,f(f(b,c),f(b,c))) != f(c,f(f(b,a),f(b,a))) )).--%--------------------------------------------------------------------------

− tests/LAT073-1.p

@@ -1,37 +0,0 @@-%---------------------------------------------------------------------------% File     : LAT073-1 : TPTP v7.2.0. Released v2.6.0.-% Domain   : Lattice Theory (Ortholattices)-% Problem  : Given single axiom MOL-23C, prove modularity-% Version  : [MRV03] (equality) axioms.-% English  : Given a single axiom candidate MOL-23C for modular ortholattices-%            (MOL) in terms of the Sheffer Stroke, prove a Sheffer stroke form-%            of modularity.--% Refs     : [MRV03] McCune et al. (2003), Sheffer Stroke Bases for Ortholatt-% Source   : [MRV03]-% Names    : MOL-23C-modularity [MRV03]--% Status   : Open-% Rating   : 1.00 v2.6.0-% Syntax   : Number of clauses     :    2 (   0 non-Horn;   2 unit;   1 RR)-%            Number of atoms       :    2 (   2 equality)-%            Maximal clause size   :    1 (   1 average)-%            Number of predicates  :    1 (   0 propositional; 2-2 arity)-%            Number of functors    :    4 (   3 constant; 0-2 arity)-%            Number of variables   :    4 (   1 singleton)-%            Maximal term depth    :    7 (   4 average)-% SPC      : CNF_OPN_RFO_PEQ_UEQ--% Comments :-%---------------------------------------------------------------------------%----Single axiom MOL-23C-cnf(mol_23C,axiom,-    ( f(f(f(B,f(A,B)),B),f(A,f(C,f(f(A,B),f(f(C,C),D))))) = A )).--%----Denial of Sheffer stroke modularity-cnf(modularity,negated_conjecture,-    (  f(a,f(b,f(a,f(c,c)))) != f(a,f(c,f(a,f(b,b)))) )).--cnf(bonus, axiom, f(A,B)=f(B,A)).--%--------------------------------------------------------------------------

− tests/LAT078-1.p

@@ -1,38 +0,0 @@-%---------------------------------------------------------------------------% File     : LAT078-1 : TPTP v9.0.0. Released v2.6.0.-% Domain   : Lattice Theory (Ortholattices)-% Problem  : Given single axiom MOL-27B2, prove associativity-% Version  : [MRV03] (equality) axioms.-% English  : Given a single axiom candidate MOL-27B2 for modular ortholattices-%            (MOL) in terms of the Sheffer Stroke, prove a Sheffer stroke form-%            of associativity.--% Refs     : [MRV03] McCune et al. (2003), Sheffer Stroke Bases for Ortholatt-% Source   : [MRV03]-% Names    : MOL-27B2-associativity [MRV03]--% Status   : Unsatisfiable-% Rating   : 0.91 v8.2.0, 0.96 v8.1.0, 0.95 v7.5.0, 0.96 v7.4.0, 1.00 v7.3.0, 0.95 v7.1.0, 0.94 v7.0.0, 0.95 v6.4.0, 1.00 v2.6.0-% Syntax   : Number of clauses     :    2 (   2 unt;   0 nHn;   1 RR)-%            Number of literals    :    2 (   2 equ;   1 neg)-%            Maximal clause size   :    1 (   1 avg)-%            Maximal term depth    :    9 (   2 avg)-%            Number of predicates  :    1 (   0 usr;   0 prp; 2-2 aty)-%            Number of functors    :    4 (   4 usr;   3 con; 0-2 aty)-%            Number of variables   :    4 (   1 sgn)-% SPC      : CNF_UNS_RFO_PEQ_UEQ--% Comments :-%---------------------------------------------------------------------------%----Single axiom MOL-27B2-cnf(mol_27B2,axiom,-    f(f(f(f(B,A),f(A,C)),D),f(A,f(f(f(B,f(B,f(f(C,C),A))),A),C))) = A ).--%----Denial of Sheffer stroke associativity-cnf(associativity,negated_conjecture,-    f(a,f(f(b,c),f(b,c))) != f(c,f(f(b,a),f(b,a))) ).--%----------------------------------------------------------------------------cnf(not, axiom,-    not(X) = f(X,X)).

− tests/PUZ037-3-2.p

@@ -1,106 +0,0 @@-%---------------------------------------------------------------------------% File     : PUZ037-3 : TPTP v7.2.0. Released v2.3.0.-% Domain   : Puzzles-% Problem  : Rubik's Cube-% Version  : [HM98] axioms : Especial.-%            Theorem formulation : Rotation in all three planes.-% English  : Rubik's Cube is a 3x3x3 cube consisting of 27 subcubes with-%            colored faces. The three layers perpendicular to any axis may-%            be rotated independently. The object is to take a scrambled-%            cube and unscramble it so that each side consists entirely-%            of one color(Blue, White, Green, Yellow, Orange, Red).--% Refs     : [HM98]  Huang & Myers (1998), Subgoal Strategies for Solving B-% Source   : [HM98]-% Names    : Rubik's Cube [HM98]--% Status   : Unsatisfiable-% Rating   : 0.20 v7.2.0, 0.22 v7.1.0, 0.14 v6.4.0, 0.17 v6.3.0, 0.25 v6.2.0, 0.12 v6.1.0, 0.00 v5.5.0, 0.20 v5.4.0, 0.33 v5.0.0, 0.50 v4.1.0, 0.60 v3.7.0, 0.50 v3.5.0, 0.33 v3.1.0, 0.44 v2.7.0, 0.50 v2.6.0, 0.44 v2.5.0, 0.75 v2.4.0, 0.67 v2.3.0-% Syntax   : Number of clauses     :   20 (   0 non-Horn;   2 unit;  20 RR)-%            Number of atoms       :   38 (   0 equality)-%            Maximal clause size   :    2 (   2 average)-%            Number of predicates  :    1 (   0 propositional; 54-54 arity)-%            Number of functors    :    6 (   6 constant; 0-0 arity)-%            Number of variables   :  972 (   0 singleton)-%            Maximal term depth    :    1 (   1 average)-% SPC      : CNF_UNS_EPR--% Comments : mzy, mzy, bzy, byx, lzx rotations to solve.-%---------------------------------------------------------------------------cnf(a, axiom,-    state(b,b,b,b,b,b,b,b,b,r,r,r,g,g,g,o,o,o,y,y,y,r,r,r,g,g,g,o,o,o,y,y,y,r,r,r,g,g,g,o,o,o,y,y,y,w,w,w,w,w,w,w,w,w) !=-    state(b,r,r,w,w,w,y,b,b,g,y,r,b,g,g,o,g,y,w,w,r,g,o,r,b,g,g,o,r,b,y,y,r,g,o,g,o,o,o,y,r,b,y,y,r,w,w,w,b,b,y,w,o,o)).--cnf(txy,axiom,-    (  state(W7,W6,W5,W8,A1,W4,W1,W2,W3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7)-    = state(W1,W8,W7,W2,A1,W6,W3,W4,W5,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7) )).--cnf(mxy,axiom,-    (  state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6)-    = state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6) )).--cnf(bxy,axiom,-    (  state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,W7,W8,W1,W6,D7,W2,W5,W4,W3)-    = state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,W1,W2,W3,W8,D7,W4,W7,W6,W5) )).--cnf(fzy,axiom,-    (  state(A1,A2,A3,A4,A5,A6,V1,U1,Y1,A7,A8,W1,V2,U2,Y2,X1,A9,B1,B2,B3,B4,B5,B6,W2,V3,U3,Y3,X2,B7,B8,B9,C1,C2,C3,C4,W3,V4,U4,Y4,X3,C5,C6,C7,C8,C9,V5,U5,Y5,D1,D2,D3,D4,D5,D6)-    = state(A1,A2,A3,A4,A5,A6,X1,X2,X3,A7,A8,Y1,Y2,Y3,Y4,Y5,A9,B1,B2,B3,B4,B5,B6,U1,U2,U3,U4,U5,B7,B8,B9,C1,C2,C3,C4,V1,V2,V3,V4,V5,C5,C6,C7,C8,C9,W1,W2,W3,D1,D2,D3,D4,D5,D6) )).--cnf(mzy,axiom,-    (  state(A1,A2,A3,Y1,Y2,Y3,A4,A5,A6,A7,X9,A8,A9,B1,B2,B3,X1,B4,B5,B6,B7,B8,X8,B9,C1,C2,C3,C4,X2,C5,C6,C7,C8,C9,X7,D1,D2,D3,D4,D5,X3,D6,D7,D8,D9,E1,E2,E3,X6,X5,X4,E4,E5,E6)-    = state(A1,A2,A3,X1,X2,X3,A4,A5,A6,A7,Y3,A8,A9,B1,B2,B3,X4,B4,B5,B6,B7,B8,Y2,B9,C1,C2,C3,C4,X5,C5,C6,C7,C8,C9,Y1,D1,D2,D3,D4,D5,X6,D6,D7,D8,D9,E1,E2,E3,X9,X8,X7,E4,E5,E6) )).--cnf(bzy,axiom,-    (  state(Y1,Y2,Y3,A1,A2,A3,A4,A5,A6,X9,A7,A8,A9,B1,B2,B3,B4,X1,W1,W8,W7,X8,B5,B6,B7,B8,B9,C1,C2,X2,W2,C3,W6,X7,C4,C5,C6,C7,C8,C9,D1,X3,W3,W4,W5,D2,D3,D4,D5,D6,D7,X6,X5,X4)-    = state(X1,X2,X3,A1,A2,A3,A4,A5,A6,Y3,A7,A8,A9,B1,B2,B3,B4,X4,W3,W2,W1,Y2,B5,B6,B7,B8,B9,C1,C2,X5,W4,C3,W8,Y1,C4,C5,C6,C7,C8,C9,D1,X6,W5,W6,W7,D2,D3,D4,D5,D6,D7,X9,X8,X7) )).--cnf(lzx,axiom,-    (  state(Y1,A1,A2,Y2,A3,A4,Y3,A5,A6,W7,W8,W1,X1,A7,A8,A9,B1,B2,B3,B4,X9,W6,B5,W2,X2,B6,B7,B8,B9,C1,C2,C3,X8,W5,W4,W3,X3,C4,C5,C6,C7,C8,C9,D1,X7,X4,D2,D3,X5,D4,D5,X6,D6,D7)-    = state(X1,A1,A2,X2,A3,A4,X3,A5,A6,W1,W2,W3,X4,A7,A8,A9,B1,B2,B3,B4,Y3,W8,B5,W4,X5,B6,B7,B8,B9,C1,C2,C3,Y2,W7,W6,W5,X6,C4,C5,C6,C7,C8,C9,D1,Y1,X7,D2,D3,X8,D4,D5,X9,D6,D7) )).--cnf(mzx,axiom,-    (  state(A1,Y1,A2,A3,Y2,A4,A5,Y3,A6,A7,A8,A9,B1,X1,B2,B3,B4,B5,B6,X9,B7,B8,B9,C1,C2,X2,C3,C4,C5,C6,C7,X8,C8,C9,D1,D2,D3,X3,D4,D5,D6,D7,D8,X7,D9,E1,X4,E2,E3,X5,E4,E5,X6,E6)-    = state(A1,X1,A2,A3,X2,A4,A5,X3,A6,A7,A8,A9,B1,X4,B2,B3,B4,B5,B6,Y3,B7,B8,B9,C1,C2,X5,C3,C4,C5,C6,C7,Y2,C8,C9,D1,D2,D3,X6,D4,D5,D6,D7,D8,Y1,D9,E1,X7,E2,E3,X8,E4,E5,X9,E6) )).--cnf(rzx,axiom,-    (  state(A1,A2,Y1,A3,A4,Y2,A5,A6,Y3,A7,A8,A9,B1,B2,X1,W1,W8,W7,X9,B3,B4,B5,B6,B7,B8,B9,X2,W2,C1,W6,X8,C2,C3,C4,C5,C6,C7,C8,X3,W3,W4,W5,X7,C9,D1,D2,D3,X4,D4,D5,X5,D6,D7,X6)-    = state(A1,A2,X1,A3,A4,X2,A5,A6,X3,A7,A8,A9,B1,B2,X4,W3,W2,W1,Y3,B3,B4,B5,B6,B7,B8,B9,X5,W4,C1,W8,Y2,C2,C3,C4,C5,C6,C7,C8,X6,W5,W6,W7,Y1,C9,D1,D2,D3,X7,D4,D5,X8,D6,D7,X9) )).--cnf(tyx,axiom,-    (  state(W1,W8,W7,W2,A1,W6,W3,W4,W5,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7)-    = state(W7,W6,W5,W8,A1,W4,W1,W2,W3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7) )).--cnf(myx,axiom,-    (  state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6)-    = state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6) )).--cnf(byx,axiom,-    (  state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,W1,W2,W3,W8,D7,W4,W7,W6,W5)-    = state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,W7,W8,W1,W6,D7,W2,W5,W4,W3) )).--cnf(fyz,axiom,-    (  state(A1,A2,A3,A4,A5,A6,X1,X2,X3,A7,A8,Y1,Y2,Y3,Y4,Y5,A9,B1,B2,B3,B4,B5,B6,U1,U2,U3,U4,U5,B7,B8,B9,C1,C2,C3,C4,V1,V2,V3,V4,V5,C5,C6,C7,C8,C9,W1,W2,W3,D1,D2,D3,D4,D5,D6)-    = state(A1,A2,A3,A4,A5,A6,V1,U1,Y1,A7,A8,W1,V2,U2,Y2,X1,A9,B1,B2,B3,B4,B5,B6,W2,V3,U3,Y3,X2,B7,B8,B9,C1,C2,C3,C4,W3,V4,U4,Y4,X3,C5,C6,C7,C8,C9,V5,U5,Y5,D1,D2,D3,D4,D5,D6) )).--cnf(myz,axiom,-    (  state(A1,A2,A3,X1,X2,X3,A4,A5,A6,A7,Y3,A8,A9,B1,B2,B3,X4,B4,B5,B6,B7,B8,Y2,B9,C1,C2,C3,C4,X5,C5,C6,C7,C8,C9,Y1,D1,D2,D3,D4,D5,X6,D6,D7,D8,D9,E1,E2,E3,X9,X8,X7,E4,E5,E6)-    = state(A1,A2,A3,Y1,Y2,Y3,A4,A5,A6,A7,X9,A8,A9,B1,B2,B3,X1,B4,B5,B6,B7,B8,X8,B9,C1,C2,C3,C4,X2,C5,C6,C7,C8,C9,X7,D1,D2,D3,D4,D5,X3,D6,D7,D8,D9,E1,E2,E3,X6,X5,X4,E4,E5,E6) )).--cnf(byz,axiom,-    (  state(X1,X2,X3,A1,A2,A3,A4,A5,A6,Y3,A7,A8,A9,B1,B2,B3,B4,X4,W3,W2,W1,Y2,B5,B6,B7,B8,B9,C1,C2,X5,W4,C3,W8,Y1,C4,C5,C6,C7,C8,C9,D1,X6,W5,W6,W7,D2,D3,D4,D5,D6,D7,X9,X8,X7)-    = state(Y1,Y2,Y3,A1,A2,A3,A4,A5,A6,X9,A7,A8,A9,B1,B2,B3,B4,X1,W1,W8,W7,X8,B5,B6,B7,B8,B9,C1,C2,X2,W2,C3,W6,X7,C4,C5,C6,C7,C8,C9,D1,X3,W3,W4,W5,D2,D3,D4,D5,D6,D7,X6,X5,X4) )).--cnf(lxz,axiom,-    (  state(X1,A1,A2,X2,A3,A4,X3,A5,A6,W1,W2,W3,X4,A7,A8,A9,B1,B2,B3,B4,Y3,W8,B5,W4,X5,B6,B7,B8,B9,C1,C2,C3,Y2,W7,W6,W5,X6,C4,C5,C6,C7,C8,C9,D1,Y1,X7,D2,D3,X8,D4,D5,X9,D6,D7)-    = state(Y1,A1,A2,Y2,A3,A4,Y3,A5,A6,W7,W8,W1,X1,A7,A8,A9,B1,B2,B3,B4,X9,W6,B5,W2,X2,B6,B7,B8,B9,C1,C2,C3,X8,W5,W4,W3,X3,C4,C5,C6,C7,C8,C9,D1,X7,X4,D2,D3,X5,D4,D5,X6,D6,D7) )).--cnf(mxz,axiom,-    (  state(A1,X1,A2,A3,X2,A4,A5,X3,A6,A7,A8,A9,B1,X4,B2,B3,B4,B5,B6,Y3,B7,B8,B9,C1,C2,X5,C3,C4,C5,C6,C7,Y2,C8,C9,D1,D2,D3,X6,D4,D5,D6,D7,D8,Y1,D9,E1,X7,E2,E3,X8,E4,E5,X9,E6)-    = state(A1,Y1,A2,A3,Y2,A4,A5,Y3,A6,A7,A8,A9,B1,X1,B2,B3,B4,B5,B6,X9,B7,B8,B9,C1,C2,X2,C3,C4,C5,C6,C7,X8,C8,C9,D1,D2,D3,X3,D4,D5,D6,D7,D8,X7,D9,E1,X4,E2,E3,X5,E4,E5,X6,E6) )).--cnf(rxz,axiom,-    (  state(A1,A2,X1,A3,A4,X2,A5,A6,X3,A7,A8,A9,B1,B2,X4,W3,W2,W1,Y3,B3,B4,B5,B6,B7,B8,B9,X5,W4,C1,W8,Y2,C2,C3,C4,C5,C6,C7,C8,X6,W5,W6,W7,Y1,C9,D1,D2,D3,X7,D4,D5,X8,D6,D7,X9)-    = state(A1,A2,Y1,A3,A4,Y2,A5,A6,Y3,A7,A8,A9,B1,B2,X1,W1,W8,W7,X9,B3,B4,B5,B6,B7,B8,B9,X2,W2,C1,W6,X8,C2,C3,C4,C5,C6,C7,C8,X3,W3,W4,W5,X7,C9,D1,D2,D3,X4,D4,D5,X5,D6,D7,X6) )).--%--------------------------------------------------------------------------

− tests/PUZ037-3.p

@@ -1,110 +0,0 @@-%---------------------------------------------------------------------------% File     : PUZ037-3 : TPTP v7.2.0. Released v2.3.0.-% Domain   : Puzzles-% Problem  : Rubik's Cube-% Version  : [HM98] axioms : Especial.-%            Theorem formulation : Rotation in all three planes.-% English  : Rubik's Cube is a 3x3x3 cube consisting of 27 subcubes with-%            colored faces. The three layers perpendicular to any axis may-%            be rotated independently. The object is to take a scrambled-%            cube and unscramble it so that each side consists entirely-%            of one color(Blue, White, Green, Yellow, Orange, Red).--% Refs     : [HM98]  Huang & Myers (1998), Subgoal Strategies for Solving B-% Source   : [HM98]-% Names    : Rubik's Cube [HM98]--% Status   : Unsatisfiable-% Rating   : 0.20 v7.2.0, 0.22 v7.1.0, 0.14 v6.4.0, 0.17 v6.3.0, 0.25 v6.2.0, 0.12 v6.1.0, 0.00 v5.5.0, 0.20 v5.4.0, 0.33 v5.0.0, 0.50 v4.1.0, 0.60 v3.7.0, 0.50 v3.5.0, 0.33 v3.1.0, 0.44 v2.7.0, 0.50 v2.6.0, 0.44 v2.5.0, 0.75 v2.4.0, 0.67 v2.3.0-% Syntax   : Number of clauses     :   20 (   0 non-Horn;   2 unit;  20 RR)-%            Number of atoms       :   38 (   0 equality)-%            Maximal clause size   :    2 (   2 average)-%            Number of predicates  :    1 (   0 propositional; 54-54 arity)-%            Number of functors    :    6 (   6 constant; 0-0 arity)-%            Number of variables   :  972 (   0 singleton)-%            Maximal term depth    :    1 (   1 average)-% SPC      : CNF_UNS_EPR--% Comments : mzy, mzy, bzy, byx, lzx rotations to solve.-%---------------------------------------------------------------------------cnf(make_like_this,negated_conjecture, lhs != rhs).--cnf(a, axiom, lhs =-    state(b,b,b,b,b,b,b,b,b,r,r,r,g,g,g,o,o,o,y,y,y,r,r,r,g,g,g,o,o,o,y,y,y,r,r,r,g,g,g,o,o,o,y,y,y,w,w,w,w,w,w,w,w,w)).--cnf(b, axiom, rhs =-    state(b,r,r,w,w,w,y,b,b,g,y,r,b,g,g,o,g,y,w,w,r,g,o,r,b,g,g,o,r,b,y,y,r,g,o,g,o,o,o,y,r,b,y,y,r,w,w,w,b,b,y,w,o,o)).--cnf(txy,axiom,-    (  state(W7,W6,W5,W8,A1,W4,W1,W2,W3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7)-    = state(W1,W8,W7,W2,A1,W6,W3,W4,W5,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7) )).--cnf(mxy,axiom,-    (  state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6)-    = state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6) )).--cnf(bxy,axiom,-    (  state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,W7,W8,W1,W6,D7,W2,W5,W4,W3)-    = state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,W1,W2,W3,W8,D7,W4,W7,W6,W5) )).--cnf(fzy,axiom,-    (  state(A1,A2,A3,A4,A5,A6,V1,U1,Y1,A7,A8,W1,V2,U2,Y2,X1,A9,B1,B2,B3,B4,B5,B6,W2,V3,U3,Y3,X2,B7,B8,B9,C1,C2,C3,C4,W3,V4,U4,Y4,X3,C5,C6,C7,C8,C9,V5,U5,Y5,D1,D2,D3,D4,D5,D6)-    = state(A1,A2,A3,A4,A5,A6,X1,X2,X3,A7,A8,Y1,Y2,Y3,Y4,Y5,A9,B1,B2,B3,B4,B5,B6,U1,U2,U3,U4,U5,B7,B8,B9,C1,C2,C3,C4,V1,V2,V3,V4,V5,C5,C6,C7,C8,C9,W1,W2,W3,D1,D2,D3,D4,D5,D6) )).--cnf(mzy,axiom,-    (  state(A1,A2,A3,Y1,Y2,Y3,A4,A5,A6,A7,X9,A8,A9,B1,B2,B3,X1,B4,B5,B6,B7,B8,X8,B9,C1,C2,C3,C4,X2,C5,C6,C7,C8,C9,X7,D1,D2,D3,D4,D5,X3,D6,D7,D8,D9,E1,E2,E3,X6,X5,X4,E4,E5,E6)-    = state(A1,A2,A3,X1,X2,X3,A4,A5,A6,A7,Y3,A8,A9,B1,B2,B3,X4,B4,B5,B6,B7,B8,Y2,B9,C1,C2,C3,C4,X5,C5,C6,C7,C8,C9,Y1,D1,D2,D3,D4,D5,X6,D6,D7,D8,D9,E1,E2,E3,X9,X8,X7,E4,E5,E6) )).--cnf(bzy,axiom,-    (  state(Y1,Y2,Y3,A1,A2,A3,A4,A5,A6,X9,A7,A8,A9,B1,B2,B3,B4,X1,W1,W8,W7,X8,B5,B6,B7,B8,B9,C1,C2,X2,W2,C3,W6,X7,C4,C5,C6,C7,C8,C9,D1,X3,W3,W4,W5,D2,D3,D4,D5,D6,D7,X6,X5,X4)-    = state(X1,X2,X3,A1,A2,A3,A4,A5,A6,Y3,A7,A8,A9,B1,B2,B3,B4,X4,W3,W2,W1,Y2,B5,B6,B7,B8,B9,C1,C2,X5,W4,C3,W8,Y1,C4,C5,C6,C7,C8,C9,D1,X6,W5,W6,W7,D2,D3,D4,D5,D6,D7,X9,X8,X7) )).--cnf(lzx,axiom,-    (  state(Y1,A1,A2,Y2,A3,A4,Y3,A5,A6,W7,W8,W1,X1,A7,A8,A9,B1,B2,B3,B4,X9,W6,B5,W2,X2,B6,B7,B8,B9,C1,C2,C3,X8,W5,W4,W3,X3,C4,C5,C6,C7,C8,C9,D1,X7,X4,D2,D3,X5,D4,D5,X6,D6,D7)-    = state(X1,A1,A2,X2,A3,A4,X3,A5,A6,W1,W2,W3,X4,A7,A8,A9,B1,B2,B3,B4,Y3,W8,B5,W4,X5,B6,B7,B8,B9,C1,C2,C3,Y2,W7,W6,W5,X6,C4,C5,C6,C7,C8,C9,D1,Y1,X7,D2,D3,X8,D4,D5,X9,D6,D7) )).--cnf(mzx,axiom,-    (  state(A1,Y1,A2,A3,Y2,A4,A5,Y3,A6,A7,A8,A9,B1,X1,B2,B3,B4,B5,B6,X9,B7,B8,B9,C1,C2,X2,C3,C4,C5,C6,C7,X8,C8,C9,D1,D2,D3,X3,D4,D5,D6,D7,D8,X7,D9,E1,X4,E2,E3,X5,E4,E5,X6,E6)-    = state(A1,X1,A2,A3,X2,A4,A5,X3,A6,A7,A8,A9,B1,X4,B2,B3,B4,B5,B6,Y3,B7,B8,B9,C1,C2,X5,C3,C4,C5,C6,C7,Y2,C8,C9,D1,D2,D3,X6,D4,D5,D6,D7,D8,Y1,D9,E1,X7,E2,E3,X8,E4,E5,X9,E6) )).--cnf(rzx,axiom,-    (  state(A1,A2,Y1,A3,A4,Y2,A5,A6,Y3,A7,A8,A9,B1,B2,X1,W1,W8,W7,X9,B3,B4,B5,B6,B7,B8,B9,X2,W2,C1,W6,X8,C2,C3,C4,C5,C6,C7,C8,X3,W3,W4,W5,X7,C9,D1,D2,D3,X4,D4,D5,X5,D6,D7,X6)-    = state(A1,A2,X1,A3,A4,X2,A5,A6,X3,A7,A8,A9,B1,B2,X4,W3,W2,W1,Y3,B3,B4,B5,B6,B7,B8,B9,X5,W4,C1,W8,Y2,C2,C3,C4,C5,C6,C7,C8,X6,W5,W6,W7,Y1,C9,D1,D2,D3,X7,D4,D5,X8,D6,D7,X9) )).--cnf(tyx,axiom,-    (  state(W1,W8,W7,W2,A1,W6,W3,W4,W5,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7)-    = state(W7,W6,W5,W8,A1,W4,W1,W2,W3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7) )).--cnf(myx,axiom,-    (  state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6)-    = state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6) )).--cnf(byx,axiom,-    (  state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,W1,W2,W3,W8,D7,W4,W7,W6,W5)-    = state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,W7,W8,W1,W6,D7,W2,W5,W4,W3) )).--cnf(fyz,axiom,-    (  state(A1,A2,A3,A4,A5,A6,X1,X2,X3,A7,A8,Y1,Y2,Y3,Y4,Y5,A9,B1,B2,B3,B4,B5,B6,U1,U2,U3,U4,U5,B7,B8,B9,C1,C2,C3,C4,V1,V2,V3,V4,V5,C5,C6,C7,C8,C9,W1,W2,W3,D1,D2,D3,D4,D5,D6)-    = state(A1,A2,A3,A4,A5,A6,V1,U1,Y1,A7,A8,W1,V2,U2,Y2,X1,A9,B1,B2,B3,B4,B5,B6,W2,V3,U3,Y3,X2,B7,B8,B9,C1,C2,C3,C4,W3,V4,U4,Y4,X3,C5,C6,C7,C8,C9,V5,U5,Y5,D1,D2,D3,D4,D5,D6) )).--cnf(myz,axiom,-    (  state(A1,A2,A3,X1,X2,X3,A4,A5,A6,A7,Y3,A8,A9,B1,B2,B3,X4,B4,B5,B6,B7,B8,Y2,B9,C1,C2,C3,C4,X5,C5,C6,C7,C8,C9,Y1,D1,D2,D3,D4,D5,X6,D6,D7,D8,D9,E1,E2,E3,X9,X8,X7,E4,E5,E6)-    = state(A1,A2,A3,Y1,Y2,Y3,A4,A5,A6,A7,X9,A8,A9,B1,B2,B3,X1,B4,B5,B6,B7,B8,X8,B9,C1,C2,C3,C4,X2,C5,C6,C7,C8,C9,X7,D1,D2,D3,D4,D5,X3,D6,D7,D8,D9,E1,E2,E3,X6,X5,X4,E4,E5,E6) )).--cnf(byz,axiom,-    (  state(X1,X2,X3,A1,A2,A3,A4,A5,A6,Y3,A7,A8,A9,B1,B2,B3,B4,X4,W3,W2,W1,Y2,B5,B6,B7,B8,B9,C1,C2,X5,W4,C3,W8,Y1,C4,C5,C6,C7,C8,C9,D1,X6,W5,W6,W7,D2,D3,D4,D5,D6,D7,X9,X8,X7)-    = state(Y1,Y2,Y3,A1,A2,A3,A4,A5,A6,X9,A7,A8,A9,B1,B2,B3,B4,X1,W1,W8,W7,X8,B5,B6,B7,B8,B9,C1,C2,X2,W2,C3,W6,X7,C4,C5,C6,C7,C8,C9,D1,X3,W3,W4,W5,D2,D3,D4,D5,D6,D7,X6,X5,X4) )).--cnf(lxz,axiom,-    (  state(X1,A1,A2,X2,A3,A4,X3,A5,A6,W1,W2,W3,X4,A7,A8,A9,B1,B2,B3,B4,Y3,W8,B5,W4,X5,B6,B7,B8,B9,C1,C2,C3,Y2,W7,W6,W5,X6,C4,C5,C6,C7,C8,C9,D1,Y1,X7,D2,D3,X8,D4,D5,X9,D6,D7)-    = state(Y1,A1,A2,Y2,A3,A4,Y3,A5,A6,W7,W8,W1,X1,A7,A8,A9,B1,B2,B3,B4,X9,W6,B5,W2,X2,B6,B7,B8,B9,C1,C2,C3,X8,W5,W4,W3,X3,C4,C5,C6,C7,C8,C9,D1,X7,X4,D2,D3,X5,D4,D5,X6,D6,D7) )).--cnf(mxz,axiom,-    (  state(A1,X1,A2,A3,X2,A4,A5,X3,A6,A7,A8,A9,B1,X4,B2,B3,B4,B5,B6,Y3,B7,B8,B9,C1,C2,X5,C3,C4,C5,C6,C7,Y2,C8,C9,D1,D2,D3,X6,D4,D5,D6,D7,D8,Y1,D9,E1,X7,E2,E3,X8,E4,E5,X9,E6)-    = state(A1,Y1,A2,A3,Y2,A4,A5,Y3,A6,A7,A8,A9,B1,X1,B2,B3,B4,B5,B6,X9,B7,B8,B9,C1,C2,X2,C3,C4,C5,C6,C7,X8,C8,C9,D1,D2,D3,X3,D4,D5,D6,D7,D8,X7,D9,E1,X4,E2,E3,X5,E4,E5,X6,E6) )).--cnf(rxz,axiom,-    (  state(A1,A2,X1,A3,A4,X2,A5,A6,X3,A7,A8,A9,B1,B2,X4,W3,W2,W1,Y3,B3,B4,B5,B6,B7,B8,B9,X5,W4,C1,W8,Y2,C2,C3,C4,C5,C6,C7,C8,X6,W5,W6,W7,Y1,C9,D1,D2,D3,X7,D4,D5,X8,D6,D7,X9)-    = state(A1,A2,Y1,A3,A4,Y2,A5,A6,Y3,A7,A8,A9,B1,B2,X1,W1,W8,W7,X9,B3,B4,B5,B6,B7,B8,B9,X2,W2,C1,W6,X8,C2,C3,C4,C5,C6,C7,C8,X3,W3,W4,W5,X7,C9,D1,D2,D3,X4,D4,D5,X5,D6,D7,X6) )).--%--------------------------------------------------------------------------

− tests/PUZ052-1.p

@@ -1,129 +0,0 @@-%---------------------------------------------------------------------------% File     : PUZ052-1 : TPTP v7.2.0. Released v2.7.0.-% Domain   : Puzzles-% Problem  : Rubik's Cube unreachability-% Version  : [HM98] axioms : Especial.-%            Theorem formulation : Rotations in one plane only.-% English  : Rubik's Cube is a 3x3x3 cube consisting of 27 subcubes with-%            colored faces. The three layers perpendicular to any axis may-%            be rotated independently. The object is to take a scrambled-%            cube and unscramble it so that each side consists entirely-%            of one color(Blue, White, Green, Yellow, Orange, Red).-%            The objective here is unreachable: there are 10 b's and only-%            8 r's.--% Refs     : [HM98]  Huang & Myers (1998), Subgoal Strategies for Solving B-%          : [Cla03] Claessen (2003), Email to G. Sutcliffe-% Source   : [Cla03]-% Names    :--% Status   : Satisfiable-% Rating   : 1.00 v2.7.0-% Syntax   : Number of clauses     :   20 (   0 non-Horn;   2 unit;  20 RR)-%            Number of atoms       :   38 (   0 equality)-%            Maximal clause size   :    2 (   2 average)-%            Number of predicates  :    1 (   0 propositional; 54-54 arity)-%            Number of functors    :    6 (   6 constant; 0-0 arity)-%            Number of variables   :  972 (   0 singleton)-%            Maximal term depth    :    1 (   1 average)-% SPC      : CNF_SAT_EPR--% Comments : Replaced one b by an r in make_like_this from PUZ037-1.p-%            Model never found; a domain of size 2 should be enough though.-%---------------------------------------------------------------------------cnf(make_like_this,negated_conjecture,-    ( state(b,b,b,b,b,b,b,b,b,b,r,r,g,g,g,o,o,o,y,y,y,r,r,r,g,g,g,o,o,o,y,y,y,r,r,r,g,g,g,o,o,o,y,y,y,w,w,w,w,w,w,w,w,w) !=-     state(b,b,b,b,b,b,b,b,b,r,r,r,g,g,g,o,o,o,y,y,y,g,g,g,o,o,o,y,y,y,r,r,r,r,r,r,g,g,g,o,o,o,y,y,y,w,w,w,w,w,w,w,w,w) )).--cnf(txy,axiom,-    ( -state(W7,W6,W5,W8,A1,W4,W1,W2,W3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7) -= state(W1,W8,W7,W2,A1,W6,W3,W4,W5,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7) )).--cnf(mxy,axiom,-    ( -state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6) -=-    state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6) )).--cnf(bxy,axiom,-    ( state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,W7,W8,W1,W6,D7,W2,W5,W4,W3)-    = -state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,W1,W2,W3,W8,D7,W4,W7,W6,W5) )).--cnf(fzy,axiom,-    ( state(A1,A2,A3,A4,A5,A6,V1,U1,Y1,A7,A8,W1,V2,U2,Y2,X1,A9,B1,B2,B3,B4,B5,B6,W2,V3,U3,Y3,X2,B7,B8,B9,C1,C2,C3,C4,W3,V4,U4,Y4,X3,C5,C6,C7,C8,C9,V5,U5,Y5,D1,D2,D3,D4,D5,D6)-    = -state(A1,A2,A3,A4,A5,A6,X1,X2,X3,A7,A8,Y1,Y2,Y3,Y4,Y5,A9,B1,B2,B3,B4,B5,B6,U1,U2,U3,U4,U5,B7,B8,B9,C1,C2,C3,C4,V1,V2,V3,V4,V5,C5,C6,C7,C8,C9,W1,W2,W3,D1,D2,D3,D4,D5,D6) )).--cnf(mzy,axiom,-    ( state(A1,A2,A3,Y1,Y2,Y3,A4,A5,A6,A7,X9,A8,A9,B1,B2,B3,X1,B4,B5,B6,B7,B8,X8,B9,C1,C2,C3,C4,X2,C5,C6,C7,C8,C9,X7,D1,D2,D3,D4,D5,X3,D6,D7,D8,D9,E1,E2,E3,X6,X5,X4,E4,E5,E6)-    = -state(A1,A2,A3,X1,X2,X3,A4,A5,A6,A7,Y3,A8,A9,B1,B2,B3,X4,B4,B5,B6,B7,B8,Y2,B9,C1,C2,C3,C4,X5,C5,C6,C7,C8,C9,Y1,D1,D2,D3,D4,D5,X6,D6,D7,D8,D9,E1,E2,E3,X9,X8,X7,E4,E5,E6) )).--cnf(bzy,axiom,-    ( state(Y1,Y2,Y3,A1,A2,A3,A4,A5,A6,X9,A7,A8,A9,B1,B2,B3,B4,X1,W1,W8,W7,X8,B5,B6,B7,B8,B9,C1,C2,X2,W2,C3,W6,X7,C4,C5,C6,C7,C8,C9,D1,X3,W3,W4,W5,D2,D3,D4,D5,D6,D7,X6,X5,X4)-    = -state(X1,X2,X3,A1,A2,A3,A4,A5,A6,Y3,A7,A8,A9,B1,B2,B3,B4,X4,W3,W2,W1,Y2,B5,B6,B7,B8,B9,C1,C2,X5,W4,C3,W8,Y1,C4,C5,C6,C7,C8,C9,D1,X6,W5,W6,W7,D2,D3,D4,D5,D6,D7,X9,X8,X7) )).--cnf(lzx,axiom,-    ( state(Y1,A1,A2,Y2,A3,A4,Y3,A5,A6,W7,W8,W1,X1,A7,A8,A9,B1,B2,B3,B4,X9,W6,B5,W2,X2,B6,B7,B8,B9,C1,C2,C3,X8,W5,W4,W3,X3,C4,C5,C6,C7,C8,C9,D1,X7,X4,D2,D3,X5,D4,D5,X6,D6,D7)-    = -state(X1,A1,A2,X2,A3,A4,X3,A5,A6,W1,W2,W3,X4,A7,A8,A9,B1,B2,B3,B4,Y3,W8,B5,W4,X5,B6,B7,B8,B9,C1,C2,C3,Y2,W7,W6,W5,X6,C4,C5,C6,C7,C8,C9,D1,Y1,X7,D2,D3,X8,D4,D5,X9,D6,D7) )).--cnf(mzx,axiom,-    ( state(A1,Y1,A2,A3,Y2,A4,A5,Y3,A6,A7,A8,A9,B1,X1,B2,B3,B4,B5,B6,X9,B7,B8,B9,C1,C2,X2,C3,C4,C5,C6,C7,X8,C8,C9,D1,D2,D3,X3,D4,D5,D6,D7,D8,X7,D9,E1,X4,E2,E3,X5,E4,E5,X6,E6)-    = -state(A1,X1,A2,A3,X2,A4,A5,X3,A6,A7,A8,A9,B1,X4,B2,B3,B4,B5,B6,Y3,B7,B8,B9,C1,C2,X5,C3,C4,C5,C6,C7,Y2,C8,C9,D1,D2,D3,X6,D4,D5,D6,D7,D8,Y1,D9,E1,X7,E2,E3,X8,E4,E5,X9,E6) )).--cnf(rzx,axiom,-    ( state(A1,A2,Y1,A3,A4,Y2,A5,A6,Y3,A7,A8,A9,B1,B2,X1,W1,W8,W7,X9,B3,B4,B5,B6,B7,B8,B9,X2,W2,C1,W6,X8,C2,C3,C4,C5,C6,C7,C8,X3,W3,W4,W5,X7,C9,D1,D2,D3,X4,D4,D5,X5,D6,D7,X6)-    = -state(A1,A2,X1,A3,A4,X2,A5,A6,X3,A7,A8,A9,B1,B2,X4,W3,W2,W1,Y3,B3,B4,B5,B6,B7,B8,B9,X5,W4,C1,W8,Y2,C2,C3,C4,C5,C6,C7,C8,X6,W5,W6,W7,Y1,C9,D1,D2,D3,X7,D4,D5,X8,D6,D7,X9) )).--cnf(tyx,axiom,-    ( state(W1,W8,W7,W2,A1,W6,W3,W4,W5,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7)-    = -state(W7,W6,W5,W8,A1,W4,W1,W2,W3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7) )).--cnf(myx,axiom,-    ( state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6)-    = -state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,D7,D8,D9,E1,E2,E3,E4,E5,E6) )).--cnf(byx,axiom,-    ( state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,X1,X2,X3,X4,X5,X6,X7,X8,X9,Y1,Y2,Y3,W1,W2,W3,W8,D7,W4,W7,W6,W5)-    = -state(A1,A2,A3,A4,A5,A6,A7,A8,A9,B1,B2,B3,B4,B5,B6,B7,B8,B9,C1,C2,C3,C4,C5,C6,C7,C8,C9,D1,D2,D3,D4,D5,D6,Y1,Y2,Y3,X1,X2,X3,X4,X5,X6,X7,X8,X9,W7,W8,W1,W6,D7,W2,W5,W4,W3) )).--cnf(fyz,axiom,-    ( state(A1,A2,A3,A4,A5,A6,X1,X2,X3,A7,A8,Y1,Y2,Y3,Y4,Y5,A9,B1,B2,B3,B4,B5,B6,U1,U2,U3,U4,U5,B7,B8,B9,C1,C2,C3,C4,V1,V2,V3,V4,V5,C5,C6,C7,C8,C9,W1,W2,W3,D1,D2,D3,D4,D5,D6)-    = -state(A1,A2,A3,A4,A5,A6,V1,U1,Y1,A7,A8,W1,V2,U2,Y2,X1,A9,B1,B2,B3,B4,B5,B6,W2,V3,U3,Y3,X2,B7,B8,B9,C1,C2,C3,C4,W3,V4,U4,Y4,X3,C5,C6,C7,C8,C9,V5,U5,Y5,D1,D2,D3,D4,D5,D6) )).--cnf(myz,axiom,-    ( state(A1,A2,A3,X1,X2,X3,A4,A5,A6,A7,Y3,A8,A9,B1,B2,B3,X4,B4,B5,B6,B7,B8,Y2,B9,C1,C2,C3,C4,X5,C5,C6,C7,C8,C9,Y1,D1,D2,D3,D4,D5,X6,D6,D7,D8,D9,E1,E2,E3,X9,X8,X7,E4,E5,E6)-    = -state(A1,A2,A3,Y1,Y2,Y3,A4,A5,A6,A7,X9,A8,A9,B1,B2,B3,X1,B4,B5,B6,B7,B8,X8,B9,C1,C2,C3,C4,X2,C5,C6,C7,C8,C9,X7,D1,D2,D3,D4,D5,X3,D6,D7,D8,D9,E1,E2,E3,X6,X5,X4,E4,E5,E6) )).--cnf(byz,axiom,-    ( state(X1,X2,X3,A1,A2,A3,A4,A5,A6,Y3,A7,A8,A9,B1,B2,B3,B4,X4,W3,W2,W1,Y2,B5,B6,B7,B8,B9,C1,C2,X5,W4,C3,W8,Y1,C4,C5,C6,C7,C8,C9,D1,X6,W5,W6,W7,D2,D3,D4,D5,D6,D7,X9,X8,X7)-    = -state(Y1,Y2,Y3,A1,A2,A3,A4,A5,A6,X9,A7,A8,A9,B1,B2,B3,B4,X1,W1,W8,W7,X8,B5,B6,B7,B8,B9,C1,C2,X2,W2,C3,W6,X7,C4,C5,C6,C7,C8,C9,D1,X3,W3,W4,W5,D2,D3,D4,D5,D6,D7,X6,X5,X4) )).--cnf(lxz,axiom,-    ( state(X1,A1,A2,X2,A3,A4,X3,A5,A6,W1,W2,W3,X4,A7,A8,A9,B1,B2,B3,B4,Y3,W8,B5,W4,X5,B6,B7,B8,B9,C1,C2,C3,Y2,W7,W6,W5,X6,C4,C5,C6,C7,C8,C9,D1,Y1,X7,D2,D3,X8,D4,D5,X9,D6,D7)-    = -state(Y1,A1,A2,Y2,A3,A4,Y3,A5,A6,W7,W8,W1,X1,A7,A8,A9,B1,B2,B3,B4,X9,W6,B5,W2,X2,B6,B7,B8,B9,C1,C2,C3,X8,W5,W4,W3,X3,C4,C5,C6,C7,C8,C9,D1,X7,X4,D2,D3,X5,D4,D5,X6,D6,D7) )).--cnf(mxz,axiom,-    ( state(A1,X1,A2,A3,X2,A4,A5,X3,A6,A7,A8,A9,B1,X4,B2,B3,B4,B5,B6,Y3,B7,B8,B9,C1,C2,X5,C3,C4,C5,C6,C7,Y2,C8,C9,D1,D2,D3,X6,D4,D5,D6,D7,D8,Y1,D9,E1,X7,E2,E3,X8,E4,E5,X9,E6)-    = -state(A1,Y1,A2,A3,Y2,A4,A5,Y3,A6,A7,A8,A9,B1,X1,B2,B3,B4,B5,B6,X9,B7,B8,B9,C1,C2,X2,C3,C4,C5,C6,C7,X8,C8,C9,D1,D2,D3,X3,D4,D5,D6,D7,D8,X7,D9,E1,X4,E2,E3,X5,E4,E5,X6,E6) )).--cnf(rxz,axiom,-    ( state(A1,A2,X1,A3,A4,X2,A5,A6,X3,A7,A8,A9,B1,B2,X4,W3,W2,W1,Y3,B3,B4,B5,B6,B7,B8,B9,X5,W4,C1,W8,Y2,C2,C3,C4,C5,C6,C7,C8,X6,W5,W6,W7,Y1,C9,D1,D2,D3,X7,D4,D5,X8,D6,D7,X9)-    = -state(A1,A2,Y1,A3,A4,Y2,A5,A6,Y3,A7,A8,A9,B1,B2,X1,W1,W8,W7,X9,B3,B4,B5,B6,B7,B8,B9,X2,W2,C1,W6,X8,C2,C3,C4,C5,C6,C7,C8,X3,W3,W4,W5,X7,C9,D1,D2,D3,X4,D4,D5,X5,D6,D7,X6) )).--%--------------------------------------------------------------------------

− tests/REL038-1.p

@@ -1,14 +0,0 @@-cnf(maddux1_join_commutativity_1, axiom, join(A, B)=join(B, A)).-cnf(maddux2_join_associativity_2, axiom, join(A, join(B, C))=join(join(A, B), C)).-cnf(maddux3_a_kind_of_de_Morgan_3, axiom, A=join(complement(join(complement(A), complement(B))), complement(join(complement(A), B)))).-cnf(maddux4_definiton_of_meet_4, axiom, meet(A, B)=complement(join(complement(A), complement(B)))).-cnf(composition_associativity_5, axiom, composition(A, composition(B, C))=composition(composition(A, B), C)).-cnf(composition_identity_6, axiom, composition(A, one)=A).-cnf(composition_distributivity_7, axiom, composition(join(A, B), C)=join(composition(A, C), composition(B, C))).-cnf(converse_idempotence_8, axiom, converse(converse(A))=A).-cnf(converse_additivity_9, axiom, converse(join(A, B))=join(converse(A), converse(B))).-cnf(converse_multiplicativity_10, axiom, converse(composition(A, B))=composition(converse(B), converse(A))).-cnf(converse_cancellativity_11, axiom, join(composition(converse(A), complement(composition(A, B))), complement(B))=complement(B)).-cnf(def_top_12, axiom, top=join(A, complement(A))).-cnf(def_zero_13, axiom, zero=meet(A, complement(A))).-cnf(goals_14, negated_conjecture, join(meet(composition(sk1, sk2), sk3), meet(composition(sk1, meet(sk2, composition(converse(sk1), sk3))), sk3))!=meet(composition(sk1, meet(sk2, composition(converse(sk1), sk3))), sk3)).

− tests/RNG025-buggy.p

@@ -1,9 +0,0 @@-% SPASS solves this instantly, Twee takes ages!-cnf(axiom, axiom, multiply(U,add(V,W))=add(multiply(U,V),multiply(U,W))).-cnf(axiom, axiom, add(U,additive_inverse(add(additive_inverse(V),U)))=V).-cnf(axiom, axiom, add(U,additive_inverse(add(V,add(W,U))))=additive_inverse(add(V,W))).-cnf(axiom, axiom, add(additive_inverse(U),V)=additive_inverse(add(U,additive_inverse(V)))).-cnf(axiom, axiom, multiply(multiply(U,V),W)=add(associator(U,V,W),multiply(U,multiply(V,W)))).-cnf(axiom, axiom, additive_inverse(add(multiply(U,multiply(V,W)),add(multiply(U,multiply(X,W)),additive_inverse(add(multiply(multiply(U,V),W),multiply(multiply(U,X),W))))))=associator(U,add(V,X),W)).--cnf(conjecture, conjecture, add(associator(U,V,W),associator(U,X,W))=associator(U,add(V,X),W)).

− tests/RNG035-7.p

@@ -1,12 +0,0 @@-cnf(left_additive_identity, axiom, add(additive_identity, X)=X).-cnf(right_additive_identity, axiom, add(X, additive_identity)=X).-cnf(left_additive_inverse, axiom, add(additive_inverse(X), X)=additive_identity).-cnf(right_additive_inverse, axiom, add(X, additive_inverse(X))=additive_identity).-cnf(associativity_for_addition, axiom, add(X, add(Y, Z))=add(add(X, Y), Z)).-cnf(commutativity_for_addition, axiom, add(X, Y)=add(Y, X)).-cnf(associativity_for_multiplication, axiom, multiply(X, multiply(Y, Z))=multiply(multiply(X, Y), Z)).-cnf(distribute1, axiom, multiply(X, add(Y, Z))=add(multiply(X, Y), multiply(X, Z))).-cnf(distribute2, axiom, multiply(add(X, Y), Z)=add(multiply(X, Z), multiply(Y, Z))).-cnf(x_fourthed_is_x, hypothesis, multiply(X, multiply(X, multiply(X, X)))=X).-cnf(a_times_b_is_c, negated_conjecture, multiply(a, b)=c).-cnf(prove_commutativity, negated_conjecture, multiply(b, a)!=c).

− tests/ROB001-1-a.p

@@ -1,42 +0,0 @@-%-------------------------------------------------------------------------------% File     : ROB001-1 : TPTP v9.0.0. Released v1.0.0.-% Domain   : Robbins Algebra-% Problem  : Is every Robbins algebra Boolean?-% Version  : [Win90] (equality) axioms.-% English  :--% Refs     : [HMT71] Henkin et al. (1971), Cylindrical Algebras-%          : [Win90] Winker (1990), Robbins Algebra: Conditions that make a-% Source   : [TPTP]-% Names    :--% Status   : Unsatisfiable-% Rating   : 1.00 v2.0.0-% Syntax   : Number of clauses     :    4 (   4 unt;   0 nHn;   1 RR)-%            Number of literals    :    4 (   4 equ;   1 neg)-%            Maximal clause size   :    1 (   1 avg)-%            Maximal term depth    :    6 (   2 avg)-%            Number of predicates  :    1 (   0 usr;   0 prp; 2-2 aty)-%            Number of functors    :    4 (   4 usr;   2 con; 0-2 aty)-%            Number of variables   :    7 (   0 sgn)-% SPC      : CNF_UNS_RFO_PEQ_UEQ--% Comments : Commutativity, associativity, and Huntington's axiom axiomatize -%            Boolean algebra.-%-------------------------------------------------------------------------------%----Include axioms for Robbins algebra-include('Axioms/ROB001-0.ax').-%-------------------------------------------------------------------------------cnf(prove_huntingtons_axiom,negated_conjecture,-    add(negate(add(a,negate(b))),negate(add(negate(a),negate(b)))) != b ).--%--------------------------------------------------------------------------------cnf(sos04,axiom,(-    g(A) = inv(add(A,inv(A))) )).--%----Definition of h-%cnf(sos05,axiom,(-%    h(A) = add(A,add(A,add(A,inv(add(A,inv(A)))))))).-cnf(sos05,axiom,(-    $hint(add(A,add(A,add(A,g(A))))))).

− tests/ROB007-1-a.p

@@ -1,12 +0,0 @@-cnf(commutativity_of_add, axiom, add(X, Y)=add(Y, X)).-cnf(associativity_of_add, axiom, add(add(X, Y), Z)=add(X, add(Y, Z))).-cnf(robbins_axiom, axiom, inv(add(inv(add(X, Y)), inv(add(X, inv(Y)))))=X).-cnf(condition, hypothesis, inv(add(a, b))=inv(b)).-cnf(prove_huntingtons_axiom, negated_conjecture, add(inv(add(a, inv(b))), inv(add(inv(a), inv(b))))!=b).--cnf(sos04,axiom,(-    g(A) = inv(add(A,inv(A))) )).--%----Definition of h-cnf(sos05,axiom,(-    h(A) = add(A,add(A,add(A,inv(add(A,inv(A)))))))).

− tests/ROB007-1-b.p

@@ -1,12 +0,0 @@-cnf(commutativity_of_add, axiom, add(X, Y)=add(Y, X)).-cnf(associativity_of_add, axiom, add(add(X, Y), Z)=add(X, add(Y, Z))).-cnf(robbins_axiom, axiom, inv(add(inv(add(X, Y)), inv(add(X, inv(Y)))))=X).-cnf(condition, hypothesis, inv(add(a, b))=inv(b)).-cnf(prove_huntingtons_axiom, negated_conjecture, add(inv(add(a, inv(b))), inv(add(inv(a), inv(b))))!=b).--cnf(sos04,axiom,(-    $hint(inv(add(A,inv(A)))) )).--%----Definition of h-cnf(sos05,axiom,(-    $hint(add(A,add(A,add(A,inv(add(A,inv(A))))))))).

− tests/ROB007-1.p

@@ -1,5 +0,0 @@-cnf(commutativity_of_add, axiom, add(X, Y)=add(Y, X)).-cnf(associativity_of_add, axiom, add(add(X, Y), Z)=add(X, add(Y, Z))).-cnf(robbins_axiom, axiom, negate(add(negate(add(X, Y)), negate(add(X, negate(Y)))))=X).-cnf(condition, hypothesis, negate(add(a, b))=negate(b)).-cnf(prove_huntingtons_axiom, negated_conjecture, add(negate(add(a, negate(b))), negate(add(negate(a), negate(b))))!=b).

− tests/ROB010-1.p

@@ -1,11 +0,0 @@-cnf(condition,hypothesis,-    ( negate(add(a,negate(b))) = c )).--cnf(prove_result,negated_conjecture,-    (  negate(add(c,negate(add(b,a)))) != a )).--cnf(commutativity_of_add,axiom,-    ( add(X,Y) = add(Y,X) )).--cnf(robbins_axiom,axiom,-    ( negate(add(negate(add(X,Y)),negate(add(X,negate(Y))))) = X )).

− tests/ROB027-1-inv.p

@@ -1,58 +0,0 @@-%---------------------------------------------------------------------------% File     : ROB027-1 : TPTP v6.3.0. Released v1.2.0.-% Domain   : Robbins Algebra-% Problem  : -(-c) = c => Boolean-% Version  : [Win90] (equality) axioms.-%            Theorem formulation : Denies Huntington's axiom.-% English  : If there are elements c and d such that c+d=d, then the-%            algebra is Boolean.--% Refs     : [HMT71] Henkin et al. (1971), Cylindrical Algebras-%          : [Win90] Winker (1990), Robbins Algebra: Conditions that make a-%          : [Wos94] Wos (1994), Two Challenge Problems-% Source   : [Wos94]-% Names    : - [Wos94]--% Status   : Open-% Rating   : 1.00 v2.0.0-% Syntax   : Number of clauses     :    5 (   0 non-Horn;   5 unit;   2 RR)-%            Number of atoms       :    5 (   5 equality)-%            Maximal clause size   :    1 (   1 average)-%            Number of predicates  :    1 (   0 propositional; 2-2 arity)-%            Number of functors    :    5 (   3 constant; 0-2 arity)-%            Number of variables   :    7 (   0 singleton)-%            Maximal term depth    :    6 (   3 average)-% SPC      : CNF_UNK_UEQ--% Comments : Commutativity, associativity, and Huntington's axiom-%            axiomatize Boolean algebra.-%---------------------------------------------------------------------------%----Include axioms for Robbins algebra-%---------------------------------------------------------------------------cnf(commutativity_of_add,axiom,-    ( add(X,Y) = add(Y,X) )).--cnf(associativity_of_add,axiom,-    ( add(add(X,Y),Z) = add(X,add(Y,Z)) )).--cnf(robbins_axiom,axiom,-    ( inv(add(inv(add(X,Y)),inv(add(X,inv(Y))))) = X )).--%---------------------------------------------------------------------------%---------------------------------------------------------------------------cnf(double_negation,hypothesis,-    ( inv(inv(c)) = c )).--cnf(prove_huntingtons_axiom,negated_conjecture,-    add(inv(add(a,inv(b))),inv(add(inv(a),inv(b)))) != b).--%---------------------------------------------------------------------------%----Definition of g-cnf(sos04,axiom,(-    g(A) = inv(add(A,inv(A))) )).--%----Definition of h-cnf(sos05,axiom,(-    h(A) = add(A,add(A,add(A,inv(add(A,inv(A)))))))).--cnf(sos06, axiom, i(X,Y) = inv(add(X, inv(add(X, Y))))).

− tests/ROB027-1-pretty.p

@@ -1,56 +0,0 @@-%---------------------------------------------------------------------------% File     : ROB027-1 : TPTP v6.3.0. Released v1.2.0.-% Domain   : Robbins Algebra-% Problem  : -(-c) = c => Boolean-% Version  : [Win90] (equality) axioms.-%            Theorem formulation : Denies Huntington's axiom.-% English  : If there are elements c and d such that c+d=d, then the-%            algebra is Boolean.--% Refs     : [HMT71] Henkin et al. (1971), Cylindrical Algebras-%          : [Win90] Winker (1990), Robbins Algebra: Conditions that make a-%          : [Wos94] Wos (1994), Two Challenge Problems-% Source   : [Wos94]-% Names    : - [Wos94]--% Status   : Open-% Rating   : 1.00 v2.0.0-% Syntax   : Number of clauses     :    5 (   0 non-Horn;   5 unit;   2 RR)-%            Number of atoms       :    5 (   5 equality)-%            Maximal clause size   :    1 (   1 average)-%            Number of predicates  :    1 (   0 propositional; 2-2 arity)-%            Number of functors    :    5 (   3 constant; 0-2 arity)-%            Number of variables   :    7 (   0 singleton)-%            Maximal term depth    :    6 (   3 average)-% SPC      : CNF_UNK_UEQ--% Comments : Commutativity, associativity, and Huntington's axiom-%            axiomatize Boolean algebra.-%---------------------------------------------------------------------------%----Include axioms for Robbins algebra-%---------------------------------------------------------------------------cnf(commutativity_of_add,axiom,-    ( '+'(X,Y) = '+'(Y,X) )).--cnf(associativity_of_add,axiom,-    ( '+'('+'(X,Y),Z) = '+'(X,'+'(Y,Z)) )).--cnf(robbins_axiom,axiom,-    ( '-'('+'('-'('+'(X,Y)),'-'('+'(X,'-'(Y))))) = X )).--%---------------------------------------------------------------------------%---------------------------------------------------------------------------cnf(double_negation,hypothesis,-    ( '-'('-'(c)) = c )).--cnf(prove_huntingtons_axiom,negated_conjecture,-    '+'('-'('+'(a,'-'(b))),'-'('+'('-'(a),'-'(b)))) != b).--%---------------------------------------------------------------------------%----Definition of g-cnf(sos04,axiom,(-    g(A) = '-'('+'(A,'-'(A))) )).--%----Definition of h-cnf(sos05,axiom,(-    h(A) = '+'(A,'+'(A,'+'(A,'-'('+'(A,'-'(A)))))))).

− tests/ROB027-1.p

@@ -1,56 +0,0 @@-%---------------------------------------------------------------------------% File     : ROB027-1 : TPTP v6.3.0. Released v1.2.0.-% Domain   : Robbins Algebra-% Problem  : -(-c) = c => Boolean-% Version  : [Win90] (equality) axioms.-%            Theorem formulation : Denies Huntington's axiom.-% English  : If there are elements c and d such that c+d=d, then the-%            algebra is Boolean.--% Refs     : [HMT71] Henkin et al. (1971), Cylindrical Algebras-%          : [Win90] Winker (1990), Robbins Algebra: Conditions that make a-%          : [Wos94] Wos (1994), Two Challenge Problems-% Source   : [Wos94]-% Names    : - [Wos94]--% Status   : Open-% Rating   : 1.00 v2.0.0-% Syntax   : Number of clauses     :    5 (   0 non-Horn;   5 unit;   2 RR)-%            Number of atoms       :    5 (   5 equality)-%            Maximal clause size   :    1 (   1 average)-%            Number of predicates  :    1 (   0 propositional; 2-2 arity)-%            Number of functors    :    5 (   3 constant; 0-2 arity)-%            Number of variables   :    7 (   0 singleton)-%            Maximal term depth    :    6 (   3 average)-% SPC      : CNF_UNK_UEQ--% Comments : Commutativity, associativity, and Huntington's axiom-%            axiomatize Boolean algebra.-%---------------------------------------------------------------------------%----Include axioms for Robbins algebra-%---------------------------------------------------------------------------cnf(commutativity_of_add,axiom,-    ( add(X,Y) = add(Y,X) )).--cnf(associativity_of_add,axiom,-    ( add(add(X,Y),Z) = add(X,add(Y,Z)) )).--cnf(robbins_axiom,axiom,-    ( negate(add(negate(add(X,Y)),negate(add(X,negate(Y))))) = X )).--%---------------------------------------------------------------------------%---------------------------------------------------------------------------cnf(double_negation,hypothesis,-    ( negate(negate(c)) = c )).--cnf(prove_huntingtons_axiom,negated_conjecture,-    add(negate(add(a,negate(b))),negate(add(negate(a),negate(b)))) != b).--%---------------------------------------------------------------------------%----Definition of g-cnf(sos04,axiom,(-    g(A) = negate(add(A,negate(A))) )).--%----Definition of h-cnf(sos05,axiom,(-    h(A) = add(A,add(A,add(A,negate(add(A,negate(A)))))))).

− tests/ROB033-1.p

@@ -1,10 +0,0 @@-cnf(commutativity_of_add, axiom, add(X, Y)=add(Y, X)).-cnf(associativity_of_add, axiom,-    add(add(X, Y), Z)=add(X, add(Y, Z))).-cnf(robbins_axiom, axiom,-    negate(add(negate(add(X, Y)), negate(add(X, negate(Y)))))=X).-cnf(sos04, axiom, g(A)=negate(add(A, negate(A)))).-cnf(sos05, axiom, h(A)=add(A, add(A, add(A, g(A))))).-cnf(goals, negated_conjecture,-    add(negate(add(x0, negate(x1))),-        negate(add(negate(x0), negate(x1))))!=x1).

− tests/aim.p

@@ -1,62 +0,0 @@-cnf(left_ident, axiom,-  '1' * X = X).-cnf(right_ident, axiom,-  X * '1' = X).-cnf(left_division_1, axiom,-  X \ (X * Y) = Y).-cnf(left_division_2, axiom,-  X * (X \ Y) = Y).-cnf(right_division_1, axiom,-  (X * Y) / Y = X).-cnf(right_division_2, axiom,-  (X / Y) * Y = X).-cnf(associator, axiom,-  (X * (Y * Z)) \ ((X * Y) * Z) = a(X,Y,Z)).-cnf(commutator, axiom,-  (X * Y) \ (Y * X) = k(Y,X)).-cnf(l, axiom,-  (Y * X) \ (Y * (X * U)) = l(U,X,Y)).-cnf(r, axiom,-  ((U * X) * Y) / (X * Y) = r(U,X,Y)).-cnf(t, axiom,-  X \ (U * X) = t(U,X)).-cnf(abelian_inner_mapping_1, axiom,-  t(t(U,X),Y) = t(t(U,Y),X)).-cnf(abelian_inner_mapping_2, axiom,-  t(l(U,X,Y),Z) = l(t(U,Z),X,Y)).-cnf(abelian_inner_mapping_3, axiom,-  t(r(U,X,Y),Z) = r(t(U,Z),X,Y)).-cnf(abelian_inner_mapping_4, axiom,-  l(r(U,X,Y),Z,W) = r(l(U,Z,W),X,Y)).-cnf(abelian_inner_mapping_5, axiom,-  l(l(U,X,Y),Z,W) = l(l(U,Z,W),X,Y)).-cnf(abelian_inner_mapping_6, axiom,-  r(r(U,X,Y),Z,W) = r(r(U,Z,W),X,Y)).--% aK (or "single-a") goals-cnf(ka, conjecture,-  k(a(x,y,z),u) = '1').-cnf(aK1, conjecture,-  a(k(x,y),z,u) = '1').-cnf(aK2, conjecture,-  a(x,k(y,z),u) = '1').-cnf(aK3, conjecture,-  a(x,y,k(z,u)) = '1').--% aa (or "double-a") goals-cnf(aa1, conjecture,-  a(a(x,y,z),u,w) = '1').-cnf(aa2, conjecture,-  a(x,a(y,z,u),w) = '1').-cnf(aa3, conjecture,-  a(x,y,a(z,u,w)) = '1').--%cnf(everything, conjecture,-%  k(a(X,Y,Z),U) = '1' |-%  a(k(X,Y),Z,U) = '1' |-%  a(X,k(Y,Z),U) = '1' |-%  a(X,Y,k(Z,U)) = '1' |-%  a(a(X,Y,Z),U,W) = '1' |-%  a(X,a(Y,Z,U),W) = '1' |-%  a(X,Y,a(Z,U,W)) = '1').-

− tests/aim2.p

@@ -1,64 +0,0 @@-cnf(left_ident, axiom,-  '1' * X = X).-cnf(right_ident, axiom,-  X * '1' = X).-cnf(left_division_1, axiom,-  X \ (X * Y) = Y).-cnf(left_division_2, axiom,-  X * (X \ Y) = Y).-cnf(right_division_1, axiom,-  (X * Y) / Y = X).-cnf(right_division_2, axiom,-  (X / Y) * Y = X).-cnf(associator, axiom,-  (X * (Y * Z)) \ ((X * Y) * Z) = a(X,Y,Z)).-cnf(commutator, axiom,-  (X * Y) \ (Y * X) = k(Y,X)).-cnf(l, axiom,-  (Y * X) \ (Y * (X * U)) = l(U,X,Y)).-cnf(r, axiom,-  ((U * X) * Y) / (X * Y) = r(U,X,Y)).-cnf(t, axiom,-  X \ (U * X) = t(U,X)).-cnf(abelian_inner_mapping_1, axiom,-  t(t(U,X),Y) = t(t(U,Y),X)).-cnf(abelian_inner_mapping_2, axiom,-  t(l(U,X,Y),Z) = l(t(U,Z),X,Y)).-cnf(abelian_inner_mapping_3, axiom,-  t(r(U,X,Y),Z) = r(t(U,Z),X,Y)).-cnf(abelian_inner_mapping_4, axiom,-  l(r(U,X,Y),Z,W) = r(l(U,Z,W),X,Y)).-cnf(abelian_inner_mapping_5, axiom,-  l(l(U,X,Y),Z,W) = l(l(U,Z,W),X,Y)).-cnf(abelian_inner_mapping_6, axiom,-  r(r(U,X,Y),Z,W) = r(r(U,Z,W),X,Y)).--% aK (or "single-a") goals-cnf(ka, conjecture,-  k(a(X,Y,Z),U) = '1').-cnf(aK1, conjecture,-  a(k(X,Y),Z,U) = '1').-cnf(aK2, conjecture,-  a(X,k(Y,Z),U) = '1').-cnf(aK3, conjecture,-  a(X,Y,k(Z,U)) = '1').--% aa (or "double-a") goals-cnf(aa1, conjecture,-  a(a(X,Y,Z),U,W) = '1').-cnf(aa2, conjecture,-  a(X,a(Y,Z,U),W) = '1').-cnf(aa3, conjecture,-  a(X,Y,a(Z,U,W)) = '1').--%cnf(everything, conjecture,-%  k(a(X,Y,Z),U) = '1' |-%  a(k(X,Y),Z,U) = '1' |-%  a(X,k(Y,Z),U) = '1' |-%  a(X,Y,k(Z,U)) = '1' |-%  a(a(X,Y,Z),U,W) = '1' |-%  a(X,a(Y,Z,U),W) = '1' |-%  a(X,Y,a(Z,U,W)) = '1').---cnf(bonus, axiom, (X * (Y / X)) \ X = Y \ (Y / (Y / X))).

− tests/append-rev.p

@@ -1,4 +0,0 @@-cnf(rev_rev, axiom, rev(rev(X)) = X).-cnf(app_assoc, axiom, X ++ (Y ++ Z) = (X ++ Y) ++ Z).-cnf(rev_app, axiom, rev(X) ++ rev(Y) = rev(Y ++ X)).-fof(conjecture, conjecture, ![A,B]: A ++ rev(B) = rev(B ++ rev(A))).

− tests/cm.p

@@ -1,3 +0,0 @@-fof(a, axiom, ![X, Y]: plus(X, Y)=plus(Y, X)).-fof(a, axiom, ![X, Y, Z]: plus(plus(X, Y), Z)=plus(X, plus(Z, Y))).-fof(a, axiom, a!=b).

− tests/deriv.p

@@ -1,37 +0,0 @@-% Axioms about arithmetic.--cnf('commutativity of +', axiom,-    X + Y = Y + X).-cnf('associativity of +', axiom,-    X + (Y + Z) = (X + Y) + Z).-cnf('commutativity of *', axiom,-    X * Y = Y * X).-cnf('associativity of *', axiom,-    X * (Y * Z) = (X * Y) * Z).-cnf('plus 0', axiom,-    '0' + X = X).-cnf('times 0', axiom,-    '0' * X = '0').-cnf('times 1', axiom,-    '1' * X = X).-cnf('distributivity', axiom,-    X * (Y + Z) = (X * Y) + (X * Z)).-cnf('minus', axiom,-    X + -X = '0').-cnf('derivative of 0', axiom,-    d('0') = '0').-cnf('derivative of 1', axiom,-    d('1') = '0').-cnf('derivative of x', axiom,-    d(x) = '1').-cnf('derivative of +', axiom,-    d(T+U) = d(T) + d(U)).-cnf('derivative of *', axiom,-    d(T*U) = (T*d(U)) + (U*d(T))).-cnf('derivative of sin', axiom,-    d(sin(T)) = cos(T) * d(T)).-cnf('derivative of cos', axiom,-    d(cos(T)) = -(sin(T)*d(T))).--fof(goal, conjecture,-    ?[T]: d(T) = x*cos(x)).

− tests/diff.p

@@ -1,8 +0,0 @@-cnf('x\\(y\\x)=x', axiom,-    X \ (Y \ X) = X).-cnf('x\\(x\\y)=y\\(y\\x)', axiom,-    X \ (X \ Y) = Y \ (Y \ X)).-cnf('(x\\y)\\z=(x\\z)\\(y\\z)', axiom,-    (X \ Y) \ Z = (X \ Z) \ (Y \ Z)).-cnf(conjecture, conjecture,-    (a \ c) \ b = (a \ b) \ c).

− tests/diff2.p

@@ -1,34 +0,0 @@-cnf('x\\(y\\x)=x', axiom,-    X \ (Y \ X) = X).-cnf('x\\(x\\y)=y\\(y\\x)', axiom,-    X \ (X \ Y) = Y \ (Y \ X)).-cnf('(x\\y)\\z=(x\\z)\\(y\\z)', axiom,-    (X \ Y) \ Z = (X \ Z) \ (Y \ Z)).--cnf(empty, axiom,-    X \ empty = X).--cnf(equals, conjecture,-    (X \ Y = empty & Y \ X = empty) => X = Y).--cnf(union, axiom,-    X \ union(Y, Z) = (X \ Y) \ Z).--cnf(union, conjecture,-    union(a,b) = union(b,a)).-cnf(union, conjecture,-    union(a,a) = a).-cnf(union, conjecture,-    union(a,union(b,c)) = union(union(a,b),c)).--cnf(intersection, axiom,-    intersection(X, Y) = X \ (X \ Y)).--cnf(intersection, conjecture,-    intersection(a,b) = intersection(b,a)).-cnf(intersection, conjecture,-    intersection(a,a) = a).-cnf(intersection, conjecture,-    intersection(a,intersection(b,c)) = intersection(intersection(a,b),c)).-cnf(intersection, conjecture,-    intersection(X, Y) = union(X,Y) \ union(X \ Y, Y \ X)).

− tests/factor.p

@@ -1,44 +0,0 @@-% Axioms about arithmetic.--cnf('commutativity_of_plus', axiom,-    X + Y = Y + X).-cnf('associativity_of_plus', axiom,-    X + (Y + Z) = (X + Y) + Z).-cnf('commutativity_of_times', axiom,-    X * Y = Y * X).-cnf('associativity_of_times', axiom,-    X * (Y * Z) = (X * Y) * Z).-cnf('plus_zero', axiom,-    '0' + X = X).-cnf('times_zero', axiom,-    '0' * X = '0').-cnf('times_one', axiom,-    '1' * X = X).-cnf('distributivity', axiom,-    X * (Y + Z) = (X * Y) + (X * Z)).-cnf('minus', axiom,-    X + -X = '0').--cnf(two, axiom, two = '1'+'1').-cnf(three, axiom, three = '1'+two).-cnf(four, axiom, four = '1'+three).-cnf(five, axiom, five = '1'+four).-cnf(six, axiom, six = '1'+five).-cnf(seven, axiom, seven = '1'+six).-cnf(eight, axiom, eight = '1'+seven).-cnf(nine, axiom, nine = '1'+eight).-cnf(minus_six, axiom, minus_four = -four).-cnf(minus_six, axiom, minus_six = -six).--fof(factoring, conjecture,-    ?[A,B,C]: ![X]:-      (X*(X*X)) + ((minus_six*(X*X)) + ((nine*X) + minus_four)) = ((X +-      -'1')*((X + -'1') * (X + -four)))).--fof(factoring, conjecture,-    ?[A,B,C]: ![X]:-    (X*(X*X)) +-    (-(('1'+('1'+('1'+('1'+('1'+'1')))))*(X*X)) +-     ((('1'+('1'+('1'+('1'+('1'+('1'+('1'+('1'+'1'))))))))*X) +-     -('1'+('1'+('1'+'1'))))) =-    (X + -A)*((X + -B)*(X + -C))).

− tests/filter.p

@@ -1,59 +0,0 @@-fof('associativity of ∘', axiom,-    ![F, G, H]:-    F ∘ (G ∘ H) = (F ∘ G) ∘ H).--fof('∘ identity', axiom,-    ![F]:-    id ∘ F = F).--fof('∘ identity', axiom,-    ![F]:-    F ∘ id = F).--fof('map functor', axiom,-    ![F, G]:-    map(F) ∘ map(G) = map(F ∘ G)).--fof('map functor', axiom,-    map(id) = id).--fof('naturality of concat', axiom,-    ![F]:-    map(F) ∘ concat = concat ∘ map(map(F))).--fof('defn filter', axiom,-    ![P]:-    filter(P) = concat ∘ map(test(P))).--% test(P) = \x -> if P(x) then [x] else []--fof('test property', axiom,-    ![P, F]:-    test(P) ∘ F =-    map(F) ∘ test(P ∘ F)).--fof('map/filter', conjecture,-    ![P, F]:-    filter(P) ∘ map(F) = map(F) ∘ filter(P ∘ F)).---% cond(P, F, G) = \x -> if P(x) then F(x) else G(x)--%fof('test defn', axiom,-%    ![P]:-%    test(P) = cond(P, unit, nil)).-%fof('cond ∘', axiom,-%    ![F, P, G, H]:-%    F ∘ cond(P, G, H) = cond(P, F ∘ G, F ∘ H)).-%fof('cond ∘', axiom,-%    ![F, P, G, H]:-%    cond(P, G, H) ∘ F = cond(P ∘ F, G ∘ F, H ∘ F)).-%fof('nil', axiom,-%    ![F]:-%    nil ∘ F = nil).-%fof('nil', axiom,-%    ![F]:-%    map(F) ∘ nil = nil).-%fof('unit', axiom,-%    ![F]:-%    map(F) ∘ unit = unit ∘ F).

− tests/filter2.p

@@ -1,59 +0,0 @@-fof('associativity of ∘', axiom,-    ![F, G, H]:-    F ∘ (G ∘ H) = (F ∘ G) ∘ H).--fof('∘ identity', axiom,-    ![F]:-    id ∘ F = F).--fof('∘ identity', axiom,-    ![F]:-    F ∘ id = F).--fof('map functor', axiom,-    ![F, G]:-    map(F) ∘ map(G) = map(F ∘ G)).--fof('map functor', axiom,-    map(id) = id).--fof('naturality of concat', axiom,-    ![F]:-    map(F) ∘ concat = concat ∘ map(map(F))).--fof('defn filter', axiom,-    ![P]:-    filter(P) = concat ∘ map(test(P))).--% test(P) = \x -> if P(x) then [x] else []--%fof('test property', axiom,-%    ![P, F]:-%    test(P) ∘ F =-%    map(F) ∘ test(P ∘ F)).--fof('map/filter', conjecture,-    ![P, F]:-    filter(P) ∘ map(F) = map(F) ∘ filter(P ∘ F)).---% cond(P, F, G) = \x -> if P(x) then F(x) else G(x)--fof('test defn', axiom,-    ![P]:-    test(P) = cond(P, unit, nil)).-fof('cond ∘', axiom,-    ![F, P, G, H]:-    F ∘ cond(P, G, H) = cond(P, F ∘ G, F ∘ H)).-fof('cond ∘', axiom,-    ![F, P, G, H]:-    cond(P, G, H) ∘ F = cond(P ∘ F, G ∘ F, H ∘ F)).-fof('nil', axiom,-    ![F]:-    nil ∘ F = nil).-fof('nil', axiom,-    ![F]:-    map(F) ∘ nil = nil).-fof('unit', axiom,-    ![F]:-    map(F) ∘ unit = unit ∘ F).

− tests/gmv.p

@@ -1,74 +0,0 @@-cnf('Associativity-∧', axiom,-    (X ∧ Y) ∧ Z = X ∧ (Y ∧ Z)).   -cnf('Associativity-∨', axiom,-    (X ∨ Y) ∨ Z = X ∨ (Y ∨ Z)).-cnf('Idempotence-∧', axiom,-    X ∧ X = X).-cnf('Idempotence-∨', axiom,-    X ∨ X = X).-cnf('Commutativity-∧', axiom,-    X ∧ Y = Y ∧ X).-cnf('Commutativity-∨', axiom,-    X ∨ Y = Y ∨ X).-cnf('Absorption a', axiom,-    (X ∧ Y) ∨ X = X).-cnf('Absorption b', axiom,-    (X ∨ Y) ∧ X = X).--cnf('Residual a', axiom,-    (X * ((X \ Z) ∧ Y)) ∨ Z = Z).-cnf('Residual b', axiom,-    ((Y ∧ (Z / X)) * X) ∨ Z = Z).-cnf('Residual c', axiom,-    (X \ ((X * Y) ∨ Z)) ∧ Y = Y).-cnf('Residual d', axiom,-    (((Y * X) ∨ Z) / X) ∧ Y = Y).--cnf('Associativity-* (fusion)', axiom,-    (X * Y) * Z = X * (Y * Z)).-cnf('Left monoid unit', axiom,-    '1' * X = X).-cnf('Right monoid unit', axiom,-    X * '1' = X).--cnf('GMV a', axiom,-    X ∨ Y = X / ((X ∨ Y) \ X)).-cnf('GMV b', axiom,-    X ∨ Y = (X / (X ∨ Y)) \ X).--cnf('Definition-@', axiom,-    X @ Y = (X * (X \ '1')) * ((Y \ '1') \ '1')).--cnf('Goal 1', conjecture,-    x @ x = x).-cnf('Goal 2', conjecture,-    (x @ y) @ z = x @ z).-cnf('Goal 3', conjecture,-    x @ (y @ z) = x @ z).-  -cnf('Goal 4', conjecture,-    (x ∧ y) @ (z ∧ u) = (x @ z) ∧ (y @ u)).-cnf('Goal 5', conjecture,-    (x ∨ y) @ (z ∨ u) = (x @ z) ∨ (y @ u)).-cnf('Goal 6', conjecture,-    (x \ y) @ (z \ u) = (x @ z) \ (y @ u)).-cnf('Goal 7', conjecture,-    (x / y) @ (z / u) = (x @ z) / (y @ u)).-  -cnf('Goal 8', conjecture,-    (x * (x \ '1')) @ '1' = x * (x \ '1')).-cnf('Goal 9', conjecture,-    '1' @ (x * (x \ '1')) = '1').-cnf('Goal 10', conjecture,-    (x \ '1') @ '1' = '1').-cnf('Goal 11', conjecture,-    '1' @ (x \ '1') = x \ '1').-  -cnf('Goal 12', conjecture,-    (x / (y \ x)) @ (x ∨ y) = x ∨ y).-cnf('Goal 13', conjecture,-    ((x / y) \ x) @ (x ∨ y) = x ∨ y).-cnf('Goal 14', conjecture,-    (x ∨ y) @ (x / (y \ x)) = x / (y \ x)).-cnf('Goal 15', conjecture,-    (x ∨ y) @ ((x / y) \ x) = (x / y) \ x).

− tests/group.p

@@ -1,14 +0,0 @@-cnf(associativity, axiom,-    X + (Y + Z) = (X + Y) + Z).-cnf(plus_zero, axiom,-    '0' + X = X).-cnf(plus_zero, axiom,-    X + '0' = X).-cnf(minus_left, axiom,-    (-X) + X = '0').-cnf(minus_right, axiom,-    X + (-X) = '0').-cnf(assumption, assumption,-    a + b = a).-cnf(goal, conjecture,-    b = '0').

− tests/haken.p

@@ -1,170 +0,0 @@-cnf(a, conjecture, a1 = a2 & a2 = a3 & a3 = a4 & a4 = a5 & a5 = a6 &-a6 = a7 & a7 = a8 & a8 = a9 & a9 = a10 & a10 = a11 & a11 = a12 & a12 =-a13 & a13 = a14 & a14 = a15 & a15 = a16 & a16 = a17 & a17 = a18 & a18-= a19 & a19 = a20 & a20 = a21 & a20 = a22 & a21 = a23 & a23 = a24 &-a24 = a25 & a25 = a26 & a26 = a27 & a27 = a28 & a28 = a29 & a29 = a30-& a30 = a31 & a31 = a32 & a32 = a33 & a33 = a34 & a34 = a35 & a35 =-a36 & a36 = a37 & a37 = a38 & a38 = a39 & a39 = a40 & a40 = a41 & a41-= a42 & a42 = a43 & a43 = a44 & a44 = a45 & a45 = a46 & a46 = a47 &-a47 = a48 & a48 = a49 & a49 = a50 & a50 = a51 & a51 = a52 & a52 = a53-& a53 = a54 & a54 = a55 & a55 = a56 & a56 = a57 & a57 = a58 & a58 =-a59 & a59 = a60 & a60 = a61 & a61 = a62 & a62 = a63 & a63 = a64 & a64-= a65 & a65 = a66 & a66 = a67 & a67 = a68 & a68 = a69 & a69 = a70 &-a70 = a71 & a71 = a72 & a72 = a73 & a73 = a74 & a74 = a75 & a75 = a76-& a76 = a77 & a77 = a78 & a78 = a79 & a79 = a80 & a80 = a81 & a81 =-a82 & a82 = a83 & a83 = a84 & a84 = a85 & a85 = a86 & a86 = a87 & a87-= a88 & a88 = a89 & a89 = a90 & a90 = a91 & a91 = a92 & a92 = a93 &-a93 = a94 & a94 = a95 & a95 = a96 & a96 = a97 & a97 = a98 & a98 = a99-& a99 = a100 & a100 = a101 & a101 = a102 & a102 = a103 & a103 = a104 &-a104 = a105 & a105 = a106 & a106 = a107 & a107 = a108 & a108 = a109 &-a109 = a110 & a110 = a111 & a111 = a112 & a112 = a113 & a113 = a114 &-a114 = a115 & a115 = a116 & a116 = a117 & a117 = a118 & a118 = a119 &-a119 = a120 & a120 = a121 & a121 = a122 & a122 = a123 & a123 = a124 &-a124 = a125 & a125 = a126 & a126 = a127 & a127 = a128 & a128 = a129 &-a129 = a130 & a130 = a131 & a131 = a132 & a132 = a133 & a133 = a134 &-a134 = a135 & a135 = a136 & a136 = a137 & a137 = a138 & a138 = a139 &-a139 = a140 & a140 = a141).-cnf(a, axiom, '*'(X, X) = X).-cnf(a, axiom, '*'('*'(X,Y),Y) = X).-cnf(a, axiom, '*'('*'(X,Y),Z) = '*'('*'(X, Z), '*'(Y, Z))).-cnf(a, axiom, a2 = '*'(a1, a42)).-cnf(a, axiom, a3 = '*'(a2, a41)).-cnf(a, axiom, a4 = '*'(a3, a14)).-cnf(a, axiom, a5 = '*'(a4, a39)).-cnf(a, axiom, a6 = '*'(a5, a136)).-cnf(a, axiom, a7 = '*'(a6, a52)).-cnf(a, axiom, a8 = '*'(a7, a17)).-cnf(a, axiom, a9 = '*'(a8, a56)).-cnf(a, axiom, a10 = '*'(a9, a134)).-cnf(a, axiom, a11 = '*'(a10, a37)).-cnf(a, axiom, a12 = '*'(a11, a21)).-cnf(a, axiom, a13 = '*'(a12, a23)).-cnf(a, axiom, a14 = '*'(a13, a32)).-cnf(a, axiom, a15 = '*'(a14, a53)).-cnf(a, axiom, a16 = '*'(a15, a136)).-cnf(a, axiom, a17 = '*'(a16, a29)).-cnf(a, axiom, a18 = '*'(a17, a133)).-cnf(a, axiom, a19 = '*'(a18, a58)).-cnf(a, axiom, a20 = '*'(a19, a26)).-cnf(a, axiom, a21 = '*'(a20, a35)).-cnf(a, axiom, a22 = '*'(a21, a141)).-cnf(a, axiom, a23 = '*'(a22, a45)).-cnf(a, axiom, a24 = '*'(a23, a35)).-cnf(a, axiom, a25 = '*'(a24, a49)).-cnf(a, axiom, a26 = '*'(a25, a138)).-cnf(a, axiom, a27 = '*'(a26, a8)).-cnf(a, axiom, a28 = '*'(a27, a37)).-cnf(a, axiom, a29 = '*'(a28, a17)).-cnf(a, axiom, a30 = '*'(a29, a14)).-cnf(a, axiom, a31 = '*'(a30, a5)).-cnf(a, axiom, a32 = '*'(a31, a39)).-cnf(a, axiom, a33 = '*'(a32, a13)).-cnf(a, axiom, a34 = '*'(a33, a131)).-cnf(a, axiom, a35 = '*'(a34, a60)).-cnf(a, axiom, a36 = '*'(a35, a139)).-cnf(a, axiom, a37 = '*'(a36, a47)).-cnf(a, axiom, a38 = '*'(a37, a17)).-cnf(a, axiom, a39 = '*'(a38, a7)).-cnf(a, axiom, a40 = '*'(a39, a4)).-cnf(a, axiom, a41 = '*'(a40, a14)).-cnf(a, axiom, a42 = '*'(a41, a2)).-cnf(a, axiom, a43 = '*'(a42, a62)).-cnf(a, axiom, a44 = '*'(a43, a128)).-cnf(a, axiom, a45 = '*'(a44, a23)).-cnf(a, axiom, a46 = '*'(a45, a141)).-cnf(a, axiom, a47 = '*'(a46, a11)).-cnf(a, axiom, a48 = '*'(a47, a20)).-cnf(a, axiom, a49 = '*'(a48, a138)).-cnf(a, axiom, a50 = '*'(a49, a131)).-cnf(a, axiom, a51 = '*'(a50, a59)).-cnf(a, axiom, a52 = '*'(a51, a39)).-cnf(a, axiom, a53 = '*'(a52, a136)).-cnf(a, axiom, a54 = '*'(a53, a29)).-cnf(a, axiom, a55 = '*'(a54, a135)).-cnf(a, axiom, a56 = '*'(a55, a37)).-cnf(a, axiom, a57 = '*'(a56, a134)).-cnf(a, axiom, a58 = '*'(a57, a26)).-cnf(a, axiom, a59 = '*'(a58, a138)).-cnf(a, axiom, a60 = '*'(a59, a131)).-cnf(a, axiom, a61 = '*'(a60, a13)).-cnf(a, axiom, a62 = '*'(a61, a1)).-cnf(a, axiom, a63 = '*'(a62, a96)).-cnf(a, axiom, a64 = '*'(a63, a127)).-cnf(a, axiom, a65 = '*'(a64, a41)).-cnf(a, axiom, a66 = '*'(a65, a2)).-cnf(a, axiom, a67 = '*'(a66, a92)).-cnf(a, axiom, a68 = '*'(a67, a98)).-cnf(a, axiom, a69 = '*'(a68, a32)).-cnf(a, axiom, a70 = '*'(a69, a13)).-cnf(a, axiom, a71 = '*'(a70, a118)).-cnf(a, axiom, a72 = '*'(a71, a109)).-cnf(a, axiom, a73 = '*'(a72, a82)).-cnf(a, axiom, a74 = '*'(a73, a32)).-cnf(a, axiom, a75 = '*'(a74, a14)).-cnf(a, axiom, a76 = '*'(a75, a68)).-cnf(a, axiom, a77 = '*'(a76, a114)).-cnf(a, axiom, a78 = '*'(a77, a13)).-cnf(a, axiom, a79 = '*'(a78, a33)).-cnf(a, axiom, a80 = '*'(a79, a119)).-cnf(a, axiom, a81 = '*'(a80, a70)).-cnf(a, axiom, a82 = '*'(a81, a109)).-cnf(a, axiom, a83 = '*'(a82, a118)).-cnf(a, axiom, a84 = '*'(a83, a39)).-cnf(a, axiom, a85 = '*'(a84, a5)).-cnf(a, axiom, a86 = '*'(a85, a30)).-cnf(a, axiom, a87 = '*'(a86, a104)).-cnf(a, axiom, a88 = '*'(a87, a4)).-cnf(a, axiom, a89 = '*'(a88, a14)).-cnf(a, axiom, a90 = '*'(a89, a41)).-cnf(a, axiom, a91 = '*'(a90, a100)).-cnf(a, axiom, a92 = '*'(a91, a124)).-cnf(a, axiom, a93 = '*'(a92, a2)).-cnf(a, axiom, a94 = '*'(a93, a41)).-cnf(a, axiom, a95 = '*'(a94, a127)).-cnf(a, axiom, a96 = '*'(a95, a64)).-cnf(a, axiom, a97 = '*'(a96, a42)).-cnf(a, axiom, a98 = '*'(a97, a1)).-cnf(a, axiom, a99 = '*'(a98, a92)).-cnf(a, axiom, a100 = '*'(a99, a124)).-cnf(a, axiom, a101 = '*'(a100, a14)).-cnf(a, axiom, a102 = '*'(a101, a40)).-cnf(a, axiom, a103 = '*'(a102, a4)).-cnf(a, axiom, a104 = '*'(a103, a87)).-cnf(a, axiom, a105 = '*'(a104, a30)).-cnf(a, axiom, a106 = '*'(a105, a5)).-cnf(a, axiom, a107 = '*'(a106, a84)).-cnf(a, axiom, a108 = '*'(a107, a39)).-cnf(a, axiom, a109 = '*'(a108, a118)).-cnf(a, axiom, a110 = '*'(a109, a70)).-cnf(a, axiom, a111 = '*'(a110, a119)).-cnf(a, axiom, a112 = '*'(a111, a79)).-cnf(a, axiom, a113 = '*'(a112, a33)).-cnf(a, axiom, a114 = '*'(a113, a13)).-cnf(a, axiom, a115 = '*'(a114, a68)).-cnf(a, axiom, a116 = '*'(a115, a14)).-cnf(a, axiom, a117 = '*'(a116, a74)).-cnf(a, axiom, a118 = '*'(a117, a32)).-cnf(a, axiom, a119 = '*'(a118, a70)).-cnf(a, axiom, a120 = '*'(a119, a13)).-cnf(a, axiom, a121 = '*'(a120, a32)).-cnf(a, axiom, a122 = '*'(a121, a68)).-cnf(a, axiom, a123 = '*'(a122, a115)).-cnf(a, axiom, a124 = '*'(a123, a75)).-cnf(a, axiom, a125 = '*'(a124, a2)).-cnf(a, axiom, a126 = '*'(a125, a65)).-cnf(a, axiom, a127 = '*'(a126, a41)).-cnf(a, axiom, a128 = '*'(a127, a96)).-cnf(a, axiom, a129 = '*'(a128, a62)).-cnf(a, axiom, a130 = '*'(a129, a1)).-cnf(a, axiom, a131 = '*'(a130, a13)).-cnf(a, axiom, a132 = '*'(a131, a138)).-cnf(a, axiom, a133 = '*'(a132, a58)).-cnf(a, axiom, a134 = '*'(a133, a26)).-cnf(a, axiom, a135 = '*'(a134, a37)).-cnf(a, axiom, a136 = '*'(a135, a29)).-cnf(a, axiom, a137 = '*'(a136, a39)).-cnf(a, axiom, a138 = '*'(a137, a51)).-cnf(a, axiom, a139 = '*'(a138, a20)).-cnf(a, axiom, a140 = '*'(a139, a47)).-cnf(a, axiom, a141 = '*'(a140, a11)).-cnf(a, axiom, a1 = '*'(a141, a23)).

− tests/loop.p

@@ -1,6 +0,0 @@-cnf(mult_ld, axiom, X * (X \ Y) = Y).-cnf(ld_mult, axiom, X \ (X * Y) = Y).-cnf(mult_rd, axiom, (X / Y) * Y = X).-cnf(rd_mult, axiom, (X * Y) / Y = X).-cnf(moufang, axiom, X * (Y * (X * Z)) = ((X * Y) * X) * Z).-cnf(conjecture, conjecture, a \ a = a / a).

− tests/loop2.p

@@ -1,6 +0,0 @@-cnf('*-\\', axiom, X * (X \ Y) = Y).-cnf('\\-*', axiom, X \ (X * Y) = Y).-cnf('*-/', axiom, (X / Y) * Y = X).-cnf('/-*', axiom, (X * Y) / Y = X).-cnf(moufang, axiom, X * (Y * (X * Z)) = ((X * Y) * X) * Z).-cnf(conjecture, conjecture, a * (b / b) = a).

− tests/lukasiewicz.p

@@ -1,6 +0,0 @@-cnf(imp_true, axiom, implies(true, X) = X).-cnf(imp_compose, axiom, implies(implies(X, Y), implies(implies(Y, Z), implies(X, Z))) = true).-cnf(imp_not, axiom, implies(implies(not(X), not(Y)), implies(Y, X)) = true).-cnf(imp_switch, axiom, implies(implies(X, Y), Y) = implies(implies(Y, X), X)).-cnf(or_def, axiom, or(X, Y) = implies(not(X), Y)).-cnf(conjecture, negated_conjecture, or(a,or(b,c)) != or(or(a,b),c)).

− tests/lukasiewicz2.p

@@ -1,5 +0,0 @@-cnf(detachment, axiom, (p(X) & p(i(X,Y))) => p(Y)).-cnf(lukasiewicz, axiom, p(i(i(i(P,Q),R),i(i(R,P),i(S,P))))).-cnf(simp, axiom, p(i(P, i(Q, Q)))).-cnf(peirce, axiom, p(i(i(i(P,Q),P),P))).-cnf(syll, conjecture, p(i(i(a,b),i(i(b,c),i(a,c))))).

− tests/minus.p

@@ -1,10 +0,0 @@-cnf(plus_zero, axiom,-    '0' + X = X).-cnf(plus_zero, axiom,-    X + '0' = X).-cnf(minus_minus, axiom,-    - -X = X).-cnf(minus_plus, axiom,-    -(X + Y) = -X + -Y).-cnf(goal, conjecture,-    -'0' = '0').

− tests/nicomachus-tptp-2.p

@@ -1,19 +0,0 @@-cnf(plus_comm, axiom, plus(X, Y)=plus(Y, X)).-cnf(plus_assoc, axiom, plus(X, plus(Y, Z))=plus(plus(X, Y), Z)).-cnf(times_comm, axiom, times(X, Y)=times(Y, X)).-cnf(times_assoc, axiom, times(X, times(Y, Z))=times(times(X, Y), Z)).-cnf(plus_zero, axiom, plus(X, zero)=X).-cnf(times_zero, axiom, times(X, zero)=zero).-cnf(times_one, axiom, times(X, one)=X).-cnf(distr, axiom, times(X, plus(Y, Z))=plus(times(X, Y), times(X, Z))).-cnf(distr, axiom, times(plus(X, Y), Z)=plus(times(X, Z), times(Y, Z))).-cnf(plus_s, axiom, plus(s(X), Y)=s(plus(X, Y))).-cnf(times_s, axiom, times(s(X), Y)=plus(Y, times(X, Y))).-cnf(sum_zero, axiom, sum(zero)=zero).-cnf(sum_s, axiom, sum(s(N))=plus(s(N), sum(N))).-cnf(cubes_zero, axiom, cubes(zero)=zero).-cnf(cubes_s, axiom, cubes(s(N))=plus(times(s(N), times(s(N), s(N))), cubes(N))).-cnf(plus_sum_step_1, axiom, plus(sum(zero), sum(zero))!=times(zero, s(zero)) | plus(sum(ih_a), sum(ih_a))=times(ih_a, s(ih_a))).-cnf(plus_sum, axiom, plus(sum(zero), sum(zero))!=times(zero, s(zero)) | plus(sum(s(ih_a)), sum(s(ih_a)))!=times(s(ih_a), s(s(ih_a))) | plus(sum(N), sum(N))=times(N, s(N))).-cnf(ih, axiom, times(sum(a), sum(a))=cubes(a)).-cnf(conjecture, negated_conjecture, times(sum(s(a)), sum(s(a)))!=cubes(s(a))).

− tests/nicomachus-tptp.p

@@ -1,20 +0,0 @@-cnf(plus_comm, axiom, plus(X, Y)=plus(Y, X)).-cnf(plus_assoc, axiom, plus(X, plus(Y, Z))=plus(plus(X, Y), Z)).-cnf(times_comm, axiom, times(X, Y)=times(Y, X)).-cnf(times_assoc, axiom, times(X, times(Y, Z))=times(times(X, Y), Z)).-cnf(plus_zero, axiom, plus(X, zero)=X).-cnf(times_zero, axiom, times(X, zero)=zero).-cnf(times_one, axiom, times(X, one)=X).-cnf(distr, axiom, times(X, plus(Y, Z))=plus(times(X, Y), times(X, Z))).-cnf(distr, axiom, times(plus(X, Y), Z)=plus(times(X, Z), times(Y, Z))).-cnf(plus_s, axiom, plus(s(X), Y)=s(plus(X, Y))).-cnf(times_s, axiom, times(s(X), Y)=plus(Y, times(X, Y))).-cnf(sum_zero, axiom, sum(zero)=zero).-cnf(sum_s, axiom, sum(s(N))=plus(s(N), sum(N))).-cnf(cubes_zero, axiom, cubes(zero)=zero).-cnf(cubes_s, axiom, cubes(s(N))=plus(times(s(N), times(s(N), s(N))), cubes(N))).-%cnf(plus_sum, axiom, plus(sum(N), sum(N))=times(N, s(N))).-cnf(plus_sum_step_1, axiom, plus(sum(zero), sum(zero)) = times(zero, s(zero)) => plus(sum(ih_a), sum(ih_a)) = times(ih_a, s(ih_a))).-cnf(plus_sum, axiom, (plus(sum(zero), sum(zero)) = times(zero, s(zero)) & plus(sum(s(ih_a)), sum(s(ih_a))) = times(s(ih_a), s(s(ih_a)))) => plus(sum(N),sum(N))=times(N,s(N))).-cnf(ih, axiom, times(sum(a), sum(a))=cubes(a)).-cnf(conjecture, negated_conjecture, times(sum(s(a)), sum(s(a)))!=cubes(s(a))).

− tests/nicomachus.p

@@ -1,36 +0,0 @@-cnf(plus_comm, axiom,-    X + Y = Y + X).-cnf(plus_assoc, axiom,-    X + (Y + Z) = (X + Y) + Z).-cnf(times_comm, axiom,-    X * Y = Y * X).-cnf(times_assoc, axiom,-    X * (Y * Z) = (X * Y) * Z).-cnf(plus_zero, axiom,-    X + zero = X).-cnf(times_zero, axiom,-    X * zero = zero).-cnf(times_one, axiom,-    X * one = X).-cnf(distr, axiom,-    X * (Y + Z) = (X * Y) + (X * Z)).-cnf(distr, axiom,-    (X + Y) * Z = (X * Z) + (Y * Z)).-cnf(plus_s, axiom,-    s(X) + Y = s(X+Y)).-cnf(times_s, axiom,-    s(X)*Y = Y + (X*Y)).-cnf(sum_zero, axiom,-    sum(zero) = zero).-cnf(sum_s, axiom,-    sum(s(N)) = s(N) + sum(N)).-cnf(cubes_zero, axiom,-    cubes(zero) = zero).-cnf(cubes_s, axiom,-    cubes(s(N)) = (s(N) * (s(N) * s(N))) + cubes(N)).-cnf(plus_sum, axiom,-    sum(N) + sum(N) = N * s(N)).-cnf(ih, axiom,-    sum(a) * sum(a) = cubes(a)).-cnf(conjecture, conjecture,-    sum(s(a)) * sum(s(a)) = cubes(s(a))).

− tests/nicomachus2.p

@@ -1,36 +0,0 @@-cnf(plus_comm, axiom,-    X + Y = Y + X).-cnf(plus_assoc, axiom,-    X + (Y + Z) = (X + Y) + Z).-cnf(times_comm, axiom,-    X * Y = Y * X).-cnf(times_assoc, axiom,-    X * (Y * Z) = (X * Y) * Z).-cnf(plus_zero, axiom,-    X + zero = X).-cnf(times_zero, axiom,-    X * zero = zero).-cnf(times_one, axiom,-    X * one = X).-cnf(distr, axiom,-    X * (Y + Z) = (X * Y) + (X * Z)).-cnf(distr, axiom,-    (X + Y) * Z = (X * Z) + (Y * Z)).-cnf(plus_s, axiom,-    s(X) + Y = s(X+Y)).-cnf(times_s, axiom,-    s(X)*Y = Y + (X*Y)).-cnf(sum_zero, axiom,-    sum(zero) = zero).-cnf(sum_s, axiom,-    sum(s(N)) = s(N) + sum(N)).-cnf(cubes_zero, axiom,-    cubes(zero) = zero).-cnf(cubes_s, axiom,-    cubes(s(N)) = (s(N) * (s(N) * s(N))) + cubes(N)).-cnf(plus_sum, axiom,-    sum(N) + sum(N) = N * s(N)).-cnf(ih, axiom,-    sum(a) * sum(a) = cubes(a)).-cnf(conjecture, conjecture,-    sum(s(a)) * sum(s(a)) = cubes(s(a))).

− tests/p.p

@@ -1,11 +0,0 @@-cnf(a, axiom, p(X)!=true | p(s(X))!=true).-cnf(a, axiom, p(X)!=false | p(s(X))!=false).-cnf(a, axiom, p(a)=true).-cnf(a, axiom, p(s(s(a)))!=true).-cnf(a, axiom, true!=false).--cnf(p, axiom, p(a)=true).-cnf(p, axiom, p(s(a))=true).-cnf(p, axiom, p(s(s(a)))=false).-cnf(p, axiom, p(s(s(s(a))))=true).-cnf(p, axiom, p(s(s(s(X))))=false => p(s(s(s(s(X)))))=true).

− tests/regexp.p

@@ -1,54 +0,0 @@-%% and, or-cnf(def, axiom, and(true,B) = B).-cnf(def, axiom, and(false,B) = false).-cnf(def, axiom, and(X,Y) = and(Y,X)).--cnf(def, axiom, or(true,B) = true).-cnf(def, axiom, or(false,B) = B).-cnf(def, axiom, or(X,Y) = or(Y,X)).--%% eq-cnf(def, axiom, eq(X,X) = true).-cnf(def, axiom, eq(X,Y) = eq(Y,X)).-cnf(def, axiom, eq(a,b) = false).-cnf(def, axiom, eq(a,c) = false).-cnf(def, axiom, eq(b,c) = false).--%% haseps-cnf(def, axiom, haseps(atom(A)) = false).-cnf(def, axiom, haseps(zero) = false).-cnf(def, axiom, haseps(eps) = true).-cnf(def, axiom, haseps(plus(P,Q)) = or(haseps(P),haseps(Q))).-cnf(def, axiom, haseps(seq(P,Q)) = and(haseps(P),haseps(Q))).-cnf(def, axiom, haseps(star(P)) = true).--%% step-cnf(def, axiom, step(atom(A),A) = eps).-cnf(def, axiom, eq(A,B) = false => step(atom(A),B) = zero).-cnf(def, axiom, step(zero,B) = zero).-cnf(def, axiom, step(eps,B) = zero).-cnf(def, axiom, step(plus(P,Q),B) = plus(step(P,B),step(Q,B))).-cnf(def, axiom, haseps(P) = true => step(seq(P,Q),B) = plus(seq(step(P,B),Q),step(Q,B))).-cnf(def, axiom, haseps(P) = false => step(seq(P,Q),B) = plus(seq(step(P,B),Q),zero)).-cnf(def, axiom, step(star(P),B) = seq(step(P,B),star(P))).--%% rec-cnf(def, axiom, rec(P,nil) = haseps(P)).-cnf(def, axiom, rec(P,cons(A,As)) = rec(step(P,A),As)).--%% question-cnf(hypothesis, axiom, rec(seq(P,Q), As) = rec(seq(Q,P), As)).-cnf(goal, axiom, true != false).--%cnf(a, axiom, atom(A) != zero & atom(A) != eps & atom(A) != plus(P, Q) & atom(A) != seq(P, Q) & atom(A) != star(P)).-%cnf(a, axiom, zero != eps & zero != plus(P, Q) & zero != seq(P, Q) & zero != star(P)).-%cnf(a, axiom, eps != plus(P, Q) & eps != seq(P, Q) & eps != star(P)).-%cnf(a, axiom, plus(P, Q) != seq(P, Q) & plus(P, Q) != star(P)).-%cnf(a, axiom, seq(P, Q) != star(P)).-%cnf(a, axiom, un_atom(atom(A)) = A).-%cnf(a, axiom, un_plus_1(plus(P, Q)) = P).-%cnf(a, axiom, un_plus_2(plus(P, Q)) = Q).-%cnf(a, axiom, un_seq_1(seq(P, Q)) = P).-%cnf(a, axiom, un_seq_2(seq(P, Q)) = Q).-%cnf(a, axiom, un_star(star(P)) = P).-%cnf(a, axiom, a != b & b != c & a != c).

− tests/rel.p

@@ -1,32 +0,0 @@-tff(type, type, '_⁻¹' : $i > $i).-tff(type, type, '_⁻' : $i > $i).--cnf('commutativity of ∨', axiom,-    A ∨ B = B ∨ A).-cnf('associativity of ∨', axiom,-    A ∨ (B ∨ C) = (A ∨ B) ∨ C).-cnf('a kind of de Morgan', axiom,-    (A⁻ ∨ B⁻)⁻ ∨ (A⁻ ∨ B)⁻ = A).-cnf('definition of ∧', axiom,-    A ∧ B = (A⁻ ∨ B⁻)⁻).-cnf('associativity of ;', axiom,-    A ; (B ; C) = (A ; B) ; C).-cnf('identity for ;', axiom,-    A ; '1' = A).-cnf('distributivity of ; over ∨', axiom,-    (A ∨ B) ; C = (A ; C) ∨ (B ; C)).-cnf('involution of ⁻¹', axiom,-    A⁻¹ ⁻¹ = A).-cnf('additivity of ⁻¹', axiom,-    (A ∨ B)⁻¹ = A⁻¹ ∨ B⁻¹).-cnf('multiplicativity of ⁻¹', axiom,-    (A ; B)⁻¹ = B⁻¹ ; A⁻¹).-cnf('cancellativity of ⁻', axiom,-    (A⁻¹ ; (A ; B)⁻) ∨ B⁻ = B⁻).-cnf('definition of top', axiom,-    top = A ∨ A⁻).-cnf('definition of zero', axiom,-    zero = A ∧ A⁻).-cnf(goal, conjecture,-    (r1 ; (r2 ∧ r3)) ∨ ((r1 ; r2) ∧ (r1 ; r3)) =-    (r1 ; r2) ∧ (r1 ; r3)).

− tests/rel2.p

@@ -1,32 +0,0 @@-tff(type, type, '_⁻¹' : $i > $i).-tff(type, type, '_⁻' : $i > $i).--cnf('commutativity of ∨', axiom,-    A ∨ B = B ∨ A).-cnf('associativity of ∨', axiom,-    A ∨ (B ∨ C) = (A ∨ B) ∨ C).-cnf('a kind of de Morgan', axiom,-    (A⁻ ∨ B⁻)⁻ ∨ (A⁻ ∨ B)⁻ = A).-cnf('definition of ∧', axiom,-    A ∧ B = (A⁻ ∨ B⁻)⁻).-cnf('associativity of ;', axiom,-    A ; (B ; C) = (A ; B) ; C).-cnf('identity for ;', axiom,-    A ; '1' = A).-cnf('distributivity of ; over ∨', axiom,-    (A ∨ B) ; C = (A ; C) ∨ (B ; C)).-cnf('involution of ⁻¹', axiom,-    A⁻¹ ⁻¹ = A).-cnf('additivity of ⁻¹', axiom,-    (A ∨ B)⁻¹ = A⁻¹ ∨ B⁻¹).-cnf('multiplicativity of ⁻¹', axiom,-    (A ; B)⁻¹ = B⁻¹ ; A⁻¹).-cnf('cancellativity of ⁻', axiom,-    (A⁻¹ ; (A ; B)⁻) ∨ B⁻ = B⁻).-cnf('definition of top', axiom,-    top = A ∨ A⁻).-cnf('definition of zero', axiom,-    zero = A ∧ A⁻).-cnf(goal, conjecture,-    ((r1 ; r2) ∧ r3) ∨ ((r1; (r2 ∧ (r1⁻¹ ; r3))) ∧ r3) =-    (r1 ; (r2 ∧ (r1⁻¹ ; r3))) ∧ r3).

− tests/rellat_appendixa.p

@@ -1,27 +0,0 @@-% http://www.dcs.bbk.ac.uk/~szabolcs/rellat-jlamp-second-submission-2.pdf-% appendix a. theorem 3.4, clause 7.-cnf(commutativity, axiom,-    X ∧ Y = Y ∧ X).-cnf(associativity, axiom,-    X ∧ (Y ∧ Z) = (X ∧ Y) ∧ Z).-cnf(commutativity, axiom,-    X ∨ Y = Y ∨ X).-cnf(associativity, axiom,-    X ∨ (Y ∨ Z) = (X ∨ Y) ∨ Z).-cnf(absorption, axiom,-    X ∨ (X ∧ Y) = X).-cnf(absorption, axiom,-    X ∧ (X ∨ Y) = X).-cnf(definition_of_upme, axiom,-    upme(X,Y,Z) = X ∧ (Y ∨ Z)).-cnf(definition_of_lome, axiom,-    lome(X,Y,Z) = (X ∧ Y) ∨ (X ∧ Z)).-cnf(definition_of_upjo, axiom,-    upjo(X,Y,Z) = (X ∨ Y) ∧ (X ∨ Z)).-cnf(definition_of_lojo, axiom,-    lojo(X,Y,Z) = X ∨ (Y ∧ Z)).--fof(conjecture, conjecture,-    (![X1, Y1, W]:-    upme(a ∧ X1,Y1,W) ∨ (Y1 ∧ W) = (((a ∧ X1) ∧ Y1) ∨ W) ∧ (((a ∧ X1) ∧ W) ∨ Y1)) =>-    upme(a ∧ z1,z2,z3) = lome(a ∧ z1,z2,z3)).

− tests/rellat_appendixb.p

@@ -1,28 +0,0 @@-% http://www.dcs.bbk.ac.uk/~szabolcs/rellat-jlamp-second-submission-2.pdf-% appendix b. theorem 3.4, clause 8.-cnf(commutativity, axiom,-    X ∧ Y = Y ∧ X).-cnf(associativity, axiom,-    X ∧ (Y ∧ Z) = (X ∧ Y) ∧ Z).-cnf(commutativity, axiom,-    X ∨ Y = Y ∨ X).-cnf(associativity, axiom,-    X ∨ (Y ∨ Z) = (X ∨ Y) ∨ Z).-cnf(absorption, axiom,-    X ∨ (X ∧ Y) = X).-cnf(absorption, axiom,-    X ∧ (X ∨ Y) = X).-cnf(definition_of_upme, axiom,-    upme(X,Y,Z) = X ∧ (Y ∨ Z)).-cnf(definition_of_lome, axiom,-    lome(X,Y,Z) = (X ∧ Y) ∨ (X ∧ Z)).-cnf(definition_of_upjo, axiom,-    upjo(X,Y,Z) = (X ∨ Y) ∧ (X ∨ Z)).-cnf(definition_of_lojo, axiom,-    lojo(X,Y,Z) = X ∨ (Y ∧ Z)).-cnf(rh1, axiom,-    upme(a ∧ X1,Y1,Z1) ∨ (Y1 ∧ Z1) = (((a ∧ X1) ∧ Y1) ∨ Z1) ∧ (((a ∧ X1) ∧ Z1) ∨ Y1)).-cnf(rh2, axiom,-    upme(X,Y,Z) = upme(X,Y,a ∧ Z) ∨ upme(X,Z,a ∧ Y)).-fof(conjecture, conjecture,-    upme(a,x2,y2) = upme(a,x2,z2) => upme(x2,y2,z2) = lome(x2,y2,z2)).

− tests/rellat_appendixb_easier.p

@@ -1,30 +0,0 @@-% http://www.dcs.bbk.ac.uk/~szabolcs/rellat-jlamp-second-submission-2.pdf-% appendix b. theorem 3.4, clause 8, assuming axiom rl1.-cnf(commutativity, axiom,-    X ∧ Y = Y ∧ X).-cnf(associativity, axiom,-    X ∧ (Y ∧ Z) = (X ∧ Y) ∧ Z).-cnf(commutativity, axiom,-    X ∨ Y = Y ∨ X).-cnf(associativity, axiom,-    X ∨ (Y ∨ Z) = (X ∨ Y) ∨ Z).-cnf(absorption, axiom,-    X ∨ (X ∧ Y) = X).-cnf(absorption, axiom,-    X ∧ (X ∨ Y) = X).-cnf(definition_of_upme, axiom,-    upme(X,Y,Z) = X ∧ (Y ∨ Z)).-cnf(definition_of_lome, axiom,-    lome(X,Y,Z) = (X ∧ Y) ∨ (X ∧ Z)).-cnf(definition_of_upjo, axiom,-    upjo(X,Y,Z) = (X ∨ Y) ∧ (X ∨ Z)).-cnf(definition_of_lojo, axiom,-    lojo(X,Y,Z) = X ∨ (Y ∧ Z)).-cnf(rh1, axiom,-    upme(a ∧ X1,Y1,Z1) ∨ (Y1 ∧ Z1) = (((a ∧ X1) ∧ Y1) ∨ Z1) ∧ (((a ∧ X1) ∧ Z1) ∨ Y1)).-cnf(rh2, axiom,-    upme(X,Y,Z) = upme(X,Y,a ∧ Z) ∨ upme(X,Z,a ∧ Y)).-cnf(rl1, axiom,-    lome(X,Y,Z) = upme(X,upme(Y,X,Z),upme(Z,X,Y))).-fof(conjecture, conjecture,-    upme(a,x2,y2) = upme(a,x2,z2) => upme(x2,y2,z2) = lome(x2,y2,z2)).

− tests/rellat_appendixc.p

@@ -1,30 +0,0 @@-% http://www.dcs.bbk.ac.uk/~szabolcs/rellat-jlamp-second-submission-2.pdf-% appendix c. theorem 3.4, clause 9.-cnf(commutativity, axiom,-    X ∧ Y = Y ∧ X).-cnf(associativity, axiom,-    X ∧ (Y ∧ Z) = (X ∧ Y) ∧ Z).-cnf(commutativity, axiom,-    X ∨ Y = Y ∨ X).-cnf(associativity, axiom,-    X ∨ (Y ∨ Z) = (X ∨ Y) ∨ Z).-cnf(absorption, axiom,-    X ∨ (X ∧ Y) = X).-cnf(absorption, axiom,-    X ∧ (X ∨ Y) = X).-cnf(definition_of_upme, axiom,-    upme(X,Y,Z) = X ∧ (Y ∨ Z)).-cnf(definition_of_lome, axiom,-    lome(X,Y,Z) = (X ∧ Y) ∨ (X ∧ Z)).-cnf(definition_of_upjo, axiom,-    upjo(X,Y,Z) = (X ∨ Y) ∧ (X ∨ Z)).-cnf(definition_of_lojo, axiom,-    lojo(X,Y,Z) = X ∨ (Y ∧ Z)).-cnf(upme_property_1, axiom,-    upme(a ∧ X1,Y1,Z1) ∨ (Y1 ∧ Z1) = (((a ∧ X1) ∧ Y1) ∨ Z1) ∧ (((a ∧ X1) ∧ Z1) ∨ Y1)).-cnf(upme_property_2, axiom,-    upme(X,Y,Z) = upme(X,Y,a ∧ Z) ∨ upme(X,Z,a ∧ Y)).-fof(conjecture, conjecture,-    (upme(a,x2,y2) = upme(a,x2,z2) &-     upme(a,x2,y2) = upme(a,y2,z2)) =>-    upjo(x2,y2,z2) = lojo(x2,y2,z2)).

− tests/rellat_theorem34_6.p

@@ -1,32 +0,0 @@-% http://www.dcs.bbk.ac.uk/~szabolcs/rellat-jlamp-second-submission-2.pdf-% theorem 3.4, clause 6.-cnf(commutativity, axiom,-    X ∧ Y = Y ∧ X).-cnf(associativity, axiom,-    X ∧ (Y ∧ Z) = (X ∧ Y) ∧ Z).-cnf(commutativity, axiom,-    X ∨ Y = Y ∨ X).-cnf(associativity, axiom,-    X ∨ (Y ∨ Z) = (X ∨ Y) ∨ Z).-cnf(absorption, axiom,-    X ∨ (X ∧ Y) = X).-cnf(absorption, axiom,-    X ∧ (X ∨ Y) = X).-cnf(definition_of_upme, axiom,-    upme(X,Y,Z) = X ∧ (Y ∨ Z)).-cnf(definition_of_lome, axiom,-    lome(X,Y,Z) = (X ∧ Y) ∨ (X ∧ Z)).-cnf(definition_of_upjo, axiom,-    upjo(X,Y,Z) = (X ∨ Y) ∧ (X ∨ Z)).-cnf(definition_of_lojo, axiom,-    lojo(X,Y,Z) = X ∨ (Y ∧ Z)).-cnf(eq1, axiom,-    upme(a ∧ Z1,Z2,Z3) = lome(a ∧ Z1,Z2,Z3)).-cnf(qu2, axiom,-    upme(a,X2,Y2) = upme(a,X2,Z2) => upme(X2,Y2,Z2) = lome(X2,Y2,Z2)).-fof(rl1, conjecture,-    lome(x,y,z) =-    (x∧(y∧(x∨z)))∨(z∧(x∨y))).-%fof(rl2, conjecture,-%    t∧(((x∨y)∧(x∨z))∨((u∨w)∧(u∨v))) =-%    (t∧(((x∨y)∧(x∨z))∨(u∨(w∧v))))∨(t∧(((u∨w)∧(u∨v))∨(x∨(y∧z))))).

− tests/rellat_theorem34_6a.p

@@ -1,29 +0,0 @@-% http://www.dcs.bbk.ac.uk/~szabolcs/rellat-jlamp-second-submission-2.pdf-% theorem 3.4, clause 6.-cnf(commutativity, axiom,-    X ∧ Y = Y ∧ X).-cnf(associativity, axiom,-    X ∧ (Y ∧ Z) = (X ∧ Y) ∧ Z).-cnf(commutativity, axiom,-    X ∨ Y = Y ∨ X).-cnf(associativity, axiom,-    X ∨ (Y ∨ Z) = (X ∨ Y) ∨ Z).-cnf(absorption, axiom,-    X ∨ (X ∧ Y) = X).-cnf(absorption, axiom,-    X ∧ (X ∨ Y) = X).-cnf(definition_of_upme, axiom,-    upme(X,Y,Z) = X ∧ (Y ∨ Z)).-cnf(definition_of_lome, axiom,-    lome(X,Y,Z) = (X ∧ Y) ∨ (X ∧ Z)).-cnf(definition_of_upjo, axiom,-    upjo(X,Y,Z) = (X ∨ Y) ∧ (X ∨ Z)).-cnf(definition_of_lojo, axiom,-    lojo(X,Y,Z) = X ∨ (Y ∧ Z)).-cnf(eq1, axiom,-    upme(a ∧ Z1,Z2,Z3) = lome(a ∧ Z1,Z2,Z3)).-cnf(qu2, axiom,-    upme(a,X2,Y2) = upme(a,X2,Z2) => upme(X2,Y2,Z2) = lome(X2,Y2,Z2)).-fof(rl1, conjecture,-    lome(x,y,z) =-    x∧((y∧(x∨z))∨(z∧(x∨y)))).

− tests/rellat_theorem34_6b.p

@@ -1,29 +0,0 @@-% http://www.dcs.bbk.ac.uk/~szabolcs/rellat-jlamp-second-submission-2.pdf-% theorem 3.4, clause 6.-cnf(commutativity, axiom,-    X ∧ Y = Y ∧ X).-cnf(associativity, axiom,-    X ∧ (Y ∧ Z) = (X ∧ Y) ∧ Z).-cnf(commutativity, axiom,-    X ∨ Y = Y ∨ X).-cnf(associativity, axiom,-    X ∨ (Y ∨ Z) = (X ∨ Y) ∨ Z).-cnf(absorption, axiom,-    X ∨ (X ∧ Y) = X).-cnf(absorption, axiom,-    X ∧ (X ∨ Y) = X).-cnf(definition_of_upme, axiom,-    upme(X,Y,Z) = X ∧ (Y ∨ Z)).-cnf(definition_of_lome, axiom,-    lome(X,Y,Z) = (X ∧ Y) ∨ (X ∧ Z)).-cnf(definition_of_upjo, axiom,-    upjo(X,Y,Z) = (X ∨ Y) ∧ (X ∨ Z)).-cnf(definition_of_lojo, axiom,-    lojo(X,Y,Z) = X ∨ (Y ∧ Z)).-cnf(eq1, axiom,-    upme(a ∧ Z1,Z2,Z3) = lome(a ∧ Z1,Z2,Z3)).-cnf(qu2, axiom,-    upme(a,X2,Y2) = upme(a,X2,Z2) => upme(X2,Y2,Z2) = lome(X2,Y2,Z2)).-fof(rl2, conjecture,-    t∧(((x∨y)∧(x∨z))∨((u∨w)∧(u∨v))) =-    (t∧(((x∨y)∧(x∨z))∨(u∨(w∧v))))∨(t∧(((u∨w)∧(u∨v))∨(x∨(y∧z))))).

− tests/ring.p

@@ -1,9 +0,0 @@-cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).-cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).-cnf(plus_zero, axiom, '+'('0', X) = X).-cnf(plus_inv, axiom, '+'(X, '-'(X)) = '0').-cnf(times_assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).-cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).-cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).-cnf(cube, axiom, X = '*'(X, '*'(X, X))).-cnf(conjecture, negated_conjecture, '*'(a, b) != '*'(b, a)).

− tests/ring2-cancel.p

@@ -1,9 +0,0 @@-cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).-cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).-cnf(plus_zero, axiom, '+'('0', X) = X).-cnf(plus_inv, axiom, '+'(X, '-'(X)) = '0').-cnf(times_assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).-cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).-cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).-cnf(power_six, axiom, X = '*'(X, '*'(X, '*'(X, '*'(X, '*'(X, X)))))).-cnf(conjecture, negated_conjecture, '+'(x, x) != '0').

− tests/ring2.p

@@ -1,9 +0,0 @@-cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).-cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).-cnf(plus_zero, axiom, '+'('0', X) = X).-cnf(plus_inv, axiom, '+'(X, '-'(X)) = '0').-cnf(times_assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).-cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).-cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).-cnf(power_six, axiom, X = '*'(X, '*'(X, '*'(X, '*'(X, '*'(X, X)))))).-cnf(conjecture, negated_conjecture, '*'(a, b) != '*'(b, a)).

− tests/ring3.p

@@ -1,9 +0,0 @@-cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).-cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).-cnf(plus_zero, axiom, '+'('0', X) = X).-cnf(plus_neg, axiom, '+'(X, '-'(X)) = '0').-cnf(times_assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).-cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).-cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).-cnf(power_four, axiom, X = '*'(X, '*'(X, '*'(X, X)))).-cnf(conjecture, negated_conjecture, '*'(a, b) != '*'(b, a)).

− tests/ring4.p

@@ -1,9 +0,0 @@-cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).-cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).-cnf(plus_zero, axiom, '+'('0', X) = X).-cnf(plus_inv, axiom, '+'(X, '-'(X)) = '0').-cnf(times_ssoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).-cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).-cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).-cnf(power_five, axiom, X = '*'(X, '*'(X, '*'(X, '*'(X, X))))).-cnf(conjecture, negated_conjecture, '*'(a, b) != '*'(b, a)).

− tests/rob.p

@@ -1,7 +0,0 @@-cnf(commutativity_of_add, axiom, add(X, Y)=add(Y, X)).-cnf(associativity_of_add, axiom,-    add(add(X, Y), Z)=add(X, add(Y, Z))).-cnf(robbins_axiom, axiom,-    negate(add(negate(add(X, Y)), negate(add(X, negate(Y)))))=X).-cnf(winker_specialised, conjecture,-    add(add(x,x), negate(add(negate(add(x,add(x,x))),x))) = add(x,x)).

− tests/rob2.p

@@ -1,7 +0,0 @@-cnf(commutativity_of_add, axiom, add(X, Y)=add(Y, X)).-cnf(associativity_of_add, axiom,-    add(add(X, Y), Z)=add(X, add(Y, Z))).-cnf(robbins_axiom, axiom,-    negate(add(negate(add(X, Y)), negate(add(X, negate(Y)))))=X).-fof(winker, conjecture,-    ?[X,Y]: add(X,Y) = X).

− tests/robbins-easy.p

@@ -1,4 +0,0 @@-cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).-cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).-cnf(funny, axiom, '+'('-'('+'('-'(X), Y)), '-'('+'('-'(X), '-'(Y)))) = X).-cnf(conjecture, negated_conjecture, '-'('+'('-'('+'(a, b)), '-'('+'(a, '-'(b))))) != a).

− tests/robbins.p

@@ -1,4 +0,0 @@-cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).-cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).-cnf(funny, axiom, '-'('+'('-'('+'(X, Y)), '-'('+'(X, '-'(Y))))) = X).-cnf(conjecture, negated_conjecture, '-'('-'(a)) != a).

− tests/sam.p

@@ -1,38 +0,0 @@-cnf(f_assoc, axiom,-    meet(X,meet(Y,Z)) = meet(meet(X,Y),Z)).-cnf(f_comm, axiom,-    meet(X,Y) = meet(Y,X)).-cnf(f_idem, axiom,-    meet(X,X) = X).-cnf(g_assoc, axiom,-    join(X,join(Y,Z)) = join(join(X,Y),Z)).-cnf(g_comm, axiom,-    join(X,Y) = join(Y,X)).-cnf(g_idem, axiom,-    join(X,X) = X).--cnf(ax31, axiom,-    meet(X, join(X,Y)) = X).-cnf(ax32, axiom,-    meet(zero, X) = zero).-cnf(ax33, axiom,-    join(zero, X) = X).-cnf(ax34, axiom,-    join(X, meet(X, Y)) = X).-cnf(ax35, axiom,-    meet(one, X) = X).-cnf(ax36, axiom,-    join(one, X) = one).-cnf(ax37, axiom,-    meet(X,Z) = X =>-    meet(join(X,Y),Z) = join(X,meet(Y,Z))).--cnf(comp, definition,-    comp(X,Y) <=> (meet(X,Y) = zero & join(X,Y) = one)).--cnf(premise1, assumption,-    comp(a, join(c,d))).-cnf(premise2, assumption,-    comp(b, join(c,d))).-cnf(goal, conjecture,-    meet(join(a,meet(b,c)),join(a,meet(b,d)))=a).

− tests/semigroup.p

@@ -1,4 +0,0 @@-cnf(assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).-cnf(two_three, axiom, '*'(X, X) = '*'(X, '*'(X, X))).-cnf(twiddle, axiom, '*'('*'(X, X), Y) = '*'(Y, '*'(X, X))).-cnf(conjecture, negated_conjecture, '*'('*'(a, b), '*'(a, b)) != '*'('*'(a, a), '*'(b, b))).

− tests/sudoku.p

@@ -1,39 +0,0 @@-cnf('associativity of ∘', axiom,-    F ∘ (G ∘ H) = (F ∘ G) ∘ H).--cnf('∘ identity', axiom,-    id ∘ F = F).--cnf('∘ identity', axiom,-    F ∘ id = F).--cnf('map functor', axiom,-    map(F) ∘ map(G) = map(F ∘ G)).--cnf('map functor', axiom,-    map(id) = id).--cnf('defn pruneBy', axiom,-    pruneBy(F) = F ∘ (map(pruneRow) ∘ F)).--cnf('defn expand', axiom,-    expand = product ∘ map(product)).--cnf('expand after boxs', axiom,-    expand ∘ boxs = map(boxs) ∘ expand).--cnf('filter with boxs', axiom,-    filter (P ∘ boxs) = map(boxs) ∘ (filter(P) ∘ map(boxs))).--cnf('boxs involution', axiom,-    boxs ∘ boxs = id).--cnf('filter after product', axiom,-    filter(all(P)) ∘ product = product ∘ map(filter(P))).--cnf('law of pruneRow', axiom,-    filter(nodups) ∘ (product ∘ pruneRow) = filter(nodups) ∘ product).--cnf('conjecture', conjecture,-    filter(all(nodups) ∘ boxs) ∘ (expand ∘ pruneBy(boxs)) =-    filter(all(nodups) ∘ boxs) ∘ expand).

− tests/sudoku2.p

@@ -1,44 +0,0 @@-cnf('associativity of ∘', axiom,-    F ∘ (G ∘ H) = (F ∘ G) ∘ H).--cnf('∘ identity', axiom,-    id ∘ F = F).--cnf('∘ identity', axiom,-    F ∘ id = F).--cnf('map functor', axiom,-    map(F) ∘ map(G) = map(F ∘ G)).--cnf('map functor', axiom,-    map(id) = id).--cnf('defn pruneBy', axiom,-    pruneBy(F) = F ∘ (map(pruneRow) ∘ F)).--cnf('defn expand', axiom,-    expand = product ∘ map(product)).--cnf('expand after boxs', axiom,-    expand ∘ boxs = map(boxs) ∘ expand).--cnf('filter with boxs', axiom,-    filter (P ∘ boxs) = map(boxs) ∘ (filter(P) ∘ map(boxs))).--cnf('boxs involution', axiom,-    boxs ∘ boxs = id).--cnf('filter after product', axiom,-    filter(all(P)) ∘ product = product ∘ map(filter(P))).--cnf('law of pruneRow', axiom,-    filter(nodups) ∘ (product ∘ pruneRow) = filter(nodups) ∘ product).--cnf('lhs', axiom,-    lhs = filter(all(nodups) ∘ boxs) ∘ (expand ∘ pruneBy(boxs))).--cnf('rhs', axiom,-    rhs = filter(all(nodups) ∘ boxs) ∘ expand).--cnf('conjecture', conjecture,-    lhs = rhs).

− tests/sudoku3.p

@@ -1,42 +0,0 @@-cnf('associativity of ∘', axiom,-    F ∘ (G ∘ H) = (F ∘ G) ∘ H).--cnf('∘ identity', axiom,-    id ∘ F = F).--cnf('∘ identity', axiom,-    F ∘ id = F).--cnf('map functor', axiom,-    map(F) ∘ map(G) = map(F ∘ G)).--cnf('map functor', axiom,-    map(id) = id).--cnf('defn pruneBy', axiom,-    pruneBy(F) = F ∘ (map(pruneRow) ∘ F)).--cnf('defn expand', axiom,-    expand = product ∘ map(product)).--cnf('expand after boxs', axiom,-    expand ∘ boxs = map(boxs) ∘ expand).--cnf('filter with boxs', axiom,-    filter (P ∘ boxs) = map(boxs) ∘ (filter(P) ∘ map(boxs))).--cnf('boxs involution', axiom,-    boxs ∘ boxs = id).--cnf('filter after product', axiom,-    filter(all(P)) ∘ product = product ∘ map(filter(P))).--cnf('law of pruneRow', axiom,-    filter(nodups) ∘ (product ∘ pruneRow) = filter(nodups) ∘ product).--cnf('map/filter', axiom,-    filter(P) ∘ map(F) = map(F) ∘ filter(P ∘ F)).--cnf('conjecture', conjecture,-    filter(all(nodups) ∘ boxs) ∘ (expand ∘ pruneBy(boxs)) =-    filter(all(nodups) ∘ boxs) ∘ expand).

− tests/sudoku4.p

@@ -1,45 +0,0 @@-fof('associativity of ∘', axiom,-    ![F,G,H]: F ∘ (G ∘ H) = (F ∘ G) ∘ H).--fof('∘ identity', axiom,-    ![F]: id ∘ F = F).--fof('∘ identity', axiom,-    ![F]: F ∘ id = F).--fof('map functor', axiom,-    ![F, G]: map(F) ∘ map(G) = map(F ∘ G)).--fof('map functor', axiom,-    map(id) = id).--fof('defn pruneBy', axiom,-    ![F]: pruneBy(F) = F ∘ (map(pruneRow) ∘ F)).--fof('defn expand', axiom,-    expand = product ∘ map(product)).--fof('expand after boxs', axiom,-    expand ∘ boxs = map(boxs) ∘ expand).--fof('filter with boxs', axiom,-    ![P, F]: filter (P ∘ boxs) = map(boxs) ∘ (filter(P) ∘ map(boxs))).--fof('boxs involution', axiom,-    boxs ∘ boxs = id).--fof('filter after product', axiom,-    ![P]: filter(all(P)) ∘ product = product ∘ map(filter(P))).--fof('law of pruneRow', axiom,-    filter(nodups) ∘ (product ∘ pruneRow) = filter(nodups) ∘ product).--fof('map/filter', axiom,-    ![P, F]: filter(P) ∘ map(F) = map(F) ∘ filter(P ∘ F)).--fof('product/map', axiom,-    ![F]: product ∘ map(F) = map(map(F)) ∘ product).--fof('conjecture', conjecture,-    filter(all(nodups) ∘ boxs) ∘ (expand ∘ pruneBy(boxs)) =-    filter(all(nodups) ∘ boxs) ∘ expand).

− tests/sudoku5.p

@@ -1,42 +0,0 @@-cnf('associativity of ∘', axiom,-    F ∘ (G ∘ H) = (F ∘ G) ∘ H).--cnf('∘ identity', axiom,-    id ∘ F = F).--cnf('∘ identity', axiom,-    F ∘ id = F).--cnf('map functor', axiom,-    map(F) ∘ map(G) = map(F ∘ G)).--cnf('map functor', axiom,-    map(id) = id).--cnf('defn pruneBy', axiom,-    pruneBy(F) = F ∘ (map(pruneRow) ∘ F)).--cnf('defn expand', axiom,-    expand = product ∘ map(product)).--cnf('expand after boxs', axiom,-    expand ∘ boxs = map(boxs) ∘ expand).--cnf('filter with boxs', axiom,-    filter (P ∘ boxs) = map(boxs) ∘ (filter(P) ∘ map(boxs))).--cnf('boxs involution', axiom,-    boxs ∘ boxs = id).--cnf('filter after product', axiom,-    filter(all(P)) ∘ product = product ∘ map(filter(P))).--cnf('law of pruneRow', axiom,-    filter(nodups) ∘ (product ∘ pruneRow) = filter(nodups) ∘ product).--cnf('product/map', axiom,-    product ∘ map(F) = map(map(F)) ∘ product).--cnf('conjecture', conjecture,-    filter(all(nodups) ∘ boxs) ∘ (expand ∘ pruneBy(boxs)) =-    filter(all(nodups) ∘ boxs) ∘ expand).

− tests/sum.p

@@ -1,30 +0,0 @@-cnf(plus_comm, axiom,-    X + Y = Y + X).-cnf(plus_assoc, axiom,-    X + (Y + Z) = (X + Y) + Z).-cnf(times_comm, axiom,-    X * Y = Y * X).-cnf(times_assoc, axiom,-    X * (Y * Z) = (X * Y) * Z).-cnf(plus_zero, axiom,-    X + zero = X).-cnf(times_zero, axiom,-    X * zero = zero).-cnf(times_one, axiom,-    X * one = X).-cnf(distr, axiom,-    X * (Y + Z) = (X * Y) + (X * Z)).-cnf(distr, axiom,-    (X + Y) * Z = (X * Z) + (Y * Z)).-cnf(plus_s, axiom,-    s(X) + Y = s(X+Y)).-cnf(times_s, axiom,-    s(X)*Y = Y + (X*Y)).-cnf(sum_zero, axiom,-    sum(zero) = zero).-cnf(sum_s, axiom,-    sum(s(N)) = s(N) + sum(N)).-cnf(ih, axiom,-    sum(a) + sum(a) = a * s(a)).-cnf(conjecture, conjecture,-    sum(s(a)) + sum(s(a)) = s(a) * s(s(a))).

− tests/union.p

@@ -1,9 +0,0 @@-cnf(elem_union_1, axiom, notelem(X, A) | ~notelem(X, union(A, B))).-cnf(elem_union_2, axiom, notelem(X, B) | ~notelem(X, union(A, B))).-cnf(elem_union_3, axiom, notelem(X, union(A, B)) | ~notelem(X, A) | ~notelem(X, B)).-cnf(elem_equals, axiom, A=B | ~notelem(sK1_elem_equals_X(A, B), A) | ~notelem(sK1_elem_equals_X(A, B), B)).-cnf(union_commutative, negated_conjecture, union(a, b)!=union(b, a)).--cnf(elem_equals_1, axiom, choice(A,B) = c1 => notelem(sK1_elem_equals_X(A, B), A)).-cnf(elem_equals_2, axiom, choice(A,B) = c2 => notelem(sK1_elem_equals_X(A, B), B)).-cnf(elem_equals_3, axiom, choice(A,B) = c3 => A=B).

− tests/union2.p

@@ -1,25 +0,0 @@-cnf(ifeq_axiom, axiom, ifeq4(A, A, B, C)=B).-cnf(ifeq_axiom, axiom, ifeq3(A, A, B, C)=B).-cnf(ifeq_axiom, axiom, ifeq2(A, A, B, C)=B).-cnf(ifeq_axiom, axiom, ifeq(A, A, B, C)=B).-cnf(elem_union_1, axiom, ifeq(notelem(X, union(A, B)), true, notelem(X, A), true)=true).-cnf(elem_union_2, axiom, ifeq(notelem(X, union(A, B)), true, notelem(X, B), true)=true).-cnf(elem_union_3, axiom, ifeq(notelem(X, B), true, ifeq(notelem(X, A), true, notelem(X, union(A, B)), true), true)=true).-cnf(elem_equals, axiom, ifeq2(notelem(sK1_elem_equals_X(A, B), B), true, ifeq2(notelem(sK1_elem_equals_X(A, B), A), true, A, B), B)=B).-%cnf(union_commutative, negated_conjecture, union(a, b)!=union(b, a)).-%cnf(elem_equals_1, axiom, ifeq3(choice(A, B), c1, notelem(sK1_elem_equals_X(A, B), A), true)=true).-%cnf(elem_equals_2, axiom, ifeq3(choice(A, B), c2, notelem(sK1_elem_equals_X(A, B), B), true)=true).-%cnf(elem_equals_3, axiom, ifeq4(choice(A, B), c3, A, B)=B).-cnf(elem_equals_1, axiom, select(c1, a, d, d) = d).-cnf(elem_equals_1, axiom, select(c2, d, b, d) = d).-cnf(elem_equals_1, axiom, select(c3, d, d, c) = d).-cnf(blah, conjecture, a=d | b=d | c=d).-cnf(select, axiom, select(C, X, X, X)=X).-cnf(select, axiom, select(c1, X, Y, Z)=X).-cnf(select, axiom, select(c2, X, Y, Z)=Y).-cnf(select, axiom, select(c3, X, Y, Z)=Z).--%select(C, X, Y, Z) = select(C, select(c1, X, Y, Z), select(c2, X, Y, Z), select(c3, X, Y, Z)).--%  d-%= select(

− tests/vbool.p

@@ -1,18 +0,0 @@-fof(associativity, axiom,-    ![X, Y, Z]:-    X ⊕ (Y ⊕ Z) = (X ⊕ Y) ⊕ Z).--fof(commutativity, axiom,-    ![X, Y]:-    X ⊕ Y = Y ⊕ X).--fof(idempotence, axiom,-    ![X]:-    X ⊕ X = X).--fof(non_injectivity, conjecture,-    ![A, B]: ?[X]: A ⊕ X = B ⊕ X).--% Examples:-% plus is commutative, associative, and injective, but not idempotent-% max is idempotent, commutative, and associativity, but not injective

− tests/veroff-short.p

@@ -1,11 +0,0 @@-cnf(majority, axiom,-    f(X,X,Y) = X).-cnf('2a', axiom,-    f(X,Y,Z) = f(Z,X,Y)).-cnf('2b', axiom,-    f(X,Y,Z) = f(X,Z,Y)).-cnf(associativity, axiom,-    f(f(X,W,Y),W,Z) = f(X,W,f(Y,W,Z))).--cnf(dist_long, conjecture,-    f(f(x,y,z),u,w) = f(x,f(y,u,w),f(z,u,w))).

− tests/veroff.p

@@ -1,11 +0,0 @@-cnf(majority, axiom,-    f(X,X,Y) = X).-cnf('2a', axiom,-    f(X,Y,Z) = f(Z,X,Y)).-cnf('2b', axiom,-    f(X,Y,Z) = f(X,Z,Y)).-cnf(associativity, axiom,-    f(f(X,W,Y),W,Z) = f(X,W,f(Y,W,Z))).--cnf(dist_long, conjecture,-    f(f(x,y,z),u,w) = f(f(x,u,w),f(y,u,w),f(z,u,w))).

− tests/winker-easy.p

@@ -1,6 +0,0 @@-% Needs case split on X < c.-cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).-cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).-cnf(idem, axiom, '+'(X, X) = X).-cnf(funny, axiom, '-'('+'('-'('+'(X, Y)), '-'('+'(X, '-'(Y))))) = X).-cnf(conjecture, negated_conjecture, '+'('-'('+'('-'(a), b)), '-'('+'('-'(a), '-'(b)))) != a).

− tests/winker.p

@@ -1,6 +0,0 @@-% Needs case split on X < c.-cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).-cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).-cnf(idem_c, axiom, '+'(c, c) = c).-cnf(funny, axiom, '-'('+'('-'('+'(X, Y)), '-'('+'(X, '-'(Y))))) = X).-cnf(conjecture, negated_conjecture, '+'('-'('+'('-'(a), b)), '-'('+'('-'(a), '-'(b)))) != a).

− tests/winker2.p

@@ -1,6 +0,0 @@-% Needs case split on X < c.-cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).-cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).-cnf(plus_c_d, axiom, '+'(c, d) = c).-cnf(funny, axiom, '-'('+'('-'('+'(X, Y)), '-'('+'(X, '-'(Y))))) = X).-cnf(conjecture, negated_conjecture, '+'('-'('+'('-'(a), b)), '-'('+'('-'(a), '-'(b)))) != a).

− tests/wos.p

@@ -1,6 +0,0 @@-cnf(a, axiom,-    prod(inv(prod(inv(prod(inv(prod(Xl,X2)),prod(X2,Xl))),prod(inv(prod(Z,Y)), prod(Z,inv(prod(prod(V,inv(X)),inv(Y))))))),X) = V).--%fof(associativity, conjecture, prod(a,prod(b,c)) = prod(prod(a,b),c)).-fof(identity_and_inverse, conjecture,  ?[X]: (![Y]: prod(X,Y)=Y & ![Y]: prod(Y, inv(Y)) = X)).-%fof(commutativity, conjecture, prod(a,b) = prod(b,a)).

− tests/y-easy.p

@@ -1,4 +0,0 @@-fof(k_def, axiom, ![X, Y]: (k @ X) @ Y = X).-fof(s_def, axiom, ![X, Y, Z]: ((s @ X) @ Y) @ Z = (X @ Z) @ (Y @ Z)).-fof(i_def, axiom, ![X]: i @ X = X).-fof(conjecture, conjecture, ?[Y]: ![F]: Y @ F = F @ (Y @ F)).

− tests/y-encoded.p

@@ -1,5 +0,0 @@-cnf(ifeq_axiom, axiom, ifeq(A, A, B, C)=B).-cnf(k_def, axiom, '@'('@'(k, X), Y)=X).-cnf(s_def, axiom, '@'('@'('@'(s, X), Y), Z)='@'('@'(X, Z), '@'(Y, Z))).-cnf(conjecture, negated_conjecture, ifeq('@'(Y, f(Y)), '@'(f(Y), '@'(Y, f(Y))), a, b)=b).-cnf(goal, negated_conjecture, a!=b).

− tests/y-i.p

@@ -1,4 +0,0 @@-fof(k_def, axiom, ![X, Y]: (k @ X) @ Y = X).-fof(s_def, axiom, ![X, Y, Z]: ((s @ X) @ Y) @ Z = (X @ Z) @ (Y @ Z)).-fof(i_def, axiom, ![X]: i @ X = X).-fof(conjecture, conjecture, ?[Y]: ![F]: Y @ F = F @ (Y @ F)).

− tests/y.p

@@ -1,3 +0,0 @@-fof(k_def, axiom, ![X, Y]: (k @ X) @ Y = X).-fof(s_def, axiom, ![X, Y, Z]: ((s @ X) @ Y) @ Z = (X @ Z) @ (Y @ Z)).-fof(conjecture, conjecture, ?[Y]: ![F]: Y @ F = F @ (Y @ F)).

twee.cabal view

@@ -1,15 +1,15 @@+cabal-version:       2.2 name:                twee-version:             2.6.1+version:             2.7.1 synopsis:            An equational theorem prover-homepage:            http://github.com/nick8325/twee-license:             BSD3+homepage:            https://twee.smallbone.se+license:             BSD-3-Clause license-file:        LICENSE author:              Nick Smallbone maintainer:          nicsma@chalmers.se category:            Theorem Provers build-type:          Simple-cabal-version:       >=1.10-extra-source-files:  README.md tests/*.p misc/*.hs misc/*.pl misc/static-libstdc+++extra-source-files:  README.md examples/*.p misc/*.hs misc/*.pl description:    Twee is an experimental equational theorem prover based on    Knuth-Bendix completion.@@ -20,65 +20,87 @@    fail to terminate if they are false.    .    The input problem should be in TPTP format (see-   http://www.tptp.org). You can use types and quantifiers, but apart+   https://www.tptp.org). You can use types and quantifiers, but apart    from that the problem must be equational.  source-repository head   type:     git-  location: https://github.com/nick8325/twee.git-  branch:   master+  location: https://codeberg.org/nick8325/twee+  branch:   main  flag static   description: Build a static binary.   default: False   manual: True -flag static-cxx-  description: Build a binary which statically links against libstdc++.-  default: False-  manual: True- flag parallel   description: Build a special parallel version of Twee.   default: False   manual: True -executable twee-  --if flag(parallel)-  --  main-is: ParallelMain.hs-  --  build-depends: async, unix-  --  c-sources: executable/link.c-  --else-  main-is: Main.hs+flag rtsopts+  description: Enable -rtsopts (e.g. for setting maximum memory use.)+  default: False+  manual: True +common executable-stuff   hs-source-dirs:      executable-  other-modules:       SequentialMain   default-language:    Haskell2010   build-depends:       base < 5,-                       twee-lib == 2.6.1,+                       twee-lib == 2.7.1,                        containers,                        pretty,                        split,-                       jukebox >= 0.5.9,+                       jukebox == 0.5.15,                        ansi-terminal >= 0.9,-                       symbol+                       symbol,+                       hashable,+                       bytestring,+                       binary,+                       process+  other-modules:       SequentialMain   ghc-options:         -W -fno-warn-incomplete-patterns    if flag(static)     ghc-options: -optl -static -  if flag(static-cxx)-    ghc-options: -pgml misc/static-libstdc+++  if flag(rtsopts)+    ghc-options: -rtsopts +executable twee+  import: executable-stuff+  main-is: Main.hs++executable twee-lpo+  import: executable-stuff+  main-is: Main.hs+  cpp-options: -DUSE_LPO++executable parallel-twee+  import: executable-stuff+  if !flag(parallel)+    buildable: False++  main-is: ParallelMain.hs+  build-depends: async, unix+  c-sources: executable/link.c+ Test-Suite twee-test     type: exitcode-stdio-1.0     Default-language: Haskell2010     hs-source-dirs:-        misc-    main-is: Test.hs-    build-depends: base < 5, QuickCheck, twee-lib == 2.6.1, containers, pretty+        test+    main-is: Main.hs+    build-depends: base < 5, QuickCheck, twee-lib == 2.7, containers, pretty, tasty, tasty-quickcheck, hashable, binary, bytestring+    other-modules:+        Common+        Index+        Nest+        Ordering+        Serial+        TermOrder+        Terms     ghc-options:       -threaded-      -rtsopts       -feager-blackholing-      -with-rtsopts=-N4+      -with-rtsopts=-N