%------------------------------------------------------------------------------ % File : Zenon---0.7.1 % Problem : ALG142+1 : TPTP v8.1.0. Released v2.7.0. % Transfm : none % Format : tptp:raw % Command : run_zenon %s %d % Computer : n032.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 : 600s % DateTime : Thu Jul 14 18:30:20 EDT 2022 % Result : Unsatisfiable 2.60s 2.85s % Output : Proof 2.71s % Verified : % SZS Type : - % Comments : %------------------------------------------------------------------------------ %----WARNING: Could not form TPTP format derivation %------------------------------------------------------------------------------ %----ORIGINAL SYSTEM OUTPUT % 0.05/0.09 % Problem : ALG142+1 : TPTP v8.1.0. Released v2.7.0. % 0.05/0.10 % Command : run_zenon %s %d % 0.09/0.29 % Computer : n032.cluster.edu % 0.09/0.29 % Model : x86_64 x86_64 % 0.09/0.29 % CPU : Intel(R) Xeon(R) CPU E5-2620 v4 @ 2.10GHz % 0.09/0.29 % Memory : 8042.1875MB % 0.09/0.29 % OS : Linux 3.10.0-693.el7.x86_64 % 0.09/0.29 % CPULimit : 300 % 0.09/0.29 % WCLimit : 600 % 0.09/0.29 % DateTime : Wed Jun 8 10:06:36 EDT 2022 % 0.09/0.29 % CPUTime : % 2.60/2.85 (* PROOF-FOUND *) % 2.60/2.85 % SZS status Unsatisfiable % 2.60/2.85 (* BEGIN-PROOF *) % 2.60/2.85 % SZS output start Proof % 2.60/2.85 Theorem zenon_thm : False. % 2.60/2.85 Proof. % 2.60/2.85 assert (zenon_L1_ : (~((e3) = (e3))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H1d. % 2.60/2.85 apply zenon_H1d. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L1_ *) % 2.60/2.85 assert (zenon_L2_ : (~((e2) = (e3))) -> ((op (e0) (e0)) = (e3)) -> ((op (e0) (e0)) = (e2)) -> False). % 2.60/2.85 do 0 intro. intros zenon_H1e zenon_H1f zenon_H20. % 2.60/2.85 cut (((op (e0) (e0)) = (e3)) = ((e2) = (e3))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H1e. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H1f. % 2.60/2.85 cut (((e3) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H1d]. % 2.60/2.85 cut (((op (e0) (e0)) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H21]. % 2.60/2.85 congruence. % 2.60/2.85 exact (zenon_H21 zenon_H20). % 2.60/2.85 apply zenon_H1d. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L2_ *) % 2.60/2.85 assert (zenon_L3_ : (((op (e0) (e0)) = (e3))/\(~((op (e0) (e3)) = (e0)))) -> ((op (e0) (e0)) = (e2)) -> (~((e2) = (e3))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H22 zenon_H20 zenon_H1e. % 2.60/2.85 apply (zenon_and_s _ _ zenon_H22). zenon_intro zenon_H1f. zenon_intro zenon_H23. % 2.60/2.85 apply (zenon_L2_); trivial. % 2.60/2.85 (* end of lemma zenon_L3_ *) % 2.60/2.85 assert (zenon_L4_ : (~((op (e0) (e0)) = (op (e0) (e1)))) -> ((op (e0) (e0)) = (e1)) -> ((op (e0) (e1)) = (e1)) -> False). % 2.60/2.85 do 0 intro. intros zenon_H24 zenon_H25 zenon_H26. % 2.60/2.85 cut (((op (e0) (e0)) = (e1)) = ((op (e0) (e0)) = (op (e0) (e1)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H24. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H25. % 2.60/2.85 cut (((e1) = (op (e0) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H27]. % 2.60/2.85 cut (((op (e0) (e0)) = (op (e0) (e0)))); [idtac | apply NNPP; zenon_intro zenon_H28]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H28. apply refl_equal. % 2.60/2.85 apply zenon_H27. apply sym_equal. exact zenon_H26. % 2.60/2.85 (* end of lemma zenon_L4_ *) % 2.60/2.85 assert (zenon_L5_ : (~((op (e0) (e0)) = (op (e0) (e1)))) -> ((op (e0) (e0)) = (e2)) -> ((op (e0) (e1)) = (e2)) -> False). % 2.60/2.85 do 0 intro. intros zenon_H24 zenon_H20 zenon_H29. % 2.60/2.85 cut (((op (e0) (e0)) = (e2)) = ((op (e0) (e0)) = (op (e0) (e1)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H24. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H20. % 2.60/2.85 cut (((e2) = (op (e0) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H2a]. % 2.60/2.85 cut (((op (e0) (e0)) = (op (e0) (e0)))); [idtac | apply NNPP; zenon_intro zenon_H28]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H28. apply refl_equal. % 2.60/2.85 apply zenon_H2a. apply sym_equal. exact zenon_H29. % 2.60/2.85 (* end of lemma zenon_L5_ *) % 2.60/2.85 assert (zenon_L6_ : ((op (e1) (e1)) = (e3)) -> ((op (e0) (e1)) = (e3)) -> (~((op (e0) (e1)) = (op (e1) (e1)))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H2b zenon_H2c zenon_H2d. % 2.60/2.85 elim (classic ((op (e1) (e1)) = (op (e1) (e1)))); [ zenon_intro zenon_H2e | zenon_intro zenon_H2f ]. % 2.60/2.85 cut (((op (e1) (e1)) = (op (e1) (e1))) = ((op (e0) (e1)) = (op (e1) (e1)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H2d. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H2e. % 2.60/2.85 cut (((op (e1) (e1)) = (op (e1) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H2f]. % 2.60/2.85 cut (((op (e1) (e1)) = (op (e0) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H30]. % 2.60/2.85 congruence. % 2.60/2.85 cut (((op (e1) (e1)) = (e3)) = ((op (e1) (e1)) = (op (e0) (e1)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H30. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H2b. % 2.60/2.85 cut (((e3) = (op (e0) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H31]. % 2.60/2.85 cut (((op (e1) (e1)) = (op (e1) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H2f]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H2f. apply refl_equal. % 2.60/2.85 apply zenon_H31. apply sym_equal. exact zenon_H2c. % 2.60/2.85 apply zenon_H2f. apply refl_equal. % 2.60/2.85 apply zenon_H2f. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L6_ *) % 2.60/2.85 assert (zenon_L7_ : (((op (e0) (e1)) = (e0))\/(((op (e0) (e1)) = (e1))\/(((op (e0) (e1)) = (e2))\/((op (e0) (e1)) = (e3))))) -> (~((op (e0) (e1)) = (e0))) -> ((op (e0) (e0)) = (e1)) -> ((op (e0) (e0)) = (e2)) -> (~((op (e0) (e0)) = (op (e0) (e1)))) -> ((op (e1) (e1)) = (e3)) -> (~((op (e0) (e1)) = (op (e1) (e1)))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H32 zenon_H33 zenon_H25 zenon_H20 zenon_H24 zenon_H2b zenon_H2d. % 2.60/2.85 apply (zenon_or_s _ _ zenon_H32); [ zenon_intro zenon_H35 | zenon_intro zenon_H34 ]. % 2.60/2.85 exact (zenon_H33 zenon_H35). % 2.60/2.85 apply (zenon_or_s _ _ zenon_H34); [ zenon_intro zenon_H26 | zenon_intro zenon_H36 ]. % 2.60/2.85 apply (zenon_L4_); trivial. % 2.60/2.85 apply (zenon_or_s _ _ zenon_H36); [ zenon_intro zenon_H29 | zenon_intro zenon_H2c ]. % 2.60/2.85 apply (zenon_L5_); trivial. % 2.60/2.85 apply (zenon_L6_); trivial. % 2.60/2.85 (* end of lemma zenon_L7_ *) % 2.60/2.85 assert (zenon_L8_ : (((op (e1) (e1)) = (e3))/\(~((op (e1) (e3)) = (e1)))) -> (~((op (e0) (e1)) = (e0))) -> (~((op (e0) (e0)) = (op (e0) (e1)))) -> ((op (e0) (e0)) = (e1)) -> ((op (e0) (e0)) = (e2)) -> (~((op (e0) (e1)) = (op (e1) (e1)))) -> (((op (e0) (e1)) = (e0))\/(((op (e0) (e1)) = (e1))\/(((op (e0) (e1)) = (e2))\/((op (e0) (e1)) = (e3))))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H37 zenon_H33 zenon_H24 zenon_H25 zenon_H20 zenon_H2d zenon_H32. % 2.60/2.85 apply (zenon_and_s _ _ zenon_H37). zenon_intro zenon_H2b. zenon_intro zenon_H38. % 2.60/2.85 apply (zenon_L7_); trivial. % 2.60/2.85 (* end of lemma zenon_L8_ *) % 2.60/2.85 assert (zenon_L9_ : (~((op (e0) (e0)) = (op (e0) (e2)))) -> ((op (e0) (e0)) = (e2)) -> ((op (e0) (e2)) = (e2)) -> False). % 2.60/2.85 do 0 intro. intros zenon_H39 zenon_H20 zenon_H3a. % 2.60/2.85 cut (((op (e0) (e0)) = (e2)) = ((op (e0) (e0)) = (op (e0) (e2)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H39. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H20. % 2.60/2.85 cut (((e2) = (op (e0) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H3b]. % 2.60/2.85 cut (((op (e0) (e0)) = (op (e0) (e0)))); [idtac | apply NNPP; zenon_intro zenon_H28]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H28. apply refl_equal. % 2.60/2.85 apply zenon_H3b. apply sym_equal. exact zenon_H3a. % 2.60/2.85 (* end of lemma zenon_L9_ *) % 2.60/2.85 assert (zenon_L10_ : ((op (e2) (e2)) = (e3)) -> ((op (e0) (e2)) = (e3)) -> (~((op (e0) (e2)) = (op (e2) (e2)))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H3c zenon_H3d zenon_H3e. % 2.60/2.85 elim (classic ((op (e2) (e2)) = (op (e2) (e2)))); [ zenon_intro zenon_H3f | zenon_intro zenon_H40 ]. % 2.60/2.85 cut (((op (e2) (e2)) = (op (e2) (e2))) = ((op (e0) (e2)) = (op (e2) (e2)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H3e. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H3f. % 2.60/2.85 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.85 cut (((op (e2) (e2)) = (op (e0) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H41]. % 2.60/2.85 congruence. % 2.60/2.85 cut (((op (e2) (e2)) = (e3)) = ((op (e2) (e2)) = (op (e0) (e2)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H41. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H3c. % 2.60/2.85 cut (((e3) = (op (e0) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H42]. % 2.60/2.85 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H40. apply refl_equal. % 2.60/2.85 apply zenon_H42. apply sym_equal. exact zenon_H3d. % 2.60/2.85 apply zenon_H40. apply refl_equal. % 2.60/2.85 apply zenon_H40. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L10_ *) % 2.60/2.85 assert (zenon_L11_ : (((op (e3) (e3)) = (e3))/\(~((op (e3) (e3)) = (e3)))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H43. % 2.60/2.85 apply (zenon_and_s _ _ zenon_H43). zenon_intro zenon_H45. zenon_intro zenon_H44. % 2.60/2.85 exact (zenon_H44 zenon_H45). % 2.60/2.85 (* end of lemma zenon_L11_ *) % 2.60/2.85 assert (zenon_L12_ : (~((e2) = (e2))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H46. % 2.60/2.85 apply zenon_H46. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L12_ *) % 2.60/2.85 assert (zenon_L13_ : (~((e0) = (e2))) -> ((op (e1) (e1)) = (e2)) -> ((op (e1) (e1)) = (e0)) -> False). % 2.60/2.85 do 0 intro. intros zenon_H47 zenon_H48 zenon_H49. % 2.60/2.85 cut (((op (e1) (e1)) = (e2)) = ((e0) = (e2))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H47. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H48. % 2.60/2.85 cut (((e2) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H46]. % 2.60/2.85 cut (((op (e1) (e1)) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H4a]. % 2.60/2.85 congruence. % 2.60/2.85 exact (zenon_H4a zenon_H49). % 2.60/2.85 apply zenon_H46. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L13_ *) % 2.60/2.85 assert (zenon_L14_ : (((op (e1) (e1)) = (e2))/\(~((op (e1) (e2)) = (e1)))) -> ((op (e1) (e1)) = (e0)) -> (~((e0) = (e2))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H4b zenon_H49 zenon_H47. % 2.60/2.85 apply (zenon_and_s _ _ zenon_H4b). zenon_intro zenon_H48. zenon_intro zenon_H4c. % 2.60/2.85 apply (zenon_L13_); trivial. % 2.60/2.85 (* end of lemma zenon_L14_ *) % 2.60/2.85 assert (zenon_L15_ : (((op (e2) (e2)) = (e2))/\(~((op (e2) (e2)) = (e2)))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H4d. % 2.60/2.85 apply (zenon_and_s _ _ zenon_H4d). zenon_intro zenon_H4f. zenon_intro zenon_H4e. % 2.60/2.85 exact (zenon_H4e zenon_H4f). % 2.60/2.85 (* end of lemma zenon_L15_ *) % 2.60/2.85 assert (zenon_L16_ : ((op (e3) (e3)) = (e2)) -> ((op (e0) (e3)) = (e2)) -> (~((op (e0) (e3)) = (op (e3) (e3)))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H50 zenon_H51 zenon_H52. % 2.60/2.85 elim (classic ((op (e3) (e3)) = (op (e3) (e3)))); [ zenon_intro zenon_H53 | zenon_intro zenon_H54 ]. % 2.60/2.85 cut (((op (e3) (e3)) = (op (e3) (e3))) = ((op (e0) (e3)) = (op (e3) (e3)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H52. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H53. % 2.60/2.85 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.85 cut (((op (e3) (e3)) = (op (e0) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H55]. % 2.60/2.85 congruence. % 2.60/2.85 cut (((op (e3) (e3)) = (e2)) = ((op (e3) (e3)) = (op (e0) (e3)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H55. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H50. % 2.60/2.85 cut (((e2) = (op (e0) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H56]. % 2.60/2.85 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H54. apply refl_equal. % 2.60/2.85 apply zenon_H56. apply sym_equal. exact zenon_H51. % 2.60/2.85 apply zenon_H54. apply refl_equal. % 2.60/2.85 apply zenon_H54. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L16_ *) % 2.60/2.85 assert (zenon_L17_ : (~((op (e0) (e0)) = (op (e0) (e3)))) -> ((op (e0) (e0)) = (e3)) -> ((op (e0) (e3)) = (e3)) -> False). % 2.60/2.85 do 0 intro. intros zenon_H57 zenon_H1f zenon_H58. % 2.60/2.85 cut (((op (e0) (e0)) = (e3)) = ((op (e0) (e0)) = (op (e0) (e3)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H57. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H1f. % 2.60/2.85 cut (((e3) = (op (e0) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H59]. % 2.60/2.85 cut (((op (e0) (e0)) = (op (e0) (e0)))); [idtac | apply NNPP; zenon_intro zenon_H28]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H28. apply refl_equal. % 2.60/2.85 apply zenon_H59. apply sym_equal. exact zenon_H58. % 2.60/2.85 (* end of lemma zenon_L17_ *) % 2.60/2.85 assert (zenon_L18_ : (~((e0) = (e3))) -> ((op (e1) (e1)) = (e3)) -> ((op (e1) (e1)) = (e0)) -> False). % 2.60/2.85 do 0 intro. intros zenon_H5a zenon_H2b zenon_H49. % 2.60/2.85 cut (((op (e1) (e1)) = (e3)) = ((e0) = (e3))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H5a. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H2b. % 2.60/2.85 cut (((e3) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H1d]. % 2.60/2.85 cut (((op (e1) (e1)) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H4a]. % 2.60/2.85 congruence. % 2.60/2.85 exact (zenon_H4a zenon_H49). % 2.60/2.85 apply zenon_H1d. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L18_ *) % 2.60/2.85 assert (zenon_L19_ : (((op (e1) (e1)) = (e3))/\(~((op (e1) (e3)) = (e1)))) -> ((op (e1) (e1)) = (e0)) -> (~((e0) = (e3))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H37 zenon_H49 zenon_H5a. % 2.60/2.85 apply (zenon_and_s _ _ zenon_H37). zenon_intro zenon_H2b. zenon_intro zenon_H38. % 2.60/2.85 apply (zenon_L18_); trivial. % 2.60/2.85 (* end of lemma zenon_L19_ *) % 2.60/2.85 assert (zenon_L20_ : (~((e1) = (e1))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H5b. % 2.60/2.85 apply zenon_H5b. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L20_ *) % 2.60/2.85 assert (zenon_L21_ : (~((e0) = (e1))) -> ((op (e0) (e0)) = (e1)) -> ((op (e0) (e0)) = (e0)) -> False). % 2.60/2.85 do 0 intro. intros zenon_H5c zenon_H25 zenon_H5d. % 2.60/2.85 cut (((op (e0) (e0)) = (e1)) = ((e0) = (e1))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H5c. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H25. % 2.60/2.85 cut (((e1) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H5b]. % 2.60/2.85 cut (((op (e0) (e0)) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H5e]. % 2.60/2.85 congruence. % 2.60/2.85 exact (zenon_H5e zenon_H5d). % 2.60/2.85 apply zenon_H5b. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L21_ *) % 2.60/2.85 assert (zenon_L22_ : ((op (e0) (e3)) = (e0)) -> ((op (e0) (e2)) = (e0)) -> (~((op (e0) (e2)) = (op (e0) (e3)))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H5f zenon_H60 zenon_H61. % 2.60/2.85 elim (classic ((op (e0) (e3)) = (op (e0) (e3)))); [ zenon_intro zenon_H62 | zenon_intro zenon_H63 ]. % 2.60/2.85 cut (((op (e0) (e3)) = (op (e0) (e3))) = ((op (e0) (e2)) = (op (e0) (e3)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H61. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H62. % 2.60/2.85 cut (((op (e0) (e3)) = (op (e0) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 2.60/2.85 cut (((op (e0) (e3)) = (op (e0) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 2.60/2.85 congruence. % 2.60/2.85 cut (((op (e0) (e3)) = (e0)) = ((op (e0) (e3)) = (op (e0) (e2)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H64. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H5f. % 2.60/2.85 cut (((e0) = (op (e0) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 2.60/2.85 cut (((op (e0) (e3)) = (op (e0) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H63. apply refl_equal. % 2.60/2.85 apply zenon_H65. apply sym_equal. exact zenon_H60. % 2.60/2.85 apply zenon_H63. apply refl_equal. % 2.60/2.85 apply zenon_H63. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L22_ *) % 2.60/2.85 assert (zenon_L23_ : (~((op (e1) (e1)) = (op (e1) (e3)))) -> ((op (e1) (e1)) = (e0)) -> ((op (e1) (e3)) = (e0)) -> False). % 2.60/2.85 do 0 intro. intros zenon_H66 zenon_H49 zenon_H67. % 2.60/2.85 cut (((op (e1) (e1)) = (e0)) = ((op (e1) (e1)) = (op (e1) (e3)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H66. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H49. % 2.60/2.85 cut (((e0) = (op (e1) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H68]. % 2.60/2.85 cut (((op (e1) (e1)) = (op (e1) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H2f]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H2f. apply refl_equal. % 2.60/2.85 apply zenon_H68. apply sym_equal. exact zenon_H67. % 2.60/2.85 (* end of lemma zenon_L23_ *) % 2.60/2.85 assert (zenon_L24_ : (~((op (e0) (e2)) = (op (e3) (e2)))) -> ((op (e0) (e2)) = (e0)) -> ((op (e3) (e2)) = (e0)) -> False). % 2.60/2.85 do 0 intro. intros zenon_H69 zenon_H60 zenon_H6a. % 2.60/2.85 cut (((op (e0) (e2)) = (e0)) = ((op (e0) (e2)) = (op (e3) (e2)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H69. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H60. % 2.60/2.85 cut (((e0) = (op (e3) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H6b]. % 2.60/2.85 cut (((op (e0) (e2)) = (op (e0) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H6c]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H6c. apply refl_equal. % 2.60/2.85 apply zenon_H6b. apply sym_equal. exact zenon_H6a. % 2.60/2.85 (* end of lemma zenon_L24_ *) % 2.60/2.85 assert (zenon_L25_ : (~((e0) = (e0))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H6d. % 2.60/2.85 apply zenon_H6d. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L25_ *) % 2.60/2.85 assert (zenon_L26_ : ((op (e3) (e2)) = (e1)) -> ((op (e2) (e2)) = (e3)) -> (~((e1) = (op (op (e2) (e2)) (e2)))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H6e zenon_H3c zenon_H6f. % 2.60/2.85 elim (classic ((op (op (e2) (e2)) (e2)) = (op (op (e2) (e2)) (e2)))); [ zenon_intro zenon_H70 | zenon_intro zenon_H71 ]. % 2.60/2.85 cut (((op (op (e2) (e2)) (e2)) = (op (op (e2) (e2)) (e2))) = ((e1) = (op (op (e2) (e2)) (e2)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H6f. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H70. % 2.60/2.85 cut (((op (op (e2) (e2)) (e2)) = (op (op (e2) (e2)) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H71]. % 2.60/2.85 cut (((op (op (e2) (e2)) (e2)) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H72]. % 2.60/2.85 congruence. % 2.60/2.85 cut (((op (e3) (e2)) = (e1)) = ((op (op (e2) (e2)) (e2)) = (e1))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H72. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H6e. % 2.60/2.85 cut (((e1) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H5b]. % 2.60/2.85 cut (((op (e3) (e2)) = (op (op (e2) (e2)) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H73]. % 2.60/2.85 congruence. % 2.60/2.85 elim (classic ((op (op (e2) (e2)) (e2)) = (op (op (e2) (e2)) (e2)))); [ zenon_intro zenon_H70 | zenon_intro zenon_H71 ]. % 2.60/2.85 cut (((op (op (e2) (e2)) (e2)) = (op (op (e2) (e2)) (e2))) = ((op (e3) (e2)) = (op (op (e2) (e2)) (e2)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H73. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H70. % 2.60/2.85 cut (((op (op (e2) (e2)) (e2)) = (op (op (e2) (e2)) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H71]. % 2.60/2.85 cut (((op (op (e2) (e2)) (e2)) = (op (e3) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H74]. % 2.60/2.85 congruence. % 2.60/2.85 cut (((e2) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H46]. % 2.60/2.85 cut (((op (e2) (e2)) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H75]. % 2.60/2.85 congruence. % 2.60/2.85 exact (zenon_H75 zenon_H3c). % 2.60/2.85 apply zenon_H46. apply refl_equal. % 2.60/2.85 apply zenon_H71. apply refl_equal. % 2.60/2.85 apply zenon_H71. apply refl_equal. % 2.60/2.85 apply zenon_H5b. apply refl_equal. % 2.60/2.85 apply zenon_H71. apply refl_equal. % 2.60/2.85 apply zenon_H71. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L26_ *) % 2.60/2.85 assert (zenon_L27_ : ((op (e2) (e3)) = (e0)) -> ((op (e3) (e2)) = (e1)) -> ((op (e2) (e2)) = (e3)) -> False). % 2.60/2.85 do 0 intro. intros zenon_H76 zenon_H6e zenon_H3c. % 2.60/2.85 apply (zenon_notand_s _ _ ax7); [ zenon_intro zenon_H78 | zenon_intro zenon_H77 ]. % 2.60/2.85 elim (classic ((op (e2) (op (e2) (e2))) = (op (e2) (op (e2) (e2))))); [ zenon_intro zenon_H79 | zenon_intro zenon_H7a ]. % 2.60/2.85 cut (((op (e2) (op (e2) (e2))) = (op (e2) (op (e2) (e2)))) = ((e0) = (op (e2) (op (e2) (e2))))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H78. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H79. % 2.60/2.85 cut (((op (e2) (op (e2) (e2))) = (op (e2) (op (e2) (e2))))); [idtac | apply NNPP; zenon_intro zenon_H7a]. % 2.60/2.85 cut (((op (e2) (op (e2) (e2))) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H7b]. % 2.60/2.85 congruence. % 2.60/2.85 cut (((op (e2) (e3)) = (e0)) = ((op (e2) (op (e2) (e2))) = (e0))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H7b. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H76. % 2.60/2.85 cut (((e0) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H6d]. % 2.60/2.85 cut (((op (e2) (e3)) = (op (e2) (op (e2) (e2))))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 2.60/2.85 congruence. % 2.60/2.85 elim (classic ((op (e2) (op (e2) (e2))) = (op (e2) (op (e2) (e2))))); [ zenon_intro zenon_H79 | zenon_intro zenon_H7a ]. % 2.60/2.85 cut (((op (e2) (op (e2) (e2))) = (op (e2) (op (e2) (e2)))) = ((op (e2) (e3)) = (op (e2) (op (e2) (e2))))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H7c. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H79. % 2.60/2.85 cut (((op (e2) (op (e2) (e2))) = (op (e2) (op (e2) (e2))))); [idtac | apply NNPP; zenon_intro zenon_H7a]. % 2.60/2.85 cut (((op (e2) (op (e2) (e2))) = (op (e2) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H7d]. % 2.60/2.85 congruence. % 2.60/2.85 cut (((op (e2) (e2)) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H75]. % 2.60/2.85 cut (((e2) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H46]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H46. apply refl_equal. % 2.60/2.85 exact (zenon_H75 zenon_H3c). % 2.60/2.85 apply zenon_H7a. apply refl_equal. % 2.60/2.85 apply zenon_H7a. apply refl_equal. % 2.60/2.85 apply zenon_H6d. apply refl_equal. % 2.60/2.85 apply zenon_H7a. apply refl_equal. % 2.60/2.85 apply zenon_H7a. apply refl_equal. % 2.60/2.85 apply (zenon_notand_s _ _ zenon_H77); [ zenon_intro zenon_H6f | zenon_intro zenon_H7e ]. % 2.60/2.85 apply (zenon_L26_); trivial. % 2.60/2.85 apply zenon_H7e. apply sym_equal. exact zenon_H3c. % 2.60/2.85 (* end of lemma zenon_L27_ *) % 2.60/2.85 assert (zenon_L28_ : ((op (e3) (e3)) = (e2)) -> ((op (e3) (e2)) = (e2)) -> (~((op (e3) (e2)) = (op (e3) (e3)))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H50 zenon_H7f zenon_H80. % 2.60/2.85 elim (classic ((op (e3) (e3)) = (op (e3) (e3)))); [ zenon_intro zenon_H53 | zenon_intro zenon_H54 ]. % 2.60/2.85 cut (((op (e3) (e3)) = (op (e3) (e3))) = ((op (e3) (e2)) = (op (e3) (e3)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H80. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H53. % 2.60/2.85 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.85 cut (((op (e3) (e3)) = (op (e3) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H81]. % 2.60/2.85 congruence. % 2.60/2.85 cut (((op (e3) (e3)) = (e2)) = ((op (e3) (e3)) = (op (e3) (e2)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H81. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H50. % 2.60/2.85 cut (((e2) = (op (e3) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H82]. % 2.60/2.85 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H54. apply refl_equal. % 2.60/2.85 apply zenon_H82. apply sym_equal. exact zenon_H7f. % 2.60/2.85 apply zenon_H54. apply refl_equal. % 2.60/2.85 apply zenon_H54. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L28_ *) % 2.60/2.85 assert (zenon_L29_ : (((op (e3) (e2)) = (e0))\/(((op (e3) (e2)) = (e1))\/(((op (e3) (e2)) = (e2))\/((op (e3) (e2)) = (e3))))) -> ((op (e0) (e2)) = (e0)) -> (~((op (e0) (e2)) = (op (e3) (e2)))) -> ((op (e2) (e2)) = (e3)) -> ((op (e2) (e3)) = (e0)) -> (~((op (e3) (e2)) = (op (e3) (e3)))) -> ((op (e3) (e3)) = (e2)) -> (~((op (e3) (e2)) = (e3))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H83 zenon_H60 zenon_H69 zenon_H3c zenon_H76 zenon_H80 zenon_H50 zenon_H84. % 2.60/2.85 apply (zenon_or_s _ _ zenon_H83); [ zenon_intro zenon_H6a | zenon_intro zenon_H85 ]. % 2.60/2.85 apply (zenon_L24_); trivial. % 2.60/2.85 apply (zenon_or_s _ _ zenon_H85); [ zenon_intro zenon_H6e | zenon_intro zenon_H86 ]. % 2.60/2.85 apply (zenon_L27_); trivial. % 2.60/2.85 apply (zenon_or_s _ _ zenon_H86); [ zenon_intro zenon_H7f | zenon_intro zenon_H87 ]. % 2.60/2.85 apply (zenon_L28_); trivial. % 2.60/2.85 exact (zenon_H84 zenon_H87). % 2.60/2.85 (* end of lemma zenon_L29_ *) % 2.60/2.85 assert (zenon_L30_ : (~((e0) = (e2))) -> ((op (e0) (e0)) = (e2)) -> ((op (e0) (e0)) = (e0)) -> False). % 2.60/2.85 do 0 intro. intros zenon_H47 zenon_H20 zenon_H5d. % 2.60/2.85 cut (((op (e0) (e0)) = (e2)) = ((e0) = (e2))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H47. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H20. % 2.60/2.85 cut (((e2) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H46]. % 2.60/2.85 cut (((op (e0) (e0)) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H5e]. % 2.60/2.85 congruence. % 2.60/2.85 exact (zenon_H5e zenon_H5d). % 2.60/2.85 apply zenon_H46. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L30_ *) % 2.60/2.85 assert (zenon_L31_ : ((op (e3) (e3)) = (e0)) -> ((op (e0) (e3)) = (e0)) -> (~((op (e0) (e3)) = (op (e3) (e3)))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H88 zenon_H5f zenon_H52. % 2.60/2.85 elim (classic ((op (e3) (e3)) = (op (e3) (e3)))); [ zenon_intro zenon_H53 | zenon_intro zenon_H54 ]. % 2.60/2.85 cut (((op (e3) (e3)) = (op (e3) (e3))) = ((op (e0) (e3)) = (op (e3) (e3)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H52. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H53. % 2.60/2.85 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.85 cut (((op (e3) (e3)) = (op (e0) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H55]. % 2.60/2.85 congruence. % 2.60/2.85 cut (((op (e3) (e3)) = (e0)) = ((op (e3) (e3)) = (op (e0) (e3)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H55. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H88. % 2.60/2.85 cut (((e0) = (op (e0) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H89]. % 2.60/2.85 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H54. apply refl_equal. % 2.60/2.85 apply zenon_H89. apply sym_equal. exact zenon_H5f. % 2.60/2.85 apply zenon_H54. apply refl_equal. % 2.60/2.85 apply zenon_H54. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L31_ *) % 2.60/2.85 assert (zenon_L32_ : ((op (e1) (e1)) = (e2)) -> ((op (e0) (e1)) = (e2)) -> (~((op (e0) (e1)) = (op (e1) (e1)))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H48 zenon_H29 zenon_H2d. % 2.60/2.85 elim (classic ((op (e1) (e1)) = (op (e1) (e1)))); [ zenon_intro zenon_H2e | zenon_intro zenon_H2f ]. % 2.60/2.85 cut (((op (e1) (e1)) = (op (e1) (e1))) = ((op (e0) (e1)) = (op (e1) (e1)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H2d. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H2e. % 2.60/2.85 cut (((op (e1) (e1)) = (op (e1) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H2f]. % 2.60/2.85 cut (((op (e1) (e1)) = (op (e0) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H30]. % 2.60/2.85 congruence. % 2.60/2.85 cut (((op (e1) (e1)) = (e2)) = ((op (e1) (e1)) = (op (e0) (e1)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H30. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H48. % 2.60/2.85 cut (((e2) = (op (e0) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H2a]. % 2.60/2.85 cut (((op (e1) (e1)) = (op (e1) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H2f]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H2f. apply refl_equal. % 2.60/2.85 apply zenon_H2a. apply sym_equal. exact zenon_H29. % 2.60/2.85 apply zenon_H2f. apply refl_equal. % 2.60/2.85 apply zenon_H2f. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L32_ *) % 2.60/2.85 assert (zenon_L33_ : (~((op (e0) (e0)) = (op (e0) (e1)))) -> ((op (e0) (e0)) = (e3)) -> ((op (e0) (e1)) = (e3)) -> False). % 2.60/2.85 do 0 intro. intros zenon_H24 zenon_H1f zenon_H2c. % 2.60/2.85 cut (((op (e0) (e0)) = (e3)) = ((op (e0) (e0)) = (op (e0) (e1)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H24. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H1f. % 2.60/2.85 cut (((e3) = (op (e0) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H31]. % 2.60/2.85 cut (((op (e0) (e0)) = (op (e0) (e0)))); [idtac | apply NNPP; zenon_intro zenon_H28]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H28. apply refl_equal. % 2.60/2.85 apply zenon_H31. apply sym_equal. exact zenon_H2c. % 2.60/2.85 (* end of lemma zenon_L33_ *) % 2.60/2.85 assert (zenon_L34_ : (((op (e0) (e0)) = (e3))/\(~((op (e0) (e3)) = (e0)))) -> (~((op (e0) (e1)) = (e0))) -> (~((op (e0) (e0)) = (op (e0) (e1)))) -> ((op (e0) (e0)) = (e1)) -> (~((op (e0) (e1)) = (op (e1) (e1)))) -> ((op (e1) (e1)) = (e2)) -> (((op (e0) (e1)) = (e0))\/(((op (e0) (e1)) = (e1))\/(((op (e0) (e1)) = (e2))\/((op (e0) (e1)) = (e3))))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H22 zenon_H33 zenon_H24 zenon_H25 zenon_H2d zenon_H48 zenon_H32. % 2.60/2.85 apply (zenon_and_s _ _ zenon_H22). zenon_intro zenon_H1f. zenon_intro zenon_H23. % 2.60/2.85 apply (zenon_or_s _ _ zenon_H32); [ zenon_intro zenon_H35 | zenon_intro zenon_H34 ]. % 2.60/2.85 exact (zenon_H33 zenon_H35). % 2.60/2.85 apply (zenon_or_s _ _ zenon_H34); [ zenon_intro zenon_H26 | zenon_intro zenon_H36 ]. % 2.60/2.85 apply (zenon_L4_); trivial. % 2.60/2.85 apply (zenon_or_s _ _ zenon_H36); [ zenon_intro zenon_H29 | zenon_intro zenon_H2c ]. % 2.60/2.85 apply (zenon_L32_); trivial. % 2.60/2.85 apply (zenon_L33_); trivial. % 2.60/2.85 (* end of lemma zenon_L34_ *) % 2.60/2.85 assert (zenon_L35_ : ((op (e1) (e1)) = (e2)) -> ((op (e1) (e1)) = (e3)) -> (~((e2) = (e3))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H48 zenon_H2b zenon_H1e. % 2.60/2.85 elim (classic ((e3) = (e3))); [ zenon_intro zenon_H8a | zenon_intro zenon_H1d ]. % 2.60/2.85 cut (((e3) = (e3)) = ((e2) = (e3))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H1e. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H8a. % 2.60/2.85 cut (((e3) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H1d]. % 2.60/2.85 cut (((e3) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H8b]. % 2.60/2.85 congruence. % 2.60/2.85 cut (((op (e1) (e1)) = (e2)) = ((e3) = (e2))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H8b. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H48. % 2.60/2.85 cut (((e2) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H46]. % 2.60/2.85 cut (((op (e1) (e1)) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 2.60/2.85 congruence. % 2.60/2.85 exact (zenon_H8c zenon_H2b). % 2.60/2.85 apply zenon_H46. apply refl_equal. % 2.60/2.85 apply zenon_H1d. apply refl_equal. % 2.60/2.85 apply zenon_H1d. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L35_ *) % 2.60/2.85 assert (zenon_L36_ : (((op (e1) (e1)) = (e3))/\(~((op (e1) (e3)) = (e1)))) -> ((op (e1) (e1)) = (e2)) -> (~((e2) = (e3))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H37 zenon_H48 zenon_H1e. % 2.60/2.85 apply (zenon_and_s _ _ zenon_H37). zenon_intro zenon_H2b. zenon_intro zenon_H38. % 2.60/2.85 apply (zenon_L35_); trivial. % 2.60/2.85 (* end of lemma zenon_L36_ *) % 2.60/2.85 assert (zenon_L37_ : (~((op (e0) (e2)) = (op (e1) (e2)))) -> ((op (e0) (e2)) = (e0)) -> ((op (e1) (e2)) = (e0)) -> False). % 2.60/2.85 do 0 intro. intros zenon_H8d zenon_H60 zenon_H8e. % 2.60/2.85 cut (((op (e0) (e2)) = (e0)) = ((op (e0) (e2)) = (op (e1) (e2)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H8d. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H60. % 2.60/2.85 cut (((e0) = (op (e1) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H8f]. % 2.60/2.85 cut (((op (e0) (e2)) = (op (e0) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H6c]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H6c. apply refl_equal. % 2.60/2.85 apply zenon_H8f. apply sym_equal. exact zenon_H8e. % 2.60/2.85 (* end of lemma zenon_L37_ *) % 2.60/2.85 assert (zenon_L38_ : (~((op (e1) (e1)) = (op (e1) (e2)))) -> ((op (e1) (e1)) = (e2)) -> ((op (e1) (e2)) = (e2)) -> False). % 2.60/2.85 do 0 intro. intros zenon_H90 zenon_H48 zenon_H91. % 2.60/2.85 cut (((op (e1) (e1)) = (e2)) = ((op (e1) (e1)) = (op (e1) (e2)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H90. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H48. % 2.60/2.85 cut (((e2) = (op (e1) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H92]. % 2.60/2.85 cut (((op (e1) (e1)) = (op (e1) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H2f]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H2f. apply refl_equal. % 2.60/2.85 apply zenon_H92. apply sym_equal. exact zenon_H91. % 2.60/2.85 (* end of lemma zenon_L38_ *) % 2.60/2.85 assert (zenon_L39_ : ((op (e2) (e2)) = (e3)) -> ((op (e1) (e2)) = (e3)) -> (~((op (e1) (e2)) = (op (e2) (e2)))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H3c zenon_H93 zenon_H94. % 2.60/2.85 elim (classic ((op (e2) (e2)) = (op (e2) (e2)))); [ zenon_intro zenon_H3f | zenon_intro zenon_H40 ]. % 2.60/2.85 cut (((op (e2) (e2)) = (op (e2) (e2))) = ((op (e1) (e2)) = (op (e2) (e2)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H94. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H3f. % 2.60/2.85 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.85 cut (((op (e2) (e2)) = (op (e1) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H95]. % 2.60/2.85 congruence. % 2.60/2.85 cut (((op (e2) (e2)) = (e3)) = ((op (e2) (e2)) = (op (e1) (e2)))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H95. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H3c. % 2.60/2.85 cut (((e3) = (op (e1) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H96]. % 2.60/2.85 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.85 congruence. % 2.60/2.85 apply zenon_H40. apply refl_equal. % 2.60/2.85 apply zenon_H96. apply sym_equal. exact zenon_H93. % 2.60/2.85 apply zenon_H40. apply refl_equal. % 2.60/2.85 apply zenon_H40. apply refl_equal. % 2.60/2.85 (* end of lemma zenon_L39_ *) % 2.60/2.85 assert (zenon_L40_ : ((op (e3) (e3)) = (e0)) -> ((op (e3) (e3)) = (e2)) -> (~((e0) = (e2))) -> False). % 2.60/2.85 do 0 intro. intros zenon_H88 zenon_H50 zenon_H47. % 2.60/2.85 elim (classic ((e2) = (e2))); [ zenon_intro zenon_H97 | zenon_intro zenon_H46 ]. % 2.60/2.85 cut (((e2) = (e2)) = ((e0) = (e2))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H47. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H97. % 2.60/2.85 cut (((e2) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H46]. % 2.60/2.85 cut (((e2) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H98]. % 2.60/2.85 congruence. % 2.60/2.85 cut (((op (e3) (e3)) = (e0)) = ((e2) = (e0))). % 2.60/2.85 intro zenon_D_pnotp. % 2.60/2.85 apply zenon_H98. % 2.60/2.85 rewrite <- zenon_D_pnotp. % 2.60/2.85 exact zenon_H88. % 2.60/2.85 cut (((e0) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H6d]. % 2.60/2.85 cut (((op (e3) (e3)) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H99]. % 2.60/2.85 congruence. % 2.60/2.85 exact (zenon_H99 zenon_H50). % 2.60/2.86 apply zenon_H6d. apply refl_equal. % 2.60/2.86 apply zenon_H46. apply refl_equal. % 2.60/2.86 apply zenon_H46. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L40_ *) % 2.60/2.86 assert (zenon_L41_ : (((op (e3) (e3)) = (e2))/\(~((op (e3) (e2)) = (e3)))) -> ((op (e3) (e3)) = (e0)) -> (~((e0) = (e2))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H9a zenon_H88 zenon_H47. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H9a). zenon_intro zenon_H50. zenon_intro zenon_H84. % 2.60/2.86 apply (zenon_L40_); trivial. % 2.60/2.86 (* end of lemma zenon_L41_ *) % 2.60/2.86 assert (zenon_L42_ : (((op (e1) (e1)) = (e1))/\(~((op (e1) (e1)) = (e1)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H9b. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H9b). zenon_intro zenon_H9d. zenon_intro zenon_H9c. % 2.60/2.86 exact (zenon_H9c zenon_H9d). % 2.60/2.86 (* end of lemma zenon_L42_ *) % 2.60/2.86 assert (zenon_L43_ : ((op (e1) (e0)) = (e0)) -> ((op (e1) (e0)) = (e1)) -> (~((e0) = (e1))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H9e zenon_H9f zenon_H5c. % 2.60/2.86 elim (classic ((e1) = (e1))); [ zenon_intro zenon_Ha0 | zenon_intro zenon_H5b ]. % 2.60/2.86 cut (((e1) = (e1)) = ((e0) = (e1))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H5c. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Ha0. % 2.60/2.86 cut (((e1) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H5b]. % 2.60/2.86 cut (((e1) = (e0))); [idtac | apply NNPP; zenon_intro zenon_Ha1]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e1) (e0)) = (e0)) = ((e1) = (e0))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Ha1. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H9e. % 2.60/2.86 cut (((e0) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H6d]. % 2.60/2.86 cut (((op (e1) (e0)) = (e1))); [idtac | apply NNPP; zenon_intro zenon_Ha2]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_Ha2 zenon_H9f). % 2.60/2.86 apply zenon_H6d. apply refl_equal. % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L43_ *) % 2.60/2.86 assert (zenon_L44_ : (~((e1) = (e3))) -> ((op (e1) (e1)) = (e3)) -> ((op (e1) (e1)) = (e1)) -> False). % 2.60/2.86 do 0 intro. intros zenon_Ha3 zenon_H2b zenon_H9d. % 2.60/2.86 cut (((op (e1) (e1)) = (e3)) = ((e1) = (e3))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Ha3. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H2b. % 2.60/2.86 cut (((e3) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H1d]. % 2.60/2.86 cut (((op (e1) (e1)) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H9c]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_H9c zenon_H9d). % 2.60/2.86 apply zenon_H1d. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L44_ *) % 2.60/2.86 assert (zenon_L45_ : ((op (e2) (e2)) = (e1)) -> ((op (e1) (e2)) = (e1)) -> (~((op (e1) (e2)) = (op (e2) (e2)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_Ha4 zenon_Ha5 zenon_H94. % 2.60/2.86 elim (classic ((op (e2) (e2)) = (op (e2) (e2)))); [ zenon_intro zenon_H3f | zenon_intro zenon_H40 ]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2))) = ((op (e1) (e2)) = (op (e2) (e2)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H94. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H3f. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e1) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H95]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e2) (e2)) = (e1)) = ((op (e2) (e2)) = (op (e1) (e2)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H95. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Ha4. % 2.60/2.86 cut (((e1) = (op (e1) (e2)))); [idtac | apply NNPP; zenon_intro zenon_Ha6]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 apply zenon_Ha6. apply sym_equal. exact zenon_Ha5. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L45_ *) % 2.60/2.86 assert (zenon_L46_ : (~((op (e2) (e0)) = (op (e2) (e1)))) -> ((op (e2) (e0)) = (e0)) -> ((op (e2) (e1)) = (e0)) -> False). % 2.60/2.86 do 0 intro. intros zenon_Ha7 zenon_Ha8 zenon_Ha9. % 2.60/2.86 cut (((op (e2) (e0)) = (e0)) = ((op (e2) (e0)) = (op (e2) (e1)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Ha7. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Ha8. % 2.60/2.86 cut (((e0) = (op (e2) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Haa]. % 2.60/2.86 cut (((op (e2) (e0)) = (op (e2) (e0)))); [idtac | apply NNPP; zenon_intro zenon_Hab]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_Hab. apply refl_equal. % 2.60/2.86 apply zenon_Haa. apply sym_equal. exact zenon_Ha9. % 2.60/2.86 (* end of lemma zenon_L46_ *) % 2.60/2.86 assert (zenon_L47_ : ((op (e2) (e2)) = (e1)) -> ((op (e2) (e1)) = (e1)) -> (~((op (e2) (e1)) = (op (e2) (e2)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_Ha4 zenon_Hac zenon_Had. % 2.60/2.86 elim (classic ((op (e2) (e2)) = (op (e2) (e2)))); [ zenon_intro zenon_H3f | zenon_intro zenon_H40 ]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2))) = ((op (e2) (e1)) = (op (e2) (e2)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Had. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H3f. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hae]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e2) (e2)) = (e1)) = ((op (e2) (e2)) = (op (e2) (e1)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hae. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Ha4. % 2.60/2.86 cut (((e1) = (op (e2) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Haf]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 apply zenon_Haf. apply sym_equal. exact zenon_Hac. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L47_ *) % 2.60/2.86 assert (zenon_L48_ : (~((op (e1) (e1)) = (op (e2) (e1)))) -> ((op (e1) (e1)) = (e3)) -> ((op (e2) (e1)) = (e3)) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hb0 zenon_H2b zenon_Hb1. % 2.60/2.86 cut (((op (e1) (e1)) = (e3)) = ((op (e1) (e1)) = (op (e2) (e1)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hb0. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H2b. % 2.60/2.86 cut (((e3) = (op (e2) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hb2]. % 2.60/2.86 cut (((op (e1) (e1)) = (op (e1) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H2f]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H2f. apply refl_equal. % 2.60/2.86 apply zenon_Hb2. apply sym_equal. exact zenon_Hb1. % 2.60/2.86 (* end of lemma zenon_L48_ *) % 2.60/2.86 assert (zenon_L49_ : ((op (e3) (e3)) = (e0)) -> ((op (e3) (e0)) = (e0)) -> (~((op (e3) (e0)) = (op (e3) (e3)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H88 zenon_Hb3 zenon_Hb4. % 2.60/2.86 elim (classic ((op (e3) (e3)) = (op (e3) (e3)))); [ zenon_intro zenon_H53 | zenon_intro zenon_H54 ]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3))) = ((op (e3) (e0)) = (op (e3) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hb4. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H53. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e0)))); [idtac | apply NNPP; zenon_intro zenon_Hb5]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e3) (e3)) = (e0)) = ((op (e3) (e3)) = (op (e3) (e0)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hb5. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H88. % 2.60/2.86 cut (((e0) = (op (e3) (e0)))); [idtac | apply NNPP; zenon_intro zenon_Hb6]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 apply zenon_Hb6. apply sym_equal. exact zenon_Hb3. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L49_ *) % 2.60/2.86 assert (zenon_L50_ : ((op (e2) (e2)) = (e1)) -> ((op (e2) (e2)) = (e3)) -> (~((e1) = (e3))) -> False). % 2.60/2.86 do 0 intro. intros zenon_Ha4 zenon_H3c zenon_Ha3. % 2.60/2.86 elim (classic ((e3) = (e3))); [ zenon_intro zenon_H8a | zenon_intro zenon_H1d ]. % 2.60/2.86 cut (((e3) = (e3)) = ((e1) = (e3))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Ha3. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H8a. % 2.60/2.86 cut (((e3) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H1d]. % 2.60/2.86 cut (((e3) = (e1))); [idtac | apply NNPP; zenon_intro zenon_Hb7]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e2) (e2)) = (e1)) = ((e3) = (e1))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hb7. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Ha4. % 2.60/2.86 cut (((e1) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H5b]. % 2.60/2.86 cut (((op (e2) (e2)) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H75]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_H75 zenon_H3c). % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 apply zenon_H1d. apply refl_equal. % 2.60/2.86 apply zenon_H1d. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L50_ *) % 2.60/2.86 assert (zenon_L51_ : (((op (e2) (e2)) = (e3))/\(~((op (e2) (e3)) = (e2)))) -> ((op (e2) (e2)) = (e1)) -> (~((e1) = (e3))) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hb8 zenon_Ha4 zenon_Ha3. % 2.60/2.86 apply (zenon_and_s _ _ zenon_Hb8). zenon_intro zenon_H3c. zenon_intro zenon_Hb9. % 2.60/2.86 apply (zenon_L50_); trivial. % 2.60/2.86 (* end of lemma zenon_L51_ *) % 2.60/2.86 assert (zenon_L52_ : (~((e0) = (e3))) -> ((op (e0) (e0)) = (e3)) -> ((op (e0) (e0)) = (e0)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H5a zenon_H1f zenon_H5d. % 2.60/2.86 cut (((op (e0) (e0)) = (e3)) = ((e0) = (e3))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H5a. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H1f. % 2.60/2.86 cut (((e3) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H1d]. % 2.60/2.86 cut (((op (e0) (e0)) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H5e]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_H5e zenon_H5d). % 2.60/2.86 apply zenon_H1d. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L52_ *) % 2.60/2.86 assert (zenon_L53_ : (~((e1) = (e2))) -> ((op (e1) (e1)) = (e2)) -> ((op (e1) (e1)) = (e1)) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hba zenon_H48 zenon_H9d. % 2.60/2.86 cut (((op (e1) (e1)) = (e2)) = ((e1) = (e2))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hba. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H48. % 2.60/2.86 cut (((e2) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H46]. % 2.60/2.86 cut (((op (e1) (e1)) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H9c]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_H9c zenon_H9d). % 2.60/2.86 apply zenon_H46. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L53_ *) % 2.60/2.86 assert (zenon_L54_ : (~((op (e0) (e0)) = (op (e1) (e0)))) -> ((op (e0) (e0)) = (e3)) -> ((op (e1) (e0)) = (e3)) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hbb zenon_H1f zenon_Hbc. % 2.60/2.86 cut (((op (e0) (e0)) = (e3)) = ((op (e0) (e0)) = (op (e1) (e0)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hbb. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H1f. % 2.60/2.86 cut (((e3) = (op (e1) (e0)))); [idtac | apply NNPP; zenon_intro zenon_Hbd]. % 2.60/2.86 cut (((op (e0) (e0)) = (op (e0) (e0)))); [idtac | apply NNPP; zenon_intro zenon_H28]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H28. apply refl_equal. % 2.60/2.86 apply zenon_Hbd. apply sym_equal. exact zenon_Hbc. % 2.60/2.86 (* end of lemma zenon_L54_ *) % 2.60/2.86 assert (zenon_L55_ : ((op (e1) (e1)) = (e2)) -> ((op (e1) (e0)) = (e2)) -> (~((op (e1) (e0)) = (op (e1) (e1)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H48 zenon_Hbe zenon_Hbf. % 2.60/2.86 elim (classic ((op (e1) (e1)) = (op (e1) (e1)))); [ zenon_intro zenon_H2e | zenon_intro zenon_H2f ]. % 2.60/2.86 cut (((op (e1) (e1)) = (op (e1) (e1))) = ((op (e1) (e0)) = (op (e1) (e1)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hbf. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H2e. % 2.60/2.86 cut (((op (e1) (e1)) = (op (e1) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H2f]. % 2.60/2.86 cut (((op (e1) (e1)) = (op (e1) (e0)))); [idtac | apply NNPP; zenon_intro zenon_Hc0]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e1) (e1)) = (e2)) = ((op (e1) (e1)) = (op (e1) (e0)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hc0. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H48. % 2.60/2.86 cut (((e2) = (op (e1) (e0)))); [idtac | apply NNPP; zenon_intro zenon_Hc1]. % 2.60/2.86 cut (((op (e1) (e1)) = (op (e1) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H2f]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H2f. apply refl_equal. % 2.60/2.86 apply zenon_Hc1. apply sym_equal. exact zenon_Hbe. % 2.60/2.86 apply zenon_H2f. apply refl_equal. % 2.60/2.86 apply zenon_H2f. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L55_ *) % 2.60/2.86 assert (zenon_L56_ : ((op (e2) (e0)) = (e0)) -> ((op (e2) (e0)) = (e2)) -> (~((e0) = (e2))) -> False). % 2.60/2.86 do 0 intro. intros zenon_Ha8 zenon_Hc2 zenon_H47. % 2.60/2.86 elim (classic ((e2) = (e2))); [ zenon_intro zenon_H97 | zenon_intro zenon_H46 ]. % 2.60/2.86 cut (((e2) = (e2)) = ((e0) = (e2))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H47. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H97. % 2.60/2.86 cut (((e2) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H46]. % 2.60/2.86 cut (((e2) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H98]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e2) (e0)) = (e0)) = ((e2) = (e0))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H98. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Ha8. % 2.60/2.86 cut (((e0) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H6d]. % 2.60/2.86 cut (((op (e2) (e0)) = (e2))); [idtac | apply NNPP; zenon_intro zenon_Hc3]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_Hc3 zenon_Hc2). % 2.60/2.86 apply zenon_H6d. apply refl_equal. % 2.60/2.86 apply zenon_H46. apply refl_equal. % 2.60/2.86 apply zenon_H46. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L56_ *) % 2.60/2.86 assert (zenon_L57_ : ((op (e0) (e2)) = (e0)) -> ((op (e0) (e1)) = (e0)) -> (~((op (e0) (e1)) = (op (e0) (e2)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H60 zenon_H35 zenon_Hc4. % 2.60/2.86 elim (classic ((op (e0) (e2)) = (op (e0) (e2)))); [ zenon_intro zenon_Hc5 | zenon_intro zenon_H6c ]. % 2.60/2.86 cut (((op (e0) (e2)) = (op (e0) (e2))) = ((op (e0) (e1)) = (op (e0) (e2)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hc4. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hc5. % 2.60/2.86 cut (((op (e0) (e2)) = (op (e0) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H6c]. % 2.60/2.86 cut (((op (e0) (e2)) = (op (e0) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hc6]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e0) (e2)) = (e0)) = ((op (e0) (e2)) = (op (e0) (e1)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hc6. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H60. % 2.60/2.86 cut (((e0) = (op (e0) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hc7]. % 2.60/2.86 cut (((op (e0) (e2)) = (op (e0) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H6c]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H6c. apply refl_equal. % 2.60/2.86 apply zenon_Hc7. apply sym_equal. exact zenon_H35. % 2.60/2.86 apply zenon_H6c. apply refl_equal. % 2.60/2.86 apply zenon_H6c. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L57_ *) % 2.60/2.86 assert (zenon_L58_ : ((op (e3) (e3)) = (e0)) -> ((op (e3) (e1)) = (e0)) -> (~((op (e3) (e1)) = (op (e3) (e3)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H88 zenon_Hc8 zenon_Hc9. % 2.60/2.86 elim (classic ((op (e3) (e3)) = (op (e3) (e3)))); [ zenon_intro zenon_H53 | zenon_intro zenon_H54 ]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3))) = ((op (e3) (e1)) = (op (e3) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hc9. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H53. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hca]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e3) (e3)) = (e0)) = ((op (e3) (e3)) = (op (e3) (e1)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hca. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H88. % 2.60/2.86 cut (((e0) = (op (e3) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hcb]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 apply zenon_Hcb. apply sym_equal. exact zenon_Hc8. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L58_ *) % 2.60/2.86 assert (zenon_L59_ : (((op (e0) (e1)) = (e0))\/(((op (e1) (e1)) = (e0))\/(((op (e2) (e1)) = (e0))\/((op (e3) (e1)) = (e0))))) -> (~((op (e0) (e1)) = (op (e0) (e2)))) -> ((op (e0) (e2)) = (e0)) -> ((op (e1) (e1)) = (e2)) -> (~((e0) = (e2))) -> ((op (e2) (e0)) = (e0)) -> (~((op (e2) (e0)) = (op (e2) (e1)))) -> ((op (e3) (e3)) = (e0)) -> (~((op (e3) (e1)) = (op (e3) (e3)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hcc zenon_Hc4 zenon_H60 zenon_H48 zenon_H47 zenon_Ha8 zenon_Ha7 zenon_H88 zenon_Hc9. % 2.60/2.86 apply (zenon_or_s _ _ zenon_Hcc); [ zenon_intro zenon_H35 | zenon_intro zenon_Hcd ]. % 2.60/2.86 apply (zenon_L57_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_Hcd); [ zenon_intro zenon_H49 | zenon_intro zenon_Hce ]. % 2.60/2.86 apply (zenon_L13_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_Hce); [ zenon_intro zenon_Ha9 | zenon_intro zenon_Hc8 ]. % 2.60/2.86 apply (zenon_L46_); trivial. % 2.60/2.86 apply (zenon_L58_); trivial. % 2.60/2.86 (* end of lemma zenon_L59_ *) % 2.60/2.86 assert (zenon_L60_ : ((op (e2) (e1)) = (e3)) -> ((op (e1) (e1)) = (e2)) -> (~((e3) = (op (op (e1) (e1)) (e1)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hb1 zenon_H48 zenon_Hcf. % 2.60/2.86 elim (classic ((op (op (e1) (e1)) (e1)) = (op (op (e1) (e1)) (e1)))); [ zenon_intro zenon_Hd0 | zenon_intro zenon_Hd1 ]. % 2.60/2.86 cut (((op (op (e1) (e1)) (e1)) = (op (op (e1) (e1)) (e1))) = ((e3) = (op (op (e1) (e1)) (e1)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hcf. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hd0. % 2.60/2.86 cut (((op (op (e1) (e1)) (e1)) = (op (op (e1) (e1)) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hd1]. % 2.60/2.86 cut (((op (op (e1) (e1)) (e1)) = (e3))); [idtac | apply NNPP; zenon_intro zenon_Hd2]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e2) (e1)) = (e3)) = ((op (op (e1) (e1)) (e1)) = (e3))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hd2. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hb1. % 2.60/2.86 cut (((e3) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H1d]. % 2.60/2.86 cut (((op (e2) (e1)) = (op (op (e1) (e1)) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hd3]. % 2.60/2.86 congruence. % 2.60/2.86 elim (classic ((op (op (e1) (e1)) (e1)) = (op (op (e1) (e1)) (e1)))); [ zenon_intro zenon_Hd0 | zenon_intro zenon_Hd1 ]. % 2.60/2.86 cut (((op (op (e1) (e1)) (e1)) = (op (op (e1) (e1)) (e1))) = ((op (e2) (e1)) = (op (op (e1) (e1)) (e1)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hd3. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hd0. % 2.60/2.86 cut (((op (op (e1) (e1)) (e1)) = (op (op (e1) (e1)) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hd1]. % 2.60/2.86 cut (((op (op (e1) (e1)) (e1)) = (op (e2) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hd4]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((e1) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H5b]. % 2.60/2.86 cut (((op (e1) (e1)) = (e2))); [idtac | apply NNPP; zenon_intro zenon_Hd5]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_Hd5 zenon_H48). % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 apply zenon_Hd1. apply refl_equal. % 2.60/2.86 apply zenon_Hd1. apply refl_equal. % 2.60/2.86 apply zenon_H1d. apply refl_equal. % 2.60/2.86 apply zenon_Hd1. apply refl_equal. % 2.60/2.86 apply zenon_Hd1. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L60_ *) % 2.60/2.86 assert (zenon_L61_ : ((op (e1) (e2)) = (e0)) -> ((op (e2) (e1)) = (e3)) -> ((op (e1) (e1)) = (e2)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H8e zenon_Hb1 zenon_H48. % 2.60/2.86 apply (zenon_notand_s _ _ ax11); [ zenon_intro zenon_Hd7 | zenon_intro zenon_Hd6 ]. % 2.60/2.86 elim (classic ((op (e1) (op (e1) (e1))) = (op (e1) (op (e1) (e1))))); [ zenon_intro zenon_Hd8 | zenon_intro zenon_Hd9 ]. % 2.60/2.86 cut (((op (e1) (op (e1) (e1))) = (op (e1) (op (e1) (e1)))) = ((e0) = (op (e1) (op (e1) (e1))))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hd7. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hd8. % 2.60/2.86 cut (((op (e1) (op (e1) (e1))) = (op (e1) (op (e1) (e1))))); [idtac | apply NNPP; zenon_intro zenon_Hd9]. % 2.60/2.86 cut (((op (e1) (op (e1) (e1))) = (e0))); [idtac | apply NNPP; zenon_intro zenon_Hda]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e1) (e2)) = (e0)) = ((op (e1) (op (e1) (e1))) = (e0))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hda. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H8e. % 2.60/2.86 cut (((e0) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H6d]. % 2.60/2.86 cut (((op (e1) (e2)) = (op (e1) (op (e1) (e1))))); [idtac | apply NNPP; zenon_intro zenon_Hdb]. % 2.60/2.86 congruence. % 2.60/2.86 elim (classic ((op (e1) (op (e1) (e1))) = (op (e1) (op (e1) (e1))))); [ zenon_intro zenon_Hd8 | zenon_intro zenon_Hd9 ]. % 2.60/2.86 cut (((op (e1) (op (e1) (e1))) = (op (e1) (op (e1) (e1)))) = ((op (e1) (e2)) = (op (e1) (op (e1) (e1))))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hdb. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hd8. % 2.60/2.86 cut (((op (e1) (op (e1) (e1))) = (op (e1) (op (e1) (e1))))); [idtac | apply NNPP; zenon_intro zenon_Hd9]. % 2.60/2.86 cut (((op (e1) (op (e1) (e1))) = (op (e1) (e2)))); [idtac | apply NNPP; zenon_intro zenon_Hdc]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e1) (e1)) = (e2))); [idtac | apply NNPP; zenon_intro zenon_Hd5]. % 2.60/2.86 cut (((e1) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H5b]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 exact (zenon_Hd5 zenon_H48). % 2.60/2.86 apply zenon_Hd9. apply refl_equal. % 2.60/2.86 apply zenon_Hd9. apply refl_equal. % 2.60/2.86 apply zenon_H6d. apply refl_equal. % 2.60/2.86 apply zenon_Hd9. apply refl_equal. % 2.60/2.86 apply zenon_Hd9. apply refl_equal. % 2.60/2.86 apply (zenon_notand_s _ _ zenon_Hd6); [ zenon_intro zenon_Hcf | zenon_intro zenon_Hdd ]. % 2.60/2.86 apply (zenon_L60_); trivial. % 2.60/2.86 apply zenon_Hdd. apply sym_equal. exact zenon_H48. % 2.60/2.86 (* end of lemma zenon_L61_ *) % 2.60/2.86 assert (zenon_L62_ : (~((e0) = (e1))) -> ((op (e2) (e2)) = (e1)) -> ((op (e2) (e2)) = (e0)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H5c zenon_Ha4 zenon_Hde. % 2.60/2.86 cut (((op (e2) (e2)) = (e1)) = ((e0) = (e1))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H5c. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Ha4. % 2.60/2.86 cut (((e1) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H5b]. % 2.60/2.86 cut (((op (e2) (e2)) = (e0))); [idtac | apply NNPP; zenon_intro zenon_Hdf]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_Hdf zenon_Hde). % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L62_ *) % 2.60/2.86 assert (zenon_L63_ : ((op (e3) (e3)) = (e0)) -> ((op (e3) (e2)) = (e0)) -> (~((op (e3) (e2)) = (op (e3) (e3)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H88 zenon_H6a zenon_H80. % 2.60/2.86 elim (classic ((op (e3) (e3)) = (op (e3) (e3)))); [ zenon_intro zenon_H53 | zenon_intro zenon_H54 ]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3))) = ((op (e3) (e2)) = (op (e3) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H80. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H53. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H81]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e3) (e3)) = (e0)) = ((op (e3) (e3)) = (op (e3) (e2)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H81. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H88. % 2.60/2.86 cut (((e0) = (op (e3) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H6b]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 apply zenon_H6b. apply sym_equal. exact zenon_H6a. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L63_ *) % 2.60/2.86 assert (zenon_L64_ : (((op (e0) (e2)) = (e0))\/(((op (e1) (e2)) = (e0))\/(((op (e2) (e2)) = (e0))\/((op (e3) (e2)) = (e0))))) -> (~((op (e3) (e1)) = (op (e3) (e3)))) -> (~((op (e2) (e0)) = (op (e2) (e1)))) -> ((op (e2) (e0)) = (e0)) -> (~((e0) = (e2))) -> (~((op (e0) (e1)) = (op (e0) (e2)))) -> (((op (e0) (e1)) = (e0))\/(((op (e1) (e1)) = (e0))\/(((op (e2) (e1)) = (e0))\/((op (e3) (e1)) = (e0))))) -> ((op (e1) (e1)) = (e2)) -> ((op (e2) (e1)) = (e3)) -> ((op (e2) (e2)) = (e1)) -> (~((e0) = (e1))) -> ((op (e3) (e3)) = (e0)) -> (~((op (e3) (e2)) = (op (e3) (e3)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_He0 zenon_Hc9 zenon_Ha7 zenon_Ha8 zenon_H47 zenon_Hc4 zenon_Hcc zenon_H48 zenon_Hb1 zenon_Ha4 zenon_H5c zenon_H88 zenon_H80. % 2.60/2.86 apply (zenon_or_s _ _ zenon_He0); [ zenon_intro zenon_H60 | zenon_intro zenon_He1 ]. % 2.60/2.86 apply (zenon_L59_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_He1); [ zenon_intro zenon_H8e | zenon_intro zenon_He2 ]. % 2.60/2.86 apply (zenon_L61_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_He2); [ zenon_intro zenon_Hde | zenon_intro zenon_H6a ]. % 2.60/2.86 apply (zenon_L62_); trivial. % 2.60/2.86 apply (zenon_L63_); trivial. % 2.60/2.86 (* end of lemma zenon_L64_ *) % 2.60/2.86 assert (zenon_L65_ : ((op (e3) (e0)) = (e1)) -> ((op (e3) (e0)) = (e2)) -> (~((e1) = (e2))) -> False). % 2.60/2.86 do 0 intro. intros zenon_He3 zenon_He4 zenon_Hba. % 2.60/2.86 elim (classic ((e2) = (e2))); [ zenon_intro zenon_H97 | zenon_intro zenon_H46 ]. % 2.60/2.86 cut (((e2) = (e2)) = ((e1) = (e2))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hba. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H97. % 2.60/2.86 cut (((e2) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H46]. % 2.60/2.86 cut (((e2) = (e1))); [idtac | apply NNPP; zenon_intro zenon_He5]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e3) (e0)) = (e1)) = ((e2) = (e1))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_He5. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_He3. % 2.60/2.86 cut (((e1) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H5b]. % 2.60/2.86 cut (((op (e3) (e0)) = (e2))); [idtac | apply NNPP; zenon_intro zenon_He6]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_He6 zenon_He4). % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 apply zenon_H46. apply refl_equal. % 2.60/2.86 apply zenon_H46. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L65_ *) % 2.60/2.86 assert (zenon_L66_ : ((op (e3) (e1)) = (e1)) -> ((op (e3) (e1)) = (e3)) -> (~((e1) = (e3))) -> False). % 2.60/2.86 do 0 intro. intros zenon_He7 zenon_He8 zenon_Ha3. % 2.60/2.86 elim (classic ((e3) = (e3))); [ zenon_intro zenon_H8a | zenon_intro zenon_H1d ]. % 2.60/2.86 cut (((e3) = (e3)) = ((e1) = (e3))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Ha3. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H8a. % 2.60/2.86 cut (((e3) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H1d]. % 2.60/2.86 cut (((e3) = (e1))); [idtac | apply NNPP; zenon_intro zenon_Hb7]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e3) (e1)) = (e1)) = ((e3) = (e1))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hb7. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_He7. % 2.60/2.86 cut (((e1) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H5b]. % 2.60/2.86 cut (((op (e3) (e1)) = (e3))); [idtac | apply NNPP; zenon_intro zenon_He9]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_He9 zenon_He8). % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 apply zenon_H1d. apply refl_equal. % 2.60/2.86 apply zenon_H1d. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L66_ *) % 2.60/2.86 assert (zenon_L67_ : (~((op (e2) (e2)) = (op (e3) (e2)))) -> ((op (e2) (e2)) = (e1)) -> ((op (e3) (e2)) = (e1)) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hea zenon_Ha4 zenon_H6e. % 2.60/2.86 cut (((op (e2) (e2)) = (e1)) = ((op (e2) (e2)) = (op (e3) (e2)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hea. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Ha4. % 2.60/2.86 cut (((e1) = (op (e3) (e2)))); [idtac | apply NNPP; zenon_intro zenon_Heb]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 apply zenon_Heb. apply sym_equal. exact zenon_H6e. % 2.60/2.86 (* end of lemma zenon_L67_ *) % 2.60/2.86 assert (zenon_L68_ : ((op (e3) (e3)) = (e0)) -> ((op (e3) (e3)) = (e1)) -> (~((e0) = (e1))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H88 zenon_Hec zenon_H5c. % 2.60/2.86 elim (classic ((e1) = (e1))); [ zenon_intro zenon_Ha0 | zenon_intro zenon_H5b ]. % 2.60/2.86 cut (((e1) = (e1)) = ((e0) = (e1))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H5c. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Ha0. % 2.60/2.86 cut (((e1) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H5b]. % 2.60/2.86 cut (((e1) = (e0))); [idtac | apply NNPP; zenon_intro zenon_Ha1]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e3) (e3)) = (e0)) = ((e1) = (e0))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Ha1. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H88. % 2.60/2.86 cut (((e0) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H6d]. % 2.60/2.86 cut (((op (e3) (e3)) = (e1))); [idtac | apply NNPP; zenon_intro zenon_Hed]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_Hed zenon_Hec). % 2.60/2.86 apply zenon_H6d. apply refl_equal. % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L68_ *) % 2.60/2.86 assert (zenon_L69_ : (((op (e3) (e0)) = (e1))\/(((op (e3) (e1)) = (e1))\/(((op (e3) (e2)) = (e1))\/((op (e3) (e3)) = (e1))))) -> (~((e1) = (e2))) -> ((op (e3) (e0)) = (e2)) -> (~((e1) = (e3))) -> ((op (e3) (e1)) = (e3)) -> ((op (e2) (e2)) = (e1)) -> (~((op (e2) (e2)) = (op (e3) (e2)))) -> ((op (e3) (e3)) = (e0)) -> (~((e0) = (e1))) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hee zenon_Hba zenon_He4 zenon_Ha3 zenon_He8 zenon_Ha4 zenon_Hea zenon_H88 zenon_H5c. % 2.60/2.86 apply (zenon_or_s _ _ zenon_Hee); [ zenon_intro zenon_He3 | zenon_intro zenon_Hef ]. % 2.60/2.86 apply (zenon_L65_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_Hef); [ zenon_intro zenon_He7 | zenon_intro zenon_Hf0 ]. % 2.60/2.86 apply (zenon_L66_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_Hf0); [ zenon_intro zenon_H6e | zenon_intro zenon_Hec ]. % 2.60/2.86 apply (zenon_L67_); trivial. % 2.60/2.86 apply (zenon_L68_); trivial. % 2.60/2.86 (* end of lemma zenon_L69_ *) % 2.60/2.86 assert (zenon_L70_ : (((op (e0) (e0)) = (e2))\/(((op (e1) (e0)) = (e2))\/(((op (e2) (e0)) = (e2))\/((op (e3) (e0)) = (e2))))) -> (~((op (e1) (e0)) = (op (e1) (e1)))) -> (((op (e0) (e1)) = (e3))\/(((op (e1) (e1)) = (e3))\/(((op (e2) (e1)) = (e3))\/((op (e3) (e1)) = (e3))))) -> ((op (e0) (e0)) = (e3)) -> (~((op (e0) (e0)) = (op (e0) (e1)))) -> (~((e2) = (e3))) -> (~((op (e3) (e2)) = (op (e3) (e3)))) -> ((op (e1) (e1)) = (e2)) -> (((op (e0) (e1)) = (e0))\/(((op (e1) (e1)) = (e0))\/(((op (e2) (e1)) = (e0))\/((op (e3) (e1)) = (e0))))) -> (~((op (e0) (e1)) = (op (e0) (e2)))) -> (~((e0) = (e2))) -> ((op (e2) (e0)) = (e0)) -> (~((op (e2) (e0)) = (op (e2) (e1)))) -> (~((op (e3) (e1)) = (op (e3) (e3)))) -> (((op (e0) (e2)) = (e0))\/(((op (e1) (e2)) = (e0))\/(((op (e2) (e2)) = (e0))\/((op (e3) (e2)) = (e0))))) -> (((op (e3) (e0)) = (e1))\/(((op (e3) (e1)) = (e1))\/(((op (e3) (e2)) = (e1))\/((op (e3) (e3)) = (e1))))) -> (~((e1) = (e2))) -> (~((e1) = (e3))) -> ((op (e2) (e2)) = (e1)) -> (~((op (e2) (e2)) = (op (e3) (e2)))) -> ((op (e3) (e3)) = (e0)) -> (~((e0) = (e1))) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hf1 zenon_Hbf zenon_Hf2 zenon_H1f zenon_H24 zenon_H1e zenon_H80 zenon_H48 zenon_Hcc zenon_Hc4 zenon_H47 zenon_Ha8 zenon_Ha7 zenon_Hc9 zenon_He0 zenon_Hee zenon_Hba zenon_Ha3 zenon_Ha4 zenon_Hea zenon_H88 zenon_H5c. % 2.60/2.86 apply (zenon_or_s _ _ zenon_Hf1); [ zenon_intro zenon_H20 | zenon_intro zenon_Hf3 ]. % 2.60/2.86 apply (zenon_L2_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_Hf3); [ zenon_intro zenon_Hbe | zenon_intro zenon_Hf4 ]. % 2.60/2.86 apply (zenon_L55_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_Hf4); [ zenon_intro zenon_Hc2 | zenon_intro zenon_He4 ]. % 2.60/2.86 apply (zenon_L56_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_Hf2); [ zenon_intro zenon_H2c | zenon_intro zenon_Hf5 ]. % 2.60/2.86 apply (zenon_L33_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_Hf5); [ zenon_intro zenon_H2b | zenon_intro zenon_Hf6 ]. % 2.60/2.86 apply (zenon_L35_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_Hf6); [ zenon_intro zenon_Hb1 | zenon_intro zenon_He8 ]. % 2.60/2.86 apply (zenon_L64_); trivial. % 2.60/2.86 apply (zenon_L69_); trivial. % 2.60/2.86 (* end of lemma zenon_L70_ *) % 2.60/2.86 assert (zenon_L71_ : ((op (e1) (e2)) = (e3)) -> ((op (e2) (e2)) = (e1)) -> (~((e3) = (op (op (e2) (e2)) (e2)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H93 zenon_Ha4 zenon_Hf7. % 2.60/2.86 elim (classic ((op (op (e2) (e2)) (e2)) = (op (op (e2) (e2)) (e2)))); [ zenon_intro zenon_H70 | zenon_intro zenon_H71 ]. % 2.60/2.86 cut (((op (op (e2) (e2)) (e2)) = (op (op (e2) (e2)) (e2))) = ((e3) = (op (op (e2) (e2)) (e2)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hf7. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H70. % 2.60/2.86 cut (((op (op (e2) (e2)) (e2)) = (op (op (e2) (e2)) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H71]. % 2.60/2.86 cut (((op (op (e2) (e2)) (e2)) = (e3))); [idtac | apply NNPP; zenon_intro zenon_Hf8]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e1) (e2)) = (e3)) = ((op (op (e2) (e2)) (e2)) = (e3))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hf8. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H93. % 2.60/2.86 cut (((e3) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H1d]. % 2.60/2.86 cut (((op (e1) (e2)) = (op (op (e2) (e2)) (e2)))); [idtac | apply NNPP; zenon_intro zenon_Hf9]. % 2.60/2.86 congruence. % 2.60/2.86 elim (classic ((op (op (e2) (e2)) (e2)) = (op (op (e2) (e2)) (e2)))); [ zenon_intro zenon_H70 | zenon_intro zenon_H71 ]. % 2.60/2.86 cut (((op (op (e2) (e2)) (e2)) = (op (op (e2) (e2)) (e2))) = ((op (e1) (e2)) = (op (op (e2) (e2)) (e2)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hf9. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H70. % 2.60/2.86 cut (((op (op (e2) (e2)) (e2)) = (op (op (e2) (e2)) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H71]. % 2.60/2.86 cut (((op (op (e2) (e2)) (e2)) = (op (e1) (e2)))); [idtac | apply NNPP; zenon_intro zenon_Hfa]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((e2) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H46]. % 2.60/2.86 cut (((op (e2) (e2)) = (e1))); [idtac | apply NNPP; zenon_intro zenon_Hfb]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_Hfb zenon_Ha4). % 2.60/2.86 apply zenon_H46. apply refl_equal. % 2.60/2.86 apply zenon_H71. apply refl_equal. % 2.60/2.86 apply zenon_H71. apply refl_equal. % 2.60/2.86 apply zenon_H1d. apply refl_equal. % 2.60/2.86 apply zenon_H71. apply refl_equal. % 2.60/2.86 apply zenon_H71. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L71_ *) % 2.60/2.86 assert (zenon_L72_ : ((op (e2) (e1)) = (e0)) -> ((op (e1) (e2)) = (e3)) -> ((op (e2) (e2)) = (e1)) -> False). % 2.60/2.86 do 0 intro. intros zenon_Ha9 zenon_H93 zenon_Ha4. % 2.60/2.86 apply (zenon_notand_s _ _ ax10); [ zenon_intro zenon_H78 | zenon_intro zenon_Hfc ]. % 2.60/2.86 elim (classic ((op (e2) (op (e2) (e2))) = (op (e2) (op (e2) (e2))))); [ zenon_intro zenon_H79 | zenon_intro zenon_H7a ]. % 2.60/2.86 cut (((op (e2) (op (e2) (e2))) = (op (e2) (op (e2) (e2)))) = ((e0) = (op (e2) (op (e2) (e2))))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H78. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H79. % 2.60/2.86 cut (((op (e2) (op (e2) (e2))) = (op (e2) (op (e2) (e2))))); [idtac | apply NNPP; zenon_intro zenon_H7a]. % 2.60/2.86 cut (((op (e2) (op (e2) (e2))) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H7b]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e2) (e1)) = (e0)) = ((op (e2) (op (e2) (e2))) = (e0))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H7b. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Ha9. % 2.60/2.86 cut (((e0) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H6d]. % 2.60/2.86 cut (((op (e2) (e1)) = (op (e2) (op (e2) (e2))))); [idtac | apply NNPP; zenon_intro zenon_Hfd]. % 2.60/2.86 congruence. % 2.60/2.86 elim (classic ((op (e2) (op (e2) (e2))) = (op (e2) (op (e2) (e2))))); [ zenon_intro zenon_H79 | zenon_intro zenon_H7a ]. % 2.60/2.86 cut (((op (e2) (op (e2) (e2))) = (op (e2) (op (e2) (e2)))) = ((op (e2) (e1)) = (op (e2) (op (e2) (e2))))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hfd. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H79. % 2.60/2.86 cut (((op (e2) (op (e2) (e2))) = (op (e2) (op (e2) (e2))))); [idtac | apply NNPP; zenon_intro zenon_H7a]. % 2.60/2.86 cut (((op (e2) (op (e2) (e2))) = (op (e2) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hfe]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e2) (e2)) = (e1))); [idtac | apply NNPP; zenon_intro zenon_Hfb]. % 2.60/2.86 cut (((e2) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H46]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H46. apply refl_equal. % 2.60/2.86 exact (zenon_Hfb zenon_Ha4). % 2.60/2.86 apply zenon_H7a. apply refl_equal. % 2.60/2.86 apply zenon_H7a. apply refl_equal. % 2.60/2.86 apply zenon_H6d. apply refl_equal. % 2.60/2.86 apply zenon_H7a. apply refl_equal. % 2.60/2.86 apply zenon_H7a. apply refl_equal. % 2.60/2.86 apply (zenon_notand_s _ _ zenon_Hfc); [ zenon_intro zenon_Hf7 | zenon_intro zenon_Hff ]. % 2.60/2.86 apply (zenon_L71_); trivial. % 2.60/2.86 apply zenon_Hff. apply sym_equal. exact zenon_Ha4. % 2.60/2.86 (* end of lemma zenon_L72_ *) % 2.60/2.86 assert (zenon_L73_ : ((op (e3) (e3)) = (e0)) -> ((op (e2) (e3)) = (e0)) -> (~((op (e2) (e3)) = (op (e3) (e3)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H88 zenon_H76 zenon_H100. % 2.60/2.86 elim (classic ((op (e3) (e3)) = (op (e3) (e3)))); [ zenon_intro zenon_H53 | zenon_intro zenon_H54 ]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3))) = ((op (e2) (e3)) = (op (e3) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H100. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H53. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e2) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H101]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e3) (e3)) = (e0)) = ((op (e3) (e3)) = (op (e2) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H101. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H88. % 2.60/2.86 cut (((e0) = (op (e2) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 apply zenon_H102. apply sym_equal. exact zenon_H76. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L73_ *) % 2.60/2.86 assert (zenon_L74_ : ((op (e1) (e3)) = (e1)) -> ((op (e1) (e3)) = (e3)) -> (~((e1) = (e3))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H103 zenon_H104 zenon_Ha3. % 2.60/2.86 elim (classic ((e3) = (e3))); [ zenon_intro zenon_H8a | zenon_intro zenon_H1d ]. % 2.60/2.86 cut (((e3) = (e3)) = ((e1) = (e3))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Ha3. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H8a. % 2.60/2.86 cut (((e3) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H1d]. % 2.60/2.86 cut (((e3) = (e1))); [idtac | apply NNPP; zenon_intro zenon_Hb7]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e1) (e3)) = (e1)) = ((e3) = (e1))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hb7. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H103. % 2.60/2.86 cut (((e1) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H5b]. % 2.60/2.86 cut (((op (e1) (e3)) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_H105 zenon_H104). % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 apply zenon_H1d. apply refl_equal. % 2.60/2.86 apply zenon_H1d. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L74_ *) % 2.60/2.86 assert (zenon_L75_ : ((((op (e0) (e0)) = (e1))/\(~((op (e0) (e1)) = (e0))))\/((((op (e1) (e1)) = (e1))/\(~((op (e1) (e1)) = (e1))))\/((((op (e2) (e2)) = (e1))/\(~((op (e2) (e1)) = (e2))))\/(((op (e3) (e3)) = (e1))/\(~((op (e3) (e1)) = (e3))))))) -> (~((op (e0) (e2)) = (op (e1) (e2)))) -> (~((op (e1) (e1)) = (op (e1) (e2)))) -> (((op (e1) (e2)) = (e0))\/(((op (e1) (e2)) = (e1))\/(((op (e1) (e2)) = (e2))\/((op (e1) (e2)) = (e3))))) -> (((op (e0) (e1)) = (e0))\/(((op (e0) (e1)) = (e1))\/(((op (e0) (e1)) = (e2))\/((op (e0) (e1)) = (e3))))) -> (~((op (e0) (e1)) = (op (e1) (e1)))) -> (((op (e0) (e0)) = (e0))\/(((op (e0) (e1)) = (e0))\/(((op (e0) (e2)) = (e0))\/((op (e0) (e3)) = (e0))))) -> (~((op (e0) (e3)) = (op (e3) (e3)))) -> ((((op (e0) (e0)) = (e2))/\(~((op (e0) (e2)) = (e0))))\/((((op (e1) (e1)) = (e2))/\(~((op (e1) (e2)) = (e1))))\/((((op (e2) (e2)) = (e2))/\(~((op (e2) (e2)) = (e2))))\/(((op (e3) (e3)) = (e2))/\(~((op (e3) (e2)) = (e3))))))) -> (~((e1) = (e2))) -> (((op (e1) (e0)) = (e3))\/(((op (e1) (e1)) = (e3))\/(((op (e1) (e2)) = (e3))\/((op (e1) (e3)) = (e3))))) -> (((op (e0) (e0)) = (e2))\/(((op (e1) (e0)) = (e2))\/(((op (e2) (e0)) = (e2))\/((op (e3) (e0)) = (e2))))) -> (~((op (e0) (e0)) = (op (e0) (e1)))) -> (((op (e0) (e2)) = (e0))\/(((op (e1) (e2)) = (e0))\/(((op (e2) (e2)) = (e0))\/((op (e3) (e2)) = (e0))))) -> (~((op (e3) (e2)) = (op (e3) (e3)))) -> (~((op (e0) (e1)) = (op (e0) (e2)))) -> (~((op (e3) (e1)) = (op (e3) (e3)))) -> (((op (e0) (e1)) = (e0))\/(((op (e1) (e1)) = (e0))\/(((op (e2) (e1)) = (e0))\/((op (e3) (e1)) = (e0))))) -> (((op (e3) (e0)) = (e1))\/(((op (e3) (e1)) = (e1))\/(((op (e3) (e2)) = (e1))\/((op (e3) (e3)) = (e1))))) -> (~((op (e2) (e2)) = (op (e3) (e2)))) -> (((op (e0) (e1)) = (e3))\/(((op (e1) (e1)) = (e3))\/(((op (e2) (e1)) = (e3))\/((op (e3) (e1)) = (e3))))) -> (~((op (e1) (e0)) = (op (e1) (e1)))) -> (~((op (e2) (e3)) = (op (e3) (e3)))) -> (((op (e2) (e0)) = (e0))\/(((op (e2) (e1)) = (e0))\/(((op (e2) (e2)) = (e0))\/((op (e2) (e3)) = (e0))))) -> (~((op (e0) (e0)) = (op (e1) (e0)))) -> (~((e0) = (e3))) -> ((((op (e0) (e0)) = (e3))/\(~((op (e0) (e3)) = (e0))))\/((((op (e1) (e1)) = (e3))/\(~((op (e1) (e3)) = (e1))))\/((((op (e2) (e2)) = (e3))/\(~((op (e2) (e3)) = (e2))))\/(((op (e3) (e3)) = (e3))/\(~((op (e3) (e3)) = (e3))))))) -> (((op (e0) (e0)) = (e0))\/(((op (e1) (e0)) = (e0))\/(((op (e2) (e0)) = (e0))\/((op (e3) (e0)) = (e0))))) -> (~((op (e3) (e0)) = (op (e3) (e3)))) -> (~((op (e2) (e0)) = (op (e2) (e1)))) -> (~((op (e2) (e1)) = (op (e2) (e2)))) -> (~((op (e1) (e1)) = (op (e2) (e1)))) -> (((op (e2) (e1)) = (e0))\/(((op (e2) (e1)) = (e1))\/(((op (e2) (e1)) = (e2))\/((op (e2) (e1)) = (e3))))) -> (~((e1) = (e3))) -> (~((op (e1) (e2)) = (op (e2) (e2)))) -> (((op (e1) (e0)) = (e1))\/(((op (e1) (e1)) = (e1))\/(((op (e1) (e2)) = (e1))\/((op (e1) (e3)) = (e1))))) -> (~((e0) = (e2))) -> (~((e2) = (e3))) -> ((op (e3) (e3)) = (e0)) -> (~((e0) = (e1))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H106 zenon_H8d zenon_H90 zenon_H107 zenon_H32 zenon_H2d zenon_H108 zenon_H52 zenon_H109 zenon_Hba zenon_H10a zenon_Hf1 zenon_H24 zenon_He0 zenon_H80 zenon_Hc4 zenon_Hc9 zenon_Hcc zenon_Hee zenon_Hea zenon_Hf2 zenon_Hbf zenon_H100 zenon_H10b zenon_Hbb zenon_H5a zenon_H10c zenon_H10d zenon_Hb4 zenon_Ha7 zenon_Had zenon_Hb0 zenon_H10e zenon_Ha3 zenon_H94 zenon_H10f zenon_H47 zenon_H1e zenon_H88 zenon_H5c. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H106); [ zenon_intro zenon_H111 | zenon_intro zenon_H110 ]. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H111). zenon_intro zenon_H25. zenon_intro zenon_H33. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H109); [ zenon_intro zenon_H113 | zenon_intro zenon_H112 ]. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H113). zenon_intro zenon_H20. zenon_intro zenon_H114. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H108); [ zenon_intro zenon_H5d | zenon_intro zenon_H115 ]. % 2.60/2.86 apply (zenon_L30_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H115); [ zenon_intro zenon_H35 | zenon_intro zenon_H116 ]. % 2.60/2.86 exact (zenon_H33 zenon_H35). % 2.60/2.86 apply (zenon_or_s _ _ zenon_H116); [ zenon_intro zenon_H60 | zenon_intro zenon_H5f ]. % 2.60/2.86 exact (zenon_H114 zenon_H60). % 2.60/2.86 apply (zenon_L31_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H112); [ zenon_intro zenon_H4b | zenon_intro zenon_H117 ]. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H4b). zenon_intro zenon_H48. zenon_intro zenon_H4c. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10c); [ zenon_intro zenon_H22 | zenon_intro zenon_H118 ]. % 2.60/2.86 apply (zenon_L34_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H118); [ zenon_intro zenon_H37 | zenon_intro zenon_H119 ]. % 2.60/2.86 apply (zenon_L36_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H119); [ zenon_intro zenon_Hb8 | zenon_intro zenon_H43 ]. % 2.60/2.86 apply (zenon_and_s _ _ zenon_Hb8). zenon_intro zenon_H3c. zenon_intro zenon_Hb9. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H108); [ zenon_intro zenon_H5d | zenon_intro zenon_H115 ]. % 2.60/2.86 apply (zenon_L21_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H115); [ zenon_intro zenon_H35 | zenon_intro zenon_H116 ]. % 2.60/2.86 exact (zenon_H33 zenon_H35). % 2.60/2.86 apply (zenon_or_s _ _ zenon_H116); [ zenon_intro zenon_H60 | zenon_intro zenon_H5f ]. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H107); [ zenon_intro zenon_H8e | zenon_intro zenon_H11a ]. % 2.60/2.86 apply (zenon_L37_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H11a); [ zenon_intro zenon_Ha5 | zenon_intro zenon_H11b ]. % 2.60/2.86 exact (zenon_H4c zenon_Ha5). % 2.60/2.86 apply (zenon_or_s _ _ zenon_H11b); [ zenon_intro zenon_H91 | zenon_intro zenon_H93 ]. % 2.60/2.86 apply (zenon_L38_); trivial. % 2.60/2.86 apply (zenon_L39_); trivial. % 2.60/2.86 apply (zenon_L31_); trivial. % 2.60/2.86 apply (zenon_L11_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H117); [ zenon_intro zenon_H4d | zenon_intro zenon_H9a ]. % 2.60/2.86 apply (zenon_L15_); trivial. % 2.60/2.86 apply (zenon_L41_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H110); [ zenon_intro zenon_H9b | zenon_intro zenon_H11c ]. % 2.60/2.86 apply (zenon_L42_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H11c); [ zenon_intro zenon_H11e | zenon_intro zenon_H11d ]. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H11e). zenon_intro zenon_Ha4. zenon_intro zenon_H11f. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H109); [ zenon_intro zenon_H113 | zenon_intro zenon_H112 ]. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H113). zenon_intro zenon_H20. zenon_intro zenon_H114. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10c); [ zenon_intro zenon_H22 | zenon_intro zenon_H118 ]. % 2.60/2.86 apply (zenon_L3_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H118); [ zenon_intro zenon_H37 | zenon_intro zenon_H119 ]. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H37). zenon_intro zenon_H2b. zenon_intro zenon_H38. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10d); [ zenon_intro zenon_H5d | zenon_intro zenon_H120 ]. % 2.60/2.86 apply (zenon_L30_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H120); [ zenon_intro zenon_H9e | zenon_intro zenon_H121 ]. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10f); [ zenon_intro zenon_H9f | zenon_intro zenon_H122 ]. % 2.60/2.86 apply (zenon_L43_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H122); [ zenon_intro zenon_H9d | zenon_intro zenon_H123 ]. % 2.60/2.86 apply (zenon_L44_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H123); [ zenon_intro zenon_Ha5 | zenon_intro zenon_H103 ]. % 2.60/2.86 apply (zenon_L45_); trivial. % 2.60/2.86 exact (zenon_H38 zenon_H103). % 2.60/2.86 apply (zenon_or_s _ _ zenon_H121); [ zenon_intro zenon_Ha8 | zenon_intro zenon_Hb3 ]. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10e); [ zenon_intro zenon_Ha9 | zenon_intro zenon_H124 ]. % 2.60/2.86 apply (zenon_L46_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H124); [ zenon_intro zenon_Hac | zenon_intro zenon_H125 ]. % 2.60/2.86 apply (zenon_L47_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H125); [ zenon_intro zenon_H126 | zenon_intro zenon_Hb1 ]. % 2.60/2.86 exact (zenon_H11f zenon_H126). % 2.60/2.86 apply (zenon_L48_); trivial. % 2.60/2.86 apply (zenon_L49_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H119); [ zenon_intro zenon_Hb8 | zenon_intro zenon_H43 ]. % 2.60/2.86 apply (zenon_L51_); trivial. % 2.60/2.86 apply (zenon_L11_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H112); [ zenon_intro zenon_H4b | zenon_intro zenon_H117 ]. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H4b). zenon_intro zenon_H48. zenon_intro zenon_H4c. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10c); [ zenon_intro zenon_H22 | zenon_intro zenon_H118 ]. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H22). zenon_intro zenon_H1f. zenon_intro zenon_H23. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10d); [ zenon_intro zenon_H5d | zenon_intro zenon_H120 ]. % 2.60/2.86 apply (zenon_L52_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H120); [ zenon_intro zenon_H9e | zenon_intro zenon_H121 ]. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10f); [ zenon_intro zenon_H9f | zenon_intro zenon_H122 ]. % 2.60/2.86 apply (zenon_L43_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H122); [ zenon_intro zenon_H9d | zenon_intro zenon_H123 ]. % 2.60/2.86 apply (zenon_L53_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H123); [ zenon_intro zenon_Ha5 | zenon_intro zenon_H103 ]. % 2.60/2.86 exact (zenon_H4c zenon_Ha5). % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10a); [ zenon_intro zenon_Hbc | zenon_intro zenon_H127 ]. % 2.60/2.86 apply (zenon_L54_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H127); [ zenon_intro zenon_H2b | zenon_intro zenon_H128 ]. % 2.60/2.86 apply (zenon_L35_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H128); [ zenon_intro zenon_H93 | zenon_intro zenon_H104 ]. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10b); [ zenon_intro zenon_Ha8 | zenon_intro zenon_H129 ]. % 2.60/2.86 apply (zenon_L70_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H129); [ zenon_intro zenon_Ha9 | zenon_intro zenon_H12a ]. % 2.60/2.86 apply (zenon_L72_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H12a); [ zenon_intro zenon_Hde | zenon_intro zenon_H76 ]. % 2.60/2.86 apply (zenon_L62_); trivial. % 2.60/2.86 apply (zenon_L73_); trivial. % 2.60/2.86 apply (zenon_L74_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H121); [ zenon_intro zenon_Ha8 | zenon_intro zenon_Hb3 ]. % 2.60/2.86 apply (zenon_L70_); trivial. % 2.60/2.86 apply (zenon_L49_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H118); [ zenon_intro zenon_H37 | zenon_intro zenon_H119 ]. % 2.60/2.86 apply (zenon_L36_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H119); [ zenon_intro zenon_Hb8 | zenon_intro zenon_H43 ]. % 2.60/2.86 apply (zenon_L51_); trivial. % 2.60/2.86 apply (zenon_L11_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H117); [ zenon_intro zenon_H4d | zenon_intro zenon_H9a ]. % 2.60/2.86 apply (zenon_L15_); trivial. % 2.60/2.86 apply (zenon_L41_); trivial. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H11d). zenon_intro zenon_Hec. zenon_intro zenon_He9. % 2.60/2.86 apply (zenon_L68_); trivial. % 2.60/2.86 (* end of lemma zenon_L75_ *) % 2.60/2.86 assert (zenon_L76_ : (~((op (e1) (e1)) = (op (e1) (e2)))) -> ((op (e1) (e1)) = (e0)) -> ((op (e1) (e2)) = (e0)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H90 zenon_H49 zenon_H8e. % 2.60/2.86 cut (((op (e1) (e1)) = (e0)) = ((op (e1) (e1)) = (op (e1) (e2)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H90. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H49. % 2.60/2.86 cut (((e0) = (op (e1) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H8f]. % 2.60/2.86 cut (((op (e1) (e1)) = (op (e1) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H2f]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H2f. apply refl_equal. % 2.60/2.86 apply zenon_H8f. apply sym_equal. exact zenon_H8e. % 2.60/2.86 (* end of lemma zenon_L76_ *) % 2.60/2.86 assert (zenon_L77_ : ((op (e2) (e2)) = (e0)) -> ((op (e2) (e0)) = (e0)) -> (~((op (e2) (e0)) = (op (e2) (e2)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hde zenon_Ha8 zenon_H12b. % 2.60/2.86 elim (classic ((op (e2) (e2)) = (op (e2) (e2)))); [ zenon_intro zenon_H3f | zenon_intro zenon_H40 ]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2))) = ((op (e2) (e0)) = (op (e2) (e2)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H12b. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H3f. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e0)))); [idtac | apply NNPP; zenon_intro zenon_H12c]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e2) (e2)) = (e0)) = ((op (e2) (e2)) = (op (e2) (e0)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H12c. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hde. % 2.60/2.86 cut (((e0) = (op (e2) (e0)))); [idtac | apply NNPP; zenon_intro zenon_H12d]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 apply zenon_H12d. apply sym_equal. exact zenon_Ha8. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L77_ *) % 2.60/2.86 assert (zenon_L78_ : (~((op (e0) (e3)) = (op (e2) (e3)))) -> ((op (e0) (e3)) = (e0)) -> ((op (e2) (e3)) = (e0)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H12e zenon_H5f zenon_H76. % 2.60/2.86 cut (((op (e0) (e3)) = (e0)) = ((op (e0) (e3)) = (op (e2) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H12e. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H5f. % 2.60/2.86 cut (((e0) = (op (e2) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 2.60/2.86 cut (((op (e0) (e3)) = (op (e0) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H63. apply refl_equal. % 2.60/2.86 apply zenon_H102. apply sym_equal. exact zenon_H76. % 2.60/2.86 (* end of lemma zenon_L78_ *) % 2.60/2.86 assert (zenon_L79_ : ((op (e2) (e3)) = (e1)) -> ((op (e3) (e3)) = (e2)) -> (~((e1) = (op (op (e3) (e3)) (e3)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H12f zenon_H50 zenon_H130. % 2.60/2.86 elim (classic ((op (op (e3) (e3)) (e3)) = (op (op (e3) (e3)) (e3)))); [ zenon_intro zenon_H131 | zenon_intro zenon_H132 ]. % 2.60/2.86 cut (((op (op (e3) (e3)) (e3)) = (op (op (e3) (e3)) (e3))) = ((e1) = (op (op (e3) (e3)) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H130. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H131. % 2.60/2.86 cut (((op (op (e3) (e3)) (e3)) = (op (op (e3) (e3)) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 2.60/2.86 cut (((op (op (e3) (e3)) (e3)) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H133]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e2) (e3)) = (e1)) = ((op (op (e3) (e3)) (e3)) = (e1))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H133. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H12f. % 2.60/2.86 cut (((e1) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H5b]. % 2.60/2.86 cut (((op (e2) (e3)) = (op (op (e3) (e3)) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H134]. % 2.60/2.86 congruence. % 2.60/2.86 elim (classic ((op (op (e3) (e3)) (e3)) = (op (op (e3) (e3)) (e3)))); [ zenon_intro zenon_H131 | zenon_intro zenon_H132 ]. % 2.60/2.86 cut (((op (op (e3) (e3)) (e3)) = (op (op (e3) (e3)) (e3))) = ((op (e2) (e3)) = (op (op (e3) (e3)) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H134. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H131. % 2.60/2.86 cut (((op (op (e3) (e3)) (e3)) = (op (op (e3) (e3)) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 2.60/2.86 cut (((op (op (e3) (e3)) (e3)) = (op (e2) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H135]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((e3) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H1d]. % 2.60/2.86 cut (((op (e3) (e3)) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H99]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_H99 zenon_H50). % 2.60/2.86 apply zenon_H1d. apply refl_equal. % 2.60/2.86 apply zenon_H132. apply refl_equal. % 2.60/2.86 apply zenon_H132. apply refl_equal. % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 apply zenon_H132. apply refl_equal. % 2.60/2.86 apply zenon_H132. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L79_ *) % 2.60/2.86 assert (zenon_L80_ : ((op (e3) (e2)) = (e0)) -> ((op (e2) (e3)) = (e1)) -> ((op (e3) (e3)) = (e2)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H6a zenon_H12f zenon_H50. % 2.60/2.86 apply (zenon_notand_s _ _ ax6); [ zenon_intro zenon_H137 | zenon_intro zenon_H136 ]. % 2.60/2.86 elim (classic ((op (e3) (op (e3) (e3))) = (op (e3) (op (e3) (e3))))); [ zenon_intro zenon_H138 | zenon_intro zenon_H139 ]. % 2.60/2.86 cut (((op (e3) (op (e3) (e3))) = (op (e3) (op (e3) (e3)))) = ((e0) = (op (e3) (op (e3) (e3))))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H137. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H138. % 2.60/2.86 cut (((op (e3) (op (e3) (e3))) = (op (e3) (op (e3) (e3))))); [idtac | apply NNPP; zenon_intro zenon_H139]. % 2.60/2.86 cut (((op (e3) (op (e3) (e3))) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H13a]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e3) (e2)) = (e0)) = ((op (e3) (op (e3) (e3))) = (e0))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H13a. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H6a. % 2.60/2.86 cut (((e0) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H6d]. % 2.60/2.86 cut (((op (e3) (e2)) = (op (e3) (op (e3) (e3))))); [idtac | apply NNPP; zenon_intro zenon_H13b]. % 2.60/2.86 congruence. % 2.60/2.86 elim (classic ((op (e3) (op (e3) (e3))) = (op (e3) (op (e3) (e3))))); [ zenon_intro zenon_H138 | zenon_intro zenon_H139 ]. % 2.60/2.86 cut (((op (e3) (op (e3) (e3))) = (op (e3) (op (e3) (e3)))) = ((op (e3) (e2)) = (op (e3) (op (e3) (e3))))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H13b. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H138. % 2.60/2.86 cut (((op (e3) (op (e3) (e3))) = (op (e3) (op (e3) (e3))))); [idtac | apply NNPP; zenon_intro zenon_H139]. % 2.60/2.86 cut (((op (e3) (op (e3) (e3))) = (op (e3) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H13c]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e3) (e3)) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H99]. % 2.60/2.86 cut (((e3) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H1d]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H1d. apply refl_equal. % 2.60/2.86 exact (zenon_H99 zenon_H50). % 2.60/2.86 apply zenon_H139. apply refl_equal. % 2.60/2.86 apply zenon_H139. apply refl_equal. % 2.60/2.86 apply zenon_H6d. apply refl_equal. % 2.60/2.86 apply zenon_H139. apply refl_equal. % 2.60/2.86 apply zenon_H139. apply refl_equal. % 2.60/2.86 apply (zenon_notand_s _ _ zenon_H136); [ zenon_intro zenon_H130 | zenon_intro zenon_H13d ]. % 2.60/2.86 apply (zenon_L79_); trivial. % 2.60/2.86 apply zenon_H13d. apply sym_equal. exact zenon_H50. % 2.60/2.86 (* end of lemma zenon_L80_ *) % 2.60/2.86 assert (zenon_L81_ : (~((op (e2) (e2)) = (op (e2) (e3)))) -> ((op (e2) (e2)) = (e3)) -> ((op (e2) (e3)) = (e3)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H13e zenon_H3c zenon_H13f. % 2.60/2.86 cut (((op (e2) (e2)) = (e3)) = ((op (e2) (e2)) = (op (e2) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H13e. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H3c. % 2.60/2.86 cut (((e3) = (op (e2) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H140]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 apply zenon_H140. apply sym_equal. exact zenon_H13f. % 2.60/2.86 (* end of lemma zenon_L81_ *) % 2.60/2.86 assert (zenon_L82_ : (((op (e0) (e2)) = (e0))\/(((op (e1) (e2)) = (e0))\/(((op (e2) (e2)) = (e0))\/((op (e3) (e2)) = (e0))))) -> (~((op (e0) (e2)) = (op (e0) (e3)))) -> ((op (e1) (e1)) = (e0)) -> (~((op (e1) (e1)) = (op (e1) (e2)))) -> (~((op (e2) (e0)) = (op (e2) (e2)))) -> ((op (e2) (e0)) = (e0)) -> (((op (e2) (e3)) = (e0))\/(((op (e2) (e3)) = (e1))\/(((op (e2) (e3)) = (e2))\/((op (e2) (e3)) = (e3))))) -> ((op (e0) (e3)) = (e0)) -> (~((op (e0) (e3)) = (op (e2) (e3)))) -> ((op (e3) (e3)) = (e2)) -> (~((op (e2) (e3)) = (e2))) -> (~((op (e2) (e2)) = (op (e2) (e3)))) -> ((op (e2) (e2)) = (e3)) -> False). % 2.60/2.86 do 0 intro. intros zenon_He0 zenon_H61 zenon_H49 zenon_H90 zenon_H12b zenon_Ha8 zenon_H141 zenon_H5f zenon_H12e zenon_H50 zenon_Hb9 zenon_H13e zenon_H3c. % 2.60/2.86 apply (zenon_or_s _ _ zenon_He0); [ zenon_intro zenon_H60 | zenon_intro zenon_He1 ]. % 2.60/2.86 apply (zenon_L22_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_He1); [ zenon_intro zenon_H8e | zenon_intro zenon_He2 ]. % 2.60/2.86 apply (zenon_L76_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_He2); [ zenon_intro zenon_Hde | zenon_intro zenon_H6a ]. % 2.60/2.86 apply (zenon_L77_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H141); [ zenon_intro zenon_H76 | zenon_intro zenon_H142 ]. % 2.60/2.86 apply (zenon_L78_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H142); [ zenon_intro zenon_H12f | zenon_intro zenon_H143 ]. % 2.60/2.86 apply (zenon_L80_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H143); [ zenon_intro zenon_H144 | zenon_intro zenon_H13f ]. % 2.60/2.86 exact (zenon_Hb9 zenon_H144). % 2.60/2.86 apply (zenon_L81_); trivial. % 2.60/2.86 (* end of lemma zenon_L82_ *) % 2.60/2.86 assert (zenon_L83_ : (~((op (e1) (e1)) = (op (e2) (e1)))) -> ((op (e1) (e1)) = (e0)) -> ((op (e2) (e1)) = (e0)) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hb0 zenon_H49 zenon_Ha9. % 2.60/2.86 cut (((op (e1) (e1)) = (e0)) = ((op (e1) (e1)) = (op (e2) (e1)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hb0. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H49. % 2.60/2.86 cut (((e0) = (op (e2) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Haa]. % 2.60/2.86 cut (((op (e1) (e1)) = (op (e1) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H2f]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H2f. apply refl_equal. % 2.60/2.86 apply zenon_Haa. apply sym_equal. exact zenon_Ha9. % 2.60/2.86 (* end of lemma zenon_L83_ *) % 2.60/2.86 assert (zenon_L84_ : ((op (e2) (e2)) = (e0)) -> ((op (e0) (e2)) = (e0)) -> (~((op (e0) (e2)) = (op (e2) (e2)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hde zenon_H60 zenon_H3e. % 2.60/2.86 elim (classic ((op (e2) (e2)) = (op (e2) (e2)))); [ zenon_intro zenon_H3f | zenon_intro zenon_H40 ]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2))) = ((op (e0) (e2)) = (op (e2) (e2)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H3e. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H3f. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e0) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H41]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e2) (e2)) = (e0)) = ((op (e2) (e2)) = (op (e0) (e2)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H41. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hde. % 2.60/2.86 cut (((e0) = (op (e0) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 apply zenon_H65. apply sym_equal. exact zenon_H60. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L84_ *) % 2.60/2.86 assert (zenon_L85_ : (~((op (e0) (e3)) = (op (e1) (e3)))) -> ((op (e0) (e3)) = (e0)) -> ((op (e1) (e3)) = (e0)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H145 zenon_H5f zenon_H67. % 2.60/2.86 cut (((op (e0) (e3)) = (e0)) = ((op (e0) (e3)) = (op (e1) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H145. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H5f. % 2.60/2.86 cut (((e0) = (op (e1) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H68]. % 2.60/2.86 cut (((op (e0) (e3)) = (op (e0) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H63. apply refl_equal. % 2.60/2.86 apply zenon_H68. apply sym_equal. exact zenon_H67. % 2.60/2.86 (* end of lemma zenon_L85_ *) % 2.60/2.86 assert (zenon_L86_ : ((op (e3) (e3)) = (e2)) -> ((op (e1) (e3)) = (e2)) -> (~((op (e1) (e3)) = (op (e3) (e3)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H50 zenon_H146 zenon_H147. % 2.60/2.86 elim (classic ((op (e3) (e3)) = (op (e3) (e3)))); [ zenon_intro zenon_H53 | zenon_intro zenon_H54 ]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3))) = ((op (e1) (e3)) = (op (e3) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H147. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H53. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e1) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H148]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e3) (e3)) = (e2)) = ((op (e3) (e3)) = (op (e1) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H148. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H50. % 2.60/2.86 cut (((e2) = (op (e1) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H149]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 apply zenon_H149. apply sym_equal. exact zenon_H146. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L86_ *) % 2.60/2.86 assert (zenon_L87_ : (~((op (e1) (e1)) = (op (e1) (e3)))) -> ((op (e1) (e1)) = (e3)) -> ((op (e1) (e3)) = (e3)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H66 zenon_H2b zenon_H104. % 2.60/2.86 cut (((op (e1) (e1)) = (e3)) = ((op (e1) (e1)) = (op (e1) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H66. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H2b. % 2.60/2.86 cut (((e3) = (op (e1) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H14a]. % 2.60/2.86 cut (((op (e1) (e1)) = (op (e1) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H2f]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H2f. apply refl_equal. % 2.60/2.86 apply zenon_H14a. apply sym_equal. exact zenon_H104. % 2.60/2.86 (* end of lemma zenon_L87_ *) % 2.60/2.86 assert (zenon_L88_ : (((op (e2) (e2)) = (e3))/\(~((op (e2) (e3)) = (e2)))) -> ((op (e2) (e2)) = (e0)) -> (~((e0) = (e3))) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hb8 zenon_Hde zenon_H5a. % 2.60/2.86 apply (zenon_and_s _ _ zenon_Hb8). zenon_intro zenon_H3c. zenon_intro zenon_Hb9. % 2.60/2.86 elim (classic ((e3) = (e3))); [ zenon_intro zenon_H8a | zenon_intro zenon_H1d ]. % 2.60/2.86 cut (((e3) = (e3)) = ((e0) = (e3))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H5a. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H8a. % 2.60/2.86 cut (((e3) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H1d]. % 2.60/2.86 cut (((e3) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H14b]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e2) (e2)) = (e0)) = ((e3) = (e0))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H14b. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hde. % 2.60/2.86 cut (((e0) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H6d]. % 2.60/2.86 cut (((op (e2) (e2)) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H75]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_H75 zenon_H3c). % 2.60/2.86 apply zenon_H6d. apply refl_equal. % 2.60/2.86 apply zenon_H1d. apply refl_equal. % 2.60/2.86 apply zenon_H1d. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L88_ *) % 2.60/2.86 assert (zenon_L89_ : ((((op (e0) (e0)) = (e3))/\(~((op (e0) (e3)) = (e0))))\/((((op (e1) (e1)) = (e3))/\(~((op (e1) (e3)) = (e1))))\/((((op (e2) (e2)) = (e3))/\(~((op (e2) (e3)) = (e2))))\/(((op (e3) (e3)) = (e3))/\(~((op (e3) (e3)) = (e3))))))) -> (((op (e0) (e0)) = (e0))\/(((op (e0) (e1)) = (e0))\/(((op (e0) (e2)) = (e0))\/((op (e0) (e3)) = (e0))))) -> (~((op (e0) (e3)) = (op (e1) (e3)))) -> (~((op (e1) (e3)) = (op (e3) (e3)))) -> ((op (e3) (e3)) = (e2)) -> (~((op (e1) (e1)) = (op (e1) (e3)))) -> (((op (e1) (e3)) = (e0))\/(((op (e1) (e3)) = (e1))\/(((op (e1) (e3)) = (e2))\/((op (e1) (e3)) = (e3))))) -> (~((op (e0) (e2)) = (op (e2) (e2)))) -> (~((op (e0) (e1)) = (e0))) -> ((op (e0) (e0)) = (e1)) -> (~((e0) = (e1))) -> (~((e0) = (e3))) -> ((op (e2) (e2)) = (e0)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H10c zenon_H108 zenon_H145 zenon_H147 zenon_H50 zenon_H66 zenon_H14c zenon_H3e zenon_H33 zenon_H25 zenon_H5c zenon_H5a zenon_Hde. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10c); [ zenon_intro zenon_H22 | zenon_intro zenon_H118 ]. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H22). zenon_intro zenon_H1f. zenon_intro zenon_H23. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H108); [ zenon_intro zenon_H5d | zenon_intro zenon_H115 ]. % 2.60/2.86 apply (zenon_L52_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H115); [ zenon_intro zenon_H35 | zenon_intro zenon_H116 ]. % 2.60/2.86 exact (zenon_H33 zenon_H35). % 2.60/2.86 apply (zenon_or_s _ _ zenon_H116); [ zenon_intro zenon_H60 | zenon_intro zenon_H5f ]. % 2.60/2.86 apply (zenon_L84_); trivial. % 2.60/2.86 exact (zenon_H23 zenon_H5f). % 2.60/2.86 apply (zenon_or_s _ _ zenon_H118); [ zenon_intro zenon_H37 | zenon_intro zenon_H119 ]. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H37). zenon_intro zenon_H2b. zenon_intro zenon_H38. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H108); [ zenon_intro zenon_H5d | zenon_intro zenon_H115 ]. % 2.60/2.86 apply (zenon_L21_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H115); [ zenon_intro zenon_H35 | zenon_intro zenon_H116 ]. % 2.60/2.86 exact (zenon_H33 zenon_H35). % 2.60/2.86 apply (zenon_or_s _ _ zenon_H116); [ zenon_intro zenon_H60 | zenon_intro zenon_H5f ]. % 2.60/2.86 apply (zenon_L84_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H14c); [ zenon_intro zenon_H67 | zenon_intro zenon_H14d ]. % 2.60/2.86 apply (zenon_L85_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H14d); [ zenon_intro zenon_H103 | zenon_intro zenon_H14e ]. % 2.60/2.86 exact (zenon_H38 zenon_H103). % 2.60/2.86 apply (zenon_or_s _ _ zenon_H14e); [ zenon_intro zenon_H146 | zenon_intro zenon_H104 ]. % 2.60/2.86 apply (zenon_L86_); trivial. % 2.60/2.86 apply (zenon_L87_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H119); [ zenon_intro zenon_Hb8 | zenon_intro zenon_H43 ]. % 2.60/2.86 apply (zenon_L88_); trivial. % 2.60/2.86 apply (zenon_L11_); trivial. % 2.60/2.86 (* end of lemma zenon_L89_ *) % 2.60/2.86 assert (zenon_L90_ : ((op (e1) (e1)) = (e0)) -> ((op (e1) (e1)) = (e1)) -> (~((e0) = (e1))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H49 zenon_H9d zenon_H5c. % 2.60/2.86 elim (classic ((e1) = (e1))); [ zenon_intro zenon_Ha0 | zenon_intro zenon_H5b ]. % 2.60/2.86 cut (((e1) = (e1)) = ((e0) = (e1))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H5c. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Ha0. % 2.60/2.86 cut (((e1) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H5b]. % 2.60/2.86 cut (((e1) = (e0))); [idtac | apply NNPP; zenon_intro zenon_Ha1]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e1) (e1)) = (e0)) = ((e1) = (e0))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Ha1. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H49. % 2.60/2.86 cut (((e0) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H6d]. % 2.60/2.86 cut (((op (e1) (e1)) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H9c]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_H9c zenon_H9d). % 2.60/2.86 apply zenon_H6d. apply refl_equal. % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L90_ *) % 2.60/2.86 assert (zenon_L91_ : (~((op (e0) (e3)) = (op (e1) (e3)))) -> ((op (e0) (e3)) = (e1)) -> ((op (e1) (e3)) = (e1)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H145 zenon_H14f zenon_H103. % 2.60/2.86 cut (((op (e0) (e3)) = (e1)) = ((op (e0) (e3)) = (op (e1) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H145. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H14f. % 2.60/2.86 cut (((e1) = (op (e1) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H150]. % 2.60/2.86 cut (((op (e0) (e3)) = (op (e0) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H63. apply refl_equal. % 2.60/2.86 apply zenon_H150. apply sym_equal. exact zenon_H103. % 2.60/2.86 (* end of lemma zenon_L91_ *) % 2.60/2.86 assert (zenon_L92_ : (((op (e0) (e3)) = (e0))\/(((op (e0) (e3)) = (e1))\/(((op (e0) (e3)) = (e2))\/((op (e0) (e3)) = (e3))))) -> (~((op (e0) (e3)) = (e0))) -> ((op (e1) (e3)) = (e1)) -> (~((op (e0) (e3)) = (op (e1) (e3)))) -> (~((op (e0) (e3)) = (op (e3) (e3)))) -> ((op (e3) (e3)) = (e2)) -> (~((op (e0) (e0)) = (op (e0) (e3)))) -> ((op (e0) (e0)) = (e3)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H151 zenon_H23 zenon_H103 zenon_H145 zenon_H52 zenon_H50 zenon_H57 zenon_H1f. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H151); [ zenon_intro zenon_H5f | zenon_intro zenon_H152 ]. % 2.60/2.86 exact (zenon_H23 zenon_H5f). % 2.60/2.86 apply (zenon_or_s _ _ zenon_H152); [ zenon_intro zenon_H14f | zenon_intro zenon_H153 ]. % 2.60/2.86 apply (zenon_L91_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H153); [ zenon_intro zenon_H51 | zenon_intro zenon_H58 ]. % 2.60/2.86 apply (zenon_L16_); trivial. % 2.60/2.86 apply (zenon_L17_); trivial. % 2.60/2.86 (* end of lemma zenon_L92_ *) % 2.60/2.86 assert (zenon_L93_ : ((((op (e0) (e0)) = (e2))/\(~((op (e0) (e2)) = (e0))))\/((((op (e1) (e1)) = (e2))/\(~((op (e1) (e2)) = (e1))))\/((((op (e2) (e2)) = (e2))/\(~((op (e2) (e2)) = (e2))))\/(((op (e3) (e3)) = (e2))/\(~((op (e3) (e2)) = (e3))))))) -> (~((e2) = (e3))) -> (~((e0) = (e2))) -> (~((op (e1) (e0)) = (e1))) -> (~((e0) = (e1))) -> ((op (e1) (e1)) = (e0)) -> (~((op (e1) (e2)) = (op (e2) (e2)))) -> ((op (e2) (e2)) = (e1)) -> (((op (e0) (e3)) = (e0))\/(((op (e0) (e3)) = (e1))\/(((op (e0) (e3)) = (e2))\/((op (e0) (e3)) = (e3))))) -> (~((op (e0) (e0)) = (op (e0) (e3)))) -> (~((op (e0) (e3)) = (op (e3) (e3)))) -> (~((op (e0) (e3)) = (op (e1) (e3)))) -> (((op (e1) (e0)) = (e1))\/(((op (e1) (e1)) = (e1))\/(((op (e1) (e2)) = (e1))\/((op (e1) (e3)) = (e1))))) -> (~((e0) = (e3))) -> (~((e1) = (e3))) -> ((((op (e0) (e0)) = (e3))/\(~((op (e0) (e3)) = (e0))))\/((((op (e1) (e1)) = (e3))/\(~((op (e1) (e3)) = (e1))))\/((((op (e2) (e2)) = (e3))/\(~((op (e2) (e3)) = (e2))))\/(((op (e3) (e3)) = (e3))/\(~((op (e3) (e3)) = (e3))))))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H109 zenon_H1e zenon_H47 zenon_Ha2 zenon_H5c zenon_H49 zenon_H94 zenon_Ha4 zenon_H151 zenon_H57 zenon_H52 zenon_H145 zenon_H10f zenon_H5a zenon_Ha3 zenon_H10c. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H109); [ zenon_intro zenon_H113 | zenon_intro zenon_H112 ]. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H113). zenon_intro zenon_H20. zenon_intro zenon_H114. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10c); [ zenon_intro zenon_H22 | zenon_intro zenon_H118 ]. % 2.60/2.86 apply (zenon_L3_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H118); [ zenon_intro zenon_H37 | zenon_intro zenon_H119 ]. % 2.60/2.86 apply (zenon_L19_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H119); [ zenon_intro zenon_Hb8 | zenon_intro zenon_H43 ]. % 2.60/2.86 apply (zenon_L51_); trivial. % 2.60/2.86 apply (zenon_L11_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H112); [ zenon_intro zenon_H4b | zenon_intro zenon_H117 ]. % 2.60/2.86 apply (zenon_L14_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H117); [ zenon_intro zenon_H4d | zenon_intro zenon_H9a ]. % 2.60/2.86 apply (zenon_L15_); trivial. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H9a). zenon_intro zenon_H50. zenon_intro zenon_H84. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10c); [ zenon_intro zenon_H22 | zenon_intro zenon_H118 ]. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H22). zenon_intro zenon_H1f. zenon_intro zenon_H23. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10f); [ zenon_intro zenon_H9f | zenon_intro zenon_H122 ]. % 2.60/2.86 exact (zenon_Ha2 zenon_H9f). % 2.60/2.86 apply (zenon_or_s _ _ zenon_H122); [ zenon_intro zenon_H9d | zenon_intro zenon_H123 ]. % 2.60/2.86 apply (zenon_L90_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H123); [ zenon_intro zenon_Ha5 | zenon_intro zenon_H103 ]. % 2.60/2.86 apply (zenon_L45_); trivial. % 2.60/2.86 apply (zenon_L92_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H118); [ zenon_intro zenon_H37 | zenon_intro zenon_H119 ]. % 2.60/2.86 apply (zenon_L19_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H119); [ zenon_intro zenon_Hb8 | zenon_intro zenon_H43 ]. % 2.60/2.86 apply (zenon_L51_); trivial. % 2.60/2.86 apply (zenon_L11_); trivial. % 2.60/2.86 (* end of lemma zenon_L93_ *) % 2.60/2.86 assert (zenon_L94_ : (~((op (e0) (e2)) = (op (e1) (e2)))) -> ((op (e0) (e2)) = (e1)) -> ((op (e1) (e2)) = (e1)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H8d zenon_H154 zenon_Ha5. % 2.60/2.86 cut (((op (e0) (e2)) = (e1)) = ((op (e0) (e2)) = (op (e1) (e2)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H8d. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H154. % 2.60/2.86 cut (((e1) = (op (e1) (e2)))); [idtac | apply NNPP; zenon_intro zenon_Ha6]. % 2.60/2.86 cut (((op (e0) (e2)) = (op (e0) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H6c]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H6c. apply refl_equal. % 2.60/2.86 apply zenon_Ha6. apply sym_equal. exact zenon_Ha5. % 2.60/2.86 (* end of lemma zenon_L94_ *) % 2.60/2.86 assert (zenon_L95_ : ((op (e3) (e3)) = (e1)) -> ((op (e1) (e3)) = (e1)) -> (~((op (e1) (e3)) = (op (e3) (e3)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hec zenon_H103 zenon_H147. % 2.60/2.86 elim (classic ((op (e3) (e3)) = (op (e3) (e3)))); [ zenon_intro zenon_H53 | zenon_intro zenon_H54 ]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3))) = ((op (e1) (e3)) = (op (e3) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H147. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H53. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e1) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H148]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e3) (e3)) = (e1)) = ((op (e3) (e3)) = (op (e1) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H148. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hec. % 2.60/2.86 cut (((e1) = (op (e1) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H150]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 apply zenon_H150. apply sym_equal. exact zenon_H103. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L95_ *) % 2.60/2.86 assert (zenon_L96_ : ((op (e3) (e3)) = (e1)) -> ((op (e3) (e3)) = (e2)) -> (~((e1) = (e2))) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hec zenon_H50 zenon_Hba. % 2.60/2.86 elim (classic ((e2) = (e2))); [ zenon_intro zenon_H97 | zenon_intro zenon_H46 ]. % 2.60/2.86 cut (((e2) = (e2)) = ((e1) = (e2))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hba. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H97. % 2.60/2.86 cut (((e2) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H46]. % 2.60/2.86 cut (((e2) = (e1))); [idtac | apply NNPP; zenon_intro zenon_He5]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e3) (e3)) = (e1)) = ((e2) = (e1))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_He5. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hec. % 2.60/2.86 cut (((e1) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H5b]. % 2.60/2.86 cut (((op (e3) (e3)) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H99]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_H99 zenon_H50). % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 apply zenon_H46. apply refl_equal. % 2.60/2.86 apply zenon_H46. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L96_ *) % 2.60/2.86 assert (zenon_L97_ : (((op (e3) (e3)) = (e2))/\(~((op (e3) (e2)) = (e3)))) -> ((op (e3) (e3)) = (e1)) -> (~((e1) = (e2))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H9a zenon_Hec zenon_Hba. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H9a). zenon_intro zenon_H50. zenon_intro zenon_H84. % 2.60/2.86 apply (zenon_L96_); trivial. % 2.60/2.86 (* end of lemma zenon_L97_ *) % 2.60/2.86 assert (zenon_L98_ : ((((op (e0) (e0)) = (e2))/\(~((op (e0) (e2)) = (e0))))\/((((op (e1) (e1)) = (e2))/\(~((op (e1) (e2)) = (e1))))\/((((op (e2) (e2)) = (e2))/\(~((op (e2) (e2)) = (e2))))\/(((op (e3) (e3)) = (e2))/\(~((op (e3) (e2)) = (e3))))))) -> ((((op (e0) (e0)) = (e3))/\(~((op (e0) (e3)) = (e0))))\/((((op (e1) (e1)) = (e3))/\(~((op (e1) (e3)) = (e1))))\/((((op (e2) (e2)) = (e3))/\(~((op (e2) (e3)) = (e2))))\/(((op (e3) (e3)) = (e3))/\(~((op (e3) (e3)) = (e3))))))) -> (((op (e1) (e0)) = (e1))\/(((op (e1) (e1)) = (e1))\/(((op (e1) (e2)) = (e1))\/((op (e1) (e3)) = (e1))))) -> (~((op (e1) (e3)) = (op (e3) (e3)))) -> (~((op (e0) (e2)) = (op (e1) (e2)))) -> (~((op (e0) (e0)) = (op (e0) (e2)))) -> (~((op (e0) (e2)) = (op (e2) (e2)))) -> (((op (e0) (e2)) = (e0))\/(((op (e0) (e2)) = (e1))\/(((op (e0) (e2)) = (e2))\/((op (e0) (e2)) = (e3))))) -> (~((e0) = (e1))) -> (~((op (e1) (e0)) = (e1))) -> (~((e0) = (e3))) -> (~((e2) = (e3))) -> (~((e0) = (e2))) -> ((op (e1) (e1)) = (e0)) -> ((op (e3) (e3)) = (e1)) -> (~((e1) = (e2))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H109 zenon_H10c zenon_H10f zenon_H147 zenon_H8d zenon_H39 zenon_H3e zenon_H155 zenon_H5c zenon_Ha2 zenon_H5a zenon_H1e zenon_H47 zenon_H49 zenon_Hec zenon_Hba. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H109); [ zenon_intro zenon_H113 | zenon_intro zenon_H112 ]. % 2.60/2.86 apply (zenon_and_s _ _ zenon_H113). zenon_intro zenon_H20. zenon_intro zenon_H114. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10c); [ zenon_intro zenon_H22 | zenon_intro zenon_H118 ]. % 2.60/2.86 apply (zenon_L3_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H118); [ zenon_intro zenon_H37 | zenon_intro zenon_H119 ]. % 2.60/2.86 apply (zenon_L19_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H119); [ zenon_intro zenon_Hb8 | zenon_intro zenon_H43 ]. % 2.60/2.86 apply (zenon_and_s _ _ zenon_Hb8). zenon_intro zenon_H3c. zenon_intro zenon_Hb9. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10f); [ zenon_intro zenon_H9f | zenon_intro zenon_H122 ]. % 2.60/2.86 exact (zenon_Ha2 zenon_H9f). % 2.60/2.86 apply (zenon_or_s _ _ zenon_H122); [ zenon_intro zenon_H9d | zenon_intro zenon_H123 ]. % 2.60/2.86 apply (zenon_L90_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H123); [ zenon_intro zenon_Ha5 | zenon_intro zenon_H103 ]. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H155); [ zenon_intro zenon_H60 | zenon_intro zenon_H156 ]. % 2.60/2.86 exact (zenon_H114 zenon_H60). % 2.60/2.86 apply (zenon_or_s _ _ zenon_H156); [ zenon_intro zenon_H154 | zenon_intro zenon_H157 ]. % 2.60/2.86 apply (zenon_L94_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H157); [ zenon_intro zenon_H3a | zenon_intro zenon_H3d ]. % 2.60/2.86 apply (zenon_L9_); trivial. % 2.60/2.86 apply (zenon_L10_); trivial. % 2.60/2.86 apply (zenon_L95_); trivial. % 2.60/2.86 apply (zenon_L11_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H112); [ zenon_intro zenon_H4b | zenon_intro zenon_H117 ]. % 2.60/2.86 apply (zenon_L14_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H117); [ zenon_intro zenon_H4d | zenon_intro zenon_H9a ]. % 2.60/2.86 apply (zenon_L15_); trivial. % 2.60/2.86 apply (zenon_L97_); trivial. % 2.60/2.86 (* end of lemma zenon_L98_ *) % 2.60/2.86 assert (zenon_L99_ : ((((op (e0) (e0)) = (e3))/\(~((op (e0) (e3)) = (e0))))\/((((op (e1) (e1)) = (e3))/\(~((op (e1) (e3)) = (e1))))\/((((op (e2) (e2)) = (e3))/\(~((op (e2) (e3)) = (e2))))\/(((op (e3) (e3)) = (e3))/\(~((op (e3) (e3)) = (e3))))))) -> (~((e2) = (e3))) -> (((op (e0) (e1)) = (e0))\/(((op (e0) (e1)) = (e1))\/(((op (e0) (e1)) = (e2))\/((op (e0) (e1)) = (e3))))) -> (~((op (e0) (e1)) = (op (e1) (e1)))) -> ((op (e0) (e0)) = (e2)) -> ((op (e0) (e0)) = (e1)) -> (~((op (e0) (e0)) = (op (e0) (e1)))) -> (~((op (e0) (e1)) = (e0))) -> (~((e0) = (e3))) -> ((op (e2) (e2)) = (e0)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H10c zenon_H1e zenon_H32 zenon_H2d zenon_H20 zenon_H25 zenon_H24 zenon_H33 zenon_H5a zenon_Hde. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H10c); [ zenon_intro zenon_H22 | zenon_intro zenon_H118 ]. % 2.60/2.86 apply (zenon_L3_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H118); [ zenon_intro zenon_H37 | zenon_intro zenon_H119 ]. % 2.60/2.86 apply (zenon_L8_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H119); [ zenon_intro zenon_Hb8 | zenon_intro zenon_H43 ]. % 2.60/2.86 apply (zenon_L88_); trivial. % 2.60/2.86 apply (zenon_L11_); trivial. % 2.60/2.86 (* end of lemma zenon_L99_ *) % 2.60/2.86 assert (zenon_L100_ : ((op (e0) (e3)) = (e0)) -> ((op (e0) (e1)) = (e0)) -> (~((op (e0) (e1)) = (op (e0) (e3)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H5f zenon_H35 zenon_H158. % 2.60/2.86 elim (classic ((op (e0) (e3)) = (op (e0) (e3)))); [ zenon_intro zenon_H62 | zenon_intro zenon_H63 ]. % 2.60/2.86 cut (((op (e0) (e3)) = (op (e0) (e3))) = ((op (e0) (e1)) = (op (e0) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H158. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H62. % 2.60/2.86 cut (((op (e0) (e3)) = (op (e0) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 2.60/2.86 cut (((op (e0) (e3)) = (op (e0) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e0) (e3)) = (e0)) = ((op (e0) (e3)) = (op (e0) (e1)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H159. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H5f. % 2.60/2.86 cut (((e0) = (op (e0) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hc7]. % 2.60/2.86 cut (((op (e0) (e3)) = (op (e0) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H63. apply refl_equal. % 2.60/2.86 apply zenon_Hc7. apply sym_equal. exact zenon_H35. % 2.60/2.86 apply zenon_H63. apply refl_equal. % 2.60/2.86 apply zenon_H63. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L100_ *) % 2.60/2.86 assert (zenon_L101_ : (~((op (e0) (e1)) = (op (e3) (e1)))) -> ((op (e0) (e1)) = (e0)) -> ((op (e3) (e1)) = (e0)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H15a zenon_H35 zenon_Hc8. % 2.60/2.86 cut (((op (e0) (e1)) = (e0)) = ((op (e0) (e1)) = (op (e3) (e1)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H15a. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H35. % 2.60/2.86 cut (((e0) = (op (e3) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hcb]. % 2.60/2.86 cut (((op (e0) (e1)) = (op (e0) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H15b. apply refl_equal. % 2.60/2.86 apply zenon_Hcb. apply sym_equal. exact zenon_Hc8. % 2.60/2.86 (* end of lemma zenon_L101_ *) % 2.60/2.86 assert (zenon_L102_ : ((op (e3) (e3)) = (e1)) -> ((op (e3) (e1)) = (e1)) -> (~((op (e3) (e1)) = (op (e3) (e3)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hec zenon_He7 zenon_Hc9. % 2.60/2.86 elim (classic ((op (e3) (e3)) = (op (e3) (e3)))); [ zenon_intro zenon_H53 | zenon_intro zenon_H54 ]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3))) = ((op (e3) (e1)) = (op (e3) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hc9. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H53. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hca]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e3) (e3)) = (e1)) = ((op (e3) (e3)) = (op (e3) (e1)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hca. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hec. % 2.60/2.86 cut (((e1) = (op (e3) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H15c]. % 2.60/2.86 cut (((op (e3) (e3)) = (op (e3) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H54]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 apply zenon_H15c. apply sym_equal. exact zenon_He7. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 apply zenon_H54. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L102_ *) % 2.60/2.86 assert (zenon_L103_ : ((op (e3) (e1)) = (e2)) -> ((op (e1) (e1)) = (e3)) -> (~((e2) = (op (op (e1) (e1)) (e1)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H15d zenon_H2b zenon_H15e. % 2.60/2.86 elim (classic ((op (op (e1) (e1)) (e1)) = (op (op (e1) (e1)) (e1)))); [ zenon_intro zenon_Hd0 | zenon_intro zenon_Hd1 ]. % 2.60/2.86 cut (((op (op (e1) (e1)) (e1)) = (op (op (e1) (e1)) (e1))) = ((e2) = (op (op (e1) (e1)) (e1)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H15e. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hd0. % 2.60/2.86 cut (((op (op (e1) (e1)) (e1)) = (op (op (e1) (e1)) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hd1]. % 2.60/2.86 cut (((op (op (e1) (e1)) (e1)) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H15f]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e3) (e1)) = (e2)) = ((op (op (e1) (e1)) (e1)) = (e2))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H15f. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H15d. % 2.60/2.86 cut (((e2) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H46]. % 2.60/2.86 cut (((op (e3) (e1)) = (op (op (e1) (e1)) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H160]. % 2.60/2.86 congruence. % 2.60/2.86 elim (classic ((op (op (e1) (e1)) (e1)) = (op (op (e1) (e1)) (e1)))); [ zenon_intro zenon_Hd0 | zenon_intro zenon_Hd1 ]. % 2.60/2.86 cut (((op (op (e1) (e1)) (e1)) = (op (op (e1) (e1)) (e1))) = ((op (e3) (e1)) = (op (op (e1) (e1)) (e1)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H160. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hd0. % 2.60/2.86 cut (((op (op (e1) (e1)) (e1)) = (op (op (e1) (e1)) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hd1]. % 2.60/2.86 cut (((op (op (e1) (e1)) (e1)) = (op (e3) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H161]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((e1) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H5b]. % 2.60/2.86 cut (((op (e1) (e1)) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_H8c zenon_H2b). % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 apply zenon_Hd1. apply refl_equal. % 2.60/2.86 apply zenon_Hd1. apply refl_equal. % 2.60/2.86 apply zenon_H46. apply refl_equal. % 2.60/2.86 apply zenon_Hd1. apply refl_equal. % 2.60/2.86 apply zenon_Hd1. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L103_ *) % 2.60/2.86 assert (zenon_L104_ : ((op (e1) (e3)) = (e0)) -> ((op (e3) (e1)) = (e2)) -> ((op (e1) (e1)) = (e3)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H67 zenon_H15d zenon_H2b. % 2.60/2.86 apply (zenon_notand_s _ _ ax9); [ zenon_intro zenon_Hd7 | zenon_intro zenon_H162 ]. % 2.60/2.86 elim (classic ((op (e1) (op (e1) (e1))) = (op (e1) (op (e1) (e1))))); [ zenon_intro zenon_Hd8 | zenon_intro zenon_Hd9 ]. % 2.60/2.86 cut (((op (e1) (op (e1) (e1))) = (op (e1) (op (e1) (e1)))) = ((e0) = (op (e1) (op (e1) (e1))))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hd7. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hd8. % 2.60/2.86 cut (((op (e1) (op (e1) (e1))) = (op (e1) (op (e1) (e1))))); [idtac | apply NNPP; zenon_intro zenon_Hd9]. % 2.60/2.86 cut (((op (e1) (op (e1) (e1))) = (e0))); [idtac | apply NNPP; zenon_intro zenon_Hda]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e1) (e3)) = (e0)) = ((op (e1) (op (e1) (e1))) = (e0))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hda. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H67. % 2.60/2.86 cut (((e0) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H6d]. % 2.60/2.86 cut (((op (e1) (e3)) = (op (e1) (op (e1) (e1))))); [idtac | apply NNPP; zenon_intro zenon_H163]. % 2.60/2.86 congruence. % 2.60/2.86 elim (classic ((op (e1) (op (e1) (e1))) = (op (e1) (op (e1) (e1))))); [ zenon_intro zenon_Hd8 | zenon_intro zenon_Hd9 ]. % 2.60/2.86 cut (((op (e1) (op (e1) (e1))) = (op (e1) (op (e1) (e1)))) = ((op (e1) (e3)) = (op (e1) (op (e1) (e1))))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H163. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hd8. % 2.60/2.86 cut (((op (e1) (op (e1) (e1))) = (op (e1) (op (e1) (e1))))); [idtac | apply NNPP; zenon_intro zenon_Hd9]. % 2.60/2.86 cut (((op (e1) (op (e1) (e1))) = (op (e1) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H164]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e1) (e1)) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 2.60/2.86 cut (((e1) = (e1))); [idtac | apply NNPP; zenon_intro zenon_H5b]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H5b. apply refl_equal. % 2.60/2.86 exact (zenon_H8c zenon_H2b). % 2.60/2.86 apply zenon_Hd9. apply refl_equal. % 2.60/2.86 apply zenon_Hd9. apply refl_equal. % 2.60/2.86 apply zenon_H6d. apply refl_equal. % 2.60/2.86 apply zenon_Hd9. apply refl_equal. % 2.60/2.86 apply zenon_Hd9. apply refl_equal. % 2.60/2.86 apply (zenon_notand_s _ _ zenon_H162); [ zenon_intro zenon_H15e | zenon_intro zenon_H165 ]. % 2.60/2.86 apply (zenon_L103_); trivial. % 2.60/2.86 apply zenon_H165. apply sym_equal. exact zenon_H2b. % 2.60/2.86 (* end of lemma zenon_L104_ *) % 2.60/2.86 assert (zenon_L105_ : (((op (e3) (e1)) = (e0))\/(((op (e3) (e1)) = (e1))\/(((op (e3) (e1)) = (e2))\/((op (e3) (e1)) = (e3))))) -> ((op (e0) (e1)) = (e0)) -> (~((op (e0) (e1)) = (op (e3) (e1)))) -> (~((op (e3) (e1)) = (op (e3) (e3)))) -> ((op (e3) (e3)) = (e1)) -> ((op (e1) (e1)) = (e3)) -> ((op (e1) (e3)) = (e0)) -> (~((op (e3) (e1)) = (e3))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H166 zenon_H35 zenon_H15a zenon_Hc9 zenon_Hec zenon_H2b zenon_H67 zenon_He9. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H166); [ zenon_intro zenon_Hc8 | zenon_intro zenon_H167 ]. % 2.60/2.86 apply (zenon_L101_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H167); [ zenon_intro zenon_He7 | zenon_intro zenon_H168 ]. % 2.60/2.86 apply (zenon_L102_); trivial. % 2.60/2.86 apply (zenon_or_s _ _ zenon_H168); [ zenon_intro zenon_H15d | zenon_intro zenon_He8 ]. % 2.60/2.86 apply (zenon_L104_); trivial. % 2.60/2.86 exact (zenon_He9 zenon_He8). % 2.60/2.86 (* end of lemma zenon_L105_ *) % 2.60/2.86 assert (zenon_L106_ : (~((op (e2) (e2)) = (op (e2) (e3)))) -> ((op (e2) (e2)) = (e0)) -> ((op (e2) (e3)) = (e0)) -> False). % 2.60/2.86 do 0 intro. intros zenon_H13e zenon_Hde zenon_H76. % 2.60/2.86 cut (((op (e2) (e2)) = (e0)) = ((op (e2) (e2)) = (op (e2) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H13e. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hde. % 2.60/2.86 cut (((e0) = (op (e2) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 apply zenon_H102. apply sym_equal. exact zenon_H76. % 2.60/2.86 (* end of lemma zenon_L106_ *) % 2.60/2.86 assert (zenon_L107_ : ((op (e2) (e2)) = (e0)) -> ((op (e2) (e1)) = (e0)) -> (~((op (e2) (e1)) = (op (e2) (e2)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hde zenon_Ha9 zenon_Had. % 2.60/2.86 elim (classic ((op (e2) (e2)) = (op (e2) (e2)))); [ zenon_intro zenon_H3f | zenon_intro zenon_H40 ]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2))) = ((op (e2) (e1)) = (op (e2) (e2)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Had. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H3f. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Hae]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e2) (e2)) = (e0)) = ((op (e2) (e2)) = (op (e2) (e1)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_Hae. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hde. % 2.60/2.86 cut (((e0) = (op (e2) (e1)))); [idtac | apply NNPP; zenon_intro zenon_Haa]. % 2.60/2.86 cut (((op (e2) (e2)) = (op (e2) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H40]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 apply zenon_Haa. apply sym_equal. exact zenon_Ha9. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 apply zenon_H40. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L107_ *) % 2.60/2.86 assert (zenon_L108_ : ((op (e1) (e3)) = (e2)) -> ((op (e3) (e3)) = (e1)) -> (~((e2) = (op (op (e3) (e3)) (e3)))) -> False). % 2.60/2.86 do 0 intro. intros zenon_H146 zenon_Hec zenon_H169. % 2.60/2.86 elim (classic ((op (op (e3) (e3)) (e3)) = (op (op (e3) (e3)) (e3)))); [ zenon_intro zenon_H131 | zenon_intro zenon_H132 ]. % 2.60/2.86 cut (((op (op (e3) (e3)) (e3)) = (op (op (e3) (e3)) (e3))) = ((e2) = (op (op (e3) (e3)) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H169. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H131. % 2.60/2.86 cut (((op (op (e3) (e3)) (e3)) = (op (op (e3) (e3)) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 2.60/2.86 cut (((op (op (e3) (e3)) (e3)) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H16a]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e1) (e3)) = (e2)) = ((op (op (e3) (e3)) (e3)) = (e2))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H16a. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H146. % 2.60/2.86 cut (((e2) = (e2))); [idtac | apply NNPP; zenon_intro zenon_H46]. % 2.60/2.86 cut (((op (e1) (e3)) = (op (op (e3) (e3)) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 2.60/2.86 congruence. % 2.60/2.86 elim (classic ((op (op (e3) (e3)) (e3)) = (op (op (e3) (e3)) (e3)))); [ zenon_intro zenon_H131 | zenon_intro zenon_H132 ]. % 2.60/2.86 cut (((op (op (e3) (e3)) (e3)) = (op (op (e3) (e3)) (e3))) = ((op (e1) (e3)) = (op (op (e3) (e3)) (e3)))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H16b. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H131. % 2.60/2.86 cut (((op (op (e3) (e3)) (e3)) = (op (op (e3) (e3)) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 2.60/2.86 cut (((op (op (e3) (e3)) (e3)) = (op (e1) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H16c]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((e3) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H1d]. % 2.60/2.86 cut (((op (e3) (e3)) = (e1))); [idtac | apply NNPP; zenon_intro zenon_Hed]. % 2.60/2.86 congruence. % 2.60/2.86 exact (zenon_Hed zenon_Hec). % 2.60/2.86 apply zenon_H1d. apply refl_equal. % 2.60/2.86 apply zenon_H132. apply refl_equal. % 2.60/2.86 apply zenon_H132. apply refl_equal. % 2.60/2.86 apply zenon_H46. apply refl_equal. % 2.60/2.86 apply zenon_H132. apply refl_equal. % 2.60/2.86 apply zenon_H132. apply refl_equal. % 2.60/2.86 (* end of lemma zenon_L108_ *) % 2.60/2.86 assert (zenon_L109_ : ((op (e3) (e1)) = (e0)) -> ((op (e1) (e3)) = (e2)) -> ((op (e3) (e3)) = (e1)) -> False). % 2.60/2.86 do 0 intro. intros zenon_Hc8 zenon_H146 zenon_Hec. % 2.60/2.86 apply (zenon_notand_s _ _ ax8); [ zenon_intro zenon_H137 | zenon_intro zenon_H16d ]. % 2.60/2.86 elim (classic ((op (e3) (op (e3) (e3))) = (op (e3) (op (e3) (e3))))); [ zenon_intro zenon_H138 | zenon_intro zenon_H139 ]. % 2.60/2.86 cut (((op (e3) (op (e3) (e3))) = (op (e3) (op (e3) (e3)))) = ((e0) = (op (e3) (op (e3) (e3))))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H137. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H138. % 2.60/2.86 cut (((op (e3) (op (e3) (e3))) = (op (e3) (op (e3) (e3))))); [idtac | apply NNPP; zenon_intro zenon_H139]. % 2.60/2.86 cut (((op (e3) (op (e3) (e3))) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H13a]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e3) (e1)) = (e0)) = ((op (e3) (op (e3) (e3))) = (e0))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H13a. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_Hc8. % 2.60/2.86 cut (((e0) = (e0))); [idtac | apply NNPP; zenon_intro zenon_H6d]. % 2.60/2.86 cut (((op (e3) (e1)) = (op (e3) (op (e3) (e3))))); [idtac | apply NNPP; zenon_intro zenon_H16e]. % 2.60/2.86 congruence. % 2.60/2.86 elim (classic ((op (e3) (op (e3) (e3))) = (op (e3) (op (e3) (e3))))); [ zenon_intro zenon_H138 | zenon_intro zenon_H139 ]. % 2.60/2.86 cut (((op (e3) (op (e3) (e3))) = (op (e3) (op (e3) (e3)))) = ((op (e3) (e1)) = (op (e3) (op (e3) (e3))))). % 2.60/2.86 intro zenon_D_pnotp. % 2.60/2.86 apply zenon_H16e. % 2.60/2.86 rewrite <- zenon_D_pnotp. % 2.60/2.86 exact zenon_H138. % 2.60/2.86 cut (((op (e3) (op (e3) (e3))) = (op (e3) (op (e3) (e3))))); [idtac | apply NNPP; zenon_intro zenon_H139]. % 2.60/2.86 cut (((op (e3) (op (e3) (e3))) = (op (e3) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H16f]. % 2.60/2.86 congruence. % 2.60/2.86 cut (((op (e3) (e3)) = (e1))); [idtac | apply NNPP; zenon_intro zenon_Hed]. % 2.60/2.86 cut (((e3) = (e3))); [idtac | apply NNPP; zenon_intro zenon_H1d]. % 2.60/2.86 congruence. % 2.60/2.86 apply zenon_H1d. apply refl_equal. % 2.60/2.86 exact (zenon_Hed zenon_Hec). % 2.60/2.86 apply zenon_H139. apply refl_equal. % 2.60/2.86 apply zenon_H139. apply refl_equal. % 2.60/2.86 apply zenon_H6d. apply refl_equal. % 2.60/2.86 apply zenon_H139. apply refl_equal. % 2.60/2.86 apply zenon_H139. apply refl_equal. % 2.60/2.86 apply (zenon_notand_s _ _ zenon_H16d); [ zenon_intro zenon_H169 | zenon_intro zenon_H170 ]. % 2.60/2.86 apply (zenon_L108_); trivial. % 2.60/2.86 apply zenon_H170. apply sym_equal. exact zenon_Hec. % 2.60/2.86 (* end of lemma zenon_L109_ *) % 2.60/2.86 assert (zenon_L110_ : (((op (e0) (e1)) = (e0))\/(((op (e1) (e1)) = (e0))\/(((op (e2) (e1)) = (e0))\/((op (e3) (e1)) = (e0))))) -> (~((op (e0) (e1)) = (op (e0) (e3)))) -> (~((e0) = (e3))) -> (~((op (e2) (e1)) = (op (e2) (e2)))) -> ((op (e2) (e2)) = (e0)) -> (((op (e1) (e3)) = (e0))\/(((op (e1) (e3)) = (e1))\/(((op (e1) (e3)) = (e2))\/((op (e1) (e3)) = (e3))))) -> ((op (e0) (e3)) = (e0)) -> (~((op (e0) (e3)) = (op (e1) (e3)))) -> (~((op (e1) (e3)) = (e1))) -> ((op (e3) (e3)) = (e1)) -> (~((op (e1) (e1)) = (op (e1) (e3)))) -> ((op (e1) (e1)) = (e3)) -> False). % 2.71/2.86 do 0 intro. intros zenon_Hcc zenon_H158 zenon_H5a zenon_Had zenon_Hde zenon_H14c zenon_H5f zenon_H145 zenon_H38 zenon_Hec zenon_H66 zenon_H2b. % 2.71/2.86 apply (zenon_or_s _ _ zenon_Hcc); [ zenon_intro zenon_H35 | zenon_intro zenon_Hcd ]. % 2.71/2.86 apply (zenon_L100_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_Hcd); [ zenon_intro zenon_H49 | zenon_intro zenon_Hce ]. % 2.71/2.86 apply (zenon_L18_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_Hce); [ zenon_intro zenon_Ha9 | zenon_intro zenon_Hc8 ]. % 2.71/2.86 apply (zenon_L107_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H14c); [ zenon_intro zenon_H67 | zenon_intro zenon_H14d ]. % 2.71/2.86 apply (zenon_L85_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H14d); [ zenon_intro zenon_H103 | zenon_intro zenon_H14e ]. % 2.71/2.86 exact (zenon_H38 zenon_H103). % 2.71/2.86 apply (zenon_or_s _ _ zenon_H14e); [ zenon_intro zenon_H146 | zenon_intro zenon_H104 ]. % 2.71/2.86 apply (zenon_L109_); trivial. % 2.71/2.86 apply (zenon_L87_); trivial. % 2.71/2.86 (* end of lemma zenon_L110_ *) % 2.71/2.86 assert (zenon_L111_ : (~((op (e1) (e3)) = (op (e3) (e3)))) -> (~((e2) = (e3))) -> (~((e0) = (e2))) -> (((op (e0) (e3)) = (e0))\/(((op (e1) (e3)) = (e0))\/(((op (e2) (e3)) = (e0))\/((op (e3) (e3)) = (e0))))) -> (~((op (e0) (e3)) = (op (e3) (e3)))) -> (((op (e0) (e0)) = (e0))\/(((op (e0) (e1)) = (e0))\/(((op (e0) (e2)) = (e0))\/((op (e0) (e3)) = (e0))))) -> (~((op (e0) (e0)) = (op (e0) (e1)))) -> (~((op (e0) (e1)) = (op (e1) (e1)))) -> (((op (e0) (e1)) = (e0))\/(((op (e0) (e1)) = (e1))\/(((op (e0) (e1)) = (e2))\/((op (e0) (e1)) = (e3))))) -> (~((e0) = (e1))) -> (((op (e1) (e2)) = (e0))\/(((op (e1) (e2)) = (e1))\/(((op (e1) (e2)) = (e2))\/((op (e1) (e2)) = (e3))))) -> (~((op (e1) (e2)) = (op (e2) (e2)))) -> (~((op (e1) (e1)) = (op (e1) (e2)))) -> (~((op (e0) (e2)) = (op (e1) (e2)))) -> ((((op (e0) (e0)) = (e3))/\(~((op (e0) (e3)) = (e0))))\/((((op (e1) (e1)) = (e3))/\(~((op (e1) (e3)) = (e1))))\/((((op (e2) (e2)) = (e3))/\(~((op (e2) (e3)) = (e2))))\/(((op (e3) (e3)) = (e3))/\(~((op (e3) (e3)) = (e3))))))) -> ((((op (e0) (e0)) = (e2))/\(~((op (e0) (e2)) = (e0))))\/((((op (e1) (e1)) = (e2))/\(~((op (e1) (e2)) = (e1))))\/((((op (e2) (e2)) = (e2))/\(~((op (e2) (e2)) = (e2))))\/(((op (e3) (e3)) = (e2))/\(~((op (e3) (e2)) = (e3))))))) -> (((op (e1) (e0)) = (e1))\/(((op (e1) (e1)) = (e1))\/(((op (e1) (e2)) = (e1))\/((op (e1) (e3)) = (e1))))) -> (~((e1) = (e3))) -> (((op (e2) (e1)) = (e0))\/(((op (e2) (e1)) = (e1))\/(((op (e2) (e1)) = (e2))\/((op (e2) (e1)) = (e3))))) -> (~((op (e1) (e1)) = (op (e2) (e1)))) -> (~((op (e2) (e1)) = (op (e2) (e2)))) -> (~((op (e2) (e0)) = (op (e2) (e1)))) -> (~((op (e3) (e0)) = (op (e3) (e3)))) -> (((op (e0) (e0)) = (e0))\/(((op (e1) (e0)) = (e0))\/(((op (e2) (e0)) = (e0))\/((op (e3) (e0)) = (e0))))) -> (~((e0) = (e3))) -> (~((op (e0) (e0)) = (op (e1) (e0)))) -> (((op (e2) (e0)) = (e0))\/(((op (e2) (e1)) = (e0))\/(((op (e2) (e2)) = (e0))\/((op (e2) (e3)) = (e0))))) -> (~((op (e2) (e3)) = (op (e3) (e3)))) -> (~((op (e1) (e0)) = (op (e1) (e1)))) -> (((op (e0) (e1)) = (e3))\/(((op (e1) (e1)) = (e3))\/(((op (e2) (e1)) = (e3))\/((op (e3) (e1)) = (e3))))) -> (~((op (e2) (e2)) = (op (e3) (e2)))) -> (((op (e3) (e0)) = (e1))\/(((op (e3) (e1)) = (e1))\/(((op (e3) (e2)) = (e1))\/((op (e3) (e3)) = (e1))))) -> (((op (e0) (e1)) = (e0))\/(((op (e1) (e1)) = (e0))\/(((op (e2) (e1)) = (e0))\/((op (e3) (e1)) = (e0))))) -> (~((op (e0) (e1)) = (op (e0) (e2)))) -> (~((op (e3) (e2)) = (op (e3) (e3)))) -> (((op (e0) (e2)) = (e0))\/(((op (e1) (e2)) = (e0))\/(((op (e2) (e2)) = (e0))\/((op (e3) (e2)) = (e0))))) -> (((op (e0) (e0)) = (e2))\/(((op (e1) (e0)) = (e2))\/(((op (e2) (e0)) = (e2))\/((op (e3) (e0)) = (e2))))) -> (((op (e1) (e0)) = (e3))\/(((op (e1) (e1)) = (e3))\/(((op (e1) (e2)) = (e3))\/((op (e1) (e3)) = (e3))))) -> (~((e1) = (e2))) -> ((((op (e0) (e0)) = (e1))/\(~((op (e0) (e1)) = (e0))))\/((((op (e1) (e1)) = (e1))/\(~((op (e1) (e1)) = (e1))))\/((((op (e2) (e2)) = (e1))/\(~((op (e2) (e1)) = (e2))))\/(((op (e3) (e3)) = (e1))/\(~((op (e3) (e1)) = (e3))))))) -> ((op (e2) (e2)) = (e0)) -> (~((op (e2) (e2)) = (op (e2) (e3)))) -> (~((op (e0) (e1)) = (op (e3) (e1)))) -> (~((op (e3) (e1)) = (op (e3) (e3)))) -> (((op (e3) (e1)) = (e0))\/(((op (e3) (e1)) = (e1))\/(((op (e3) (e1)) = (e2))\/((op (e3) (e1)) = (e3))))) -> (~((op (e0) (e1)) = (op (e0) (e3)))) -> (~((op (e0) (e3)) = (op (e1) (e3)))) -> (~((op (e1) (e1)) = (op (e1) (e3)))) -> (((op (e1) (e3)) = (e0))\/(((op (e1) (e3)) = (e1))\/(((op (e1) (e3)) = (e2))\/((op (e1) (e3)) = (e3))))) -> (~((op (e1) (e1)) = (op (e3) (e1)))) -> (~((op (e0) (e2)) = (op (e2) (e2)))) -> False). % 2.71/2.86 do 0 intro. intros zenon_H147 zenon_H1e zenon_H47 zenon_H171 zenon_H52 zenon_H108 zenon_H24 zenon_H2d zenon_H32 zenon_H5c zenon_H107 zenon_H94 zenon_H90 zenon_H8d zenon_H10c zenon_H109 zenon_H10f zenon_Ha3 zenon_H10e zenon_Hb0 zenon_Had zenon_Ha7 zenon_Hb4 zenon_H10d zenon_H5a zenon_Hbb zenon_H10b zenon_H100 zenon_Hbf zenon_Hf2 zenon_Hea zenon_Hee zenon_Hcc zenon_Hc4 zenon_H80 zenon_He0 zenon_Hf1 zenon_H10a zenon_Hba zenon_H106 zenon_Hde zenon_H13e zenon_H15a zenon_Hc9 zenon_H166 zenon_H158 zenon_H145 zenon_H66 zenon_H14c zenon_H172 zenon_H3e. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H106); [ zenon_intro zenon_H111 | zenon_intro zenon_H110 ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H111). zenon_intro zenon_H25. zenon_intro zenon_H33. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H109); [ zenon_intro zenon_H113 | zenon_intro zenon_H112 ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H113). zenon_intro zenon_H20. zenon_intro zenon_H114. % 2.71/2.86 apply (zenon_L99_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H112); [ zenon_intro zenon_H4b | zenon_intro zenon_H117 ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H4b). zenon_intro zenon_H48. zenon_intro zenon_H4c. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H10c); [ zenon_intro zenon_H22 | zenon_intro zenon_H118 ]. % 2.71/2.86 apply (zenon_L34_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H118); [ zenon_intro zenon_H37 | zenon_intro zenon_H119 ]. % 2.71/2.86 apply (zenon_L36_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H119); [ zenon_intro zenon_Hb8 | zenon_intro zenon_H43 ]. % 2.71/2.86 apply (zenon_L88_); trivial. % 2.71/2.86 apply (zenon_L11_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H117); [ zenon_intro zenon_H4d | zenon_intro zenon_H9a ]. % 2.71/2.86 apply (zenon_L15_); trivial. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H9a). zenon_intro zenon_H50. zenon_intro zenon_H84. % 2.71/2.86 apply (zenon_L89_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H110); [ zenon_intro zenon_H9b | zenon_intro zenon_H11c ]. % 2.71/2.86 apply (zenon_L42_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H11c); [ zenon_intro zenon_H11e | zenon_intro zenon_H11d ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H11e). zenon_intro zenon_Ha4. zenon_intro zenon_H11f. % 2.71/2.86 apply (zenon_L62_); trivial. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H11d). zenon_intro zenon_Hec. zenon_intro zenon_He9. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H109); [ zenon_intro zenon_H113 | zenon_intro zenon_H112 ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H113). zenon_intro zenon_H20. zenon_intro zenon_H114. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H10c); [ zenon_intro zenon_H22 | zenon_intro zenon_H118 ]. % 2.71/2.86 apply (zenon_L3_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H118); [ zenon_intro zenon_H37 | zenon_intro zenon_H119 ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H37). zenon_intro zenon_H2b. zenon_intro zenon_H38. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H108); [ zenon_intro zenon_H5d | zenon_intro zenon_H115 ]. % 2.71/2.86 apply (zenon_L30_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H115); [ zenon_intro zenon_H35 | zenon_intro zenon_H116 ]. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H171); [ zenon_intro zenon_H5f | zenon_intro zenon_H173 ]. % 2.71/2.86 apply (zenon_L100_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H173); [ zenon_intro zenon_H67 | zenon_intro zenon_H174 ]. % 2.71/2.86 apply (zenon_L105_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H174); [ zenon_intro zenon_H76 | zenon_intro zenon_H88 ]. % 2.71/2.86 apply (zenon_L106_); trivial. % 2.71/2.86 apply (zenon_L75_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H116); [ zenon_intro zenon_H60 | zenon_intro zenon_H5f ]. % 2.71/2.86 exact (zenon_H114 zenon_H60). % 2.71/2.86 apply (zenon_L110_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H119); [ zenon_intro zenon_Hb8 | zenon_intro zenon_H43 ]. % 2.71/2.86 apply (zenon_L88_); trivial. % 2.71/2.86 apply (zenon_L11_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H112); [ zenon_intro zenon_H4b | zenon_intro zenon_H117 ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H4b). zenon_intro zenon_H48. zenon_intro zenon_H4c. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H10c); [ zenon_intro zenon_H22 | zenon_intro zenon_H118 ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H22). zenon_intro zenon_H1f. zenon_intro zenon_H23. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H108); [ zenon_intro zenon_H5d | zenon_intro zenon_H115 ]. % 2.71/2.86 apply (zenon_L52_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H115); [ zenon_intro zenon_H35 | zenon_intro zenon_H116 ]. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H166); [ zenon_intro zenon_Hc8 | zenon_intro zenon_H167 ]. % 2.71/2.86 apply (zenon_L101_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H167); [ zenon_intro zenon_He7 | zenon_intro zenon_H168 ]. % 2.71/2.86 apply (zenon_L102_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H168); [ zenon_intro zenon_H15d | zenon_intro zenon_He8 ]. % 2.71/2.86 cut (((op (e1) (e1)) = (e2)) = ((op (e1) (e1)) = (op (e3) (e1)))). % 2.71/2.86 intro zenon_D_pnotp. % 2.71/2.86 apply zenon_H172. % 2.71/2.86 rewrite <- zenon_D_pnotp. % 2.71/2.86 exact zenon_H48. % 2.71/2.86 cut (((e2) = (op (e3) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H175]. % 2.71/2.86 cut (((op (e1) (e1)) = (op (e1) (e1)))); [idtac | apply NNPP; zenon_intro zenon_H2f]. % 2.71/2.86 congruence. % 2.71/2.86 apply zenon_H2f. apply refl_equal. % 2.71/2.86 apply zenon_H175. apply sym_equal. exact zenon_H15d. % 2.71/2.86 exact (zenon_He9 zenon_He8). % 2.71/2.86 apply (zenon_or_s _ _ zenon_H116); [ zenon_intro zenon_H60 | zenon_intro zenon_H5f ]. % 2.71/2.86 apply (zenon_L84_); trivial. % 2.71/2.86 exact (zenon_H23 zenon_H5f). % 2.71/2.86 apply (zenon_or_s _ _ zenon_H118); [ zenon_intro zenon_H37 | zenon_intro zenon_H119 ]. % 2.71/2.86 apply (zenon_L36_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H119); [ zenon_intro zenon_Hb8 | zenon_intro zenon_H43 ]. % 2.71/2.86 apply (zenon_L88_); trivial. % 2.71/2.86 apply (zenon_L11_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H117); [ zenon_intro zenon_H4d | zenon_intro zenon_H9a ]. % 2.71/2.86 apply (zenon_L15_); trivial. % 2.71/2.86 apply (zenon_L97_); trivial. % 2.71/2.86 (* end of lemma zenon_L111_ *) % 2.71/2.86 apply (zenon_and_s _ _ ax1). zenon_intro zenon_H177. zenon_intro zenon_H176. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H176). zenon_intro zenon_H32. zenon_intro zenon_H178. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H178). zenon_intro zenon_H155. zenon_intro zenon_H179. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H179). zenon_intro zenon_H151. zenon_intro zenon_H17a. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H17a). zenon_intro zenon_H17c. zenon_intro zenon_H17b. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H17b). zenon_intro zenon_H17e. zenon_intro zenon_H17d. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H17d). zenon_intro zenon_H107. zenon_intro zenon_H17f. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H17f). zenon_intro zenon_H14c. zenon_intro zenon_H180. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H180). zenon_intro zenon_H182. zenon_intro zenon_H181. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H181). zenon_intro zenon_H10e. zenon_intro zenon_H183. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H183). zenon_intro zenon_H185. zenon_intro zenon_H184. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H184). zenon_intro zenon_H141. zenon_intro zenon_H186. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H186). zenon_intro zenon_H188. zenon_intro zenon_H187. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H187). zenon_intro zenon_H166. zenon_intro zenon_H189. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H189). zenon_intro zenon_H83. zenon_intro zenon_H18a. % 2.71/2.86 apply (zenon_and_s _ _ ax2). zenon_intro zenon_H108. zenon_intro zenon_H18b. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H18b). zenon_intro zenon_H10d. zenon_intro zenon_H18c. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H18c). zenon_intro zenon_H18e. zenon_intro zenon_H18d. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H18d). zenon_intro zenon_H190. zenon_intro zenon_H18f. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H18f). zenon_intro zenon_H192. zenon_intro zenon_H191. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H191). zenon_intro zenon_Hf1. zenon_intro zenon_H193. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H193). zenon_intro zenon_H195. zenon_intro zenon_H194. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H194). zenon_intro zenon_H197. zenon_intro zenon_H196. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H196). zenon_intro zenon_H199. zenon_intro zenon_H198. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H198). zenon_intro zenon_Hcc. zenon_intro zenon_H19a. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H19a). zenon_intro zenon_H10f. zenon_intro zenon_H19b. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H19b). zenon_intro zenon_H19d. zenon_intro zenon_H19c. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H19c). zenon_intro zenon_H19f. zenon_intro zenon_H19e. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H19e). zenon_intro zenon_H1a1. zenon_intro zenon_H1a0. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1a0). zenon_intro zenon_H10a. zenon_intro zenon_H1a2. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1a2). zenon_intro zenon_Hf2. zenon_intro zenon_H1a3. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1a3). zenon_intro zenon_H10b. zenon_intro zenon_H1a4. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1a4). zenon_intro zenon_He0. zenon_intro zenon_H1a5. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1a5). zenon_intro zenon_H1a7. zenon_intro zenon_H1a6. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1a6). zenon_intro zenon_H1a9. zenon_intro zenon_H1a8. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1a8). zenon_intro zenon_H1ab. zenon_intro zenon_H1aa. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1aa). zenon_intro zenon_H1ad. zenon_intro zenon_H1ac. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1ac). zenon_intro zenon_H1af. zenon_intro zenon_H1ae. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1ae). zenon_intro zenon_H1b1. zenon_intro zenon_H1b0. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1b0). zenon_intro zenon_H1b3. zenon_intro zenon_H1b2. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1b2). zenon_intro zenon_H171. zenon_intro zenon_H1b4. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1b4). zenon_intro zenon_Hee. zenon_intro zenon_H1b5. % 2.71/2.86 apply (zenon_and_s _ _ ax3). zenon_intro zenon_Hbb. zenon_intro zenon_H1b6. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1b6). zenon_intro zenon_H1b8. zenon_intro zenon_H1b7. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1b7). zenon_intro zenon_H1ba. zenon_intro zenon_H1b9. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1b9). zenon_intro zenon_H1bc. zenon_intro zenon_H1bb. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1bb). zenon_intro zenon_H1be. zenon_intro zenon_H1bd. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1bd). zenon_intro zenon_H1c0. zenon_intro zenon_H1bf. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1bf). zenon_intro zenon_H2d. zenon_intro zenon_H1c1. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1c1). zenon_intro zenon_H1c3. zenon_intro zenon_H1c2. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1c2). zenon_intro zenon_H15a. zenon_intro zenon_H1c4. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1c4). zenon_intro zenon_Hb0. zenon_intro zenon_H1c5. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1c5). zenon_intro zenon_H172. zenon_intro zenon_H1c6. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1c6). zenon_intro zenon_H1c8. zenon_intro zenon_H1c7. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1c7). zenon_intro zenon_H8d. zenon_intro zenon_H1c9. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1c9). zenon_intro zenon_H3e. zenon_intro zenon_H1ca. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1ca). zenon_intro zenon_H69. zenon_intro zenon_H1cb. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1cb). zenon_intro zenon_H94. zenon_intro zenon_H1cc. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1cc). zenon_intro zenon_H1ce. zenon_intro zenon_H1cd. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1cd). zenon_intro zenon_Hea. zenon_intro zenon_H1cf. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1cf). zenon_intro zenon_H145. zenon_intro zenon_H1d0. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1d0). zenon_intro zenon_H12e. zenon_intro zenon_H1d1. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1d1). zenon_intro zenon_H52. zenon_intro zenon_H1d2. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1d2). zenon_intro zenon_H1d4. zenon_intro zenon_H1d3. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1d3). zenon_intro zenon_H147. zenon_intro zenon_H1d5. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1d5). zenon_intro zenon_H100. zenon_intro zenon_H1d6. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1d6). zenon_intro zenon_H24. zenon_intro zenon_H1d7. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1d7). zenon_intro zenon_H39. zenon_intro zenon_H1d8. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1d8). zenon_intro zenon_H57. zenon_intro zenon_H1d9. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1d9). zenon_intro zenon_Hc4. zenon_intro zenon_H1da. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1da). zenon_intro zenon_H158. zenon_intro zenon_H1db. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1db). zenon_intro zenon_H61. zenon_intro zenon_H1dc. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1dc). zenon_intro zenon_Hbf. zenon_intro zenon_H1dd. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1dd). zenon_intro zenon_H1df. zenon_intro zenon_H1de. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1de). zenon_intro zenon_H1e1. zenon_intro zenon_H1e0. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1e0). zenon_intro zenon_H90. zenon_intro zenon_H1e2. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1e2). zenon_intro zenon_H66. zenon_intro zenon_H1e3. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1e3). zenon_intro zenon_H1e5. zenon_intro zenon_H1e4. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1e4). zenon_intro zenon_Ha7. zenon_intro zenon_H1e6. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1e6). zenon_intro zenon_H12b. zenon_intro zenon_H1e7. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1e7). zenon_intro zenon_H1e9. zenon_intro zenon_H1e8. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1e8). zenon_intro zenon_Had. zenon_intro zenon_H1ea. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1ea). zenon_intro zenon_H1ec. zenon_intro zenon_H1eb. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1eb). zenon_intro zenon_H13e. zenon_intro zenon_H1ed. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1ed). zenon_intro zenon_H1ef. zenon_intro zenon_H1ee. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1ee). zenon_intro zenon_H1f1. zenon_intro zenon_H1f0. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1f0). zenon_intro zenon_Hb4. zenon_intro zenon_H1f2. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1f2). zenon_intro zenon_H1f4. zenon_intro zenon_H1f3. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1f3). zenon_intro zenon_Hc9. zenon_intro zenon_H80. % 2.71/2.86 apply (zenon_and_s _ _ ax4). zenon_intro zenon_H5c. zenon_intro zenon_H1f5. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1f5). zenon_intro zenon_H47. zenon_intro zenon_H1f6. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1f6). zenon_intro zenon_H5a. zenon_intro zenon_H1f7. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1f7). zenon_intro zenon_Hba. zenon_intro zenon_H1f8. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1f8). zenon_intro zenon_Ha3. zenon_intro zenon_H1e. % 2.71/2.86 apply (zenon_and_s _ _ ax5). zenon_intro zenon_H1fa. zenon_intro zenon_H1f9. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1f9). zenon_intro zenon_H106. zenon_intro zenon_H1fb. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1fb). zenon_intro zenon_H109. zenon_intro zenon_H10c. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H1fa); [ zenon_intro zenon_H1fd | zenon_intro zenon_H1fc ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1fd). zenon_intro zenon_H5d. zenon_intro zenon_H5e. % 2.71/2.86 exact (zenon_H5e zenon_H5d). % 2.71/2.86 apply (zenon_or_s _ _ zenon_H1fc); [ zenon_intro zenon_H1ff | zenon_intro zenon_H1fe ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H1ff). zenon_intro zenon_H49. zenon_intro zenon_Ha2. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H106); [ zenon_intro zenon_H111 | zenon_intro zenon_H110 ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H111). zenon_intro zenon_H25. zenon_intro zenon_H33. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H109); [ zenon_intro zenon_H113 | zenon_intro zenon_H112 ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H113). zenon_intro zenon_H20. zenon_intro zenon_H114. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H10c); [ zenon_intro zenon_H22 | zenon_intro zenon_H118 ]. % 2.71/2.86 apply (zenon_L3_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H118); [ zenon_intro zenon_H37 | zenon_intro zenon_H119 ]. % 2.71/2.86 apply (zenon_L8_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H119); [ zenon_intro zenon_Hb8 | zenon_intro zenon_H43 ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_Hb8). zenon_intro zenon_H3c. zenon_intro zenon_Hb9. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H155); [ zenon_intro zenon_H60 | zenon_intro zenon_H156 ]. % 2.71/2.86 exact (zenon_H114 zenon_H60). % 2.71/2.86 apply (zenon_or_s _ _ zenon_H156); [ zenon_intro zenon_H154 | zenon_intro zenon_H157 ]. % 2.71/2.86 cut (((op (e0) (e0)) = (e1)) = ((op (e0) (e0)) = (op (e0) (e2)))). % 2.71/2.86 intro zenon_D_pnotp. % 2.71/2.86 apply zenon_H39. % 2.71/2.86 rewrite <- zenon_D_pnotp. % 2.71/2.86 exact zenon_H25. % 2.71/2.86 cut (((e1) = (op (e0) (e2)))); [idtac | apply NNPP; zenon_intro zenon_H200]. % 2.71/2.86 cut (((op (e0) (e0)) = (op (e0) (e0)))); [idtac | apply NNPP; zenon_intro zenon_H28]. % 2.71/2.86 congruence. % 2.71/2.86 apply zenon_H28. apply refl_equal. % 2.71/2.86 apply zenon_H200. apply sym_equal. exact zenon_H154. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H157); [ zenon_intro zenon_H3a | zenon_intro zenon_H3d ]. % 2.71/2.86 apply (zenon_L9_); trivial. % 2.71/2.86 apply (zenon_L10_); trivial. % 2.71/2.86 apply (zenon_L11_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H112); [ zenon_intro zenon_H4b | zenon_intro zenon_H117 ]. % 2.71/2.86 apply (zenon_L14_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H117); [ zenon_intro zenon_H4d | zenon_intro zenon_H9a ]. % 2.71/2.86 apply (zenon_L15_); trivial. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H9a). zenon_intro zenon_H50. zenon_intro zenon_H84. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H10c); [ zenon_intro zenon_H22 | zenon_intro zenon_H118 ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H22). zenon_intro zenon_H1f. zenon_intro zenon_H23. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H151); [ zenon_intro zenon_H5f | zenon_intro zenon_H152 ]. % 2.71/2.86 exact (zenon_H23 zenon_H5f). % 2.71/2.86 apply (zenon_or_s _ _ zenon_H152); [ zenon_intro zenon_H14f | zenon_intro zenon_H153 ]. % 2.71/2.86 cut (((op (e0) (e0)) = (e1)) = ((op (e0) (e0)) = (op (e0) (e3)))). % 2.71/2.86 intro zenon_D_pnotp. % 2.71/2.86 apply zenon_H57. % 2.71/2.86 rewrite <- zenon_D_pnotp. % 2.71/2.86 exact zenon_H25. % 2.71/2.86 cut (((e1) = (op (e0) (e3)))); [idtac | apply NNPP; zenon_intro zenon_H201]. % 2.71/2.86 cut (((op (e0) (e0)) = (op (e0) (e0)))); [idtac | apply NNPP; zenon_intro zenon_H28]. % 2.71/2.86 congruence. % 2.71/2.86 apply zenon_H28. apply refl_equal. % 2.71/2.86 apply zenon_H201. apply sym_equal. exact zenon_H14f. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H153); [ zenon_intro zenon_H51 | zenon_intro zenon_H58 ]. % 2.71/2.86 apply (zenon_L16_); trivial. % 2.71/2.86 apply (zenon_L17_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H118); [ zenon_intro zenon_H37 | zenon_intro zenon_H119 ]. % 2.71/2.86 apply (zenon_L19_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H119); [ zenon_intro zenon_Hb8 | zenon_intro zenon_H43 ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_Hb8). zenon_intro zenon_H3c. zenon_intro zenon_Hb9. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H108); [ zenon_intro zenon_H5d | zenon_intro zenon_H115 ]. % 2.71/2.86 apply (zenon_L21_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H115); [ zenon_intro zenon_H35 | zenon_intro zenon_H116 ]. % 2.71/2.86 exact (zenon_H33 zenon_H35). % 2.71/2.86 apply (zenon_or_s _ _ zenon_H116); [ zenon_intro zenon_H60 | zenon_intro zenon_H5f ]. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H171); [ zenon_intro zenon_H5f | zenon_intro zenon_H173 ]. % 2.71/2.86 apply (zenon_L22_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H173); [ zenon_intro zenon_H67 | zenon_intro zenon_H174 ]. % 2.71/2.86 apply (zenon_L23_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H174); [ zenon_intro zenon_H76 | zenon_intro zenon_H88 ]. % 2.71/2.86 apply (zenon_L29_); trivial. % 2.71/2.86 apply (zenon_L75_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H10b); [ zenon_intro zenon_Ha8 | zenon_intro zenon_H129 ]. % 2.71/2.86 apply (zenon_L82_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H129); [ zenon_intro zenon_Ha9 | zenon_intro zenon_H12a ]. % 2.71/2.86 apply (zenon_L83_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H12a); [ zenon_intro zenon_Hde | zenon_intro zenon_H76 ]. % 2.71/2.86 apply (zenon_L89_); trivial. % 2.71/2.86 apply (zenon_L78_); trivial. % 2.71/2.86 apply (zenon_L11_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H110); [ zenon_intro zenon_H9b | zenon_intro zenon_H11c ]. % 2.71/2.86 apply (zenon_L42_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H11c); [ zenon_intro zenon_H11e | zenon_intro zenon_H11d ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H11e). zenon_intro zenon_Ha4. zenon_intro zenon_H11f. % 2.71/2.86 apply (zenon_L93_); trivial. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H11d). zenon_intro zenon_Hec. zenon_intro zenon_He9. % 2.71/2.86 apply (zenon_L98_); trivial. % 2.71/2.86 apply (zenon_or_s _ _ zenon_H1fe); [ zenon_intro zenon_H203 | zenon_intro zenon_H202 ]. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H203). zenon_intro zenon_Hde. zenon_intro zenon_Hc3. % 2.71/2.86 apply (zenon_L111_); trivial. % 2.71/2.86 apply (zenon_and_s _ _ zenon_H202). zenon_intro zenon_H88. zenon_intro zenon_H204. % 2.71/2.86 apply (zenon_L75_); trivial. % 2.71/2.86 Qed. % 2.71/2.86 % SZS output end Proof % 2.71/2.86 (* END-PROOF *) % 2.71/2.86 nodes searched: 73649 % 2.71/2.86 max branch formulas: 266 % 2.71/2.86 proof nodes created: 4324 % 2.71/2.86 formulas created: 26078 % 2.71/2.86 %------------------------------------------------------------------------------