TSTP Solution File: SEU487^1 by cocATP---0.2.0
View Problem
- Process Solution
%------------------------------------------------------------------------------
% File : cocATP---0.2.0
% Problem : SEU487^1 : TPTP v6.1.0. Bugfixed v3.7.0.
% Transfm : none
% Format : tptp:raw
% Command : python CASC.py /export/starexec/sandbox/benchmark/theBenchmark.p
% Computer : n114.star.cs.uiowa.edu
% Model : x86_64 x86_64
% CPU : Intel(R) Xeon(R) CPU E5-2609 0 2.40GHz
% Memory : 32286.75MB
% OS : Linux 2.6.32-431.20.3.el6.x86_64
% CPULimit : 300s
% DateTime : Thu Jul 17 13:32:17 EDT 2014
% Result : Timeout 300.01s
% Output : None
% Verified :
% SZS Type : None (Parsing solution fails)
% Syntax : Number of formulae : 0
% Comments :
%------------------------------------------------------------------------------
%----NO SOLUTION OUTPUT BY SYSTEM
%------------------------------------------------------------------------------
%----ORIGINAL SYSTEM OUTPUT
% % Problem : SEU487^1 : TPTP v6.1.0. Bugfixed v3.7.0.
% % Command : python CASC.py /export/starexec/sandbox/benchmark/theBenchmark.p
% % Computer : n114.star.cs.uiowa.edu
% % Model : x86_64 x86_64
% % CPU : Intel(R) Xeon(R) CPU E5-2609 0 @ 2.40GHz
% % Memory : 32286.75MB
% % OS : Linux 2.6.32-431.20.3.el6.x86_64
% % CPULimit : 300
% % DateTime : Thu Jul 17 10:21:31 CDT 2014
% % CPUTime : 300.01
% Python 2.7.5
% Using paths ['/home/cristobal/cocATP/CASC/TPTP/', '/export/starexec/sandbox/benchmark/', '/export/starexec/sandbox/benchmark/']
% Failed to open /home/cristobal/cocATP/CASC/TPTP/Axioms/SET009^0.ax, trying next directory
% FOF formula (<kernel.Constant object at 0x1355830>, <kernel.DependentProduct object at 0x13556c8>) of role type named subrel_type
% Using role type
% Declaring subrel:((fofType->(fofType->Prop))->((fofType->(fofType->Prop))->Prop))
% FOF formula (((eq ((fofType->(fofType->Prop))->((fofType->(fofType->Prop))->Prop))) subrel) (fun (R:(fofType->(fofType->Prop))) (S:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), (((R X) Y)->((S X) Y))))) of role definition named subrel
% A new definition: (((eq ((fofType->(fofType->Prop))->((fofType->(fofType->Prop))->Prop))) subrel) (fun (R:(fofType->(fofType->Prop))) (S:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), (((R X) Y)->((S X) Y)))))
% Defined: subrel:=(fun (R:(fofType->(fofType->Prop))) (S:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), (((R X) Y)->((S X) Y))))
% FOF formula (<kernel.Constant object at 0x1355830>, <kernel.DependentProduct object at 0x13556c8>) of role type named inv_type
% Using role type
% Declaring inv:((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))
% FOF formula (((eq ((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))) inv) (fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((R Y) X))) of role definition named inverse
% A new definition: (((eq ((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))) inv) (fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((R Y) X)))
% Defined: inv:=(fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((R Y) X))
% FOF formula (<kernel.Constant object at 0x1355830>, <kernel.DependentProduct object at 0x1355710>) of role type named idem_type
% Using role type
% Declaring idem:(((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))->Prop)
% FOF formula (((eq (((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))->Prop)) idem) (fun (F:((fofType->(fofType->Prop))->(fofType->(fofType->Prop))))=> (forall (R:(fofType->(fofType->Prop))), (((eq (fofType->(fofType->Prop))) (F (F R))) (F R))))) of role definition named idempotent
% A new definition: (((eq (((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))->Prop)) idem) (fun (F:((fofType->(fofType->Prop))->(fofType->(fofType->Prop))))=> (forall (R:(fofType->(fofType->Prop))), (((eq (fofType->(fofType->Prop))) (F (F R))) (F R)))))
% Defined: idem:=(fun (F:((fofType->(fofType->Prop))->(fofType->(fofType->Prop))))=> (forall (R:(fofType->(fofType->Prop))), (((eq (fofType->(fofType->Prop))) (F (F R))) (F R))))
% FOF formula (<kernel.Constant object at 0x1355b00>, <kernel.DependentProduct object at 0x15370e0>) of role type named infl_type
% Using role type
% Declaring infl:(((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))->Prop)
% FOF formula (((eq (((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))->Prop)) infl) (fun (F:((fofType->(fofType->Prop))->(fofType->(fofType->Prop))))=> (forall (R:(fofType->(fofType->Prop))), ((subrel R) (F R))))) of role definition named inflationary
% A new definition: (((eq (((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))->Prop)) infl) (fun (F:((fofType->(fofType->Prop))->(fofType->(fofType->Prop))))=> (forall (R:(fofType->(fofType->Prop))), ((subrel R) (F R)))))
% Defined: infl:=(fun (F:((fofType->(fofType->Prop))->(fofType->(fofType->Prop))))=> (forall (R:(fofType->(fofType->Prop))), ((subrel R) (F R))))
% FOF formula (<kernel.Constant object at 0x1355830>, <kernel.DependentProduct object at 0x1537fc8>) of role type named mono_type
% Using role type
% Declaring mono:(((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))->Prop)
% FOF formula (((eq (((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))->Prop)) mono) (fun (F:((fofType->(fofType->Prop))->(fofType->(fofType->Prop))))=> (forall (R:(fofType->(fofType->Prop))) (S:(fofType->(fofType->Prop))), (((subrel R) S)->((subrel (F R)) (F S)))))) of role definition named monotonic
% A new definition: (((eq (((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))->Prop)) mono) (fun (F:((fofType->(fofType->Prop))->(fofType->(fofType->Prop))))=> (forall (R:(fofType->(fofType->Prop))) (S:(fofType->(fofType->Prop))), (((subrel R) S)->((subrel (F R)) (F S))))))
% Defined: mono:=(fun (F:((fofType->(fofType->Prop))->(fofType->(fofType->Prop))))=> (forall (R:(fofType->(fofType->Prop))) (S:(fofType->(fofType->Prop))), (((subrel R) S)->((subrel (F R)) (F S)))))
% FOF formula (<kernel.Constant object at 0x1355950>, <kernel.DependentProduct object at 0x1537ab8>) of role type named refl_type
% Using role type
% Declaring refl:((fofType->(fofType->Prop))->Prop)
% FOF formula (((eq ((fofType->(fofType->Prop))->Prop)) refl) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType), ((R X) X)))) of role definition named reflexive
% A new definition: (((eq ((fofType->(fofType->Prop))->Prop)) refl) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType), ((R X) X))))
% Defined: refl:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType), ((R X) X)))
% FOF formula (<kernel.Constant object at 0x1537fc8>, <kernel.DependentProduct object at 0x1537cf8>) of role type named irrefl_type
% Using role type
% Declaring irrefl:((fofType->(fofType->Prop))->Prop)
% FOF formula (((eq ((fofType->(fofType->Prop))->Prop)) irrefl) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType), (((R X) X)->False)))) of role definition named irreflexive
% A new definition: (((eq ((fofType->(fofType->Prop))->Prop)) irrefl) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType), (((R X) X)->False))))
% Defined: irrefl:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType), (((R X) X)->False)))
% FOF formula (<kernel.Constant object at 0x1537ab8>, <kernel.DependentProduct object at 0x15375a8>) of role type named rc_type
% Using role type
% Declaring rc:((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))
% FOF formula (((eq ((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))) rc) (fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((or (((eq fofType) X) Y)) ((R X) Y)))) of role definition named reflexive_closure
% A new definition: (((eq ((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))) rc) (fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((or (((eq fofType) X) Y)) ((R X) Y))))
% Defined: rc:=(fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((or (((eq fofType) X) Y)) ((R X) Y)))
% FOF formula (<kernel.Constant object at 0x1537ab8>, <kernel.DependentProduct object at 0x1537248>) of role type named symm_type
% Using role type
% Declaring symm:((fofType->(fofType->Prop))->Prop)
% FOF formula (((eq ((fofType->(fofType->Prop))->Prop)) symm) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), (((R X) Y)->((R Y) X))))) of role definition named symmetric
% A new definition: (((eq ((fofType->(fofType->Prop))->Prop)) symm) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), (((R X) Y)->((R Y) X)))))
% Defined: symm:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), (((R X) Y)->((R Y) X))))
% FOF formula (<kernel.Constant object at 0x1537908>, <kernel.DependentProduct object at 0x1537f38>) of role type named antisymm_type
% Using role type
% Declaring antisymm:((fofType->(fofType->Prop))->Prop)
% FOF formula (((eq ((fofType->(fofType->Prop))->Prop)) antisymm) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), (((and ((R X) Y)) ((R Y) X))->(((eq fofType) X) Y))))) of role definition named antisymmetric
% A new definition: (((eq ((fofType->(fofType->Prop))->Prop)) antisymm) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), (((and ((R X) Y)) ((R Y) X))->(((eq fofType) X) Y)))))
% Defined: antisymm:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), (((and ((R X) Y)) ((R Y) X))->(((eq fofType) X) Y))))
% FOF formula (<kernel.Constant object at 0x1537ab8>, <kernel.DependentProduct object at 0x1536638>) of role type named asymm_type
% Using role type
% Declaring asymm:((fofType->(fofType->Prop))->Prop)
% FOF formula (((eq ((fofType->(fofType->Prop))->Prop)) asymm) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), (((R X) Y)->(((R Y) X)->False))))) of role definition named asymmetric
% A new definition: (((eq ((fofType->(fofType->Prop))->Prop)) asymm) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), (((R X) Y)->(((R Y) X)->False)))))
% Defined: asymm:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), (((R X) Y)->(((R Y) X)->False))))
% FOF formula (<kernel.Constant object at 0x1537f38>, <kernel.DependentProduct object at 0x1536ea8>) of role type named sc_type
% Using role type
% Declaring sc:((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))
% FOF formula (((eq ((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))) sc) (fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((or ((R Y) X)) ((R X) Y)))) of role definition named symmetric_closure
% A new definition: (((eq ((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))) sc) (fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((or ((R Y) X)) ((R X) Y))))
% Defined: sc:=(fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((or ((R Y) X)) ((R X) Y)))
% FOF formula (<kernel.Constant object at 0x1536050>, <kernel.DependentProduct object at 0x15365a8>) of role type named trans_type
% Using role type
% Declaring trans:((fofType->(fofType->Prop))->Prop)
% FOF formula (((eq ((fofType->(fofType->Prop))->Prop)) trans) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType) (Z:fofType), (((and ((R X) Y)) ((R Y) Z))->((R X) Z))))) of role definition named transitive
% A new definition: (((eq ((fofType->(fofType->Prop))->Prop)) trans) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType) (Z:fofType), (((and ((R X) Y)) ((R Y) Z))->((R X) Z)))))
% Defined: trans:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType) (Z:fofType), (((and ((R X) Y)) ((R Y) Z))->((R X) Z))))
% FOF formula (<kernel.Constant object at 0x15367a0>, <kernel.DependentProduct object at 0x1536ea8>) of role type named tc_type
% Using role type
% Declaring tc:((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))
% FOF formula (((eq ((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))) tc) (fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> (forall (S:(fofType->(fofType->Prop))), (((and (trans S)) ((subrel R) S))->((S X) Y))))) of role definition named transitive_closure
% A new definition: (((eq ((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))) tc) (fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> (forall (S:(fofType->(fofType->Prop))), (((and (trans S)) ((subrel R) S))->((S X) Y)))))
% Defined: tc:=(fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> (forall (S:(fofType->(fofType->Prop))), (((and (trans S)) ((subrel R) S))->((S X) Y))))
% FOF formula (<kernel.Constant object at 0x133a680>, <kernel.DependentProduct object at 0x133a758>) of role type named trc_type
% Using role type
% Declaring trc:((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))
% FOF formula (((eq ((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))) trc) (fun (R:(fofType->(fofType->Prop)))=> (rc (tc R)))) of role definition named transitive_reflexive_closure
% A new definition: (((eq ((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))) trc) (fun (R:(fofType->(fofType->Prop)))=> (rc (tc R))))
% Defined: trc:=(fun (R:(fofType->(fofType->Prop)))=> (rc (tc R)))
% FOF formula (<kernel.Constant object at 0x133a7e8>, <kernel.DependentProduct object at 0x133aa28>) of role type named trsc_type
% Using role type
% Declaring trsc:((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))
% FOF formula (((eq ((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))) trsc) (fun (R:(fofType->(fofType->Prop)))=> (sc (rc (tc R))))) of role definition named transitive_reflexive_symmetric_closure
% A new definition: (((eq ((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))) trsc) (fun (R:(fofType->(fofType->Prop)))=> (sc (rc (tc R)))))
% Defined: trsc:=(fun (R:(fofType->(fofType->Prop)))=> (sc (rc (tc R))))
% FOF formula (<kernel.Constant object at 0x133a7e8>, <kernel.DependentProduct object at 0x133a878>) of role type named po_type
% Using role type
% Declaring po:((fofType->(fofType->Prop))->Prop)
% FOF formula (((eq ((fofType->(fofType->Prop))->Prop)) po) (fun (R:(fofType->(fofType->Prop)))=> ((and ((and (refl R)) (antisymm R))) (trans R)))) of role definition named partial_order
% A new definition: (((eq ((fofType->(fofType->Prop))->Prop)) po) (fun (R:(fofType->(fofType->Prop)))=> ((and ((and (refl R)) (antisymm R))) (trans R))))
% Defined: po:=(fun (R:(fofType->(fofType->Prop)))=> ((and ((and (refl R)) (antisymm R))) (trans R)))
% FOF formula (<kernel.Constant object at 0x133a830>, <kernel.DependentProduct object at 0x133a710>) of role type named so_type
% Using role type
% Declaring so:((fofType->(fofType->Prop))->Prop)
% FOF formula (((eq ((fofType->(fofType->Prop))->Prop)) so) (fun (R:(fofType->(fofType->Prop)))=> ((and (asymm R)) (trans R)))) of role definition named strict_order
% A new definition: (((eq ((fofType->(fofType->Prop))->Prop)) so) (fun (R:(fofType->(fofType->Prop)))=> ((and (asymm R)) (trans R))))
% Defined: so:=(fun (R:(fofType->(fofType->Prop)))=> ((and (asymm R)) (trans R)))
% FOF formula (<kernel.Constant object at 0x133a878>, <kernel.DependentProduct object at 0x133a6c8>) of role type named total_type
% Using role type
% Declaring total:((fofType->(fofType->Prop))->Prop)
% FOF formula (((eq ((fofType->(fofType->Prop))->Prop)) total) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), ((or ((or (((eq fofType) X) Y)) ((R X) Y))) ((R Y) X))))) of role definition named total
% A new definition: (((eq ((fofType->(fofType->Prop))->Prop)) total) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), ((or ((or (((eq fofType) X) Y)) ((R X) Y))) ((R Y) X)))))
% Defined: total:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), ((or ((or (((eq fofType) X) Y)) ((R X) Y))) ((R Y) X))))
% FOF formula (<kernel.Constant object at 0x133a6c8>, <kernel.DependentProduct object at 0x133ab90>) of role type named term_type
% Using role type
% Declaring term:((fofType->(fofType->Prop))->Prop)
% FOF formula (((eq ((fofType->(fofType->Prop))->Prop)) term) (fun (R:(fofType->(fofType->Prop)))=> (forall (A:(fofType->Prop)), (((ex fofType) (fun (X:fofType)=> (A X)))->((ex fofType) (fun (X:fofType)=> ((and (A X)) (forall (Y:fofType), ((A Y)->(((R X) Y)->False)))))))))) of role definition named terminating
% A new definition: (((eq ((fofType->(fofType->Prop))->Prop)) term) (fun (R:(fofType->(fofType->Prop)))=> (forall (A:(fofType->Prop)), (((ex fofType) (fun (X:fofType)=> (A X)))->((ex fofType) (fun (X:fofType)=> ((and (A X)) (forall (Y:fofType), ((A Y)->(((R X) Y)->False))))))))))
% Defined: term:=(fun (R:(fofType->(fofType->Prop)))=> (forall (A:(fofType->Prop)), (((ex fofType) (fun (X:fofType)=> (A X)))->((ex fofType) (fun (X:fofType)=> ((and (A X)) (forall (Y:fofType), ((A Y)->(((R X) Y)->False)))))))))
% FOF formula (<kernel.Constant object at 0x133ac20>, <kernel.DependentProduct object at 0x133afc8>) of role type named ind_type
% Using role type
% Declaring ind:((fofType->(fofType->Prop))->Prop)
% FOF formula (((eq ((fofType->(fofType->Prop))->Prop)) ind) (fun (R:(fofType->(fofType->Prop)))=> (forall (P:(fofType->Prop)), ((forall (X:fofType), ((forall (Y:fofType), ((((tc R) X) Y)->(P Y)))->(P X)))->(forall (X:fofType), (P X)))))) of role definition named satisfying_the_induction_principle
% A new definition: (((eq ((fofType->(fofType->Prop))->Prop)) ind) (fun (R:(fofType->(fofType->Prop)))=> (forall (P:(fofType->Prop)), ((forall (X:fofType), ((forall (Y:fofType), ((((tc R) X) Y)->(P Y)))->(P X)))->(forall (X:fofType), (P X))))))
% Defined: ind:=(fun (R:(fofType->(fofType->Prop)))=> (forall (P:(fofType->Prop)), ((forall (X:fofType), ((forall (Y:fofType), ((((tc R) X) Y)->(P Y)))->(P X)))->(forall (X:fofType), (P X)))))
% FOF formula (<kernel.Constant object at 0x133a518>, <kernel.DependentProduct object at 0x133ac20>) of role type named innf_type
% Using role type
% Declaring innf:((fofType->(fofType->Prop))->(fofType->Prop))
% FOF formula (((eq ((fofType->(fofType->Prop))->(fofType->Prop))) innf) (fun (R:(fofType->(fofType->Prop))) (X:fofType)=> (((ex fofType) (fun (Y:fofType)=> ((R X) Y)))->False))) of role definition named in_normal_form
% A new definition: (((eq ((fofType->(fofType->Prop))->(fofType->Prop))) innf) (fun (R:(fofType->(fofType->Prop))) (X:fofType)=> (((ex fofType) (fun (Y:fofType)=> ((R X) Y)))->False)))
% Defined: innf:=(fun (R:(fofType->(fofType->Prop))) (X:fofType)=> (((ex fofType) (fun (Y:fofType)=> ((R X) Y)))->False))
% FOF formula (<kernel.Constant object at 0x133afc8>, <kernel.DependentProduct object at 0x133a7e8>) of role type named nfof_type
% Using role type
% Declaring nfof:((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))
% FOF formula (((eq ((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))) nfof) (fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((and (((trc R) Y) X)) ((innf R) X)))) of role definition named normal_form_of
% A new definition: (((eq ((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))) nfof) (fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((and (((trc R) Y) X)) ((innf R) X))))
% Defined: nfof:=(fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((and (((trc R) Y) X)) ((innf R) X)))
% FOF formula (<kernel.Constant object at 0x133a518>, <kernel.DependentProduct object at 0x133ad40>) of role type named norm_type
% Using role type
% Declaring norm:((fofType->(fofType->Prop))->Prop)
% FOF formula (((eq ((fofType->(fofType->Prop))->Prop)) norm) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType), ((ex fofType) (fun (Y:fofType)=> (((nfof R) Y) X)))))) of role definition named normalizing
% A new definition: (((eq ((fofType->(fofType->Prop))->Prop)) norm) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType), ((ex fofType) (fun (Y:fofType)=> (((nfof R) Y) X))))))
% Defined: norm:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType), ((ex fofType) (fun (Y:fofType)=> (((nfof R) Y) X)))))
% FOF formula (<kernel.Constant object at 0x133a518>, <kernel.DependentProduct object at 0x133aa70>) of role type named join_type
% Using role type
% Declaring join:((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))
% FOF formula (((eq ((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))) join) (fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((ex fofType) (fun (Z:fofType)=> ((and (((trc R) X) Z)) (((trc R) Y) Z)))))) of role definition named joinable
% A new definition: (((eq ((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))) join) (fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((ex fofType) (fun (Z:fofType)=> ((and (((trc R) X) Z)) (((trc R) Y) Z))))))
% Defined: join:=(fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((ex fofType) (fun (Z:fofType)=> ((and (((trc R) X) Z)) (((trc R) Y) Z)))))
% FOF formula (<kernel.Constant object at 0x133a5a8>, <kernel.DependentProduct object at 0x1525290>) of role type named lconfl_type
% Using role type
% Declaring lconfl:((fofType->(fofType->Prop))->Prop)
% FOF formula (((eq ((fofType->(fofType->Prop))->Prop)) lconfl) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType) (Z:fofType), (((and ((R X) Z)) ((R X) Y))->(((join R) Z) Y))))) of role definition named locally_confluent
% A new definition: (((eq ((fofType->(fofType->Prop))->Prop)) lconfl) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType) (Z:fofType), (((and ((R X) Z)) ((R X) Y))->(((join R) Z) Y)))))
% Defined: lconfl:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType) (Z:fofType), (((and ((R X) Z)) ((R X) Y))->(((join R) Z) Y))))
% FOF formula (<kernel.Constant object at 0x133a8c0>, <kernel.DependentProduct object at 0x15253b0>) of role type named sconfl_type
% Using role type
% Declaring sconfl:((fofType->(fofType->Prop))->Prop)
% FOF formula (((eq ((fofType->(fofType->Prop))->Prop)) sconfl) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType) (Z:fofType), (((and ((R X) Z)) (((trc R) X) Y))->(((join R) Z) Y))))) of role definition named semi_confluent
% A new definition: (((eq ((fofType->(fofType->Prop))->Prop)) sconfl) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType) (Z:fofType), (((and ((R X) Z)) (((trc R) X) Y))->(((join R) Z) Y)))))
% Defined: sconfl:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType) (Z:fofType), (((and ((R X) Z)) (((trc R) X) Y))->(((join R) Z) Y))))
% FOF formula (<kernel.Constant object at 0x15253b0>, <kernel.DependentProduct object at 0x1525488>) of role type named confl_type
% Using role type
% Declaring confl:((fofType->(fofType->Prop))->Prop)
% FOF formula (((eq ((fofType->(fofType->Prop))->Prop)) confl) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType) (Z:fofType), (((and (((trc R) X) Z)) (((trc R) X) Y))->(((join R) Z) Y))))) of role definition named confluent
% A new definition: (((eq ((fofType->(fofType->Prop))->Prop)) confl) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType) (Z:fofType), (((and (((trc R) X) Z)) (((trc R) X) Y))->(((join R) Z) Y)))))
% Defined: confl:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType) (Z:fofType), (((and (((trc R) X) Z)) (((trc R) X) Y))->(((join R) Z) Y))))
% FOF formula (<kernel.Constant object at 0x15255a8>, <kernel.DependentProduct object at 0x15252d8>) of role type named cr_type
% Using role type
% Declaring cr:((fofType->(fofType->Prop))->Prop)
% FOF formula (((eq ((fofType->(fofType->Prop))->Prop)) cr) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), ((((trsc R) X) Y)->(((join R) X) Y))))) of role definition named church_rosser
% A new definition: (((eq ((fofType->(fofType->Prop))->Prop)) cr) (fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), ((((trsc R) X) Y)->(((join R) X) Y)))))
% Defined: cr:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), ((((trsc R) X) Y)->(((join R) X) Y))))
% FOF formula ((ex fofType) (fun (W:fofType)=> ((ex fofType) (fun (X:fofType)=> ((ex fofType) (fun (Y:fofType)=> ((ex fofType) (fun (Z:fofType)=> ((and ((and ((and ((and ((and (not (((eq fofType) W) X))) (not (((eq fofType) W) Y)))) (not (((eq fofType) W) Z)))) (not (((eq fofType) X) Y)))) (not (((eq fofType) X) Z)))) (not (((eq fofType) Y) Z))))))))))) of role hypothesis named four_individuals
% A new axiom: ((ex fofType) (fun (W:fofType)=> ((ex fofType) (fun (X:fofType)=> ((ex fofType) (fun (Y:fofType)=> ((ex fofType) (fun (Z:fofType)=> ((and ((and ((and ((and ((and (not (((eq fofType) W) X))) (not (((eq fofType) W) Y)))) (not (((eq fofType) W) Z)))) (not (((eq fofType) X) Y)))) (not (((eq fofType) X) Z)))) (not (((eq fofType) Y) Z)))))))))))
% FOF formula ((forall (R:(fofType->(fofType->Prop))), ((lconfl R)->(confl R)))->False) of role conjecture named local_confluence_does_not_imply_confluence
% Conjecture to prove = ((forall (R:(fofType->(fofType->Prop))), ((lconfl R)->(confl R)))->False):Prop
% Parameter fofType_DUMMY:fofType.
% We need to prove ['((forall (R:(fofType->(fofType->Prop))), ((lconfl R)->(confl R)))->False)']
% Parameter fofType:Type.
% Definition subrel:=(fun (R:(fofType->(fofType->Prop))) (S:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), (((R X) Y)->((S X) Y)))):((fofType->(fofType->Prop))->((fofType->(fofType->Prop))->Prop)).
% Definition inv:=(fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((R Y) X)):((fofType->(fofType->Prop))->(fofType->(fofType->Prop))).
% Definition idem:=(fun (F:((fofType->(fofType->Prop))->(fofType->(fofType->Prop))))=> (forall (R:(fofType->(fofType->Prop))), (((eq (fofType->(fofType->Prop))) (F (F R))) (F R)))):(((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))->Prop).
% Definition infl:=(fun (F:((fofType->(fofType->Prop))->(fofType->(fofType->Prop))))=> (forall (R:(fofType->(fofType->Prop))), ((subrel R) (F R)))):(((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))->Prop).
% Definition mono:=(fun (F:((fofType->(fofType->Prop))->(fofType->(fofType->Prop))))=> (forall (R:(fofType->(fofType->Prop))) (S:(fofType->(fofType->Prop))), (((subrel R) S)->((subrel (F R)) (F S))))):(((fofType->(fofType->Prop))->(fofType->(fofType->Prop)))->Prop).
% Definition refl:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType), ((R X) X))):((fofType->(fofType->Prop))->Prop).
% Definition irrefl:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType), (((R X) X)->False))):((fofType->(fofType->Prop))->Prop).
% Definition rc:=(fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((or (((eq fofType) X) Y)) ((R X) Y))):((fofType->(fofType->Prop))->(fofType->(fofType->Prop))).
% Definition symm:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), (((R X) Y)->((R Y) X)))):((fofType->(fofType->Prop))->Prop).
% Definition antisymm:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), (((and ((R X) Y)) ((R Y) X))->(((eq fofType) X) Y)))):((fofType->(fofType->Prop))->Prop).
% Definition asymm:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), (((R X) Y)->(((R Y) X)->False)))):((fofType->(fofType->Prop))->Prop).
% Definition sc:=(fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((or ((R Y) X)) ((R X) Y))):((fofType->(fofType->Prop))->(fofType->(fofType->Prop))).
% Definition trans:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType) (Z:fofType), (((and ((R X) Y)) ((R Y) Z))->((R X) Z)))):((fofType->(fofType->Prop))->Prop).
% Definition tc:=(fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> (forall (S:(fofType->(fofType->Prop))), (((and (trans S)) ((subrel R) S))->((S X) Y)))):((fofType->(fofType->Prop))->(fofType->(fofType->Prop))).
% Definition trc:=(fun (R:(fofType->(fofType->Prop)))=> (rc (tc R))):((fofType->(fofType->Prop))->(fofType->(fofType->Prop))).
% Definition trsc:=(fun (R:(fofType->(fofType->Prop)))=> (sc (rc (tc R)))):((fofType->(fofType->Prop))->(fofType->(fofType->Prop))).
% Definition po:=(fun (R:(fofType->(fofType->Prop)))=> ((and ((and (refl R)) (antisymm R))) (trans R))):((fofType->(fofType->Prop))->Prop).
% Definition so:=(fun (R:(fofType->(fofType->Prop)))=> ((and (asymm R)) (trans R))):((fofType->(fofType->Prop))->Prop).
% Definition total:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), ((or ((or (((eq fofType) X) Y)) ((R X) Y))) ((R Y) X)))):((fofType->(fofType->Prop))->Prop).
% Definition term:=(fun (R:(fofType->(fofType->Prop)))=> (forall (A:(fofType->Prop)), (((ex fofType) (fun (X:fofType)=> (A X)))->((ex fofType) (fun (X:fofType)=> ((and (A X)) (forall (Y:fofType), ((A Y)->(((R X) Y)->False))))))))):((fofType->(fofType->Prop))->Prop).
% Definition ind:=(fun (R:(fofType->(fofType->Prop)))=> (forall (P:(fofType->Prop)), ((forall (X:fofType), ((forall (Y:fofType), ((((tc R) X) Y)->(P Y)))->(P X)))->(forall (X:fofType), (P X))))):((fofType->(fofType->Prop))->Prop).
% Definition innf:=(fun (R:(fofType->(fofType->Prop))) (X:fofType)=> (((ex fofType) (fun (Y:fofType)=> ((R X) Y)))->False)):((fofType->(fofType->Prop))->(fofType->Prop)).
% Definition nfof:=(fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((and (((trc R) Y) X)) ((innf R) X))):((fofType->(fofType->Prop))->(fofType->(fofType->Prop))).
% Definition norm:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType), ((ex fofType) (fun (Y:fofType)=> (((nfof R) Y) X))))):((fofType->(fofType->Prop))->Prop).
% Definition join:=(fun (R:(fofType->(fofType->Prop))) (X:fofType) (Y:fofType)=> ((ex fofType) (fun (Z:fofType)=> ((and (((trc R) X) Z)) (((trc R) Y) Z))))):((fofType->(fofType->Prop))->(fofType->(fofType->Prop))).
% Definition lconfl:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType) (Z:fofType), (((and ((R X) Z)) ((R X) Y))->(((join R) Z) Y)))):((fofType->(fofType->Prop))->Prop).
% Definition sconfl:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType) (Z:fofType), (((and ((R X) Z)) (((trc R) X) Y))->(((join R) Z) Y)))):((fofType->(fofType->Prop))->Prop).
% Definition confl:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType) (Z:fofType), (((and (((trc R) X) Z)) (((trc R) X) Y))->(((join R) Z) Y)))):((fofType->(fofType->Prop))->Prop).
% Definition cr:=(fun (R:(fofType->(fofType->Prop)))=> (forall (X:fofType) (Y:fofType), ((((trsc R) X) Y)->(((join R) X) Y)))):((fofType->(fofType->Prop))->Prop).
% Axiom four_individuals:((ex fofType) (fun (W:fofType)=> ((ex fofType) (fun (X:fofType)=> ((ex fofType) (fun (Y:fofType)=> ((ex fofType) (fun (Z:fofType)=> ((and ((and ((and ((and ((and (not (((eq fofType) W) X))) (not (((eq fofType) W) Y)))) (not (((eq fofType) W) Z)))) (not (((eq fofType) X) Y)))) (not (((eq fofType) X) Z)))) (not (((eq fofType) Y) Z))))))))))).
% Trying to prove ((forall (R:(fofType->(fofType->Prop))), ((lconfl R)->(confl R)))->False)
% Found eq_ref000:=(eq_ref00 P):((P x4)->(P x4))
% Found (eq_ref00 P) as proof of (P0 x4)
% Found ((eq_ref0 x4) P) as proof of (P0 x4)
% Found (((eq_ref fofType) x4) P) as proof of (P0 x4)
% Found (((eq_ref fofType) x4) P) as proof of (P0 x4)
% Found eq_ref000:=(eq_ref00 P):((P x01)->(P x01))
% Found (eq_ref00 P) as proof of (P0 x01)
% Found ((eq_ref0 x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found eq_ref000:=(eq_ref00 P):((P x01)->(P x01))
% Found (eq_ref00 P) as proof of (P0 x01)
% Found ((eq_ref0 x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found eq_ref000:=(eq_ref00 P):((P x01)->(P x01))
% Found (eq_ref00 P) as proof of (P0 x01)
% Found ((eq_ref0 x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found eq_ref000:=(eq_ref00 P):((P x01)->(P x01))
% Found (eq_ref00 P) as proof of (P0 x01)
% Found ((eq_ref0 x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found eq_ref000:=(eq_ref00 P):((P x01)->(P x01))
% Found (eq_ref00 P) as proof of (P0 x01)
% Found ((eq_ref0 x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found eq_ref00:=(eq_ref0 x4):(((eq fofType) x4) x4)
% Found (eq_ref0 x4) as proof of (((eq fofType) x4) b)
% Found ((eq_ref fofType) x4) as proof of (((eq fofType) x4) b)
% Found ((eq_ref fofType) x4) as proof of (((eq fofType) x4) b)
% Found ((eq_ref fofType) x4) as proof of (((eq fofType) x4) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x6)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x6)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x6)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x6)
% Found eq_ref00:=(eq_ref0 x01):(((eq fofType) x01) x01)
% Found (eq_ref0 x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x01):(((eq fofType) x01) x01)
% Found (eq_ref0 x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x01):(((eq fofType) x01) x01)
% Found (eq_ref0 x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x01):(((eq fofType) x01) x01)
% Found (eq_ref0 x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x01):(((eq fofType) x01) x01)
% Found (eq_ref0 x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref000:=(eq_ref00 P):((P x4)->(P x4))
% Found (eq_ref00 P) as proof of (P0 x4)
% Found ((eq_ref0 x4) P) as proof of (P0 x4)
% Found (((eq_ref fofType) x4) P) as proof of (P0 x4)
% Found (((eq_ref fofType) x4) P) as proof of (P0 x4)
% Found eq_ref000:=(eq_ref00 P):((P x2)->(P x2))
% Found (eq_ref00 P) as proof of (P0 x2)
% Found ((eq_ref0 x2) P) as proof of (P0 x2)
% Found (((eq_ref fofType) x2) P) as proof of (P0 x2)
% Found (((eq_ref fofType) x2) P) as proof of (P0 x2)
% Found eq_ref000:=(eq_ref00 P):((P x01)->(P x01))
% Found (eq_ref00 P) as proof of (P0 x01)
% Found ((eq_ref0 x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found eq_ref000:=(eq_ref00 P):((P x00)->(P x00))
% Found (eq_ref00 P) as proof of (P0 x00)
% Found ((eq_ref0 x00) P) as proof of (P0 x00)
% Found (((eq_ref fofType) x00) P) as proof of (P0 x00)
% Found (((eq_ref fofType) x00) P) as proof of (P0 x00)
% Found eq_ref000:=(eq_ref00 P):((P x00)->(P x00))
% Found (eq_ref00 P) as proof of (P0 x00)
% Found ((eq_ref0 x00) P) as proof of (P0 x00)
% Found (((eq_ref fofType) x00) P) as proof of (P0 x00)
% Found (((eq_ref fofType) x00) P) as proof of (P0 x00)
% Found eq_ref000:=(eq_ref00 P):((P x01)->(P x01))
% Found (eq_ref00 P) as proof of (P0 x01)
% Found ((eq_ref0 x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found eq_ref000:=(eq_ref00 P):((P x01)->(P x01))
% Found (eq_ref00 P) as proof of (P0 x01)
% Found ((eq_ref0 x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found eq_ref000:=(eq_ref00 P):((P x00)->(P x00))
% Found (eq_ref00 P) as proof of (P0 x00)
% Found ((eq_ref0 x00) P) as proof of (P0 x00)
% Found (((eq_ref fofType) x00) P) as proof of (P0 x00)
% Found (((eq_ref fofType) x00) P) as proof of (P0 x00)
% Found eq_ref000:=(eq_ref00 P):((P x00)->(P x00))
% Found (eq_ref00 P) as proof of (P0 x00)
% Found ((eq_ref0 x00) P) as proof of (P0 x00)
% Found (((eq_ref fofType) x00) P) as proof of (P0 x00)
% Found (((eq_ref fofType) x00) P) as proof of (P0 x00)
% Found eq_ref000:=(eq_ref00 P):((P x01)->(P x01))
% Found (eq_ref00 P) as proof of (P0 x01)
% Found ((eq_ref0 x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found eq_ref000:=(eq_ref00 P):((P x01)->(P x01))
% Found (eq_ref00 P) as proof of (P0 x01)
% Found ((eq_ref0 x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found eq_ref000:=(eq_ref00 P):((P x00)->(P x00))
% Found (eq_ref00 P) as proof of (P0 x00)
% Found ((eq_ref0 x00) P) as proof of (P0 x00)
% Found (((eq_ref fofType) x00) P) as proof of (P0 x00)
% Found (((eq_ref fofType) x00) P) as proof of (P0 x00)
% Found eq_ref000:=(eq_ref00 P):((P x00)->(P x00))
% Found (eq_ref00 P) as proof of (P0 x00)
% Found ((eq_ref0 x00) P) as proof of (P0 x00)
% Found (((eq_ref fofType) x00) P) as proof of (P0 x00)
% Found (((eq_ref fofType) x00) P) as proof of (P0 x00)
% Found eq_ref000:=(eq_ref00 P):((P x01)->(P x01))
% Found (eq_ref00 P) as proof of (P0 x01)
% Found ((eq_ref0 x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found eq_ref000:=(eq_ref00 P):((P x4)->(P x4))
% Found (eq_ref00 P) as proof of (P0 x4)
% Found ((eq_ref0 x4) P) as proof of (P0 x4)
% Found (((eq_ref fofType) x4) P) as proof of (P0 x4)
% Found (((eq_ref fofType) x4) P) as proof of (P0 x4)
% Found eq_ref000:=(eq_ref00 P):((P x01)->(P x01))
% Found (eq_ref00 P) as proof of (P0 x01)
% Found ((eq_ref0 x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found eq_ref000:=(eq_ref00 P):((P x01)->(P x01))
% Found (eq_ref00 P) as proof of (P0 x01)
% Found ((eq_ref0 x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found eq_ref000:=(eq_ref00 P):((P x01)->(P x01))
% Found (eq_ref00 P) as proof of (P0 x01)
% Found ((eq_ref0 x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found eq_ref000:=(eq_ref00 P):((P x01)->(P x01))
% Found (eq_ref00 P) as proof of (P0 x01)
% Found ((eq_ref0 x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found eq_ref000:=(eq_ref00 P):((P x01)->(P x01))
% Found (eq_ref00 P) as proof of (P0 x01)
% Found ((eq_ref0 x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found (((eq_ref fofType) x01) P) as proof of (P0 x01)
% Found eq_ref00:=(eq_ref0 x4):(((eq fofType) x4) x4)
% Found (eq_ref0 x4) as proof of (((eq fofType) x4) b)
% Found ((eq_ref fofType) x4) as proof of (((eq fofType) x4) b)
% Found ((eq_ref fofType) x4) as proof of (((eq fofType) x4) b)
% Found ((eq_ref fofType) x4) as proof of (((eq fofType) x4) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x6)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x6)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x6)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x6)
% Found eq_ref00:=(eq_ref0 x2):(((eq fofType) x2) x2)
% Found (eq_ref0 x2) as proof of (((eq fofType) x2) b)
% Found ((eq_ref fofType) x2) as proof of (((eq fofType) x2) b)
% Found ((eq_ref fofType) x2) as proof of (((eq fofType) x2) b)
% Found ((eq_ref fofType) x2) as proof of (((eq fofType) x2) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x6)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x6)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x6)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x6)
% Found eq_ref00:=(eq_ref0 x00):(((eq fofType) x00) x00)
% Found (eq_ref0 x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x01):(((eq fofType) x01) x01)
% Found (eq_ref0 x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x01):(((eq fofType) x01) x01)
% Found (eq_ref0 x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x00):(((eq fofType) x00) x00)
% Found (eq_ref0 x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x01):(((eq fofType) x01) x01)
% Found (eq_ref0 x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x00):(((eq fofType) x00) x00)
% Found (eq_ref0 x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x01):(((eq fofType) x01) x01)
% Found (eq_ref0 x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x00):(((eq fofType) x00) x00)
% Found (eq_ref0 x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x00):(((eq fofType) x00) x00)
% Found (eq_ref0 x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x01):(((eq fofType) x01) x01)
% Found (eq_ref0 x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x00):(((eq fofType) x00) x00)
% Found (eq_ref0 x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found ((eq_ref fofType) x00) as proof of (((eq fofType) x00) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x01):(((eq fofType) x01) x01)
% Found (eq_ref0 x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x6):(((eq fofType) x6) x6)
% Found (eq_ref0 x6) as proof of (((eq fofType) x6) b)
% Found ((eq_ref fofType) x6) as proof of (((eq fofType) x6) b)
% Found ((eq_ref fofType) x6) as proof of (((eq fofType) x6) b)
% Found ((eq_ref fofType) x6) as proof of (((eq fofType) x6) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x4)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x4)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x4)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x4)
% Found eq_ref00:=(eq_ref0 x4):(((eq fofType) x4) x4)
% Found (eq_ref0 x4) as proof of (((eq fofType) x4) b)
% Found ((eq_ref fofType) x4) as proof of (((eq fofType) x4) b)
% Found ((eq_ref fofType) x4) as proof of (((eq fofType) x4) b)
% Found ((eq_ref fofType) x4) as proof of (((eq fofType) x4) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x6)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x6)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x6)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x6)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x01)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x01)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x01)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x01)
% Found eq_ref00:=(eq_ref0 x02):(((eq fofType) x02) x02)
% Found (eq_ref0 x02) as proof of (((eq fofType) x02) b)
% Found ((eq_ref fofType) x02) as proof of (((eq fofType) x02) b)
% Found ((eq_ref fofType) x02) as proof of (((eq fofType) x02) b)
% Found ((eq_ref fofType) x02) as proof of (((eq fofType) x02) b)
% Found eq_ref00:=(eq_ref0 x01):(((eq fofType) x01) x01)
% Found (eq_ref0 x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x02):(((eq fofType) x02) x02)
% Found (eq_ref0 x02) as proof of (((eq fofType) x02) b)
% Found ((eq_ref fofType) x02) as proof of (((eq fofType) x02) b)
% Found ((eq_ref fofType) x02) as proof of (((eq fofType) x02) b)
% Found ((eq_ref fofType) x02) as proof of (((eq fofType) x02) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x01)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x01)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x01)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x01)
% Found eq_ref00:=(eq_ref0 x01):(((eq fofType) x01) x01)
% Found (eq_ref0 x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x01)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x01)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x01)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x01)
% Found eq_ref00:=(eq_ref0 x02):(((eq fofType) x02) x02)
% Found (eq_ref0 x02) as proof of (((eq fofType) x02) b)
% Found ((eq_ref fofType) x02) as proof of (((eq fofType) x02) b)
% Found ((eq_ref fofType) x02) as proof of (((eq fofType) x02) b)
% Found ((eq_ref fofType) x02) as proof of (((eq fofType) x02) b)
% Found eq_ref00:=(eq_ref0 x01):(((eq fofType) x01) x01)
% Found (eq_ref0 x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x02):(((eq fofType) x02) x02)
% Found (eq_ref0 x02) as proof of (((eq fofType) x02) b)
% Found ((eq_ref fofType) x02) as proof of (((eq fofType) x02) b)
% Found ((eq_ref fofType) x02) as proof of (((eq fofType) x02) b)
% Found ((eq_ref fofType) x02) as proof of (((eq fofType) x02) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x01)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x01)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x01)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x01)
% Found eq_ref00:=(eq_ref0 x01):(((eq fofType) x01) x01)
% Found (eq_ref0 x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found ((eq_ref fofType) x01) as proof of (((eq fofType) x01) b)
% Found eq_ref00:=(eq_ref0 b):(((eq fofType) b) b)
% Found (eq_ref0 b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found ((eq_ref fofType) b) as proof of (((eq fofType) b) x02)
% Found eq_ref00:=(eq_ref0 x02):(((eq fofType) x02) x02)
% Found (eq_ref0 x02) as proof of (((eq fofType) x02) b)
% Found ((eq_ref fofType) x02) as proof of (((eq fofType) x02) b)
% Found ((eq_ref fofType) x02) as proof of (((eq fofType) x02) b)
% Found ((eq_ref fofType) x02) as proof of (((eq fofType) x02) b)
% Found eq_ref00:=(eq_ref0
% EOF
%------------------------------------------------------------------------------