TSTP Solution File: SWW473+5 by Bliksem---1.12
View Problem
- Process Solution
%------------------------------------------------------------------------------
% File : Bliksem---1.12
% Problem : SWW473+5 : TPTP v8.1.0. Released v5.3.0.
% Transfm : none
% Format : tptp:raw
% Command : bliksem %s
% Computer : n025.cluster.edu
% Model : x86_64 x86_64
% CPU : Intel(R) Xeon(R) CPU E5-2620 v4 2.10GHz
% Memory : 8042.1875MB
% OS : Linux 3.10.0-693.el7.x86_64
% CPULimit : 300s
% WCLimit : 0s
% DateTime : Wed Jul 20 23:22:17 EDT 2022
% Result : Timeout 300.01s 300.44s
% Output : None
% Verified :
% SZS Type : -
% Comments :
%------------------------------------------------------------------------------
%----No solution output by system
%------------------------------------------------------------------------------
%----ORIGINAL SYSTEM OUTPUT
% 0.04/0.13 % Problem : SWW473+5 : TPTP v8.1.0. Released v5.3.0.
% 0.04/0.14 % Command : bliksem %s
% 0.14/0.36 % Computer : n025.cluster.edu
% 0.14/0.36 % Model : x86_64 x86_64
% 0.14/0.36 % CPU : Intel(R) Xeon(R) CPU E5-2620 v4 @ 2.10GHz
% 0.14/0.36 % Memory : 8042.1875MB
% 0.14/0.36 % OS : Linux 3.10.0-693.el7.x86_64
% 0.14/0.36 % CPULimit : 300
% 0.14/0.36 % DateTime : Sun Jun 5 09:59:32 EDT 2022
% 0.14/0.36 % CPUTime :
% 0.85/1.27 *** allocated 10000 integers for termspace/termends
% 0.85/1.27 *** allocated 10000 integers for clauses
% 0.85/1.27 *** allocated 10000 integers for justifications
% 0.85/1.27 Bliksem 1.12
% 0.85/1.27
% 0.85/1.27
% 0.85/1.27 Automatic Strategy Selection
% 0.85/1.27
% 0.85/1.27 *** allocated 15000 integers for termspace/termends
% 0.85/1.27 *** allocated 22500 integers for termspace/termends
% 0.85/1.27 *** allocated 33750 integers for termspace/termends
% 0.85/1.27
% 0.85/1.27 Clauses:
% 0.85/1.27
% 0.85/1.27 { ti( fun( fun( X, Y ), fun( fun( Z, X ), fun( Z, Y ) ) ), combb( X, Y, Z )
% 0.85/1.27 ) = combb( X, Y, Z ) }.
% 0.85/1.27 { ti( fun( fun( X, fun( Y, Z ) ), fun( Y, fun( X, Z ) ) ), combc( X, Y, Z )
% 0.85/1.27 ) = combc( X, Y, Z ) }.
% 0.85/1.27 { ti( fun( X, X ), combi( X ) ) = combi( X ) }.
% 0.85/1.27 { ti( fun( fun( X, fun( Y, Z ) ), fun( fun( X, Y ), fun( X, Z ) ) ), combs
% 0.85/1.27 ( X, Y, Z ) ) = combs( X, Y, Z ) }.
% 0.85/1.27 { ti( fun( fun( X, bool ), nat ), finite_card( X ) ) = finite_card( X ) }.
% 0.85/1.27 { ti( fun( fun( X, bool ), bool ), finite_finite( X ) ) = finite_finite( X
% 0.85/1.27 ) }.
% 0.85/1.27 { ti( fun( nat, fun( nat, nat ) ), minus_minus( nat ) ) = minus_minus( nat
% 0.85/1.27 ) }.
% 0.85/1.27 { ti( X, undefined( X ) ) = undefined( X ) }.
% 0.85/1.27 { ti( fun( nat, nat ), suc ) = suc }.
% 0.85/1.27 { ! preorder( X ), ti( fun( X, fun( X, bool ) ), ord_less_eq( X ) ) =
% 0.85/1.27 ord_less_eq( X ) }.
% 0.85/1.27 { ti( fun( fun( X, bool ), fun( X, bool ) ), collect( X ) ) = collect( X )
% 0.85/1.27 }.
% 0.85/1.27 { ti( fun( fun( X, Y ), fun( fun( X, bool ), fun( Y, bool ) ) ), image( X,
% 0.85/1.27 Y ) ) = image( X, Y ) }.
% 0.85/1.27 { ti( fun( X, fun( fun( X, bool ), fun( X, bool ) ) ), insert( X ) ) =
% 0.85/1.27 insert( X ) }.
% 0.85/1.27 { ti( fun( bool, bool ), fNot ) = fNot }.
% 0.85/1.27 { ti( fun( bool, fun( bool, bool ) ), fconj ) = fconj }.
% 0.85/1.27 { ti( fun( bool, fun( bool, bool ) ), fdisj ) = fdisj }.
% 0.85/1.27 { ti( fun( X, fun( X, bool ) ), fequal( X ) ) = fequal( X ) }.
% 0.85/1.27 { ti( fun( bool, fun( bool, bool ) ), fimplies ) = fimplies }.
% 0.85/1.27 { hAPP( X, Y, ti( fun( X, Y ), Z ), T ) = hAPP( X, Y, Z, T ) }.
% 0.85/1.27 { hAPP( X, Y, Z, ti( X, T ) ) = hAPP( X, Y, Z, T ) }.
% 0.85/1.27 { ti( X, hAPP( Y, X, Z, T ) ) = hAPP( Y, X, Z, T ) }.
% 0.85/1.27 { ! hBOOL( ti( bool, X ) ), hBOOL( X ) }.
% 0.85/1.27 { ! hBOOL( X ), hBOOL( ti( bool, X ) ) }.
% 0.85/1.27 { ti( fun( X, fun( fun( X, bool ), bool ) ), member( X ) ) = member( X ) }
% 0.85/1.27 .
% 0.85/1.27 { ti( fun( x_a, bool ), g ) = g }.
% 0.85/1.27 { ti( fun( fun( x_a, bool ), fun( fun( x_a, bool ), bool ) ), p ) = p }.
% 0.85/1.27 { ti( fun( pname, bool ), u ) = u }.
% 0.85/1.27 { ti( fun( pname, x_a ), mgt_call ) = mgt_call }.
% 0.85/1.27 { ti( nat, na ) = na }.
% 0.85/1.27 { ti( pname, pn ) = pn }.
% 0.85/1.27 { ! hBOOL( hAPP( fun( x_a, bool ), bool, hAPP( fun( x_a, bool ), fun( fun(
% 0.85/1.27 x_a, bool ), bool ), ord_less_eq( fun( x_a, bool ) ), X ), Y ) ), hBOOL(
% 0.85/1.27 hAPP( fun( x_a, bool ), bool, hAPP( fun( x_a, bool ), fun( fun( x_a, bool
% 0.85/1.27 ), bool ), p, Y ), X ) ) }.
% 0.85/1.27 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), hBOOL(
% 0.85/1.27 hAPP( fun( fun( X, bool ), bool ), bool, finite_finite( fun( X, bool ) )
% 0.85/1.27 , hAPP( fun( fun( X, bool ), bool ), fun( fun( X, bool ), bool ), collect
% 0.85/1.27 ( fun( X, bool ) ), hAPP( fun( X, bool ), fun( fun( X, bool ), bool ),
% 0.85/1.27 hAPP( fun( fun( X, bool ), fun( fun( X, bool ), bool ) ), fun( fun( X,
% 0.85/1.27 bool ), fun( fun( X, bool ), bool ) ), combc( fun( X, bool ), fun( X,
% 0.85/1.27 bool ), bool ), ord_less_eq( fun( X, bool ) ) ), Y ) ) ) ) }.
% 0.85/1.27 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), hBOOL(
% 0.85/1.27 hAPP( fun( Z, bool ), bool, finite_finite( Z ), hAPP( fun( X, bool ), fun
% 0.85/1.27 ( Z, bool ), hAPP( fun( X, Z ), fun( fun( X, bool ), fun( Z, bool ) ),
% 0.85/1.27 image( X, Z ), T ), Y ) ) ) }.
% 0.85/1.27 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), hBOOL(
% 0.85/1.27 hAPP( fun( X, bool ), bool, finite_finite( X ), hAPP( fun( X, bool ), fun
% 0.85/1.27 ( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X )
% 0.85/1.27 , Z ), Y ) ) ) }.
% 0.85/1.27 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), hBOOL(
% 0.85/1.27 hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat ), hAPP(
% 0.85/1.27 fun( Z, bool ), nat, finite_card( Z ), hAPP( fun( X, bool ), fun( Z, bool
% 0.85/1.27 ), hAPP( fun( X, Z ), fun( fun( X, bool ), fun( Z, bool ) ), image( X, Z
% 0.85/1.27 ), T ), Y ) ) ), hAPP( fun( X, bool ), nat, finite_card( X ), Y ) ) ) }
% 0.85/1.27 .
% 0.85/1.27 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), ! hBOOL(
% 0.85/1.27 hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ),
% 0.85/1.27 bool ), ord_less_eq( fun( X, bool ) ), Z ), Y ) ), hBOOL( hAPP( nat, bool
% 0.85/1.27 , hAPP( nat, fun( nat, bool ), ord_less_eq( nat ), hAPP( fun( X, bool ),
% 0.85/1.27 nat, finite_card( X ), Z ) ), hAPP( fun( X, bool ), nat, finite_card( X )
% 0.85/1.27 , Y ) ) ) }.
% 0.85/1.27 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), ! hBOOL(
% 0.85/1.27 hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ),
% 0.85/1.27 bool ), ord_less_eq( fun( X, bool ) ), Z ), Y ) ), ! hBOOL( hAPP( nat,
% 0.85/1.27 bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat ), hAPP( fun( X, bool
% 0.85/1.27 ), nat, finite_card( X ), Y ) ), hAPP( fun( X, bool ), nat, finite_card
% 0.85/1.27 ( X ), Z ) ) ), ti( fun( X, bool ), Z ) = ti( fun( X, bool ), Y ) }.
% 0.85/1.27 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), hBOOL(
% 0.85/1.27 hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat ), hAPP(
% 0.85/1.27 fun( X, bool ), nat, finite_card( X ), Y ) ), hAPP( fun( X, bool ), nat,
% 0.85/1.27 finite_card( X ), hAPP( fun( X, bool ), fun( X, bool ), hAPP( X, fun( fun
% 0.85/1.27 ( X, bool ), fun( X, bool ) ), insert( X ), Z ), Y ) ) ) ) }.
% 0.85/1.27 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), ! hBOOL(
% 0.85/1.27 hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ), member
% 0.85/1.27 ( X ), Z ), Y ) ), hAPP( fun( X, bool ), nat, finite_card( X ), hAPP( fun
% 0.85/1.27 ( X, bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool )
% 0.85/1.27 ), insert( X ), Z ), Y ) ) = hAPP( fun( X, bool ), nat, finite_card( X )
% 0.85/1.27 , Y ) }.
% 0.85/1.27 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), hBOOL(
% 0.85/1.27 hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ), member
% 0.85/1.27 ( X ), Z ), Y ) ), hAPP( fun( X, bool ), nat, finite_card( X ), hAPP( fun
% 0.85/1.27 ( X, bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool )
% 0.85/1.27 ), insert( X ), Z ), Y ) ) = hAPP( nat, nat, suc, hAPP( fun( X, bool ),
% 0.85/1.27 nat, finite_card( X ), Y ) ) }.
% 0.85/1.27 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), hBOOL(
% 0.85/1.27 hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ), member
% 0.85/1.27 ( X ), Z ), Y ) ), hAPP( fun( X, bool ), nat, finite_card( X ), hAPP( fun
% 0.85/1.27 ( X, bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool )
% 0.85/1.27 ), insert( X ), Z ), Y ) ) = hAPP( nat, nat, suc, hAPP( fun( X, bool ),
% 0.85/1.27 nat, finite_card( X ), Y ) ) }.
% 0.85/1.27 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), hAPP( fun( X,
% 0.85/1.27 bool ), fun( X, bool ), collect( X ), Z ) ) ), hBOOL( hAPP( fun( X, bool
% 0.85/1.27 ), bool, finite_finite( X ), hAPP( fun( X, bool ), fun( X, bool ),
% 0.85/1.27 collect( X ), hAPP( fun( X, bool ), fun( X, bool ), hAPP( fun( X, fun(
% 0.85/1.27 bool, bool ) ), fun( fun( X, bool ), fun( X, bool ) ), combs( X, bool,
% 0.85/1.27 bool ), hAPP( fun( X, bool ), fun( X, fun( bool, bool ) ), hAPP( fun(
% 0.85/1.27 bool, fun( bool, bool ) ), fun( fun( X, bool ), fun( X, fun( bool, bool )
% 0.85/1.27 ) ), combb( bool, fun( bool, bool ), X ), fconj ), Z ) ), Y ) ) ) ) }.
% 0.85/1.27 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), hAPP( fun( X,
% 0.85/1.27 bool ), fun( X, bool ), collect( X ), Y ) ) ), hBOOL( hAPP( fun( X, bool
% 0.85/1.27 ), bool, finite_finite( X ), hAPP( fun( X, bool ), fun( X, bool ),
% 0.85/1.27 collect( X ), hAPP( fun( X, bool ), fun( X, bool ), hAPP( fun( X, fun(
% 0.85/1.27 bool, bool ) ), fun( fun( X, bool ), fun( X, bool ) ), combs( X, bool,
% 0.85/1.27 bool ), hAPP( fun( X, bool ), fun( X, fun( bool, bool ) ), hAPP( fun(
% 0.85/1.27 bool, fun( bool, bool ) ), fun( fun( X, bool ), fun( X, fun( bool, bool )
% 0.85/1.27 ) ), combb( bool, fun( bool, bool ), X ), fconj ), Z ) ), Y ) ) ) ) }.
% 0.85/1.27 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.27 , X ), Y ) ), hAPP( nat, nat, hAPP( nat, fun( nat, nat ), minus_minus(
% 0.85/1.27 nat ), hAPP( nat, nat, suc, Y ) ), X ) = hAPP( nat, nat, suc, hAPP( nat,
% 0.85/1.27 nat, hAPP( nat, fun( nat, nat ), minus_minus( nat ), Y ), X ) ) }.
% 0.85/1.27 { hBOOL( hAPP( fun( nat, bool ), bool, finite_finite( nat ), hAPP( fun( nat
% 0.85/1.27 , bool ), fun( nat, bool ), collect( nat ), hAPP( nat, fun( nat, bool ),
% 0.85/1.27 hAPP( fun( nat, fun( nat, bool ) ), fun( nat, fun( nat, bool ) ), combc(
% 0.85/1.27 nat, nat, bool ), ord_less_eq( nat ) ), X ) ) ) ) }.
% 0.85/1.27 { hAPP( fun( nat, bool ), nat, finite_card( nat ), hAPP( fun( nat, bool ),
% 0.85/1.27 fun( nat, bool ), collect( nat ), hAPP( nat, fun( nat, bool ), hAPP( fun
% 0.85/1.27 ( nat, fun( nat, bool ) ), fun( nat, fun( nat, bool ) ), combc( nat, nat
% 0.85/1.27 , bool ), ord_less_eq( nat ) ), X ) ) ) = hAPP( nat, nat, suc, X ) }.
% 0.85/1.27 { ! finite_finite_1( X ), hBOOL( hAPP( fun( X, bool ), bool, finite_finite
% 0.85/1.27 ( X ), Y ) ) }.
% 0.85/1.27 { ! finite_finite_1( X ), hBOOL( hAPP( fun( X, bool ), bool, finite_finite
% 0.85/1.27 ( X ), Y ) ) }.
% 0.85/1.27 { ! hAPP( nat, nat, suc, X ) = hAPP( nat, nat, suc, Y ), X = Y }.
% 0.85/1.27 { ! hAPP( nat, nat, suc, X ) = hAPP( nat, nat, suc, Y ), X = Y }.
% 0.85/1.27 { ! X = Y, hAPP( nat, nat, suc, X ) = hAPP( nat, nat, suc, Y ) }.
% 0.85/1.27 { ! hAPP( nat, nat, suc, X ) = X }.
% 0.85/1.27 { ! X = hAPP( nat, nat, suc, X ) }.
% 0.85/1.27 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.27 , X ), Y ) ), ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ),
% 0.85/1.27 ord_less_eq( nat ), Y ), X ) ), X = Y }.
% 0.85/1.27 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.27 , X ), Y ) ), ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ),
% 0.85/1.27 ord_less_eq( nat ), Y ), Z ) ), hBOOL( hAPP( nat, bool, hAPP( nat, fun(
% 0.85/1.28 nat, bool ), ord_less_eq( nat ), X ), Z ) ) }.
% 0.85/1.28 { ! X = Y, hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq
% 0.85/1.28 ( nat ), X ), Y ) ) }.
% 0.85/1.28 { hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat ),
% 0.85/1.28 X ), Y ) ), hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ),
% 0.85/1.28 ord_less_eq( nat ), Y ), X ) ) }.
% 0.85/1.28 { hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat ),
% 0.85/1.28 X ), X ) ) }.
% 0.85/1.28 { hAPP( nat, nat, hAPP( nat, fun( nat, nat ), minus_minus( nat ), hAPP( nat
% 0.85/1.28 , nat, hAPP( nat, fun( nat, nat ), minus_minus( nat ), X ), Y ) ), Z ) =
% 0.85/1.28 hAPP( nat, nat, hAPP( nat, fun( nat, nat ), minus_minus( nat ), hAPP( nat
% 0.85/1.28 , nat, hAPP( nat, fun( nat, nat ), minus_minus( nat ), X ), Z ) ), Y ) }
% 0.85/1.28 .
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), hAPP( fun( X,
% 0.85/1.28 bool ), fun( X, bool ), collect( X ), hAPP( fun( X, bool ), fun( X, bool
% 0.85/1.28 ), hAPP( fun( X, fun( bool, bool ) ), fun( fun( X, bool ), fun( X, bool
% 0.85/1.28 ) ), combs( X, bool, bool ), hAPP( fun( X, bool ), fun( X, fun( bool,
% 0.85/1.28 bool ) ), hAPP( fun( bool, fun( bool, bool ) ), fun( fun( X, bool ), fun
% 0.85/1.28 ( X, fun( bool, bool ) ) ), combb( bool, fun( bool, bool ), X ), fdisj )
% 0.85/1.28 , Y ) ), Z ) ) ) ), hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X )
% 0.85/1.28 , hAPP( fun( X, bool ), fun( X, bool ), collect( X ), Y ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), hAPP( fun( X,
% 0.85/1.28 bool ), fun( X, bool ), collect( X ), hAPP( fun( X, bool ), fun( X, bool
% 0.85/1.28 ), hAPP( fun( X, fun( bool, bool ) ), fun( fun( X, bool ), fun( X, bool
% 0.85/1.28 ) ), combs( X, bool, bool ), hAPP( fun( X, bool ), fun( X, fun( bool,
% 0.85/1.28 bool ) ), hAPP( fun( bool, fun( bool, bool ) ), fun( fun( X, bool ), fun
% 0.85/1.28 ( X, fun( bool, bool ) ) ), combb( bool, fun( bool, bool ), X ), fdisj )
% 0.85/1.28 , Y ) ), Z ) ) ) ), hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X )
% 0.85/1.28 , hAPP( fun( X, bool ), fun( X, bool ), collect( X ), Z ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), hAPP( fun( X,
% 0.85/1.28 bool ), fun( X, bool ), collect( X ), Y ) ) ), ! hBOOL( hAPP( fun( X,
% 0.85/1.28 bool ), bool, finite_finite( X ), hAPP( fun( X, bool ), fun( X, bool ),
% 0.85/1.28 collect( X ), Z ) ) ), hBOOL( hAPP( fun( X, bool ), bool, finite_finite(
% 0.85/1.28 X ), hAPP( fun( X, bool ), fun( X, bool ), collect( X ), hAPP( fun( X,
% 0.85/1.28 bool ), fun( X, bool ), hAPP( fun( X, fun( bool, bool ) ), fun( fun( X,
% 0.85/1.28 bool ), fun( X, bool ) ), combs( X, bool, bool ), hAPP( fun( X, bool ),
% 0.85/1.28 fun( X, fun( bool, bool ) ), hAPP( fun( bool, fun( bool, bool ) ), fun(
% 0.85/1.28 fun( X, bool ), fun( X, fun( bool, bool ) ) ), combb( bool, fun( bool,
% 0.85/1.28 bool ), X ), fdisj ), Y ) ), Z ) ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), hAPP( fun( X,
% 0.85/1.28 bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) ),
% 0.85/1.28 insert( X ), Y ), Z ) ) ), hBOOL( hAPP( fun( X, bool ), bool,
% 0.85/1.28 finite_finite( X ), Z ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Z ) ), hBOOL(
% 0.85/1.28 hAPP( fun( X, bool ), bool, finite_finite( X ), hAPP( fun( X, bool ), fun
% 0.85/1.28 ( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X )
% 0.85/1.28 , Y ), Z ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( X, bool ) ), Y ), Z ) ), ! hBOOL( hAPP
% 0.85/1.28 ( fun( X, bool ), bool, finite_finite( X ), Z ) ), hBOOL( hAPP( fun( X,
% 0.85/1.28 bool ), bool, finite_finite( X ), Y ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), ! hBOOL(
% 0.85/1.28 hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ),
% 0.85/1.28 bool ), ord_less_eq( fun( X, bool ) ), Z ), Y ) ), hBOOL( hAPP( fun( X,
% 0.85/1.28 bool ), bool, finite_finite( X ), Z ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , hAPP( nat, nat, suc, X ) ), Y ) ), hBOOL( hAPP( nat, bool, hAPP( nat,
% 0.85/1.28 fun( nat, bool ), ord_less_eq( nat ), X ), Y ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , X ), hAPP( nat, nat, suc, Y ) ) ), hBOOL( hAPP( nat, bool, hAPP( nat,
% 0.85/1.28 fun( nat, bool ), ord_less_eq( nat ), X ), Y ) ), X = hAPP( nat, nat, suc
% 0.85/1.28 , Y ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , X ), Y ) ), hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ),
% 0.85/1.28 ord_less_eq( nat ), X ), hAPP( nat, nat, suc, Y ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , hAPP( nat, nat, suc, X ) ), hAPP( nat, nat, suc, Y ) ) ), hBOOL( hAPP(
% 0.85/1.28 nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat ), X ), Y ) ) }
% 0.85/1.28 .
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , X ), Y ) ), hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ),
% 0.85/1.28 ord_less_eq( nat ), hAPP( nat, nat, suc, X ) ), hAPP( nat, nat, suc, Y )
% 0.85/1.28 ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , X ), hAPP( nat, nat, suc, Y ) ) ), hBOOL( hAPP( nat, bool, hAPP( nat,
% 0.85/1.28 fun( nat, bool ), ord_less_eq( nat ), X ), Y ) ), X = hAPP( nat, nat, suc
% 0.85/1.28 , Y ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , X ), Y ) ), hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ),
% 0.85/1.28 ord_less_eq( nat ), X ), hAPP( nat, nat, suc, Y ) ) ) }.
% 0.85/1.28 { ! X = hAPP( nat, nat, suc, Y ), hBOOL( hAPP( nat, bool, hAPP( nat, fun(
% 0.85/1.28 nat, bool ), ord_less_eq( nat ), X ), hAPP( nat, nat, suc, Y ) ) ) }.
% 0.85/1.28 { hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat ),
% 0.85/1.28 X ), Y ) ), hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ),
% 0.85/1.28 ord_less_eq( nat ), hAPP( nat, nat, suc, Y ) ), X ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , hAPP( nat, nat, suc, Y ) ), X ) ), ! hBOOL( hAPP( nat, bool, hAPP( nat
% 0.85/1.28 , fun( nat, bool ), ord_less_eq( nat ), X ), Y ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , hAPP( nat, nat, suc, X ) ), X ) ) }.
% 0.85/1.28 { hAPP( nat, nat, hAPP( nat, fun( nat, nat ), minus_minus( nat ), hAPP( nat
% 0.85/1.28 , nat, hAPP( nat, fun( nat, nat ), minus_minus( nat ), hAPP( nat, nat,
% 0.85/1.28 suc, X ) ), Y ) ), hAPP( nat, nat, suc, Z ) ) = hAPP( nat, nat, hAPP( nat
% 0.85/1.28 , fun( nat, nat ), minus_minus( nat ), hAPP( nat, nat, hAPP( nat, fun(
% 0.85/1.28 nat, nat ), minus_minus( nat ), X ), Y ) ), Z ) }.
% 0.85/1.28 { hAPP( nat, nat, hAPP( nat, fun( nat, nat ), minus_minus( nat ), hAPP( nat
% 0.85/1.28 , nat, suc, X ) ), hAPP( nat, nat, suc, Y ) ) = hAPP( nat, nat, hAPP( nat
% 0.85/1.28 , fun( nat, nat ), minus_minus( nat ), X ), Y ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , X ), Y ) ), ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ),
% 0.85/1.28 ord_less_eq( nat ), X ), Z ) ), ! hBOOL( hAPP( nat, bool, hAPP( nat, fun
% 0.85/1.28 ( nat, bool ), ord_less_eq( nat ), hAPP( nat, nat, hAPP( nat, fun( nat,
% 0.85/1.28 nat ), minus_minus( nat ), Y ), X ) ), hAPP( nat, nat, hAPP( nat, fun(
% 0.85/1.28 nat, nat ), minus_minus( nat ), Z ), X ) ) ), hBOOL( hAPP( nat, bool,
% 0.85/1.28 hAPP( nat, fun( nat, bool ), ord_less_eq( nat ), Y ), Z ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , X ), Y ) ), ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ),
% 0.85/1.28 ord_less_eq( nat ), X ), Z ) ), ! hBOOL( hAPP( nat, bool, hAPP( nat, fun
% 0.85/1.28 ( nat, bool ), ord_less_eq( nat ), Y ), Z ) ), hBOOL( hAPP( nat, bool,
% 0.85/1.28 hAPP( nat, fun( nat, bool ), ord_less_eq( nat ), hAPP( nat, nat, hAPP(
% 0.85/1.28 nat, fun( nat, nat ), minus_minus( nat ), Y ), X ) ), hAPP( nat, nat,
% 0.85/1.28 hAPP( nat, fun( nat, nat ), minus_minus( nat ), Z ), X ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , X ), Y ) ), ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ),
% 0.85/1.28 ord_less_eq( nat ), X ), Z ) ), hAPP( nat, nat, hAPP( nat, fun( nat, nat
% 0.85/1.28 ), minus_minus( nat ), hAPP( nat, nat, hAPP( nat, fun( nat, nat ),
% 0.85/1.28 minus_minus( nat ), Y ), X ) ), hAPP( nat, nat, hAPP( nat, fun( nat, nat
% 0.85/1.28 ), minus_minus( nat ), Z ), X ) ) = hAPP( nat, nat, hAPP( nat, fun( nat
% 0.85/1.28 , nat ), minus_minus( nat ), Y ), Z ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , X ), Y ) ), ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ),
% 0.85/1.28 ord_less_eq( nat ), X ), Z ) ), ! hAPP( nat, nat, hAPP( nat, fun( nat,
% 0.85/1.28 nat ), minus_minus( nat ), Y ), X ) = hAPP( nat, nat, hAPP( nat, fun( nat
% 0.85/1.28 , nat ), minus_minus( nat ), Z ), X ), Y = Z }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , X ), Y ) ), ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ),
% 0.85/1.28 ord_less_eq( nat ), X ), Z ) ), ! Y = Z, hAPP( nat, nat, hAPP( nat, fun(
% 0.85/1.28 nat, nat ), minus_minus( nat ), Y ), X ) = hAPP( nat, nat, hAPP( nat, fun
% 0.85/1.28 ( nat, nat ), minus_minus( nat ), Z ), X ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , X ), Y ) ), hAPP( nat, nat, hAPP( nat, fun( nat, nat ), minus_minus(
% 0.85/1.28 nat ), Y ), hAPP( nat, nat, hAPP( nat, fun( nat, nat ), minus_minus( nat
% 0.85/1.28 ), Y ), X ) ) = X }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , X ), Y ) ), hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ),
% 0.85/1.28 ord_less_eq( nat ), hAPP( nat, nat, hAPP( nat, fun( nat, nat ),
% 0.85/1.28 minus_minus( nat ), X ), Z ) ), hAPP( nat, nat, hAPP( nat, fun( nat, nat
% 0.85/1.28 ), minus_minus( nat ), Y ), Z ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , X ), Y ) ), hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ),
% 0.85/1.28 ord_less_eq( nat ), hAPP( nat, nat, hAPP( nat, fun( nat, nat ),
% 0.85/1.28 minus_minus( nat ), Z ), Y ) ), hAPP( nat, nat, hAPP( nat, fun( nat, nat
% 0.85/1.28 ), minus_minus( nat ), Z ), X ) ) ) }.
% 0.85/1.28 { hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat ),
% 0.85/1.28 hAPP( nat, nat, hAPP( nat, fun( nat, nat ), minus_minus( nat ), X ), Y )
% 0.85/1.28 ), X ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), ! hBOOL(
% 0.85/1.28 hAPP( fun( Z, bool ), bool, hAPP( fun( Z, bool ), fun( fun( Z, bool ),
% 0.85/1.28 bool ), ord_less_eq( fun( Z, bool ) ), T ), hAPP( fun( X, bool ), fun( Z
% 0.85/1.28 , bool ), hAPP( fun( X, Z ), fun( fun( X, bool ), fun( Z, bool ) ), image
% 0.85/1.28 ( X, Z ), U ), Y ) ) ), hBOOL( hAPP( fun( Z, bool ), bool, finite_finite
% 0.85/1.28 ( Z ), T ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), ! hBOOL(
% 0.85/1.28 hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ),
% 0.85/1.28 bool ), ord_less_eq( fun( X, bool ) ), Y ), hAPP( fun( Z, bool ), fun( X
% 0.85/1.28 , bool ), hAPP( fun( Z, X ), fun( fun( Z, bool ), fun( X, bool ) ), image
% 0.85/1.28 ( Z, X ), T ), U ) ) ), hBOOL( hAPP( fun( Z, bool ), bool, finite_finite
% 0.85/1.28 ( Z ), skol1( W, V0, Z, V1, V2 ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), ! hBOOL(
% 0.85/1.28 hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ),
% 0.85/1.28 bool ), ord_less_eq( fun( X, bool ) ), Y ), hAPP( fun( Z, bool ), fun( X
% 0.85/1.28 , bool ), hAPP( fun( Z, X ), fun( fun( Z, bool ), fun( X, bool ) ), image
% 0.85/1.28 ( Z, X ), T ), U ) ) ), hBOOL( hAPP( fun( Z, bool ), bool, hAPP( fun( Z,
% 0.85/1.28 bool ), fun( fun( Z, bool ), bool ), ord_less_eq( fun( Z, bool ) ), skol1
% 0.85/1.28 ( W, V0, Z, V1, U ) ), U ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), ! hBOOL(
% 0.85/1.28 hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ),
% 0.85/1.28 bool ), ord_less_eq( fun( X, bool ) ), Y ), hAPP( fun( Z, bool ), fun( X
% 0.85/1.28 , bool ), hAPP( fun( Z, X ), fun( fun( Z, bool ), fun( X, bool ) ), image
% 0.85/1.28 ( Z, X ), T ), U ) ) ), ti( fun( X, bool ), Y ) = hAPP( fun( Z, bool ),
% 0.85/1.28 fun( X, bool ), hAPP( fun( Z, X ), fun( fun( Z, bool ), fun( X, bool ) )
% 0.85/1.28 , image( Z, X ), T ), skol1( X, Y, Z, T, U ) ) }.
% 0.85/1.28 { ! order( X ), ! hBOOL( hAPP( X, bool, hAPP( X, fun( X, bool ),
% 0.85/1.28 ord_less_eq( X ), hAPP( nat, X, Y, skol2( X, Y ) ) ), hAPP( nat, X, Y,
% 0.85/1.28 hAPP( nat, nat, suc, skol2( X, Y ) ) ) ) ), ! hBOOL( hAPP( nat, bool,
% 0.85/1.28 hAPP( nat, fun( nat, bool ), ord_less_eq( nat ), Z ), T ) ), hBOOL( hAPP
% 0.85/1.28 ( X, bool, hAPP( X, fun( X, bool ), ord_less_eq( X ), hAPP( nat, X, Y, Z
% 0.85/1.28 ) ), hAPP( nat, X, Y, T ) ) ) }.
% 0.85/1.28 { hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), ! hBOOL(
% 0.85/1.28 hAPP( fun( Z, bool ), bool, finite_finite( Z ), hAPP( fun( X, bool ), fun
% 0.85/1.28 ( Z, bool ), hAPP( fun( X, Z ), fun( fun( X, bool ), fun( Z, bool ) ),
% 0.85/1.28 image( X, Z ), T ), Y ) ) ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( X,
% 0.85/1.28 fun( fun( X, bool ), bool ), member( X ), skol3( X, Y, U, W ) ), Y ) ) }
% 0.85/1.28 .
% 0.85/1.28 { hBOOL( hAPP( fun( X, bool ), bool, finite_finite( X ), Y ) ), ! hBOOL(
% 0.85/1.28 hAPP( fun( Z, bool ), bool, finite_finite( Z ), hAPP( fun( X, bool ), fun
% 0.85/1.28 ( Z, bool ), hAPP( fun( X, Z ), fun( fun( X, bool ), fun( Z, bool ) ),
% 0.85/1.28 image( X, Z ), T ), Y ) ) ), ! hBOOL( hAPP( fun( X, bool ), bool,
% 0.85/1.28 finite_finite( X ), hAPP( fun( X, bool ), fun( X, bool ), collect( X ),
% 0.85/1.28 hAPP( fun( X, bool ), fun( X, bool ), hAPP( fun( X, fun( bool, bool ) ),
% 0.85/1.28 fun( fun( X, bool ), fun( X, bool ) ), combs( X, bool, bool ), hAPP( fun
% 0.85/1.28 ( X, bool ), fun( X, fun( bool, bool ) ), hAPP( fun( bool, fun( bool,
% 0.85/1.28 bool ) ), fun( fun( X, bool ), fun( X, fun( bool, bool ) ) ), combb( bool
% 0.85/1.28 , fun( bool, bool ), X ), fconj ), hAPP( fun( X, bool ), fun( X, bool ),
% 0.85/1.28 hAPP( fun( X, fun( fun( X, bool ), bool ) ), fun( fun( X, bool ), fun( X
% 0.85/1.28 , bool ) ), combc( X, fun( X, bool ), bool ), member( X ) ), Y ) ) ),
% 0.85/1.28 hAPP( Z, fun( X, bool ), hAPP( fun( X, fun( Z, bool ) ), fun( Z, fun( X,
% 0.85/1.28 bool ) ), combc( X, Z, bool ), hAPP( fun( X, Z ), fun( X, fun( Z, bool )
% 0.85/1.28 ), hAPP( fun( Z, fun( Z, bool ) ), fun( fun( X, Z ), fun( X, fun( Z,
% 0.85/1.28 bool ) ) ), combb( Z, fun( Z, bool ), X ), fequal( Z ) ), T ) ), hAPP( X
% 0.85/1.28 , Z, T, skol3( X, Y, Z, T ) ) ) ) ) ) ) }.
% 0.85/1.28 { ! ti( X, Z ) = hAPP( Y, X, T, U ), ! hBOOL( hAPP( fun( Y, bool ), bool,
% 0.85/1.28 hAPP( Y, fun( fun( Y, bool ), bool ), member( Y ), U ), W ) ), hBOOL(
% 0.85/1.28 hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ), member
% 0.85/1.28 ( X ), Z ), hAPP( fun( Y, bool ), fun( X, bool ), hAPP( fun( Y, X ), fun
% 0.85/1.28 ( fun( Y, bool ), fun( X, bool ) ), image( Y, X ), T ), W ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( X, bool ) ), Y ), Z ) ), ! hBOOL( hAPP
% 0.85/1.28 ( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ), bool )
% 0.85/1.28 , ord_less_eq( fun( X, bool ) ), Z ), Y ) ), ti( fun( X, bool ), Y ) = ti
% 0.85/1.28 ( fun( X, bool ), Z ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( X, bool ) ), Y ), Z ) ), ! hBOOL( hAPP
% 0.85/1.28 ( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ), member( X )
% 0.85/1.28 , T ), Y ) ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X,
% 0.85/1.28 bool ), bool ), member( X ), T ), Z ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), Z ), T ) ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( X,
% 0.85/1.28 fun( fun( X, bool ), bool ), member( X ), Z ), hAPP( fun( X, bool ), fun
% 0.85/1.28 ( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X )
% 0.85/1.28 , Y ), T ) ) ) }.
% 0.85/1.28 { ! ti( X, Z ) = ti( X, Y ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( X,
% 0.85/1.28 fun( fun( X, bool ), bool ), member( X ), Z ), hAPP( fun( X, bool ), fun
% 0.85/1.28 ( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X )
% 0.85/1.28 , Y ), T ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), Y ), hAPP( fun( X, bool ), fun( X, bool ), hAPP( X, fun(
% 0.85/1.28 fun( X, bool ), fun( X, bool ) ), insert( X ), Z ), T ) ) ), ti( X, Y ) =
% 0.85/1.28 ti( X, Z ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X,
% 0.85/1.28 bool ), bool ), member( X ), Y ), T ) ) }.
% 0.85/1.28 { hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ),
% 0.85/1.28 member( X ), Y ), hAPP( fun( X, bool ), fun( X, bool ), hAPP( X, fun( fun
% 0.85/1.28 ( X, bool ), fun( X, bool ) ), insert( X ), Y ), Z ) ) ) }.
% 0.85/1.28 { hAPP( fun( X, bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun(
% 0.85/1.28 X, bool ) ), insert( X ), Y ), Z ) = hAPP( fun( X, bool ), fun( X, bool )
% 0.85/1.28 , collect( X ), hAPP( fun( X, bool ), fun( X, bool ), hAPP( fun( X, fun(
% 0.85/1.28 bool, bool ) ), fun( fun( X, bool ), fun( X, bool ) ), combs( X, bool,
% 0.85/1.28 bool ), hAPP( fun( X, bool ), fun( X, fun( bool, bool ) ), hAPP( fun(
% 0.85/1.28 bool, fun( bool, bool ) ), fun( fun( X, bool ), fun( X, fun( bool, bool )
% 0.85/1.28 ) ), combb( bool, fun( bool, bool ), X ), fdisj ), hAPP( X, fun( X, bool
% 0.85/1.28 ), hAPP( fun( X, fun( X, bool ) ), fun( X, fun( X, bool ) ), combc( X, X
% 0.85/1.28 , bool ), fequal( X ) ), Y ) ) ), hAPP( fun( X, bool ), fun( X, bool ),
% 0.85/1.28 hAPP( fun( X, fun( fun( X, bool ), bool ) ), fun( fun( X, bool ), fun( X
% 0.85/1.28 , bool ) ), combc( X, fun( X, bool ), bool ), member( X ) ), Z ) ) ) }.
% 0.85/1.28 { hAPP( fun( X, bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun(
% 0.85/1.28 X, bool ) ), insert( X ), Y ), hAPP( fun( X, bool ), fun( X, bool ),
% 0.85/1.28 collect( X ), Z ) ) = hAPP( fun( X, bool ), fun( X, bool ), collect( X )
% 0.85/1.28 , hAPP( fun( X, bool ), fun( X, bool ), hAPP( fun( X, fun( bool, bool ) )
% 0.85/1.28 , fun( fun( X, bool ), fun( X, bool ) ), combs( X, bool, bool ), hAPP(
% 0.85/1.28 fun( X, bool ), fun( X, fun( bool, bool ) ), hAPP( fun( bool, fun( bool,
% 0.85/1.28 bool ) ), fun( fun( X, bool ), fun( X, fun( bool, bool ) ) ), combb( bool
% 0.85/1.28 , fun( bool, bool ), X ), fimplies ), hAPP( fun( X, bool ), fun( X, bool
% 0.85/1.28 ), hAPP( fun( bool, bool ), fun( fun( X, bool ), fun( X, bool ) ), combb
% 0.85/1.28 ( bool, bool, X ), fNot ), hAPP( X, fun( X, bool ), hAPP( fun( X, fun( X
% 0.85/1.28 , bool ) ), fun( X, fun( X, bool ) ), combc( X, X, bool ), fequal( X ) )
% 0.85/1.28 , Y ) ) ) ), Z ) ) }.
% 0.85/1.28 { hAPP( fun( X, bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun(
% 0.85/1.28 X, bool ) ), insert( X ), Y ), hAPP( fun( X, bool ), fun( X, bool ), hAPP
% 0.85/1.28 ( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X ), Y ), Z ) ) =
% 0.85/1.28 hAPP( fun( X, bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun(
% 0.85/1.28 X, bool ) ), insert( X ), Y ), Z ) }.
% 0.85/1.28 { hAPP( fun( X, bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun(
% 0.85/1.28 X, bool ) ), insert( X ), Y ), hAPP( fun( X, bool ), fun( X, bool ), hAPP
% 0.85/1.28 ( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X ), Z ), T ) ) =
% 0.85/1.28 hAPP( fun( X, bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun(
% 0.85/1.28 X, bool ) ), insert( X ), Z ), hAPP( fun( X, bool ), fun( X, bool ), hAPP
% 0.85/1.28 ( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X ), Y ), T ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), Y ), hAPP( fun( X, bool ), fun( X, bool ), hAPP( X, fun(
% 0.85/1.28 fun( X, bool ), fun( X, bool ) ), insert( X ), Z ), T ) ) ), ti( X, Y ) =
% 0.85/1.28 ti( X, Z ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X,
% 0.85/1.28 bool ), bool ), member( X ), Y ), T ) ) }.
% 0.85/1.28 { ! ti( X, Y ) = ti( X, Z ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( X,
% 0.85/1.28 fun( fun( X, bool ), bool ), member( X ), Y ), hAPP( fun( X, bool ), fun
% 0.85/1.28 ( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X )
% 0.85/1.28 , Z ), T ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), Y ), T ) ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( X,
% 0.85/1.28 fun( fun( X, bool ), bool ), member( X ), Y ), hAPP( fun( X, bool ), fun
% 0.85/1.28 ( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X )
% 0.85/1.28 , Z ), T ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( X, bool, hAPP( fun( X, bool ), fun( X, bool ), hAPP( X,
% 0.85/1.28 fun( fun( X, bool ), fun( X, bool ) ), insert( X ), Y ), Z ), T ) ), ti(
% 0.85/1.28 X, Y ) = ti( X, T ), hBOOL( hAPP( X, bool, Z, T ) ) }.
% 0.85/1.28 { ! ti( X, Y ) = ti( X, T ), hBOOL( hAPP( X, bool, hAPP( fun( X, bool ),
% 0.85/1.28 fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X
% 0.85/1.28 ), Y ), Z ), T ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( X, bool, Z, T ) ), hBOOL( hAPP( X, bool, hAPP( fun( X,
% 0.85/1.28 bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) ),
% 0.85/1.28 insert( X ), Y ), Z ), T ) ) }.
% 0.85/1.28 { hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ),
% 0.85/1.28 member( X ), Y ), Z ) ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun
% 0.85/1.28 ( fun( X, bool ), bool ), member( X ), Y ), T ) ), ! hAPP( fun( X, bool )
% 0.85/1.28 , fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) ), insert
% 0.85/1.28 ( X ), Y ), Z ) = hAPP( fun( X, bool ), fun( X, bool ), hAPP( X, fun( fun
% 0.85/1.28 ( X, bool ), fun( X, bool ) ), insert( X ), Y ), T ), ti( fun( X, bool )
% 0.85/1.28 , Z ) = ti( fun( X, bool ), T ) }.
% 0.85/1.28 { hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ),
% 0.85/1.28 member( X ), Y ), Z ) ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun
% 0.85/1.28 ( fun( X, bool ), bool ), member( X ), Y ), T ) ), ! ti( fun( X, bool ),
% 0.85/1.28 Z ) = ti( fun( X, bool ), T ), hAPP( fun( X, bool ), fun( X, bool ), hAPP
% 0.85/1.28 ( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X ), Y ), Z ) = hAPP
% 0.85/1.28 ( fun( X, bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X,
% 0.85/1.28 bool ) ), insert( X ), Y ), T ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), Y ), Z ) ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( X,
% 0.85/1.28 fun( fun( X, bool ), bool ), member( X ), Y ), hAPP( fun( X, bool ), fun
% 0.85/1.28 ( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X )
% 0.85/1.28 , T ), Z ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), Y ), Z ) ), hAPP( fun( X, bool ), fun( X, bool ), hAPP( X
% 0.85/1.28 , fun( fun( X, bool ), fun( X, bool ) ), insert( X ), Y ), Z ) = ti( fun
% 0.85/1.28 ( X, bool ), Z ) }.
% 0.85/1.28 { hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( X, bool ) ), Y ), Y ) ) }.
% 0.85/1.28 { ! ti( fun( X, bool ), Y ) = ti( fun( X, bool ), Z ), hBOOL( hAPP( fun( X
% 0.85/1.28 , bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ), bool ),
% 0.85/1.28 ord_less_eq( fun( X, bool ) ), Y ), Z ) ) }.
% 0.85/1.28 { ! ti( fun( X, bool ), Y ) = ti( fun( X, bool ), Z ), hBOOL( hAPP( fun( X
% 0.85/1.28 , bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ), bool ),
% 0.85/1.28 ord_less_eq( fun( X, bool ) ), Z ), Y ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( X, bool ) ), Y ), Z ) ), ! hBOOL( hAPP
% 0.85/1.28 ( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ), bool )
% 0.85/1.28 , ord_less_eq( fun( X, bool ) ), Z ), Y ) ), ti( fun( X, bool ), Y ) = ti
% 0.85/1.28 ( fun( X, bool ), Z ) }.
% 0.85/1.28 { ! ti( fun( X, bool ), Y ) = ti( fun( X, bool ), Z ), hBOOL( hAPP( fun( X
% 0.85/1.28 , bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ), bool ),
% 0.85/1.28 ord_less_eq( fun( X, bool ) ), Y ), Z ) ) }.
% 0.85/1.28 { ! ti( fun( X, bool ), Y ) = ti( fun( X, bool ), Z ), hBOOL( hAPP( fun( X
% 0.85/1.28 , bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ), bool ),
% 0.85/1.28 ord_less_eq( fun( X, bool ) ), Z ), Y ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( X, bool ) ), Y ), Z ) ), ! hBOOL( hAPP
% 0.85/1.28 ( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ), member( X )
% 0.85/1.28 , T ), Y ) ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X,
% 0.85/1.28 bool ), bool ), member( X ), T ), Z ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), Y ), Z ) ), ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun
% 0.85/1.28 ( X, bool ), fun( fun( X, bool ), bool ), ord_less_eq( fun( X, bool ) ),
% 0.85/1.28 Z ), T ) ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool
% 0.85/1.28 ), bool ), member( X ), Y ), T ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( X, bool ) ), Y ), Z ) ), ! hBOOL( hAPP
% 0.85/1.28 ( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ), member( X )
% 0.85/1.28 , T ), Y ) ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X,
% 0.85/1.28 bool ), bool ), member( X ), T ), Z ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( X, bool ) ), Y ), Z ) ), ! hBOOL( hAPP
% 0.85/1.28 ( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ), bool )
% 0.85/1.28 , ord_less_eq( fun( X, bool ) ), Z ), T ) ), hBOOL( hAPP( fun( X, bool )
% 0.85/1.28 , bool, hAPP( fun( X, bool ), fun( fun( X, bool ), bool ), ord_less_eq(
% 0.85/1.28 fun( X, bool ) ), Y ), T ) ) }.
% 0.85/1.28 { ! ti( fun( X, bool ), Y ) = ti( fun( X, bool ), Z ), hBOOL( hAPP( fun( X
% 0.85/1.28 , bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ), bool ),
% 0.85/1.28 ord_less_eq( fun( X, bool ) ), Y ), Z ) ) }.
% 0.85/1.28 { ! ti( fun( X, bool ), Y ) = ti( fun( X, bool ), Z ), hBOOL( hAPP( fun( X
% 0.85/1.28 , bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ), bool ),
% 0.85/1.28 ord_less_eq( fun( X, bool ) ), Z ), Y ) ) }.
% 0.85/1.28 { ! hAPP( X, Y, Z, skol4( X, Y, Z, T ) ) = hAPP( X, Y, T, skol4( X, Y, Z, T
% 0.85/1.28 ) ), ti( fun( X, Y ), Z ) = ti( fun( X, Y ), T ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), Y ), Z ) ), hBOOL( hAPP( X, bool, Z, Y ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( X, bool, Z, Y ) ), hBOOL( hAPP( fun( X, bool ), bool, hAPP
% 0.85/1.28 ( X, fun( fun( X, bool ), bool ), member( X ), Y ), Z ) ) }.
% 0.85/1.28 { hAPP( fun( X, bool ), fun( X, bool ), collect( X ), Y ) = ti( fun( X,
% 0.85/1.28 bool ), Y ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), Z ), hAPP( fun( Y, bool ), fun( X, bool ), hAPP( fun( Y, X
% 0.85/1.28 ), fun( fun( Y, bool ), fun( X, bool ) ), image( Y, X ), T ), U ) ) ),
% 0.85/1.28 hBOOL( hAPP( fun( Y, bool ), bool, hAPP( Y, fun( fun( Y, bool ), bool ),
% 0.85/1.28 member( Y ), skol5( W, Y, V0, V1, U ) ), U ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), Z ), hAPP( fun( Y, bool ), fun( X, bool ), hAPP( fun( Y, X
% 0.85/1.28 ), fun( fun( Y, bool ), fun( X, bool ) ), image( Y, X ), T ), U ) ) ),
% 0.85/1.28 ti( X, Z ) = hAPP( Y, X, T, skol5( X, Y, Z, T, U ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( Y, bool ), bool, hAPP( Y, fun( fun( Y, bool ), bool )
% 0.85/1.28 , member( Y ), W ), U ) ), ! ti( X, Z ) = hAPP( Y, X, T, W ), hBOOL( hAPP
% 0.85/1.28 ( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ), member( X )
% 0.85/1.28 , Z ), hAPP( fun( Y, bool ), fun( X, bool ), hAPP( fun( Y, X ), fun( fun
% 0.85/1.28 ( Y, bool ), fun( X, bool ) ), image( Y, X ), T ), U ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), Y ), Z ) ), hBOOL( hAPP( fun( T, bool ), bool, hAPP( T,
% 0.85/1.28 fun( fun( T, bool ), bool ), member( T ), hAPP( X, T, U, Y ) ), hAPP( fun
% 0.85/1.28 ( X, bool ), fun( T, bool ), hAPP( fun( X, T ), fun( fun( X, bool ), fun
% 0.85/1.28 ( T, bool ) ), image( X, T ), U ), Z ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), Y ), Z ) ), ! ti( T, U ) = hAPP( X, T, W, Y ), hBOOL( hAPP
% 0.85/1.28 ( fun( T, bool ), bool, hAPP( T, fun( fun( T, bool ), bool ), member( T )
% 0.85/1.28 , U ), hAPP( fun( X, bool ), fun( T, bool ), hAPP( fun( X, T ), fun( fun
% 0.85/1.28 ( X, bool ), fun( T, bool ) ), image( X, T ), W ), Z ) ) ) }.
% 0.85/1.28 { hAPP( fun( X, bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun(
% 0.85/1.28 X, bool ) ), insert( X ), Y ), Z ) = hAPP( fun( X, bool ), fun( X, bool )
% 0.85/1.28 , collect( X ), hAPP( fun( X, bool ), fun( X, bool ), hAPP( fun( X, fun(
% 0.85/1.28 bool, bool ) ), fun( fun( X, bool ), fun( X, bool ) ), combs( X, bool,
% 0.85/1.28 bool ), hAPP( fun( X, bool ), fun( X, fun( bool, bool ) ), hAPP( fun(
% 0.85/1.28 bool, fun( bool, bool ) ), fun( fun( X, bool ), fun( X, fun( bool, bool )
% 0.85/1.28 ) ), combb( bool, fun( bool, bool ), X ), fdisj ), hAPP( X, fun( X, bool
% 0.85/1.28 ), hAPP( fun( X, fun( X, bool ) ), fun( X, fun( X, bool ) ), combc( X, X
% 0.85/1.28 , bool ), fequal( X ) ), Y ) ) ), hAPP( fun( X, bool ), fun( X, bool ),
% 0.85/1.28 hAPP( fun( X, fun( fun( X, bool ), bool ) ), fun( fun( X, bool ), fun( X
% 0.85/1.28 , bool ) ), combc( X, fun( X, bool ), bool ), member( X ) ), Z ) ) ) }.
% 0.85/1.28 { hAPP( fun( X, bool ), fun( Y, bool ), hAPP( fun( X, Y ), fun( fun( X,
% 0.85/1.28 bool ), fun( Y, bool ) ), image( X, Y ), T ), hAPP( fun( Z, bool ), fun(
% 0.85/1.28 X, bool ), hAPP( fun( Z, X ), fun( fun( Z, bool ), fun( X, bool ) ),
% 0.85/1.28 image( Z, X ), U ), W ) ) = hAPP( fun( Z, bool ), fun( Y, bool ), hAPP(
% 0.85/1.28 fun( Z, Y ), fun( fun( Z, bool ), fun( Y, bool ) ), image( Z, Y ), hAPP(
% 0.85/1.28 fun( Z, X ), fun( Z, Y ), hAPP( fun( X, Y ), fun( fun( Z, X ), fun( Z, Y
% 0.85/1.28 ) ), combb( X, Y, Z ), T ), U ) ), W ) }.
% 0.85/1.28 { hAPP( fun( X, bool ), fun( X, bool ), hAPP( fun( X, X ), fun( fun( X,
% 0.85/1.28 bool ), fun( X, bool ) ), image( X, X ), combi( X ) ), Y ) = ti( fun( X,
% 0.85/1.28 bool ), Y ) }.
% 0.85/1.28 { hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( X, bool ) ), Y ), hAPP( fun( X, bool )
% 0.85/1.28 , fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) ), insert
% 0.85/1.28 ( X ), Z ), Y ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( X, bool ) ), hAPP( fun( X, bool ), fun
% 0.85/1.28 ( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X )
% 0.85/1.28 , Y ), Z ) ), T ) ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun
% 0.85/1.28 ( X, bool ), bool ), member( X ), Y ), T ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( X, bool ) ), hAPP( fun( X, bool ), fun
% 0.85/1.28 ( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X )
% 0.85/1.28 , Y ), Z ) ), T ) ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X,
% 0.85/1.28 bool ), fun( fun( X, bool ), bool ), ord_less_eq( fun( X, bool ) ), Z ),
% 0.85/1.28 T ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), Y ), T ) ), ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun
% 0.85/1.28 ( X, bool ), fun( fun( X, bool ), bool ), ord_less_eq( fun( X, bool ) ),
% 0.85/1.28 Z ), T ) ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun
% 0.85/1.28 ( fun( X, bool ), bool ), ord_less_eq( fun( X, bool ) ), hAPP( fun( X,
% 0.85/1.28 bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) ),
% 0.85/1.28 insert( X ), Y ), Z ) ), T ) ) }.
% 0.85/1.28 { hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ),
% 0.85/1.28 member( X ), Y ), Z ) ), ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun(
% 0.85/1.28 X, bool ), fun( fun( X, bool ), bool ), ord_less_eq( fun( X, bool ) ), Z
% 0.85/1.28 ), hAPP( fun( X, bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ),
% 0.85/1.28 fun( X, bool ) ), insert( X ), Y ), T ) ) ), hBOOL( hAPP( fun( X, bool )
% 0.85/1.28 , bool, hAPP( fun( X, bool ), fun( fun( X, bool ), bool ), ord_less_eq(
% 0.85/1.28 fun( X, bool ) ), Z ), T ) ) }.
% 0.85/1.28 { hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ),
% 0.85/1.28 member( X ), Y ), Z ) ), ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun(
% 0.85/1.28 X, bool ), fun( fun( X, bool ), bool ), ord_less_eq( fun( X, bool ) ), Z
% 0.85/1.28 ), T ) ), hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun(
% 0.85/1.28 fun( X, bool ), bool ), ord_less_eq( fun( X, bool ) ), Z ), hAPP( fun( X
% 0.85/1.28 , bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) )
% 0.85/1.28 , insert( X ), Y ), T ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( X, bool ) ), Y ), Z ) ), hBOOL( hAPP(
% 0.85/1.28 fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ), bool ),
% 0.85/1.28 ord_less_eq( fun( X, bool ) ), Y ), hAPP( fun( X, bool ), fun( X, bool )
% 0.85/1.28 , hAPP( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X ), T ), Z ) )
% 0.85/1.28 ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( X, bool ) ), Y ), Z ) ), hBOOL( hAPP(
% 0.85/1.28 fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ), bool ),
% 0.85/1.28 ord_less_eq( fun( X, bool ) ), hAPP( fun( X, bool ), fun( X, bool ), hAPP
% 0.85/1.28 ( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X ), T ), Y ) ), hAPP
% 0.85/1.28 ( fun( X, bool ), fun( X, bool ), hAPP( X, fun( fun( X, bool ), fun( X,
% 0.85/1.28 bool ) ), insert( X ), T ), Z ) ) ) }.
% 0.85/1.28 { hAPP( fun( X, bool ), fun( Y, bool ), hAPP( fun( X, Y ), fun( fun( X,
% 0.85/1.28 bool ), fun( Y, bool ) ), image( X, Y ), Z ), hAPP( fun( X, bool ), fun(
% 0.85/1.28 X, bool ), hAPP( X, fun( fun( X, bool ), fun( X, bool ) ), insert( X ), T
% 0.85/1.28 ), U ) ) = hAPP( fun( Y, bool ), fun( Y, bool ), hAPP( Y, fun( fun( Y,
% 0.85/1.28 bool ), fun( Y, bool ) ), insert( Y ), hAPP( X, Y, Z, T ) ), hAPP( fun( X
% 0.85/1.28 , bool ), fun( Y, bool ), hAPP( fun( X, Y ), fun( fun( X, bool ), fun( Y
% 0.85/1.28 , bool ) ), image( X, Y ), Z ), U ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), Y ), Z ) ), hAPP( fun( T, bool ), fun( T, bool ), hAPP( T
% 0.85/1.28 , fun( fun( T, bool ), fun( T, bool ) ), insert( T ), hAPP( X, T, U, Y )
% 0.85/1.28 ), hAPP( fun( X, bool ), fun( T, bool ), hAPP( fun( X, T ), fun( fun( X
% 0.85/1.28 , bool ), fun( T, bool ) ), image( X, T ), U ), Z ) ) = hAPP( fun( X,
% 0.85/1.28 bool ), fun( T, bool ), hAPP( fun( X, T ), fun( fun( X, bool ), fun( T,
% 0.85/1.28 bool ) ), image( X, T ), U ), Z ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( X, bool ) ), Z ), hAPP( fun( Y, bool )
% 0.85/1.28 , fun( X, bool ), hAPP( fun( Y, X ), fun( fun( Y, bool ), fun( X, bool )
% 0.85/1.28 ), image( Y, X ), T ), U ) ) ), hBOOL( hAPP( fun( Y, bool ), bool, hAPP
% 0.85/1.28 ( fun( Y, bool ), fun( fun( Y, bool ), bool ), ord_less_eq( fun( Y, bool
% 0.85/1.28 ) ), skol6( W, Y, V0, V1, U ) ), U ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( X, bool ) ), Z ), hAPP( fun( Y, bool )
% 0.85/1.28 , fun( X, bool ), hAPP( fun( Y, X ), fun( fun( Y, bool ), fun( X, bool )
% 0.85/1.28 ), image( Y, X ), T ), U ) ) ), ti( fun( X, bool ), Z ) = hAPP( fun( Y,
% 0.85/1.28 bool ), fun( X, bool ), hAPP( fun( Y, X ), fun( fun( Y, bool ), fun( X,
% 0.85/1.28 bool ) ), image( Y, X ), T ), skol6( X, Y, Z, T, U ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( Y, bool ), bool, hAPP( fun( Y, bool ), fun( fun( Y,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( Y, bool ) ), W ), U ) ), ! ti( fun( X,
% 0.85/1.28 bool ), Z ) = hAPP( fun( Y, bool ), fun( X, bool ), hAPP( fun( Y, X ),
% 0.85/1.28 fun( fun( Y, bool ), fun( X, bool ) ), image( Y, X ), T ), W ), hBOOL(
% 0.85/1.28 hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ),
% 0.85/1.28 bool ), ord_less_eq( fun( X, bool ) ), Z ), hAPP( fun( Y, bool ), fun( X
% 0.85/1.28 , bool ), hAPP( fun( Y, X ), fun( fun( Y, bool ), fun( X, bool ) ), image
% 0.85/1.28 ( Y, X ), T ), U ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X,
% 0.85/1.28 bool ), bool ), ord_less_eq( fun( X, bool ) ), Y ), Z ) ), hBOOL( hAPP(
% 0.85/1.28 fun( T, bool ), bool, hAPP( fun( T, bool ), fun( fun( T, bool ), bool ),
% 0.85/1.28 ord_less_eq( fun( T, bool ) ), hAPP( fun( X, bool ), fun( T, bool ), hAPP
% 0.85/1.28 ( fun( X, T ), fun( fun( X, bool ), fun( T, bool ) ), image( X, T ), U )
% 0.85/1.28 , Y ) ), hAPP( fun( X, bool ), fun( T, bool ), hAPP( fun( X, T ), fun(
% 0.85/1.28 fun( X, bool ), fun( T, bool ) ), image( X, T ), U ), Z ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), Z ), hAPP( fun( Y, bool ), fun( X, bool ), hAPP( fun( Y, X
% 0.85/1.28 ), fun( fun( Y, bool ), fun( X, bool ) ), image( Y, X ), T ), U ) ) ),
% 0.85/1.28 hBOOL( hAPP( fun( Y, bool ), bool, hAPP( Y, fun( fun( Y, bool ), bool ),
% 0.85/1.28 member( Y ), skol7( W, Y, V0, V1, U ) ), U ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), Z ), hAPP( fun( Y, bool ), fun( X, bool ), hAPP( fun( Y, X
% 0.85/1.28 ), fun( fun( Y, bool ), fun( X, bool ) ), image( Y, X ), T ), U ) ) ),
% 0.85/1.28 ti( X, Z ) = hAPP( Y, X, T, skol7( X, Y, Z, T, U ) ) }.
% 0.85/1.28 { hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ),
% 0.85/1.28 member( X ), skol8( X, T, Z ) ), Z ) ), hBOOL( hAPP( fun( X, bool ), bool
% 0.85/1.28 , hAPP( fun( X, bool ), fun( fun( X, bool ), bool ), ord_less_eq( fun( X
% 0.85/1.28 , bool ) ), Z ), Y ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), skol8( X, Y, Z ) ), Y ) ), hBOOL( hAPP( fun( X, bool ),
% 0.85/1.28 bool, hAPP( fun( X, bool ), fun( fun( X, bool ), bool ), ord_less_eq( fun
% 0.85/1.28 ( X, bool ) ), Z ), Y ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, X, Y ) ), hBOOL( hAPP( nat, bool, X, hAPP( nat
% 0.85/1.28 , nat, suc, skol9( X ) ) ) ), hBOOL( hAPP( nat, bool, X, hAPP( nat, nat,
% 0.85/1.28 hAPP( nat, fun( nat, nat ), minus_minus( nat ), Y ), Z ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, X, Y ) ), ! hBOOL( hAPP( nat, bool, X, skol9( X
% 0.85/1.28 ) ) ), hBOOL( hAPP( nat, bool, X, hAPP( nat, nat, hAPP( nat, fun( nat,
% 0.85/1.28 nat ), minus_minus( nat ), Y ), Z ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , hAPP( nat, nat, suc, Y ) ), X ) ), X = hAPP( nat, nat, suc, skol10( X )
% 0.85/1.28 ) }.
% 0.85/1.28 { hBOOL( hAPP( fun( Y, bool ), bool, hAPP( Y, fun( fun( Y, bool ), bool ),
% 0.85/1.28 member( Y ), skol11( W, Y, V0, V1, U ) ), U ) ), hBOOL( hAPP( fun( X,
% 0.85/1.28 bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ), bool ),
% 0.85/1.28 ord_less_eq( fun( X, bool ) ), hAPP( fun( Y, bool ), fun( X, bool ), hAPP
% 0.85/1.28 ( fun( Y, X ), fun( fun( Y, bool ), fun( X, bool ) ), image( Y, X ), Z )
% 0.85/1.28 , U ) ), T ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 0.85/1.28 , member( X ), hAPP( Y, X, Z, skol11( X, Y, Z, T, U ) ) ), T ) ), hBOOL(
% 0.85/1.28 hAPP( fun( X, bool ), bool, hAPP( fun( X, bool ), fun( fun( X, bool ),
% 0.85/1.28 bool ), ord_less_eq( fun( X, bool ) ), hAPP( fun( Y, bool ), fun( X, bool
% 0.85/1.28 ), hAPP( fun( Y, X ), fun( fun( Y, bool ), fun( X, bool ) ), image( Y, X
% 0.85/1.28 ), Z ), U ) ), T ) ) }.
% 0.85/1.28 { ! preorder( X ), hBOOL( hAPP( X, bool, hAPP( X, fun( X, bool ),
% 0.85/1.28 ord_less_eq( X ), Y ), Y ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( fun( nat, bool ), bool, finite_finite( nat ), X ) ), !
% 0.85/1.28 hBOOL( hAPP( fun( nat, bool ), bool, hAPP( nat, fun( fun( nat, bool ),
% 0.85/1.28 bool ), member( nat ), Y ), X ) ), hBOOL( hAPP( nat, bool, hAPP( nat, fun
% 0.85/1.28 ( nat, bool ), ord_less_eq( nat ), Y ), skol12( X ) ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat )
% 0.85/1.28 , skol13( Z, Y ) ), Y ) ), hBOOL( hAPP( fun( nat, bool ), bool,
% 0.85/1.28 finite_finite( nat ), X ) ) }.
% 0.85/1.28 { hBOOL( hAPP( fun( nat, bool ), bool, hAPP( nat, fun( fun( nat, bool ),
% 0.85/1.28 bool ), member( nat ), skol13( X, Y ) ), X ) ), hBOOL( hAPP( fun( nat,
% 0.85/1.28 bool ), bool, finite_finite( nat ), X ) ) }.
% 0.85/1.28 { ! preorder( X ), preorder( fun( Y, X ) ) }.
% 0.85/1.28 { ! finite_finite_1( Y ), ! finite_finite_1( X ), finite_finite_1( fun( X,
% 0.85/1.28 Y ) ) }.
% 0.85/1.28 { ! order( X ), order( fun( Y, X ) ) }.
% 0.85/1.28 { preorder( nat ) }.
% 0.85/1.28 { order( nat ) }.
% 0.85/1.28 { preorder( bool ) }.
% 0.85/1.28 { finite_finite_1( bool ) }.
% 0.85/1.28 { order( bool ) }.
% 0.85/1.28 { ti( X, ti( X, Y ) ) = ti( X, Y ) }.
% 0.85/1.28 { ! hBOOL( hAPP( bool, bool, fNot, X ) ), ! hBOOL( X ) }.
% 0.85/1.28 { hBOOL( X ), hBOOL( hAPP( bool, bool, fNot, X ) ) }.
% 0.85/1.28 { hAPP( X, Y, hAPP( fun( X, Z ), fun( X, Y ), hAPP( fun( Z, Y ), fun( fun(
% 0.85/1.28 X, Z ), fun( X, Y ) ), combb( Z, Y, X ), T ), U ), W ) = hAPP( Z, Y, T,
% 0.85/1.28 hAPP( X, Z, U, W ) ) }.
% 0.85/1.28 { hAPP( X, Y, hAPP( Z, fun( X, Y ), hAPP( fun( X, fun( Z, Y ) ), fun( Z,
% 0.85/1.28 fun( X, Y ) ), combc( X, Z, Y ), T ), U ), W ) = hAPP( Z, Y, hAPP( X, fun
% 0.85/1.28 ( Z, Y ), T, W ), U ) }.
% 0.85/1.28 { hAPP( X, X, combi( X ), Y ) = ti( X, Y ) }.
% 0.85/1.28 { hAPP( X, Y, hAPP( fun( X, Z ), fun( X, Y ), hAPP( fun( X, fun( Z, Y ) ),
% 0.85/1.28 fun( fun( X, Z ), fun( X, Y ) ), combs( X, Z, Y ), T ), U ), W ) = hAPP(
% 0.85/1.28 Z, Y, hAPP( X, fun( Z, Y ), T, W ), hAPP( X, Z, U, W ) ) }.
% 0.85/1.28 { ! hBOOL( X ), ! hBOOL( Y ), hBOOL( hAPP( bool, bool, hAPP( bool, fun(
% 0.85/1.28 bool, bool ), fconj, X ), Y ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( bool, bool, hAPP( bool, fun( bool, bool ), fconj, X ), Y )
% 0.85/1.28 ), hBOOL( X ) }.
% 0.85/1.28 { ! hBOOL( hAPP( bool, bool, hAPP( bool, fun( bool, bool ), fconj, Y ), X )
% 0.85/1.28 ), hBOOL( X ) }.
% 0.85/1.28 { ! hBOOL( X ), hBOOL( hAPP( bool, bool, hAPP( bool, fun( bool, bool ),
% 0.85/1.28 fdisj, X ), Y ) ) }.
% 0.85/1.28 { ! hBOOL( X ), hBOOL( hAPP( bool, bool, hAPP( bool, fun( bool, bool ),
% 0.85/1.28 fdisj, Y ), X ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( bool, bool, hAPP( bool, fun( bool, bool ), fdisj, X ), Y )
% 0.85/1.28 ), hBOOL( X ), hBOOL( Y ) }.
% 0.85/1.28 { ! hBOOL( hAPP( X, bool, hAPP( X, fun( X, bool ), fequal( X ), Y ), Z ) )
% 0.85/1.28 , ti( X, Y ) = ti( X, Z ) }.
% 0.85/1.28 { ! ti( X, Y ) = ti( X, Z ), hBOOL( hAPP( X, bool, hAPP( X, fun( X, bool )
% 0.85/1.28 , fequal( X ), Y ), Z ) ) }.
% 0.85/1.28 { hBOOL( X ), hBOOL( hAPP( bool, bool, hAPP( bool, fun( bool, bool ),
% 0.85/1.28 fimplies, X ), Y ) ) }.
% 0.85/1.28 { ! hBOOL( X ), hBOOL( hAPP( bool, bool, hAPP( bool, fun( bool, bool ),
% 0.85/1.28 fimplies, Y ), X ) ) }.
% 0.85/1.28 { ! hBOOL( hAPP( bool, bool, hAPP( bool, fun( bool, bool ), fimplies, X ),
% 0.85/1.28 Y ) ), ! hBOOL( X ), hBOOL( Y ) }.
% 0.85/1.28 { hBOOL( hAPP( fun( pname, bool ), bool, finite_finite( pname ), u ) ) }.
% 0.85/1.28 { hBOOL( hAPP( fun( x_a, bool ), bool, hAPP( fun( x_a, bool ), fun( fun(
% 0.85/1.28 x_a, bool ), bool ), ord_less_eq( fun( x_a, bool ) ), g ), hAPP( fun(
% 0.85/1.28 pname, bool ), fun( x_a, bool ), hAPP( fun( pname, x_a ), fun( fun( pname
% 30.01/30.46 , bool ), fun( x_a, bool ) ), image( pname, x_a ), mgt_call ), u ) ) ) }
% 30.01/30.46 .
% 30.01/30.46 { hBOOL( hAPP( nat, bool, hAPP( nat, fun( nat, bool ), ord_less_eq( nat ),
% 30.01/30.46 hAPP( nat, nat, suc, na ) ), hAPP( fun( x_a, bool ), nat, finite_card(
% 30.01/30.46 x_a ), hAPP( fun( pname, bool ), fun( x_a, bool ), hAPP( fun( pname, x_a
% 30.01/30.46 ), fun( fun( pname, bool ), fun( x_a, bool ) ), image( pname, x_a ),
% 30.01/30.46 mgt_call ), u ) ) ) ) }.
% 30.01/30.46 { hAPP( fun( x_a, bool ), nat, finite_card( x_a ), g ) = hAPP( nat, nat,
% 30.01/30.46 hAPP( nat, fun( nat, nat ), minus_minus( nat ), hAPP( fun( x_a, bool ),
% 30.01/30.46 nat, finite_card( x_a ), hAPP( fun( pname, bool ), fun( x_a, bool ), hAPP
% 30.01/30.46 ( fun( pname, x_a ), fun( fun( pname, bool ), fun( x_a, bool ) ), image(
% 30.01/30.46 pname, x_a ), mgt_call ), u ) ) ), hAPP( nat, nat, suc, na ) ) }.
% 30.01/30.46 { hBOOL( hAPP( fun( pname, bool ), bool, hAPP( pname, fun( fun( pname, bool
% 30.01/30.46 ), bool ), member( pname ), pn ), u ) ) }.
% 30.01/30.46 { ! hBOOL( hAPP( fun( x_a, bool ), bool, hAPP( x_a, fun( fun( x_a, bool ),
% 30.01/30.46 bool ), member( x_a ), hAPP( pname, x_a, mgt_call, pn ) ), g ) ) }.
% 30.01/30.46 { ! hBOOL( hAPP( fun( x_a, bool ), bool, hAPP( fun( x_a, bool ), fun( fun(
% 30.01/30.46 x_a, bool ), bool ), ord_less_eq( fun( x_a, bool ) ), hAPP( fun( x_a,
% 30.01/30.46 bool ), fun( x_a, bool ), hAPP( x_a, fun( fun( x_a, bool ), fun( x_a,
% 30.01/30.46 bool ) ), insert( x_a ), hAPP( pname, x_a, mgt_call, pn ) ), g ) ), hAPP
% 30.01/30.46 ( fun( pname, bool ), fun( x_a, bool ), hAPP( fun( pname, x_a ), fun( fun
% 30.01/30.46 ( pname, bool ), fun( x_a, bool ) ), image( pname, x_a ), mgt_call ), u )
% 30.01/30.46 ) ) }.
% 30.01/30.46
% 30.01/30.46 *** allocated 15000 integers for clauses
% 30.01/30.46 *** allocated 22500 integers for clauses
% 30.01/30.46 percentage equality = 0.264095, percentage horn = 0.898305
% 30.01/30.46 This is a problem with some equality
% 30.01/30.46
% 30.01/30.46
% 30.01/30.46
% 30.01/30.46 Options Used:
% 30.01/30.46
% 30.01/30.46 useres = 1
% 30.01/30.46 useparamod = 1
% 30.01/30.46 useeqrefl = 1
% 30.01/30.46 useeqfact = 1
% 30.01/30.46 usefactor = 1
% 30.01/30.46 usesimpsplitting = 0
% 30.01/30.46 usesimpdemod = 5
% 30.01/30.46 usesimpres = 3
% 30.01/30.46
% 30.01/30.46 resimpinuse = 1000
% 30.01/30.46 resimpclauses = 20000
% 30.01/30.46 substype = eqrewr
% 30.01/30.46 backwardsubs = 1
% 30.01/30.46 selectoldest = 5
% 30.01/30.46
% 30.01/30.46 litorderings [0] = split
% 30.01/30.46 litorderings [1] = extend the termordering, first sorting on arguments
% 30.01/30.46
% 30.01/30.46 termordering = kbo
% 30.01/30.46
% 30.01/30.46 litapriori = 0
% 30.01/30.46 termapriori = 1
% 30.01/30.46 litaposteriori = 0
% 30.01/30.46 termaposteriori = 0
% 30.01/30.46 demodaposteriori = 0
% 30.01/30.46 ordereqreflfact = 0
% 30.01/30.46
% 30.01/30.46 litselect = negord
% 30.01/30.46
% 30.01/30.46 maxweight = 15
% 30.01/30.46 maxdepth = 30000
% 30.01/30.46 maxlength = 115
% 30.01/30.46 maxnrvars = 195
% 30.01/30.46 excuselevel = 1
% 30.01/30.46 increasemaxweight = 1
% 30.01/30.46
% 30.01/30.46 maxselected = 10000000
% 30.01/30.46 maxnrclauses = 10000000
% 30.01/30.46
% 30.01/30.46 showgenerated = 0
% 30.01/30.46 showkept = 0
% 30.01/30.46 showselected = 0
% 30.01/30.46 showdeleted = 0
% 30.01/30.46 showresimp = 1
% 30.01/30.46 showstatus = 2000
% 30.01/30.46
% 30.01/30.46 prologoutput = 0
% 30.01/30.46 nrgoals = 5000000
% 30.01/30.46 totalproof = 1
% 30.01/30.46
% 30.01/30.46 Symbols occurring in the translation:
% 30.01/30.46
% 30.01/30.46 {} [0, 0] (w:1, o:2, a:1, s:1, b:0),
% 30.01/30.46 . [1, 2] (w:1, o:98, a:1, s:1, b:0),
% 30.01/30.46 ! [4, 1] (w:0, o:76, a:1, s:1, b:0),
% 30.01/30.46 = [13, 2] (w:1, o:0, a:0, s:1, b:0),
% 30.01/30.46 ==> [14, 2] (w:1, o:0, a:0, s:1, b:0),
% 30.01/30.46 fun [38, 2] (w:1, o:122, a:1, s:1, b:0),
% 30.01/30.46 combb [39, 3] (w:1, o:127, a:1, s:1, b:0),
% 30.01/30.46 ti [40, 2] (w:1, o:125, a:1, s:1, b:0),
% 30.01/30.46 combc [41, 3] (w:1, o:128, a:1, s:1, b:0),
% 30.01/30.46 combi [42, 1] (w:1, o:82, a:1, s:1, b:0),
% 30.01/30.46 combs [43, 3] (w:1, o:129, a:1, s:1, b:0),
% 30.01/30.46 bool [44, 0] (w:1, o:9, a:1, s:1, b:0),
% 30.01/30.46 nat [45, 0] (w:1, o:11, a:1, s:1, b:0),
% 30.01/30.46 finite_card [46, 1] (w:1, o:83, a:1, s:1, b:0),
% 30.01/30.46 finite_finite [47, 1] (w:1, o:84, a:1, s:1, b:0),
% 30.01/30.46 minus_minus [48, 1] (w:1, o:85, a:1, s:1, b:0),
% 30.01/30.46 undefined [49, 1] (w:1, o:86, a:1, s:1, b:0),
% 30.01/30.46 suc [50, 0] (w:1, o:12, a:1, s:1, b:0),
% 30.01/30.46 preorder [51, 1] (w:1, o:89, a:1, s:1, b:0),
% 30.01/30.46 ord_less_eq [52, 1] (w:1, o:87, a:1, s:1, b:0),
% 30.01/30.46 collect [53, 1] (w:1, o:81, a:1, s:1, b:0),
% 30.01/30.46 image [54, 2] (w:1, o:126, a:1, s:1, b:0),
% 30.01/30.46 insert [55, 1] (w:1, o:91, a:1, s:1, b:0),
% 30.01/30.46 fNot [56, 0] (w:1, o:13, a:1, s:1, b:0),
% 30.01/30.46 fconj [57, 0] (w:1, o:14, a:1, s:1, b:0),
% 30.01/30.46 fdisj [58, 0] (w:1, o:15, a:1, s:1, b:0),
% 30.01/30.46 fequal [59, 1] (w:1, o:92, a:1, s:1, b:0), Cputime limit exceeded (core dumped)
%------------------------------------------------------------------------------