%------------------------------------------------------------------------------ % File : Zenon---0.7.1 % Problem : SWV181+1 : TPTP v8.1.0. Bugfixed v3.3.0. % Transfm : none % Format : tptp:raw % Command : run_zenon %s %d % Computer : n021.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 : Wed Jul 20 23:03:13 EDT 2022 % Result : Theorem 119.80s 120.08s % Output : Proof 119.90s % Verified : % SZS Type : - % Comments : %------------------------------------------------------------------------------ %----WARNING: Could not form TPTP format derivation %------------------------------------------------------------------------------ %----ORIGINAL SYSTEM OUTPUT % 0.03/0.13 % Problem : SWV181+1 : TPTP v8.1.0. Bugfixed v3.3.0. % 0.03/0.13 % Command : run_zenon %s %d % 0.13/0.34 % Computer : n021.cluster.edu % 0.13/0.34 % Model : x86_64 x86_64 % 0.13/0.34 % CPU : Intel(R) Xeon(R) CPU E5-2620 v4 @ 2.10GHz % 0.13/0.34 % Memory : 8042.1875MB % 0.13/0.34 % OS : Linux 3.10.0-693.el7.x86_64 % 0.13/0.35 % CPULimit : 300 % 0.13/0.35 % WCLimit : 600 % 0.13/0.35 % DateTime : Wed Jun 15 07:56:29 EDT 2022 % 0.13/0.35 % CPUTime : % 119.80/120.08 (* PROOF-FOUND *) % 119.80/120.08 % SZS status Theorem % 119.80/120.08 (* BEGIN-PROOF *) % 119.80/120.08 % SZS output start Proof % 119.80/120.08 Theorem cl5_nebula_init_0081 : (((leq (tptp_float_0_001) (pv76))/\((leq (n1) (loopcounter))/\((gt (n1) (loopcounter))/\((forall A : zenon_U, (((leq (n0) A)/\(leq A (n135299)))->(forall B : zenon_U, (((leq (n0) B)/\(leq B (n4)))->((a_select3 (q_init) A B) = (init))))))/\((forall C : zenon_U, (((leq (n0) C)/\(leq C (n4)))->((a_select3 (center_init) C (n0)) = (init))))/\(((gt (loopcounter) (n0))->(forall D : zenon_U, (((leq (n0) D)/\(leq D (n4)))->((a_select2 (mu_init) D) = (init)))))/\(((gt (loopcounter) (n0))->(forall E : zenon_U, (((leq (n0) E)/\(leq E (n4)))->((a_select2 (rho_init) E) = (init)))))/\((gt (loopcounter) (n0))->(forall F : zenon_U, (((leq (n0) F)/\(leq F (n4)))->((a_select2 (sigma_init) F) = (init))))))))))))->(forall G : zenon_U, (((leq (n0) G)/\(leq G (n4)))->((a_select2 (muold_init) G) = (init))))). % 119.80/120.08 Proof. % 119.80/120.08 assert (zenon_L1_ : forall (zenon_TG_dq : zenon_U), (gt (succ zenon_TG_dq) (n0)) -> (~(leq (n0) zenon_TG_dq)) -> False). % 119.80/120.08 do 1 intro. intros zenon_H5c zenon_H5d. % 119.80/120.08 generalize (leq_succ_gt_equiv (n0)). zenon_intro zenon_H5f. % 119.80/120.08 generalize (zenon_H5f zenon_TG_dq). zenon_intro zenon_H60. % 119.80/120.08 apply (zenon_equiv_s _ _ zenon_H60); [ zenon_intro zenon_H5d; zenon_intro zenon_H62 | zenon_intro zenon_H61; zenon_intro zenon_H5c ]. % 119.80/120.08 exact (zenon_H62 zenon_H5c). % 119.80/120.08 exact (zenon_H5d zenon_H61). % 119.80/120.08 (* end of lemma zenon_L1_ *) % 119.80/120.08 assert (zenon_L2_ : (~((n2) = (n2))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H63. % 119.80/120.08 apply zenon_H63. apply refl_equal. % 119.80/120.08 (* end of lemma zenon_L2_ *) % 119.80/120.08 assert (zenon_L3_ : (~((n1) = (n1))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H64. % 119.80/120.08 apply zenon_H64. apply refl_equal. % 119.80/120.08 (* end of lemma zenon_L3_ *) % 119.80/120.08 assert (zenon_L4_ : (~((n0) = (n0))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H65. % 119.80/120.08 apply zenon_H65. apply refl_equal. % 119.80/120.08 (* end of lemma zenon_L4_ *) % 119.80/120.08 assert (zenon_L5_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (~(leq (n0) (loopcounter))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_H67 zenon_H68. % 119.80/120.08 generalize (leq_succ_gt_equiv (n0)). zenon_intro zenon_H5f. % 119.80/120.08 generalize (zenon_H5f (loopcounter)). zenon_intro zenon_H69. % 119.80/120.08 apply (zenon_equiv_s _ _ zenon_H69); [ zenon_intro zenon_H68; zenon_intro zenon_H6c | zenon_intro zenon_H6b; zenon_intro zenon_H6a ]. % 119.80/120.08 elim (classic ((~((succ (loopcounter)) = (n1)))/\(~(gt (succ (loopcounter)) (n1))))); [ zenon_intro zenon_H6d | zenon_intro zenon_H6e ]. % 119.80/120.08 apply (zenon_and_s _ _ zenon_H6d). zenon_intro zenon_H70. zenon_intro zenon_H6f. % 119.80/120.08 exact (zenon_H6f zenon_H67). % 119.80/120.08 cut ((gt (n1) (n0)) = (gt (succ (loopcounter)) (n0))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H6c. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact gt_1_0. % 119.80/120.08 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.08 cut (((n1) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H71]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_notand_s _ _ zenon_H6e); [ zenon_intro zenon_H73 | zenon_intro zenon_H72 ]. % 119.80/120.08 apply zenon_H73. zenon_intro zenon_H74. % 119.80/120.08 elim (classic ((succ (loopcounter)) = (succ (loopcounter)))); [ zenon_intro zenon_H75 | zenon_intro zenon_H76 ]. % 119.80/120.08 cut (((succ (loopcounter)) = (succ (loopcounter))) = ((n1) = (succ (loopcounter)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H71. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H75. % 119.80/120.08 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.80/120.08 cut (((succ (loopcounter)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H70]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H70 zenon_H74). % 119.80/120.08 apply zenon_H76. apply refl_equal. % 119.80/120.08 apply zenon_H76. apply refl_equal. % 119.80/120.08 apply zenon_H72. zenon_intro zenon_H67. % 119.80/120.08 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.80/120.08 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.80/120.08 generalize (zenon_H78 (n0)). zenon_intro zenon_H79. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H79); [ zenon_intro zenon_H6f | zenon_intro zenon_H7a ]. % 119.80/120.08 exact (zenon_H6f zenon_H67). % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H7a); [ zenon_intro zenon_H7b | zenon_intro zenon_H6a ]. % 119.80/120.08 exact (zenon_H7b gt_1_0). % 119.80/120.08 exact (zenon_H6c zenon_H6a). % 119.80/120.08 apply zenon_H65. apply refl_equal. % 119.80/120.08 exact (zenon_H68 zenon_H6b). % 119.80/120.08 (* end of lemma zenon_L5_ *) % 119.80/120.08 assert (zenon_L6_ : (~((loopcounter) = (loopcounter))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H7c. % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 (* end of lemma zenon_L6_ *) % 119.80/120.08 assert (zenon_L7_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (n1) (loopcounter)) -> (~(leq (loopcounter) (n0))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_H7d zenon_H7e. % 119.80/120.08 generalize (leq_succ_gt_equiv (loopcounter)). zenon_intro zenon_H7f. % 119.80/120.08 generalize (zenon_H7f (n0)). zenon_intro zenon_H80. % 119.80/120.08 apply (zenon_equiv_s _ _ zenon_H80); [ zenon_intro zenon_H7e; zenon_intro zenon_H83 | zenon_intro zenon_H82; zenon_intro zenon_H81 ]. % 119.80/120.08 elim (classic ((~((succ (n0)) = (n1)))/\(~(gt (succ (n0)) (n1))))); [ zenon_intro zenon_H84 | zenon_intro zenon_H85 ]. % 119.80/120.08 apply (zenon_and_s _ _ zenon_H84). zenon_intro zenon_H87. zenon_intro zenon_H86. % 119.80/120.08 exact (zenon_H87 successor_1). % 119.80/120.08 cut ((gt (n1) (loopcounter)) = (gt (succ (n0)) (loopcounter))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H83. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H7d. % 119.80/120.08 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.08 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_notand_s _ _ zenon_H85); [ zenon_intro zenon_H8a | zenon_intro zenon_H89 ]. % 119.80/120.08 apply zenon_H8a. zenon_intro successor_1. % 119.80/120.08 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.80/120.08 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H88. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H8b. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H87 successor_1). % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 apply zenon_H89. zenon_intro zenon_H8d. % 119.80/120.08 generalize (zenon_H66 (succ (n0))). zenon_intro zenon_H8e. % 119.80/120.08 generalize (zenon_H8e (n1)). zenon_intro zenon_H8f. % 119.80/120.08 generalize (zenon_H8f (loopcounter)). zenon_intro zenon_H90. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H90); [ zenon_intro zenon_H86 | zenon_intro zenon_H91 ]. % 119.80/120.08 exact (zenon_H86 zenon_H8d). % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H91); [ zenon_intro zenon_H92 | zenon_intro zenon_H81 ]. % 119.80/120.08 exact (zenon_H92 zenon_H7d). % 119.80/120.08 exact (zenon_H83 zenon_H81). % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 exact (zenon_H7e zenon_H82). % 119.80/120.08 (* end of lemma zenon_L7_ *) % 119.80/120.08 assert (zenon_L8_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((n0) = (loopcounter))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_H93. % 119.80/120.08 generalize (finite_domain_0 (loopcounter)). zenon_intro zenon_H94. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H94); [ zenon_intro zenon_H96 | zenon_intro zenon_H95 ]. % 119.80/120.08 apply (zenon_notand_s _ _ zenon_H96); [ zenon_intro zenon_H68 | zenon_intro zenon_H7e ]. % 119.80/120.08 apply (zenon_L5_); trivial. % 119.80/120.08 apply (zenon_L7_); trivial. % 119.80/120.08 apply zenon_H93. apply sym_equal. exact zenon_H95. % 119.80/120.08 (* end of lemma zenon_L8_ *) % 119.80/120.08 assert (zenon_L9_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~((succ (n0)) = (succ (loopcounter)))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_H97 zenon_H7d zenon_H67. % 119.80/120.08 cut (((n0) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H93]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_L8_); trivial. % 119.80/120.08 (* end of lemma zenon_L9_ *) % 119.80/120.08 assert (zenon_L10_ : (~((succ (n3)) = (succ (succ (succ (succ (n0))))))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H98. % 119.80/120.08 cut (((n3) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H99]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H99. apply sym_equal. exact successor_3. % 119.80/120.08 (* end of lemma zenon_L10_ *) % 119.80/120.08 assert (zenon_L11_ : (~(gt (succ (n3)) (n2))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H9a. % 119.80/120.08 elim (classic (gt (succ (succ (succ (succ (n0))))) (n2))); [ zenon_intro zenon_H9b | zenon_intro zenon_H9c ]. % 119.80/120.08 cut ((gt (succ (succ (succ (succ (n0))))) (n2)) = (gt (succ (n3)) (n2))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H9a. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H9b. % 119.80/120.08 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.80/120.08 cut (((succ (succ (succ (succ (n0))))) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H9d]. % 119.80/120.08 congruence. % 119.80/120.08 elim (classic ((succ (n3)) = (succ (n3)))); [ zenon_intro zenon_H9e | zenon_intro zenon_H9f ]. % 119.80/120.08 cut (((succ (n3)) = (succ (n3))) = ((succ (succ (succ (succ (n0))))) = (succ (n3)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H9d. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H9e. % 119.80/120.08 cut (((succ (n3)) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H9f]. % 119.80/120.08 cut (((succ (n3)) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_H98]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_L10_); trivial. % 119.80/120.08 apply zenon_H9f. apply refl_equal. % 119.80/120.08 apply zenon_H9f. apply refl_equal. % 119.80/120.08 apply zenon_H63. apply refl_equal. % 119.80/120.08 cut ((gt (n4) (n2)) = (gt (succ (succ (succ (succ (n0))))) (n2))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H9c. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact gt_4_2. % 119.80/120.08 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.80/120.08 cut (((n4) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_Ha0]. % 119.80/120.08 congruence. % 119.80/120.08 elim (classic ((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0))))))); [ zenon_intro zenon_Ha1 | zenon_intro zenon_Ha2 ]. % 119.80/120.08 cut (((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0)))))) = ((n4) = (succ (succ (succ (succ (n0))))))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Ha0. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Ha1. % 119.80/120.08 cut (((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_Ha2]. % 119.80/120.08 cut (((succ (succ (succ (succ (n0))))) = (n4))); [idtac | apply NNPP; zenon_intro zenon_Ha3]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_Ha3 successor_4). % 119.80/120.08 apply zenon_Ha2. apply refl_equal. % 119.80/120.08 apply zenon_Ha2. apply refl_equal. % 119.80/120.08 apply zenon_H63. apply refl_equal. % 119.80/120.08 (* end of lemma zenon_L11_ *) % 119.80/120.08 assert (zenon_L12_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (n1) (loopcounter)) -> (~(leq (loopcounter) (n3))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_H7d zenon_Ha4. % 119.80/120.08 generalize (leq_succ_gt_equiv (loopcounter)). zenon_intro zenon_H7f. % 119.80/120.08 generalize (zenon_H7f (n3)). zenon_intro zenon_Ha5. % 119.80/120.08 apply (zenon_equiv_s _ _ zenon_Ha5); [ zenon_intro zenon_Ha4; zenon_intro zenon_Ha8 | zenon_intro zenon_Ha7; zenon_intro zenon_Ha6 ]. % 119.80/120.08 elim (classic ((~((succ (n3)) = (n1)))/\(~(gt (succ (n3)) (n1))))); [ zenon_intro zenon_Ha9 | zenon_intro zenon_Haa ]. % 119.80/120.08 apply (zenon_and_s _ _ zenon_Ha9). zenon_intro zenon_Hac. zenon_intro zenon_Hab. % 119.80/120.08 elim (classic ((~((succ (n3)) = (n2)))/\(~(gt (succ (n3)) (n2))))); [ zenon_intro zenon_Had | zenon_intro zenon_Hae ]. % 119.80/120.08 apply (zenon_and_s _ _ zenon_Had). zenon_intro zenon_Haf. zenon_intro zenon_H9a. % 119.80/120.08 apply (zenon_L11_); trivial. % 119.80/120.08 cut ((gt (n2) (n1)) = (gt (succ (n3)) (n1))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hab. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact gt_2_1. % 119.80/120.08 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.08 cut (((n2) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_Hb0]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_notand_s _ _ zenon_Hae); [ zenon_intro zenon_Hb2 | zenon_intro zenon_Hb1 ]. % 119.80/120.08 apply zenon_Hb2. zenon_intro zenon_Hb3. % 119.80/120.08 elim (classic ((succ (n3)) = (succ (n3)))); [ zenon_intro zenon_H9e | zenon_intro zenon_H9f ]. % 119.80/120.08 cut (((succ (n3)) = (succ (n3))) = ((n2) = (succ (n3)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hb0. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H9e. % 119.80/120.08 cut (((succ (n3)) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H9f]. % 119.80/120.08 cut (((succ (n3)) = (n2))); [idtac | apply NNPP; zenon_intro zenon_Haf]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_Haf zenon_Hb3). % 119.80/120.08 apply zenon_H9f. apply refl_equal. % 119.80/120.08 apply zenon_H9f. apply refl_equal. % 119.80/120.08 apply zenon_Hb1. zenon_intro zenon_Hb4. % 119.80/120.08 generalize (zenon_H66 (succ (n3))). zenon_intro zenon_Hb5. % 119.80/120.08 generalize (zenon_Hb5 (n2)). zenon_intro zenon_Hb6. % 119.80/120.08 generalize (zenon_Hb6 (n1)). zenon_intro zenon_Hb7. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_Hb7); [ zenon_intro zenon_H9a | zenon_intro zenon_Hb8 ]. % 119.80/120.08 exact (zenon_H9a zenon_Hb4). % 119.80/120.08 apply (zenon_imply_s _ _ zenon_Hb8); [ zenon_intro zenon_Hba | zenon_intro zenon_Hb9 ]. % 119.80/120.08 exact (zenon_Hba gt_2_1). % 119.80/120.08 exact (zenon_Hab zenon_Hb9). % 119.80/120.08 apply zenon_H64. apply refl_equal. % 119.80/120.08 cut ((gt (n1) (loopcounter)) = (gt (succ (n3)) (loopcounter))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Ha8. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H7d. % 119.80/120.08 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.08 cut (((n1) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_Hbb]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_notand_s _ _ zenon_Haa); [ zenon_intro zenon_Hbd | zenon_intro zenon_Hbc ]. % 119.80/120.08 apply zenon_Hbd. zenon_intro zenon_Hbe. % 119.80/120.08 elim (classic ((succ (n3)) = (succ (n3)))); [ zenon_intro zenon_H9e | zenon_intro zenon_H9f ]. % 119.80/120.08 cut (((succ (n3)) = (succ (n3))) = ((n1) = (succ (n3)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hbb. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H9e. % 119.80/120.08 cut (((succ (n3)) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H9f]. % 119.80/120.08 cut (((succ (n3)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_Hac]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_Hac zenon_Hbe). % 119.80/120.08 apply zenon_H9f. apply refl_equal. % 119.80/120.08 apply zenon_H9f. apply refl_equal. % 119.80/120.08 apply zenon_Hbc. zenon_intro zenon_Hb9. % 119.80/120.08 generalize (zenon_H66 (succ (n3))). zenon_intro zenon_Hb5. % 119.80/120.08 generalize (zenon_Hb5 (n1)). zenon_intro zenon_Hbf. % 119.80/120.08 generalize (zenon_Hbf (loopcounter)). zenon_intro zenon_Hc0. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_Hc0); [ zenon_intro zenon_Hab | zenon_intro zenon_Hc1 ]. % 119.80/120.08 exact (zenon_Hab zenon_Hb9). % 119.80/120.08 apply (zenon_imply_s _ _ zenon_Hc1); [ zenon_intro zenon_H92 | zenon_intro zenon_Ha6 ]. % 119.80/120.08 exact (zenon_H92 zenon_H7d). % 119.80/120.08 exact (zenon_Ha8 zenon_Ha6). % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 exact (zenon_Ha4 zenon_Ha7). % 119.80/120.08 (* end of lemma zenon_L12_ *) % 119.80/120.08 assert (zenon_L13_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~((succ (n0)) = (succ (loopcounter)))) -> (~((loopcounter) = (n3))) -> (~((loopcounter) = (n2))) -> (~((loopcounter) = (n1))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_H97 zenon_Hc2 zenon_Hc3 zenon_Hc4 zenon_H7d zenon_H67. % 119.80/120.08 cut (((n0) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H93]. % 119.80/120.08 congruence. % 119.80/120.08 generalize (finite_domain_3 (loopcounter)). zenon_intro zenon_Hc5. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_Hc5); [ zenon_intro zenon_Hc7 | zenon_intro zenon_Hc6 ]. % 119.80/120.08 apply (zenon_notand_s _ _ zenon_Hc7); [ zenon_intro zenon_H68 | zenon_intro zenon_Ha4 ]. % 119.80/120.08 apply (zenon_L5_); trivial. % 119.80/120.08 apply (zenon_L12_); trivial. % 119.80/120.08 apply (zenon_or_s _ _ zenon_Hc6); [ zenon_intro zenon_H95 | zenon_intro zenon_Hc8 ]. % 119.80/120.08 apply zenon_H93. apply sym_equal. exact zenon_H95. % 119.80/120.08 apply (zenon_or_s _ _ zenon_Hc8); [ zenon_intro zenon_Hca | zenon_intro zenon_Hc9 ]. % 119.80/120.08 exact (zenon_Hc4 zenon_Hca). % 119.80/120.08 apply (zenon_or_s _ _ zenon_Hc9); [ zenon_intro zenon_Hcc | zenon_intro zenon_Hcb ]. % 119.80/120.08 exact (zenon_Hc3 zenon_Hcc). % 119.80/120.08 exact (zenon_Hc2 zenon_Hcb). % 119.80/120.08 (* end of lemma zenon_L13_ *) % 119.80/120.08 assert (zenon_L14_ : (gt (n1) (loopcounter)) -> (~((loopcounter) = (n1))) -> (~((loopcounter) = (n2))) -> (~((loopcounter) = (n3))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n0)) (succ (n0)))) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.08 do 0 intro. intros zenon_H7d zenon_Hc4 zenon_Hc3 zenon_Hc2 zenon_H66 zenon_Hcd zenon_H67. % 119.80/120.08 elim (classic ((~((succ (n0)) = (succ (loopcounter))))/\(~(gt (succ (n0)) (succ (loopcounter)))))); [ zenon_intro zenon_Hce | zenon_intro zenon_Hcf ]. % 119.80/120.08 apply (zenon_and_s _ _ zenon_Hce). zenon_intro zenon_H97. zenon_intro zenon_Hd0. % 119.80/120.08 apply (zenon_L13_); trivial. % 119.80/120.08 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.80/120.08 cut ((gt (succ (loopcounter)) (n1)) = (gt (succ (n0)) (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hcd. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H67. % 119.80/120.08 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.08 cut (((succ (loopcounter)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_Hd2]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_notand_s _ _ zenon_Hcf); [ zenon_intro zenon_Hd4 | zenon_intro zenon_Hd3 ]. % 119.80/120.08 apply zenon_Hd4. zenon_intro zenon_Hd5. % 119.80/120.08 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.80/120.08 cut (((succ (n0)) = (succ (n0))) = ((succ (loopcounter)) = (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hd2. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H8b. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 cut (((succ (n0)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H97]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H97 zenon_Hd5). % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 apply zenon_Hd3. zenon_intro zenon_Hd6. % 119.80/120.08 generalize (zenon_H66 (succ (n0))). zenon_intro zenon_H8e. % 119.80/120.08 generalize (zenon_H8e (succ (loopcounter))). zenon_intro zenon_Hd7. % 119.80/120.08 generalize (zenon_Hd7 (n1)). zenon_intro zenon_Hd8. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_Hd8); [ zenon_intro zenon_Hd0 | zenon_intro zenon_Hd9 ]. % 119.80/120.08 exact (zenon_Hd0 zenon_Hd6). % 119.80/120.08 apply (zenon_imply_s _ _ zenon_Hd9); [ zenon_intro zenon_H6f | zenon_intro zenon_H8d ]. % 119.80/120.08 exact (zenon_H6f zenon_H67). % 119.80/120.08 cut ((gt (succ (n0)) (n1)) = (gt (succ (n0)) (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hcd. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H8d. % 119.80/120.08 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 exact (zenon_H88 zenon_Hd1). % 119.80/120.08 exact (zenon_H88 zenon_Hd1). % 119.80/120.08 apply zenon_H88. apply sym_equal. exact successor_1. % 119.80/120.08 (* end of lemma zenon_L14_ *) % 119.80/120.08 assert (zenon_L15_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n0)) (n1))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n1))) -> (~((loopcounter) = (n2))) -> (~((loopcounter) = (n3))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_H86 zenon_H67 zenon_H7d zenon_Hc4 zenon_Hc3 zenon_Hc2. % 119.80/120.08 elim (classic (gt (succ (n0)) (succ (n0)))); [ zenon_intro zenon_Hda | zenon_intro zenon_Hcd ]. % 119.80/120.08 cut ((gt (succ (n0)) (succ (n0))) = (gt (succ (n0)) (n1))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H86. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hda. % 119.80/120.08 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 exact (zenon_H87 successor_1). % 119.80/120.08 apply (zenon_L14_); trivial. % 119.80/120.08 (* end of lemma zenon_L15_ *) % 119.80/120.08 assert (zenon_L16_ : (~((loopcounter) = (n3))) -> (~((loopcounter) = (n2))) -> (~((loopcounter) = (n1))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(gt (n1) (succ (loopcounter)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.80/120.08 do 0 intro. intros zenon_Hc2 zenon_Hc3 zenon_Hc4 zenon_H7d zenon_H67 zenon_Hdb zenon_H66. % 119.80/120.08 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.80/120.08 elim (classic (gt (succ (n0)) (succ (loopcounter)))); [ zenon_intro zenon_Hd6 | zenon_intro zenon_Hd0 ]. % 119.80/120.08 cut ((gt (succ (n0)) (succ (loopcounter))) = (gt (n1) (succ (loopcounter)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hdb. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hd6. % 119.80/120.08 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.80/120.08 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.08 congruence. % 119.80/120.08 elim (classic ((n1) = (n1))); [ zenon_intro zenon_Hdc | zenon_intro zenon_H64 ]. % 119.80/120.08 cut (((n1) = (n1)) = ((succ (n0)) = (n1))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H87. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hdc. % 119.80/120.08 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.08 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H88 zenon_Hd1). % 119.80/120.08 apply zenon_H64. apply refl_equal. % 119.80/120.08 apply zenon_H64. apply refl_equal. % 119.80/120.08 apply zenon_H76. apply refl_equal. % 119.80/120.08 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.80/120.08 elim (classic (gt (succ (n0)) (n1))); [ zenon_intro zenon_H8d | zenon_intro zenon_H86 ]. % 119.80/120.08 elim (classic (gt (succ (n0)) (succ (n0)))); [ zenon_intro zenon_Hda | zenon_intro zenon_Hcd ]. % 119.80/120.08 cut ((gt (succ (n0)) (succ (n0))) = (gt (succ (n0)) (succ (loopcounter)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hd0. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hda. % 119.80/120.08 cut (((succ (n0)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H97]. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 apply (zenon_L13_); trivial. % 119.80/120.08 cut ((gt (succ (n0)) (n1)) = (gt (succ (n0)) (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hcd. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H8d. % 119.80/120.08 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 exact (zenon_H88 zenon_Hd1). % 119.80/120.08 apply (zenon_L15_); trivial. % 119.80/120.08 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.80/120.08 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H88. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H8b. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H87 successor_1). % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.80/120.08 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H88. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H8b. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H87 successor_1). % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 (* end of lemma zenon_L16_ *) % 119.80/120.08 assert (zenon_L17_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (n1))) -> (~(gt (n1) (succ (loopcounter)))) -> (~((loopcounter) = (n3))) -> (~((loopcounter) = (n2))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_Hdd zenon_Hdb zenon_Hc2 zenon_Hc3 zenon_H7d zenon_H67. % 119.80/120.08 elim (classic ((loopcounter) = (n1))); [ zenon_intro zenon_Hca | zenon_intro zenon_Hc4 ]. % 119.80/120.08 cut ((gt (n1) (loopcounter)) = (gt (n1) (n1))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hdd. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H7d. % 119.80/120.08 cut (((loopcounter) = (n1))); [idtac | apply NNPP; zenon_intro zenon_Hc4]. % 119.80/120.08 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H64. apply refl_equal. % 119.80/120.08 exact (zenon_Hc4 zenon_Hca). % 119.80/120.08 apply (zenon_L16_); trivial. % 119.80/120.08 (* end of lemma zenon_L17_ *) % 119.80/120.08 assert (zenon_L18_ : (~((loopcounter) = (n3))) -> (~((loopcounter) = (n2))) -> (gt (n1) (loopcounter)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (n1))) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.08 do 0 intro. intros zenon_Hc2 zenon_Hc3 zenon_H7d zenon_H66 zenon_Hdd zenon_H67. % 119.80/120.08 elim (classic ((~((n1) = (succ (loopcounter))))/\(~(gt (n1) (succ (loopcounter)))))); [ zenon_intro zenon_Hde | zenon_intro zenon_Hdf ]. % 119.80/120.08 apply (zenon_and_s _ _ zenon_Hde). zenon_intro zenon_H71. zenon_intro zenon_Hdb. % 119.80/120.08 apply (zenon_L17_); trivial. % 119.80/120.08 cut ((gt (succ (loopcounter)) (n1)) = (gt (n1) (n1))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hdd. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H67. % 119.80/120.08 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.08 cut (((succ (loopcounter)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H70]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_notand_s _ _ zenon_Hdf); [ zenon_intro zenon_He1 | zenon_intro zenon_He0 ]. % 119.80/120.08 apply zenon_He1. zenon_intro zenon_He2. % 119.80/120.08 elim (classic ((n1) = (n1))); [ zenon_intro zenon_Hdc | zenon_intro zenon_H64 ]. % 119.80/120.08 cut (((n1) = (n1)) = ((succ (loopcounter)) = (n1))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H70. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hdc. % 119.80/120.08 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.08 cut (((n1) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H71]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H71 zenon_He2). % 119.80/120.08 apply zenon_H64. apply refl_equal. % 119.80/120.08 apply zenon_H64. apply refl_equal. % 119.80/120.08 apply zenon_He0. zenon_intro zenon_He3. % 119.80/120.08 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.80/120.08 generalize (zenon_He4 (succ (loopcounter))). zenon_intro zenon_He5. % 119.80/120.08 generalize (zenon_He5 (n1)). zenon_intro zenon_He6. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_He6); [ zenon_intro zenon_Hdb | zenon_intro zenon_He7 ]. % 119.80/120.08 exact (zenon_Hdb zenon_He3). % 119.80/120.08 apply (zenon_imply_s _ _ zenon_He7); [ zenon_intro zenon_H6f | zenon_intro zenon_He8 ]. % 119.80/120.08 exact (zenon_H6f zenon_H67). % 119.80/120.08 exact (zenon_Hdd zenon_He8). % 119.80/120.08 apply zenon_H64. apply refl_equal. % 119.80/120.08 (* end of lemma zenon_L18_ *) % 119.80/120.08 assert (zenon_L19_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n0)) (succ (n0)))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n2))) -> (~((loopcounter) = (n3))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_Hcd zenon_H67 zenon_H7d zenon_Hc3 zenon_Hc2. % 119.80/120.08 elim (classic (gt (n1) (succ (n0)))); [ zenon_intro zenon_He9 | zenon_intro zenon_Hea ]. % 119.80/120.08 cut ((gt (n1) (succ (n0))) = (gt (succ (n0)) (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hcd. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_He9. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.08 congruence. % 119.80/120.08 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.80/120.08 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H88. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H8b. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H87 successor_1). % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.80/120.08 elim (classic (gt (n1) (n1))); [ zenon_intro zenon_He8 | zenon_intro zenon_Hdd ]. % 119.80/120.08 cut ((gt (n1) (n1)) = (gt (n1) (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hea. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_He8. % 119.80/120.08 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.08 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H64. apply refl_equal. % 119.80/120.08 exact (zenon_H88 zenon_Hd1). % 119.80/120.08 apply (zenon_L18_); trivial. % 119.80/120.08 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.80/120.08 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H88. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H8b. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H87 successor_1). % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 (* end of lemma zenon_L19_ *) % 119.80/120.08 assert (zenon_L20_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n2))) -> (~((loopcounter) = (n3))) -> (~(gt (n1) (succ (loopcounter)))) -> (~(gt (loopcounter) (succ (n0)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H67 zenon_H7d zenon_Hc3 zenon_Hc2 zenon_Hdb zenon_Heb zenon_H66. % 119.80/120.08 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.80/120.08 elim (classic (gt (succ (n0)) (succ (n0)))); [ zenon_intro zenon_Hda | zenon_intro zenon_Hcd ]. % 119.80/120.08 elim (classic (gt (n1) (succ (n0)))); [ zenon_intro zenon_He9 | zenon_intro zenon_Hea ]. % 119.80/120.08 cut ((gt (n1) (succ (n0))) = (gt (loopcounter) (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Heb. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_He9. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 cut (((n1) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_Hec]. % 119.80/120.08 congruence. % 119.80/120.08 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.80/120.08 cut (((loopcounter) = (loopcounter)) = ((n1) = (loopcounter))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hec. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hed. % 119.80/120.08 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.08 cut (((loopcounter) = (n1))); [idtac | apply NNPP; zenon_intro zenon_Hc4]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_L16_); trivial. % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 cut ((gt (succ (n0)) (succ (n0))) = (gt (n1) (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hea. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hda. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.08 congruence. % 119.80/120.08 elim (classic ((n1) = (n1))); [ zenon_intro zenon_Hdc | zenon_intro zenon_H64 ]. % 119.80/120.08 cut (((n1) = (n1)) = ((succ (n0)) = (n1))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H87. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hdc. % 119.80/120.08 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.08 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H88 zenon_Hd1). % 119.80/120.08 apply zenon_H64. apply refl_equal. % 119.80/120.08 apply zenon_H64. apply refl_equal. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 apply (zenon_L19_); trivial. % 119.80/120.08 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.80/120.08 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H88. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H8b. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H87 successor_1). % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 (* end of lemma zenon_L20_ *) % 119.80/120.08 assert (zenon_L21_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (loopcounter) (n1))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n2))) -> (~((loopcounter) = (n3))) -> (~(gt (n1) (succ (loopcounter)))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_Hee zenon_H67 zenon_H7d zenon_Hc3 zenon_Hc2 zenon_Hdb. % 119.80/120.08 elim (classic (gt (loopcounter) (succ (n0)))); [ zenon_intro zenon_Hef | zenon_intro zenon_Heb ]. % 119.80/120.08 cut ((gt (loopcounter) (succ (n0))) = (gt (loopcounter) (n1))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hee. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hef. % 119.80/120.08 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.08 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 exact (zenon_H87 successor_1). % 119.80/120.08 apply (zenon_L20_); trivial. % 119.80/120.08 (* end of lemma zenon_L21_ *) % 119.80/120.08 assert (zenon_L22_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n2))) -> (~((loopcounter) = (n3))) -> (~(gt (n1) (succ (loopcounter)))) -> (~(gt (loopcounter) (succ (loopcounter)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H67 zenon_H7d zenon_Hc3 zenon_Hc2 zenon_Hdb zenon_Hf0 zenon_H66. % 119.80/120.08 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.80/120.08 elim (classic (gt (loopcounter) (n1))); [ zenon_intro zenon_Hf1 | zenon_intro zenon_Hee ]. % 119.80/120.08 elim (classic (gt (loopcounter) (succ (n0)))); [ zenon_intro zenon_Hef | zenon_intro zenon_Heb ]. % 119.80/120.08 cut ((gt (loopcounter) (succ (n0))) = (gt (loopcounter) (succ (loopcounter)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hf0. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hef. % 119.80/120.08 cut (((succ (n0)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H97]. % 119.80/120.08 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 apply (zenon_L9_); trivial. % 119.80/120.08 cut ((gt (loopcounter) (n1)) = (gt (loopcounter) (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Heb. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hf1. % 119.80/120.08 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.08 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 exact (zenon_H88 zenon_Hd1). % 119.80/120.08 apply (zenon_L21_); trivial. % 119.80/120.08 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.80/120.08 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H88. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H8b. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H87 successor_1). % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 (* end of lemma zenon_L22_ *) % 119.80/120.08 assert (zenon_L23_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n2))) -> (~((loopcounter) = (n3))) -> (~(gt (n1) (succ (loopcounter)))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_Hc3 zenon_Hc2 zenon_Hdb. % 119.80/120.08 elim (classic (gt (loopcounter) (succ (loopcounter)))); [ zenon_intro zenon_Hf2 | zenon_intro zenon_Hf0 ]. % 119.80/120.08 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.80/120.08 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.80/120.08 generalize (zenon_Hf3 (succ (loopcounter))). zenon_intro zenon_Hf4. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_Hf4); [ zenon_intro zenon_H92 | zenon_intro zenon_Hf5 ]. % 119.80/120.08 exact (zenon_H92 zenon_H7d). % 119.80/120.08 apply (zenon_imply_s _ _ zenon_Hf5); [ zenon_intro zenon_Hf0 | zenon_intro zenon_He3 ]. % 119.80/120.08 exact (zenon_Hf0 zenon_Hf2). % 119.80/120.08 exact (zenon_Hdb zenon_He3). % 119.80/120.08 apply (zenon_L22_); trivial. % 119.80/120.08 (* end of lemma zenon_L23_ *) % 119.80/120.08 assert (zenon_L24_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n0)) (succ (loopcounter)))) -> (~((loopcounter) = (n3))) -> (~((loopcounter) = (n2))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_Hd0 zenon_Hc2 zenon_Hc3 zenon_H7d zenon_H67. % 119.80/120.08 elim (classic ((~((succ (n0)) = (succ (loopcounter))))/\(~(gt (succ (n0)) (succ (loopcounter)))))); [ zenon_intro zenon_Hce | zenon_intro zenon_Hcf ]. % 119.80/120.08 apply (zenon_and_s _ _ zenon_Hce). zenon_intro zenon_H97. zenon_intro zenon_Hd0. % 119.80/120.08 apply (zenon_L9_); trivial. % 119.80/120.08 elim (classic (gt (n1) (succ (loopcounter)))); [ zenon_intro zenon_He3 | zenon_intro zenon_Hdb ]. % 119.80/120.08 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.80/120.08 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.80/120.08 generalize (zenon_H78 (succ (loopcounter))). zenon_intro zenon_Hf6. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_Hf6); [ zenon_intro zenon_H6f | zenon_intro zenon_Hf7 ]. % 119.80/120.08 exact (zenon_H6f zenon_H67). % 119.80/120.08 apply (zenon_imply_s _ _ zenon_Hf7); [ zenon_intro zenon_Hdb | zenon_intro zenon_Hf8 ]. % 119.80/120.08 exact (zenon_Hdb zenon_He3). % 119.80/120.08 cut ((gt (succ (loopcounter)) (succ (loopcounter))) = (gt (succ (n0)) (succ (loopcounter)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hd0. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hf8. % 119.80/120.08 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.80/120.08 cut (((succ (loopcounter)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_Hd2]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_notand_s _ _ zenon_Hcf); [ zenon_intro zenon_Hd4 | zenon_intro zenon_Hd3 ]. % 119.80/120.08 apply zenon_Hd4. zenon_intro zenon_Hd5. % 119.80/120.08 apply zenon_Hd2. apply sym_equal. exact zenon_Hd5. % 119.80/120.08 exact (zenon_Hd3 zenon_Hd0). % 119.80/120.08 apply zenon_H76. apply refl_equal. % 119.80/120.08 apply (zenon_L23_); trivial. % 119.80/120.08 (* end of lemma zenon_L24_ *) % 119.80/120.08 assert (zenon_L25_ : (~(gt (n2) (succ (n0)))) -> False). % 119.80/120.08 do 0 intro. intros zenon_Hf9. % 119.80/120.08 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.80/120.08 cut ((gt (n2) (n1)) = (gt (n2) (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hf9. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact gt_2_1. % 119.80/120.08 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.08 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H63. apply refl_equal. % 119.80/120.08 exact (zenon_H88 zenon_Hd1). % 119.80/120.08 apply zenon_H88. apply sym_equal. exact successor_1. % 119.80/120.08 (* end of lemma zenon_L25_ *) % 119.80/120.08 assert (zenon_L26_ : (~((succ (n1)) = (succ (succ (n0))))) -> False). % 119.80/120.08 do 0 intro. intros zenon_Hfa. % 119.80/120.08 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H88. apply sym_equal. exact successor_1. % 119.80/120.08 (* end of lemma zenon_L26_ *) % 119.80/120.08 assert (zenon_L27_ : (~(gt (succ (n1)) (succ (n0)))) -> False). % 119.80/120.08 do 0 intro. intros zenon_Hfb. % 119.80/120.08 elim (classic (gt (n2) (succ (n0)))); [ zenon_intro zenon_Hfc | zenon_intro zenon_Hf9 ]. % 119.80/120.08 elim (classic (gt (succ (succ (n0))) (succ (n0)))); [ zenon_intro zenon_Hfd | zenon_intro zenon_Hfe ]. % 119.80/120.08 cut ((gt (succ (succ (n0))) (succ (n0))) = (gt (succ (n1)) (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hfb. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hfd. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 cut (((succ (succ (n0))) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_Hff]. % 119.80/120.08 congruence. % 119.80/120.08 elim (classic ((succ (n1)) = (succ (n1)))); [ zenon_intro zenon_H100 | zenon_intro zenon_H101 ]. % 119.80/120.08 cut (((succ (n1)) = (succ (n1))) = ((succ (succ (n0))) = (succ (n1)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hff. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H100. % 119.80/120.08 cut (((succ (n1)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H101]. % 119.80/120.08 cut (((succ (n1)) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_Hfa]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_L26_); trivial. % 119.80/120.08 apply zenon_H101. apply refl_equal. % 119.80/120.08 apply zenon_H101. apply refl_equal. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 cut ((gt (n2) (succ (n0))) = (gt (succ (succ (n0))) (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hfe. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hfc. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 cut (((n2) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 119.80/120.08 congruence. % 119.80/120.08 elim (classic ((succ (succ (n0))) = (succ (succ (n0))))); [ zenon_intro zenon_H103 | zenon_intro zenon_H104 ]. % 119.80/120.08 cut (((succ (succ (n0))) = (succ (succ (n0)))) = ((n2) = (succ (succ (n0))))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H102. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H103. % 119.80/120.08 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.80/120.08 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H105 successor_2). % 119.80/120.08 apply zenon_H104. apply refl_equal. % 119.80/120.08 apply zenon_H104. apply refl_equal. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 apply (zenon_L25_); trivial. % 119.80/120.08 (* end of lemma zenon_L27_ *) % 119.80/120.08 assert (zenon_L28_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (loopcounter) (n1))) -> (~((n0) = (n1))) -> (~((loopcounter) = (n1))) -> (~((loopcounter) = (n3))) -> (~((loopcounter) = (n2))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_Hee zenon_H106 zenon_Hc4 zenon_Hc2 zenon_Hc3 zenon_H7d zenon_H67. % 119.80/120.08 elim (classic (gt (loopcounter) (succ (n0)))); [ zenon_intro zenon_Hef | zenon_intro zenon_Heb ]. % 119.80/120.08 cut ((gt (loopcounter) (succ (n0))) = (gt (loopcounter) (n1))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hee. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hef. % 119.80/120.08 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.08 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 exact (zenon_H87 successor_1). % 119.80/120.08 generalize (finite_domain_0 (n1)). zenon_intro zenon_H107. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H107); [ zenon_intro zenon_H109 | zenon_intro zenon_H108 ]. % 119.80/120.08 apply (zenon_notand_s _ _ zenon_H109); [ zenon_intro zenon_H10b | zenon_intro zenon_H10a ]. % 119.80/120.08 generalize (leq_succ_gt_equiv (n0)). zenon_intro zenon_H5f. % 119.80/120.08 generalize (zenon_H5f (n1)). zenon_intro zenon_H10c. % 119.80/120.08 apply (zenon_equiv_s _ _ zenon_H10c); [ zenon_intro zenon_H10b; zenon_intro zenon_H10f | zenon_intro zenon_H10e; zenon_intro zenon_H10d ]. % 119.80/120.08 elim (classic ((~((succ (n1)) = (n1)))/\(~(gt (succ (n1)) (n1))))); [ zenon_intro zenon_H110 | zenon_intro zenon_H111 ]. % 119.80/120.08 apply (zenon_and_s _ _ zenon_H110). zenon_intro zenon_H113. zenon_intro zenon_H112. % 119.80/120.08 elim (classic ((~((succ (n1)) = (succ (loopcounter))))/\(~(gt (succ (n1)) (succ (loopcounter)))))); [ zenon_intro zenon_H114 | zenon_intro zenon_H115 ]. % 119.80/120.08 apply (zenon_and_s _ _ zenon_H114). zenon_intro zenon_H117. zenon_intro zenon_H116. % 119.80/120.08 elim (classic (gt (succ (n1)) (succ (n0)))); [ zenon_intro zenon_H118 | zenon_intro zenon_Hfb ]. % 119.80/120.08 elim (classic (gt (succ (n1)) (n1))); [ zenon_intro zenon_H119 | zenon_intro zenon_H112 ]. % 119.80/120.08 elim (classic (gt (n1) (succ (loopcounter)))); [ zenon_intro zenon_He3 | zenon_intro zenon_Hdb ]. % 119.80/120.08 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.80/120.08 generalize (zenon_H11a (n1)). zenon_intro zenon_H11b. % 119.80/120.08 generalize (zenon_H11b (succ (loopcounter))). zenon_intro zenon_H11c. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H11c); [ zenon_intro zenon_H112 | zenon_intro zenon_H11d ]. % 119.80/120.08 exact (zenon_H112 zenon_H119). % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H11d); [ zenon_intro zenon_Hdb | zenon_intro zenon_H11e ]. % 119.80/120.08 exact (zenon_Hdb zenon_He3). % 119.80/120.08 exact (zenon_H116 zenon_H11e). % 119.80/120.08 apply (zenon_L20_); trivial. % 119.80/120.08 cut ((gt (succ (n1)) (succ (n0))) = (gt (succ (n1)) (n1))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H112. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H118. % 119.80/120.08 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.08 cut (((succ (n1)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H101]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H101. apply refl_equal. % 119.80/120.08 exact (zenon_H87 successor_1). % 119.80/120.08 apply (zenon_L27_); trivial. % 119.80/120.08 cut ((gt (succ (loopcounter)) (n1)) = (gt (succ (n1)) (n1))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H112. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H67. % 119.80/120.08 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.08 cut (((succ (loopcounter)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H11f]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_notand_s _ _ zenon_H115); [ zenon_intro zenon_H121 | zenon_intro zenon_H120 ]. % 119.80/120.08 apply zenon_H121. zenon_intro zenon_H122. % 119.80/120.08 elim (classic ((succ (n1)) = (succ (n1)))); [ zenon_intro zenon_H100 | zenon_intro zenon_H101 ]. % 119.80/120.08 cut (((succ (n1)) = (succ (n1))) = ((succ (loopcounter)) = (succ (n1)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H11f. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H100. % 119.80/120.08 cut (((succ (n1)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H101]. % 119.80/120.08 cut (((succ (n1)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H117]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H117 zenon_H122). % 119.80/120.08 apply zenon_H101. apply refl_equal. % 119.80/120.08 apply zenon_H101. apply refl_equal. % 119.80/120.08 apply zenon_H120. zenon_intro zenon_H11e. % 119.80/120.08 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.80/120.08 generalize (zenon_H11a (succ (loopcounter))). zenon_intro zenon_H123. % 119.80/120.08 generalize (zenon_H123 (n1)). zenon_intro zenon_H124. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H124); [ zenon_intro zenon_H116 | zenon_intro zenon_H125 ]. % 119.80/120.08 exact (zenon_H116 zenon_H11e). % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H125); [ zenon_intro zenon_H6f | zenon_intro zenon_H119 ]. % 119.80/120.08 exact (zenon_H6f zenon_H67). % 119.80/120.08 exact (zenon_H112 zenon_H119). % 119.80/120.08 apply zenon_H64. apply refl_equal. % 119.80/120.08 cut ((gt (n1) (n0)) = (gt (succ (n1)) (n0))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H10f. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact gt_1_0. % 119.80/120.08 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.08 cut (((n1) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H126]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_notand_s _ _ zenon_H111); [ zenon_intro zenon_H128 | zenon_intro zenon_H127 ]. % 119.80/120.08 apply zenon_H128. zenon_intro zenon_H129. % 119.80/120.08 elim (classic ((succ (n1)) = (succ (n1)))); [ zenon_intro zenon_H100 | zenon_intro zenon_H101 ]. % 119.80/120.08 cut (((succ (n1)) = (succ (n1))) = ((n1) = (succ (n1)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H126. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H100. % 119.80/120.08 cut (((succ (n1)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H101]. % 119.80/120.08 cut (((succ (n1)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H113]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H113 zenon_H129). % 119.80/120.08 apply zenon_H101. apply refl_equal. % 119.80/120.08 apply zenon_H101. apply refl_equal. % 119.80/120.08 apply zenon_H127. zenon_intro zenon_H119. % 119.80/120.08 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.80/120.08 generalize (zenon_H11a (n1)). zenon_intro zenon_H11b. % 119.80/120.08 generalize (zenon_H11b (n0)). zenon_intro zenon_H12a. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H12a); [ zenon_intro zenon_H112 | zenon_intro zenon_H12b ]. % 119.80/120.08 exact (zenon_H112 zenon_H119). % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H12b); [ zenon_intro zenon_H7b | zenon_intro zenon_H10d ]. % 119.80/120.08 exact (zenon_H7b gt_1_0). % 119.80/120.08 exact (zenon_H10f zenon_H10d). % 119.80/120.08 apply zenon_H65. apply refl_equal. % 119.80/120.08 exact (zenon_H10b zenon_H10e). % 119.80/120.08 generalize (leq_succ_gt_equiv (n1)). zenon_intro zenon_H12c. % 119.80/120.08 generalize (zenon_H12c (n0)). zenon_intro zenon_H12d. % 119.80/120.08 apply (zenon_equiv_s _ _ zenon_H12d); [ zenon_intro zenon_H10a; zenon_intro zenon_H86 | zenon_intro zenon_H12e; zenon_intro zenon_H8d ]. % 119.80/120.08 apply (zenon_L15_); trivial. % 119.80/120.08 exact (zenon_H10a zenon_H12e). % 119.80/120.08 apply zenon_H106. apply sym_equal. exact zenon_H108. % 119.80/120.08 (* end of lemma zenon_L28_ *) % 119.80/120.08 assert (zenon_L29_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n0) (n0))) -> ((loopcounter) = (n0)) -> (~((n0) = (n1))) -> (~((loopcounter) = (n3))) -> (~((loopcounter) = (n2))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_H12f zenon_H95 zenon_H106 zenon_Hc2 zenon_Hc3 zenon_H7d zenon_H67. % 119.80/120.08 elim (classic (gt (n0) (loopcounter))); [ zenon_intro zenon_H130 | zenon_intro zenon_H131 ]. % 119.80/120.08 cut ((gt (n0) (loopcounter)) = (gt (n0) (n0))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H12f. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H130. % 119.80/120.08 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.80/120.08 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H65. apply refl_equal. % 119.80/120.08 exact (zenon_H132 zenon_H95). % 119.80/120.08 elim (classic ((n0) = (loopcounter))); [ zenon_intro zenon_H133 | zenon_intro zenon_H93 ]. % 119.80/120.08 elim (classic (gt (loopcounter) (loopcounter))); [ zenon_intro zenon_H134 | zenon_intro zenon_H135 ]. % 119.80/120.08 cut ((gt (loopcounter) (loopcounter)) = (gt (n0) (loopcounter))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H131. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H134. % 119.80/120.08 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.08 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.80/120.08 congruence. % 119.80/120.08 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.80/120.08 cut (((n0) = (n0)) = ((loopcounter) = (n0))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H132. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H136. % 119.80/120.08 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.08 cut (((n0) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H93]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H93 zenon_H133). % 119.80/120.08 apply zenon_H65. apply refl_equal. % 119.80/120.08 apply zenon_H65. apply refl_equal. % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 elim (classic ((~((loopcounter) = (n1)))/\(~(gt (loopcounter) (n1))))); [ zenon_intro zenon_H137 | zenon_intro zenon_H138 ]. % 119.80/120.08 apply (zenon_and_s _ _ zenon_H137). zenon_intro zenon_Hc4. zenon_intro zenon_Hee. % 119.80/120.08 apply (zenon_L28_); trivial. % 119.80/120.08 cut ((gt (n1) (loopcounter)) = (gt (loopcounter) (loopcounter))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H135. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H7d. % 119.80/120.08 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.08 cut (((n1) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_Hec]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_notand_s _ _ zenon_H138); [ zenon_intro zenon_H13a | zenon_intro zenon_H139 ]. % 119.80/120.08 apply zenon_H13a. zenon_intro zenon_Hca. % 119.80/120.08 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.80/120.08 cut (((loopcounter) = (loopcounter)) = ((n1) = (loopcounter))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hec. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hed. % 119.80/120.08 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.08 cut (((loopcounter) = (n1))); [idtac | apply NNPP; zenon_intro zenon_Hc4]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_Hc4 zenon_Hca). % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 apply zenon_H139. zenon_intro zenon_Hf1. % 119.80/120.08 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.80/120.08 generalize (zenon_H13b (n1)). zenon_intro zenon_H13c. % 119.80/120.08 generalize (zenon_H13c (loopcounter)). zenon_intro zenon_H13d. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H13d); [ zenon_intro zenon_Hee | zenon_intro zenon_H13e ]. % 119.80/120.08 exact (zenon_Hee zenon_Hf1). % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H13e); [ zenon_intro zenon_H92 | zenon_intro zenon_H134 ]. % 119.80/120.08 exact (zenon_H92 zenon_H7d). % 119.80/120.08 exact (zenon_H135 zenon_H134). % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.80/120.08 cut (((loopcounter) = (loopcounter)) = ((n0) = (loopcounter))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H93. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hed. % 119.80/120.08 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.08 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H132 zenon_H95). % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 (* end of lemma zenon_L29_ *) % 119.80/120.08 assert (zenon_L30_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((loopcounter) = (n1)) -> (~(gt (n0) (n1))) -> (~((loopcounter) = (n3))) -> (~((loopcounter) = (n2))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_Hca zenon_H13f zenon_Hc2 zenon_Hc3 zenon_H7d zenon_H67. % 119.80/120.08 elim (classic (gt (n1) (n1))); [ zenon_intro zenon_He8 | zenon_intro zenon_Hdd ]. % 119.80/120.08 elim (classic (gt (loopcounter) (n1))); [ zenon_intro zenon_Hf1 | zenon_intro zenon_Hee ]. % 119.80/120.08 cut ((gt (loopcounter) (n1)) = (gt (n0) (n1))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H13f. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hf1. % 119.80/120.08 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.08 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.80/120.08 congruence. % 119.80/120.08 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.80/120.08 cut (((n0) = (n0)) = ((loopcounter) = (n0))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H132. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H136. % 119.80/120.08 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.08 cut (((n0) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H93]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_L8_); trivial. % 119.80/120.08 apply zenon_H65. apply refl_equal. % 119.80/120.08 apply zenon_H65. apply refl_equal. % 119.80/120.08 apply zenon_H64. apply refl_equal. % 119.80/120.08 cut ((gt (n1) (n1)) = (gt (loopcounter) (n1))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hee. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_He8. % 119.80/120.08 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.08 cut (((n1) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_Hec]. % 119.80/120.08 congruence. % 119.80/120.08 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.80/120.08 cut (((loopcounter) = (loopcounter)) = ((n1) = (loopcounter))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hec. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hed. % 119.80/120.08 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.08 cut (((loopcounter) = (n1))); [idtac | apply NNPP; zenon_intro zenon_Hc4]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_Hc4 zenon_Hca). % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 apply zenon_H64. apply refl_equal. % 119.80/120.08 apply (zenon_L18_); trivial. % 119.80/120.08 (* end of lemma zenon_L30_ *) % 119.80/120.08 assert (zenon_L31_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (n0) (succ (loopcounter)))) -> (~((n0) = (n1))) -> (~((loopcounter) = (n3))) -> (~((loopcounter) = (n2))) -> (~(gt (n0) (n1))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_H140 zenon_H106 zenon_Hc2 zenon_Hc3 zenon_H13f. % 119.80/120.08 generalize (finite_domain_3 (loopcounter)). zenon_intro zenon_Hc5. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_Hc5); [ zenon_intro zenon_Hc7 | zenon_intro zenon_Hc6 ]. % 119.80/120.08 apply (zenon_notand_s _ _ zenon_Hc7); [ zenon_intro zenon_H68 | zenon_intro zenon_Ha4 ]. % 119.80/120.08 apply (zenon_L5_); trivial. % 119.80/120.08 apply (zenon_L12_); trivial. % 119.80/120.08 apply (zenon_or_s _ _ zenon_Hc6); [ zenon_intro zenon_H95 | zenon_intro zenon_Hc8 ]. % 119.80/120.08 elim (classic ((n0) = (loopcounter))); [ zenon_intro zenon_H133 | zenon_intro zenon_H93 ]. % 119.80/120.08 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.80/120.08 elim (classic (gt (n0) (loopcounter))); [ zenon_intro zenon_H130 | zenon_intro zenon_H131 ]. % 119.80/120.08 elim (classic (gt (loopcounter) (succ (loopcounter)))); [ zenon_intro zenon_Hf2 | zenon_intro zenon_Hf0 ]. % 119.80/120.08 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.80/120.08 generalize (zenon_H142 (loopcounter)). zenon_intro zenon_H143. % 119.80/120.08 generalize (zenon_H143 (succ (loopcounter))). zenon_intro zenon_H144. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H144); [ zenon_intro zenon_H131 | zenon_intro zenon_H145 ]. % 119.80/120.08 exact (zenon_H131 zenon_H130). % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H145); [ zenon_intro zenon_Hf0 | zenon_intro zenon_H146 ]. % 119.80/120.08 exact (zenon_Hf0 zenon_Hf2). % 119.80/120.08 exact (zenon_H140 zenon_H146). % 119.80/120.08 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.80/120.08 elim (classic (gt (loopcounter) (n1))); [ zenon_intro zenon_Hf1 | zenon_intro zenon_Hee ]. % 119.80/120.08 elim (classic (gt (loopcounter) (succ (n0)))); [ zenon_intro zenon_Hef | zenon_intro zenon_Heb ]. % 119.80/120.08 elim (classic (gt (succ (n0)) (succ (loopcounter)))); [ zenon_intro zenon_Hd6 | zenon_intro zenon_Hd0 ]. % 119.80/120.08 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.80/120.08 generalize (zenon_H13b (succ (n0))). zenon_intro zenon_H147. % 119.80/120.08 generalize (zenon_H147 (succ (loopcounter))). zenon_intro zenon_H148. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H148); [ zenon_intro zenon_Heb | zenon_intro zenon_H149 ]. % 119.80/120.08 exact (zenon_Heb zenon_Hef). % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H149); [ zenon_intro zenon_Hd0 | zenon_intro zenon_Hf2 ]. % 119.80/120.08 exact (zenon_Hd0 zenon_Hd6). % 119.80/120.08 exact (zenon_Hf0 zenon_Hf2). % 119.80/120.08 apply (zenon_L24_); trivial. % 119.80/120.08 cut ((gt (loopcounter) (n1)) = (gt (loopcounter) (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Heb. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hf1. % 119.80/120.08 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.08 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 exact (zenon_H88 zenon_Hd1). % 119.80/120.08 elim (classic (gt (succ (n0)) (succ (loopcounter)))); [ zenon_intro zenon_Hd6 | zenon_intro zenon_Hd0 ]. % 119.80/120.08 elim (classic (gt (n1) (succ (loopcounter)))); [ zenon_intro zenon_He3 | zenon_intro zenon_Hdb ]. % 119.80/120.08 cut ((gt (n1) (succ (loopcounter))) = (gt (loopcounter) (succ (loopcounter)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hf0. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_He3. % 119.80/120.08 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.80/120.08 cut (((n1) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_Hec]. % 119.80/120.08 congruence. % 119.80/120.08 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.80/120.08 cut (((loopcounter) = (loopcounter)) = ((n1) = (loopcounter))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hec. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hed. % 119.80/120.08 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.08 cut (((loopcounter) = (n1))); [idtac | apply NNPP; zenon_intro zenon_Hc4]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_L28_); trivial. % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 apply zenon_H76. apply refl_equal. % 119.80/120.08 cut ((gt (succ (n0)) (succ (loopcounter))) = (gt (n1) (succ (loopcounter)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_Hdb. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hd6. % 119.80/120.08 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.80/120.08 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.08 congruence. % 119.80/120.08 elim (classic ((n1) = (n1))); [ zenon_intro zenon_Hdc | zenon_intro zenon_H64 ]. % 119.80/120.08 cut (((n1) = (n1)) = ((succ (n0)) = (n1))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H87. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hdc. % 119.80/120.08 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.08 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H88 zenon_Hd1). % 119.80/120.08 apply zenon_H64. apply refl_equal. % 119.80/120.08 apply zenon_H64. apply refl_equal. % 119.80/120.08 apply zenon_H76. apply refl_equal. % 119.80/120.08 apply (zenon_L24_); trivial. % 119.80/120.08 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.80/120.08 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H88. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H8b. % 119.80/120.08 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.08 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H87 successor_1). % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 apply zenon_H8c. apply refl_equal. % 119.80/120.08 cut ((gt (n0) (n0)) = (gt (n0) (loopcounter))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H131. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H141. % 119.80/120.08 cut (((n0) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H93]. % 119.80/120.08 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.08 congruence. % 119.80/120.08 apply zenon_H65. apply refl_equal. % 119.80/120.08 exact (zenon_H93 zenon_H133). % 119.80/120.08 apply (zenon_L29_); trivial. % 119.80/120.08 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.80/120.08 cut (((loopcounter) = (loopcounter)) = ((n0) = (loopcounter))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H93. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_Hed. % 119.80/120.08 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.08 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H132 zenon_H95). % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 apply zenon_H7c. apply refl_equal. % 119.80/120.08 apply (zenon_or_s _ _ zenon_Hc8); [ zenon_intro zenon_Hca | zenon_intro zenon_Hc9 ]. % 119.80/120.08 apply (zenon_L30_); trivial. % 119.80/120.08 apply (zenon_or_s _ _ zenon_Hc9); [ zenon_intro zenon_Hcc | zenon_intro zenon_Hcb ]. % 119.80/120.08 exact (zenon_Hc3 zenon_Hcc). % 119.80/120.08 exact (zenon_Hc2 zenon_Hcb). % 119.80/120.08 (* end of lemma zenon_L31_ *) % 119.80/120.08 assert (zenon_L32_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (n0) (n0))) -> (~((loopcounter) = (n2))) -> (~((loopcounter) = (n3))) -> (~((n0) = (n1))) -> (~(gt (n0) (n1))) -> False). % 119.80/120.08 do 0 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_H12f zenon_Hc3 zenon_Hc2 zenon_H106 zenon_H13f. % 119.80/120.08 generalize (finite_domain_3 (loopcounter)). zenon_intro zenon_Hc5. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_Hc5); [ zenon_intro zenon_Hc7 | zenon_intro zenon_Hc6 ]. % 119.80/120.08 apply (zenon_notand_s _ _ zenon_Hc7); [ zenon_intro zenon_H68 | zenon_intro zenon_Ha4 ]. % 119.80/120.08 apply (zenon_L5_); trivial. % 119.80/120.08 apply (zenon_L12_); trivial. % 119.80/120.08 apply (zenon_or_s _ _ zenon_Hc6); [ zenon_intro zenon_H95 | zenon_intro zenon_Hc8 ]. % 119.80/120.08 apply (zenon_L29_); trivial. % 119.80/120.08 apply (zenon_or_s _ _ zenon_Hc8); [ zenon_intro zenon_Hca | zenon_intro zenon_Hc9 ]. % 119.80/120.08 apply (zenon_L30_); trivial. % 119.80/120.08 apply (zenon_or_s _ _ zenon_Hc9); [ zenon_intro zenon_Hcc | zenon_intro zenon_Hcb ]. % 119.80/120.08 exact (zenon_Hc3 zenon_Hcc). % 119.80/120.08 exact (zenon_Hc2 zenon_Hcb). % 119.80/120.08 (* end of lemma zenon_L32_ *) % 119.80/120.08 assert (zenon_L33_ : (~((loopcounter) = (n3))) -> (~((loopcounter) = (n2))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n0) (n0))) -> False). % 119.80/120.08 do 0 intro. intros zenon_Hc2 zenon_Hc3 zenon_H7d zenon_H67 zenon_H66 zenon_H12f. % 119.80/120.08 elim (classic ((~((n0) = (n1)))/\(~(gt (n0) (n1))))); [ zenon_intro zenon_H14a | zenon_intro zenon_H14b ]. % 119.80/120.08 apply (zenon_and_s _ _ zenon_H14a). zenon_intro zenon_H106. zenon_intro zenon_H13f. % 119.80/120.08 apply (zenon_L32_); trivial. % 119.80/120.08 cut ((gt (n1) (n0)) = (gt (n0) (n0))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H12f. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact gt_1_0. % 119.80/120.08 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.08 cut (((n1) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H14c]. % 119.80/120.08 congruence. % 119.80/120.08 apply (zenon_notand_s _ _ zenon_H14b); [ zenon_intro zenon_H14e | zenon_intro zenon_H14d ]. % 119.80/120.08 apply zenon_H14e. zenon_intro zenon_H14f. % 119.80/120.08 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.80/120.08 cut (((n0) = (n0)) = ((n1) = (n0))). % 119.80/120.08 intro zenon_D_pnotp. % 119.80/120.08 apply zenon_H14c. % 119.80/120.08 rewrite <- zenon_D_pnotp. % 119.80/120.08 exact zenon_H136. % 119.80/120.08 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.08 cut (((n0) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H106]. % 119.80/120.08 congruence. % 119.80/120.08 exact (zenon_H106 zenon_H14f). % 119.80/120.08 apply zenon_H65. apply refl_equal. % 119.80/120.08 apply zenon_H65. apply refl_equal. % 119.80/120.08 apply zenon_H14d. zenon_intro zenon_H150. % 119.80/120.08 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.80/120.08 generalize (zenon_H142 (n1)). zenon_intro zenon_H151. % 119.80/120.08 generalize (zenon_H151 (n0)). zenon_intro zenon_H152. % 119.80/120.08 apply (zenon_imply_s _ _ zenon_H152); [ zenon_intro zenon_H13f | zenon_intro zenon_H153 ]. % 119.80/120.09 exact (zenon_H13f zenon_H150). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H153); [ zenon_intro zenon_H7b | zenon_intro zenon_H141 ]. % 119.80/120.09 exact (zenon_H7b gt_1_0). % 119.80/120.09 exact (zenon_H12f zenon_H141). % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L33_ *) % 119.80/120.09 assert (zenon_L34_ : (~((loopcounter) = (n3))) -> (~((loopcounter) = (n2))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n0) (n0))) -> False). % 119.80/120.09 do 0 intro. intros zenon_Hc2 zenon_Hc3 zenon_H7d zenon_H67 zenon_H66 zenon_H12f. % 119.80/120.09 apply (zenon_L33_); trivial. % 119.80/120.09 (* end of lemma zenon_L34_ *) % 119.80/120.09 assert (zenon_L35_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (~((loopcounter) = (n2))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_H154 zenon_H155 zenon_Hc2 zenon_Hc3 zenon_H7d zenon_H67. % 119.80/120.09 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.80/120.09 cut ((gt (n0) (sum (n0) (tptp_minus_1) zenon_E)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H154. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H156. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.80/120.09 congruence. % 119.80/120.09 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H159. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H15a. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H15b zenon_H155). % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.80/120.09 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.80/120.09 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H157. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H141. % 119.80/120.09 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.80/120.09 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 exact (zenon_H159 zenon_H15c). % 119.80/120.09 apply (zenon_L34_); trivial. % 119.80/120.09 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H159. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H15a. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H15b zenon_H155). % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L35_ *) % 119.80/120.09 assert (zenon_L36_ : (~((loopcounter) = (n3))) -> (~((loopcounter) = (n2))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(gt (n0) (succ (tptp_minus_1)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.80/120.09 do 0 intro. intros zenon_Hc2 zenon_Hc3 zenon_H7d zenon_H67 zenon_H15d zenon_H66 zenon_H155. % 119.80/120.09 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.80/120.09 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.80/120.09 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.80/120.09 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (tptp_minus_1)))); [ zenon_intro zenon_H15e | zenon_intro zenon_H15f ]. % 119.80/120.09 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.80/120.09 generalize (zenon_H142 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H160. % 119.80/120.09 generalize (zenon_H160 (succ (tptp_minus_1))). zenon_intro zenon_H161. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H161); [ zenon_intro zenon_H157 | zenon_intro zenon_H162 ]. % 119.80/120.09 exact (zenon_H157 zenon_H156). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H162); [ zenon_intro zenon_H15f | zenon_intro zenon_H163 ]. % 119.80/120.09 exact (zenon_H15f zenon_H15e). % 119.80/120.09 exact (zenon_H15d zenon_H163). % 119.80/120.09 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H164 | zenon_intro zenon_H154 ]. % 119.80/120.09 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (n0))); [ zenon_intro zenon_H165 | zenon_intro zenon_H166 ]. % 119.80/120.09 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (n0)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (tptp_minus_1)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H15f. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H165. % 119.80/120.09 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H167. apply sym_equal. exact succ_tptp_minus_1. % 119.80/120.09 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (n0))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H166. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H164. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 exact (zenon_H15b zenon_H155). % 119.80/120.09 apply (zenon_L35_); trivial. % 119.80/120.09 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H157. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H141. % 119.80/120.09 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.80/120.09 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 exact (zenon_H159 zenon_H15c). % 119.80/120.09 apply (zenon_L34_); trivial. % 119.80/120.09 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H159. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H15a. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H15b zenon_H155). % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L36_ *) % 119.80/120.09 assert (zenon_L37_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (tptp_minus_1)) (succ (tptp_minus_1)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (~((loopcounter) = (n2))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_H168 zenon_H155 zenon_Hc2 zenon_Hc3 zenon_H7d zenon_H67. % 119.80/120.09 elim (classic (gt (n0) (succ (tptp_minus_1)))); [ zenon_intro zenon_H163 | zenon_intro zenon_H15d ]. % 119.80/120.09 cut ((gt (n0) (succ (tptp_minus_1))) = (gt (succ (tptp_minus_1)) (succ (tptp_minus_1)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H168. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H163. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.80/120.09 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.80/120.09 congruence. % 119.80/120.09 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H167. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H16a. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H16b succ_tptp_minus_1). % 119.80/120.09 apply zenon_H169. apply refl_equal. % 119.80/120.09 apply zenon_H169. apply refl_equal. % 119.80/120.09 apply zenon_H169. apply refl_equal. % 119.80/120.09 apply (zenon_L36_); trivial. % 119.80/120.09 (* end of lemma zenon_L37_ *) % 119.80/120.09 assert (zenon_L38_ : (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~((loopcounter) = (n3))) -> (~((loopcounter) = (n2))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (succ (tptp_minus_1)) (succ (loopcounter)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.80/120.09 do 0 intro. intros zenon_H7d zenon_H67 zenon_Hc2 zenon_Hc3 zenon_H140 zenon_H155 zenon_H16c zenon_H66. % 119.80/120.09 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.80/120.09 elim (classic (gt (succ (tptp_minus_1)) (n1))); [ zenon_intro zenon_H16d | zenon_intro zenon_H16e ]. % 119.80/120.09 elim (classic (gt (succ (tptp_minus_1)) (succ (n0)))); [ zenon_intro zenon_H16f | zenon_intro zenon_H170 ]. % 119.80/120.09 elim (classic (gt (succ (n0)) (succ (loopcounter)))); [ zenon_intro zenon_Hd6 | zenon_intro zenon_Hd0 ]. % 119.80/120.09 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.80/120.09 generalize (zenon_H171 (succ (n0))). zenon_intro zenon_H172. % 119.80/120.09 generalize (zenon_H172 (succ (loopcounter))). zenon_intro zenon_H173. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H173); [ zenon_intro zenon_H170 | zenon_intro zenon_H174 ]. % 119.80/120.09 exact (zenon_H170 zenon_H16f). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H174); [ zenon_intro zenon_Hd0 | zenon_intro zenon_H175 ]. % 119.80/120.09 exact (zenon_Hd0 zenon_Hd6). % 119.80/120.09 exact (zenon_H16c zenon_H175). % 119.80/120.09 apply (zenon_L24_); trivial. % 119.80/120.09 cut ((gt (succ (tptp_minus_1)) (n1)) = (gt (succ (tptp_minus_1)) (succ (n0)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H170. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H16d. % 119.80/120.09 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H169. apply refl_equal. % 119.80/120.09 exact (zenon_H88 zenon_Hd1). % 119.80/120.09 elim (classic (gt (succ (tptp_minus_1)) (succ (tptp_minus_1)))); [ zenon_intro zenon_H176 | zenon_intro zenon_H168 ]. % 119.80/120.09 elim (classic (gt (succ (tptp_minus_1)) (n0))); [ zenon_intro zenon_H177 | zenon_intro zenon_H178 ]. % 119.80/120.09 cut ((gt (succ (tptp_minus_1)) (n0)) = (gt (succ (tptp_minus_1)) (n1))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H16e. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H177. % 119.80/120.09 cut (((n0) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H106]. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H169. apply refl_equal. % 119.80/120.09 elim (classic (gt (n0) (n1))); [ zenon_intro zenon_H150 | zenon_intro zenon_H13f ]. % 119.80/120.09 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.80/120.09 generalize (zenon_H171 (n0)). zenon_intro zenon_H179. % 119.80/120.09 generalize (zenon_H179 (n1)). zenon_intro zenon_H17a. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H17a); [ zenon_intro zenon_H178 | zenon_intro zenon_H17b ]. % 119.80/120.09 exact (zenon_H178 zenon_H177). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H17b); [ zenon_intro zenon_H13f | zenon_intro zenon_H16d ]. % 119.80/120.09 exact (zenon_H13f zenon_H150). % 119.80/120.09 exact (zenon_H16e zenon_H16d). % 119.80/120.09 apply (zenon_L31_); trivial. % 119.80/120.09 cut ((gt (succ (tptp_minus_1)) (succ (tptp_minus_1))) = (gt (succ (tptp_minus_1)) (n0))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H178. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H176. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H169. apply refl_equal. % 119.80/120.09 exact (zenon_H16b succ_tptp_minus_1). % 119.80/120.09 apply (zenon_L37_); trivial. % 119.80/120.09 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.80/120.09 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H88. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H8b. % 119.80/120.09 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.09 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H87 successor_1). % 119.80/120.09 apply zenon_H8c. apply refl_equal. % 119.80/120.09 apply zenon_H8c. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L38_ *) % 119.80/120.09 assert (zenon_L39_ : (~((loopcounter) = (n3))) -> (~((loopcounter) = (n2))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(gt (n0) (succ (loopcounter)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.80/120.09 do 0 intro. intros zenon_Hc2 zenon_Hc3 zenon_H7d zenon_H67 zenon_H140 zenon_H66 zenon_H155. % 119.80/120.09 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.80/120.09 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.80/120.09 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.80/120.09 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (loopcounter)))); [ zenon_intro zenon_H17c | zenon_intro zenon_H17d ]. % 119.80/120.09 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.80/120.09 generalize (zenon_H142 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H160. % 119.80/120.09 generalize (zenon_H160 (succ (loopcounter))). zenon_intro zenon_H17e. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H17e); [ zenon_intro zenon_H157 | zenon_intro zenon_H17f ]. % 119.80/120.09 exact (zenon_H157 zenon_H156). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H17f); [ zenon_intro zenon_H17d | zenon_intro zenon_H146 ]. % 119.80/120.09 exact (zenon_H17d zenon_H17c). % 119.80/120.09 exact (zenon_H140 zenon_H146). % 119.80/120.09 elim (classic ((n0) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H180 | zenon_intro zenon_H167 ]. % 119.80/120.09 elim (classic (gt (succ (tptp_minus_1)) (succ (loopcounter)))); [ zenon_intro zenon_H175 | zenon_intro zenon_H16c ]. % 119.80/120.09 elim (classic (gt (n0) (succ (loopcounter)))); [ zenon_intro zenon_H146 | zenon_intro zenon_H140 ]. % 119.80/120.09 cut ((gt (n0) (succ (loopcounter))) = (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (loopcounter)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H17d. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H146. % 119.80/120.09 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.80/120.09 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.80/120.09 congruence. % 119.80/120.09 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H159. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H15a. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H15b zenon_H155). % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H76. apply refl_equal. % 119.80/120.09 cut ((gt (succ (tptp_minus_1)) (succ (loopcounter))) = (gt (n0) (succ (loopcounter)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H140. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H175. % 119.80/120.09 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.80/120.09 congruence. % 119.80/120.09 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.80/120.09 cut (((n0) = (n0)) = ((succ (tptp_minus_1)) = (n0))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H16b. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H136. % 119.80/120.09 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.09 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H167 zenon_H180). % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 apply zenon_H76. apply refl_equal. % 119.80/120.09 apply (zenon_L38_); trivial. % 119.80/120.09 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H167. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H16a. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H16b succ_tptp_minus_1). % 119.80/120.09 apply zenon_H169. apply refl_equal. % 119.80/120.09 apply zenon_H169. apply refl_equal. % 119.80/120.09 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H157. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H141. % 119.80/120.09 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.80/120.09 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 exact (zenon_H159 zenon_H15c). % 119.80/120.09 apply (zenon_L34_); trivial. % 119.80/120.09 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H159. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H15a. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H15b zenon_H155). % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L39_ *) % 119.80/120.09 assert (zenon_L40_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (n2))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_H181 zenon_H155 zenon_H140 zenon_Hc2 zenon_H7d zenon_H67. % 119.80/120.09 elim (classic ((loopcounter) = (n2))); [ zenon_intro zenon_Hcc | zenon_intro zenon_Hc3 ]. % 119.80/120.09 cut ((gt (n1) (loopcounter)) = (gt (n1) (n2))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H181. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H7d. % 119.80/120.09 cut (((loopcounter) = (n2))); [idtac | apply NNPP; zenon_intro zenon_Hc3]. % 119.80/120.09 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H64. apply refl_equal. % 119.80/120.09 exact (zenon_Hc3 zenon_Hcc). % 119.80/120.09 apply (zenon_L39_); trivial. % 119.80/120.09 (* end of lemma zenon_L40_ *) % 119.80/120.09 assert (zenon_L41_ : (gt (n1) (loopcounter)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n0)) (succ (n0)))) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.09 do 0 intro. intros zenon_H7d zenon_H66 zenon_Hcd zenon_H67. % 119.80/120.09 elim (classic ((~((succ (n0)) = (succ (loopcounter))))/\(~(gt (succ (n0)) (succ (loopcounter)))))); [ zenon_intro zenon_Hce | zenon_intro zenon_Hcf ]. % 119.80/120.09 apply (zenon_and_s _ _ zenon_Hce). zenon_intro zenon_H97. zenon_intro zenon_Hd0. % 119.80/120.09 apply (zenon_L9_); trivial. % 119.80/120.09 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.80/120.09 cut ((gt (succ (loopcounter)) (n1)) = (gt (succ (n0)) (succ (n0)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_Hcd. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H67. % 119.80/120.09 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.09 cut (((succ (loopcounter)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_Hd2]. % 119.80/120.09 congruence. % 119.80/120.09 apply (zenon_notand_s _ _ zenon_Hcf); [ zenon_intro zenon_Hd4 | zenon_intro zenon_Hd3 ]. % 119.80/120.09 apply zenon_Hd4. zenon_intro zenon_Hd5. % 119.80/120.09 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.80/120.09 cut (((succ (n0)) = (succ (n0))) = ((succ (loopcounter)) = (succ (n0)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_Hd2. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H8b. % 119.80/120.09 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.09 cut (((succ (n0)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H97]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H97 zenon_Hd5). % 119.80/120.09 apply zenon_H8c. apply refl_equal. % 119.80/120.09 apply zenon_H8c. apply refl_equal. % 119.80/120.09 apply zenon_Hd3. zenon_intro zenon_Hd6. % 119.80/120.09 generalize (zenon_H66 (succ (n0))). zenon_intro zenon_H8e. % 119.80/120.09 generalize (zenon_H8e (succ (loopcounter))). zenon_intro zenon_Hd7. % 119.80/120.09 generalize (zenon_Hd7 (n1)). zenon_intro zenon_Hd8. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_Hd8); [ zenon_intro zenon_Hd0 | zenon_intro zenon_Hd9 ]. % 119.80/120.09 exact (zenon_Hd0 zenon_Hd6). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_Hd9); [ zenon_intro zenon_H6f | zenon_intro zenon_H8d ]. % 119.80/120.09 exact (zenon_H6f zenon_H67). % 119.80/120.09 cut ((gt (succ (n0)) (n1)) = (gt (succ (n0)) (succ (n0)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_Hcd. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H8d. % 119.80/120.09 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.09 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H8c. apply refl_equal. % 119.80/120.09 exact (zenon_H88 zenon_Hd1). % 119.80/120.09 exact (zenon_H88 zenon_Hd1). % 119.80/120.09 apply zenon_H88. apply sym_equal. exact successor_1. % 119.80/120.09 (* end of lemma zenon_L41_ *) % 119.80/120.09 assert (zenon_L42_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~((loopcounter) = (n3))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (succ (n0)) (n2))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_Hc2 zenon_H140 zenon_H155 zenon_H182 zenon_H67 zenon_H7d. % 119.80/120.09 elim (classic (gt (succ (n0)) (succ (n0)))); [ zenon_intro zenon_Hda | zenon_intro zenon_Hcd ]. % 119.80/120.09 elim (classic (gt (succ (n0)) (n1))); [ zenon_intro zenon_H8d | zenon_intro zenon_H86 ]. % 119.80/120.09 elim (classic (gt (n1) (n2))); [ zenon_intro zenon_H183 | zenon_intro zenon_H181 ]. % 119.80/120.09 generalize (zenon_H66 (succ (n0))). zenon_intro zenon_H8e. % 119.80/120.09 generalize (zenon_H8e (n1)). zenon_intro zenon_H8f. % 119.80/120.09 generalize (zenon_H8f (n2)). zenon_intro zenon_H184. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H184); [ zenon_intro zenon_H86 | zenon_intro zenon_H185 ]. % 119.80/120.09 exact (zenon_H86 zenon_H8d). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H185); [ zenon_intro zenon_H181 | zenon_intro zenon_H186 ]. % 119.80/120.09 exact (zenon_H181 zenon_H183). % 119.80/120.09 exact (zenon_H182 zenon_H186). % 119.80/120.09 apply (zenon_L40_); trivial. % 119.80/120.09 cut ((gt (succ (n0)) (succ (n0))) = (gt (succ (n0)) (n1))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H86. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_Hda. % 119.80/120.09 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.09 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H8c. apply refl_equal. % 119.80/120.09 exact (zenon_H87 successor_1). % 119.80/120.09 apply (zenon_L41_); trivial. % 119.80/120.09 (* end of lemma zenon_L42_ *) % 119.80/120.09 assert (zenon_L43_ : ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (n1))) -> False). % 119.80/120.09 do 0 intro. intros zenon_H155 zenon_H140 zenon_Hc2 zenon_H7d zenon_H67 zenon_H66 zenon_Hdd. % 119.80/120.09 elim (classic ((~((n1) = (n2)))/\(~(gt (n1) (n2))))); [ zenon_intro zenon_H187 | zenon_intro zenon_H188 ]. % 119.80/120.09 apply (zenon_and_s _ _ zenon_H187). zenon_intro zenon_H189. zenon_intro zenon_H181. % 119.80/120.09 apply (zenon_L40_); trivial. % 119.80/120.09 cut ((gt (n2) (n1)) = (gt (n1) (n1))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_Hdd. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact gt_2_1. % 119.80/120.09 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.09 cut (((n2) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H18a]. % 119.80/120.09 congruence. % 119.80/120.09 apply (zenon_notand_s _ _ zenon_H188); [ zenon_intro zenon_H18c | zenon_intro zenon_H18b ]. % 119.80/120.09 apply zenon_H18c. zenon_intro zenon_H18d. % 119.80/120.09 elim (classic ((n1) = (n1))); [ zenon_intro zenon_Hdc | zenon_intro zenon_H64 ]. % 119.80/120.09 cut (((n1) = (n1)) = ((n2) = (n1))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H18a. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_Hdc. % 119.80/120.09 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.09 cut (((n1) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H189]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H189 zenon_H18d). % 119.80/120.09 apply zenon_H64. apply refl_equal. % 119.80/120.09 apply zenon_H64. apply refl_equal. % 119.80/120.09 apply zenon_H18b. zenon_intro zenon_H183. % 119.80/120.09 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.80/120.09 generalize (zenon_He4 (n2)). zenon_intro zenon_H18e. % 119.80/120.09 generalize (zenon_H18e (n1)). zenon_intro zenon_H18f. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H18f); [ zenon_intro zenon_H181 | zenon_intro zenon_H190 ]. % 119.80/120.09 exact (zenon_H181 zenon_H183). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H190); [ zenon_intro zenon_Hba | zenon_intro zenon_He8 ]. % 119.80/120.09 exact (zenon_Hba gt_2_1). % 119.80/120.09 exact (zenon_Hdd zenon_He8). % 119.80/120.09 apply zenon_H64. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L43_ *) % 119.80/120.09 assert (zenon_L44_ : ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(gt (succ (n0)) (succ (loopcounter)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.80/120.09 do 0 intro. intros zenon_H155 zenon_H140 zenon_Hc2 zenon_H7d zenon_H67 zenon_Hd0 zenon_H66. % 119.80/120.09 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.80/120.09 elim (classic (gt (succ (n0)) (n1))); [ zenon_intro zenon_H8d | zenon_intro zenon_H86 ]. % 119.80/120.09 elim (classic (gt (succ (n0)) (succ (n0)))); [ zenon_intro zenon_Hda | zenon_intro zenon_Hcd ]. % 119.80/120.09 cut ((gt (succ (n0)) (succ (n0))) = (gt (succ (n0)) (succ (loopcounter)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_Hd0. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_Hda. % 119.80/120.09 cut (((succ (n0)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H97]. % 119.80/120.09 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H8c. apply refl_equal. % 119.80/120.09 apply (zenon_L9_); trivial. % 119.80/120.09 cut ((gt (succ (n0)) (n1)) = (gt (succ (n0)) (succ (n0)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_Hcd. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H8d. % 119.80/120.09 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.09 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H8c. apply refl_equal. % 119.80/120.09 exact (zenon_H88 zenon_Hd1). % 119.80/120.09 elim (classic ((~((succ (n0)) = (n2)))/\(~(gt (succ (n0)) (n2))))); [ zenon_intro zenon_H191 | zenon_intro zenon_H192 ]. % 119.80/120.09 apply (zenon_and_s _ _ zenon_H191). zenon_intro zenon_H193. zenon_intro zenon_H182. % 119.80/120.09 apply (zenon_L42_); trivial. % 119.80/120.09 cut ((gt (n2) (n1)) = (gt (succ (n0)) (n1))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H86. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact gt_2_1. % 119.80/120.09 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.09 cut (((n2) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H194]. % 119.80/120.09 congruence. % 119.80/120.09 apply (zenon_notand_s _ _ zenon_H192); [ zenon_intro zenon_H196 | zenon_intro zenon_H195 ]. % 119.80/120.09 apply zenon_H196. zenon_intro zenon_H197. % 119.80/120.09 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.80/120.09 cut (((succ (n0)) = (succ (n0))) = ((n2) = (succ (n0)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H194. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H8b. % 119.80/120.09 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.09 cut (((succ (n0)) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H193]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H193 zenon_H197). % 119.80/120.09 apply zenon_H8c. apply refl_equal. % 119.80/120.09 apply zenon_H8c. apply refl_equal. % 119.80/120.09 apply zenon_H195. zenon_intro zenon_H186. % 119.80/120.09 generalize (zenon_H66 (succ (n0))). zenon_intro zenon_H8e. % 119.80/120.09 generalize (zenon_H8e (n2)). zenon_intro zenon_H198. % 119.80/120.09 generalize (zenon_H198 (n1)). zenon_intro zenon_H199. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H199); [ zenon_intro zenon_H182 | zenon_intro zenon_H19a ]. % 119.80/120.09 exact (zenon_H182 zenon_H186). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H19a); [ zenon_intro zenon_Hba | zenon_intro zenon_H8d ]. % 119.80/120.09 exact (zenon_Hba gt_2_1). % 119.80/120.09 exact (zenon_H86 zenon_H8d). % 119.80/120.09 apply zenon_H64. apply refl_equal. % 119.80/120.09 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.80/120.09 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H88. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H8b. % 119.80/120.09 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.09 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H87 successor_1). % 119.80/120.09 apply zenon_H8c. apply refl_equal. % 119.80/120.09 apply zenon_H8c. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L44_ *) % 119.80/120.09 assert (zenon_L45_ : (~((loopcounter) = (n1))) -> (~((n0) = (n1))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (loopcounter) (n1))) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.09 do 0 intro. intros zenon_Hc4 zenon_H106 zenon_H66 zenon_Hee zenon_Hc2 zenon_H7d zenon_H67. % 119.80/120.09 elim (classic ((~((loopcounter) = (n2)))/\(~(gt (loopcounter) (n2))))); [ zenon_intro zenon_H19b | zenon_intro zenon_H19c ]. % 119.80/120.09 apply (zenon_and_s _ _ zenon_H19b). zenon_intro zenon_Hc3. zenon_intro zenon_H19d. % 119.80/120.09 apply (zenon_L28_); trivial. % 119.80/120.09 cut ((gt (n2) (n1)) = (gt (loopcounter) (n1))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_Hee. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact gt_2_1. % 119.80/120.09 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.09 cut (((n2) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H19e]. % 119.80/120.09 congruence. % 119.80/120.09 apply (zenon_notand_s _ _ zenon_H19c); [ zenon_intro zenon_H1a0 | zenon_intro zenon_H19f ]. % 119.80/120.09 apply zenon_H1a0. zenon_intro zenon_Hcc. % 119.80/120.09 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.80/120.09 cut (((loopcounter) = (loopcounter)) = ((n2) = (loopcounter))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H19e. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_Hed. % 119.80/120.09 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.09 cut (((loopcounter) = (n2))); [idtac | apply NNPP; zenon_intro zenon_Hc3]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_Hc3 zenon_Hcc). % 119.80/120.09 apply zenon_H7c. apply refl_equal. % 119.80/120.09 apply zenon_H7c. apply refl_equal. % 119.80/120.09 apply zenon_H19f. zenon_intro zenon_H1a1. % 119.80/120.09 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.80/120.09 generalize (zenon_H13b (n2)). zenon_intro zenon_H1a2. % 119.80/120.09 generalize (zenon_H1a2 (n1)). zenon_intro zenon_H1a3. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H1a3); [ zenon_intro zenon_H19d | zenon_intro zenon_H1a4 ]. % 119.80/120.09 exact (zenon_H19d zenon_H1a1). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H1a4); [ zenon_intro zenon_Hba | zenon_intro zenon_Hf1 ]. % 119.80/120.09 exact (zenon_Hba gt_2_1). % 119.80/120.09 exact (zenon_Hee zenon_Hf1). % 119.80/120.09 apply zenon_H64. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L45_ *) % 119.80/120.09 assert (zenon_L46_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (loopcounter) (n1))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_Hee zenon_H155 zenon_H140 zenon_Hc2 zenon_H7d zenon_H67. % 119.80/120.09 elim (classic ((~((loopcounter) = (n2)))/\(~(gt (loopcounter) (n2))))); [ zenon_intro zenon_H19b | zenon_intro zenon_H19c ]. % 119.80/120.09 apply (zenon_and_s _ _ zenon_H19b). zenon_intro zenon_Hc3. zenon_intro zenon_H19d. % 119.80/120.09 apply (zenon_L39_); trivial. % 119.80/120.09 cut ((gt (n2) (n1)) = (gt (loopcounter) (n1))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_Hee. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact gt_2_1. % 119.80/120.09 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.09 cut (((n2) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H19e]. % 119.80/120.09 congruence. % 119.80/120.09 apply (zenon_notand_s _ _ zenon_H19c); [ zenon_intro zenon_H1a0 | zenon_intro zenon_H19f ]. % 119.80/120.09 apply zenon_H1a0. zenon_intro zenon_Hcc. % 119.80/120.09 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.80/120.09 cut (((loopcounter) = (loopcounter)) = ((n2) = (loopcounter))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H19e. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_Hed. % 119.80/120.09 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.09 cut (((loopcounter) = (n2))); [idtac | apply NNPP; zenon_intro zenon_Hc3]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_Hc3 zenon_Hcc). % 119.80/120.09 apply zenon_H7c. apply refl_equal. % 119.80/120.09 apply zenon_H7c. apply refl_equal. % 119.80/120.09 apply zenon_H19f. zenon_intro zenon_H1a1. % 119.80/120.09 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.80/120.09 generalize (zenon_H13b (n2)). zenon_intro zenon_H1a2. % 119.80/120.09 generalize (zenon_H1a2 (n1)). zenon_intro zenon_H1a3. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H1a3); [ zenon_intro zenon_H19d | zenon_intro zenon_H1a4 ]. % 119.80/120.09 exact (zenon_H19d zenon_H1a1). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H1a4); [ zenon_intro zenon_Hba | zenon_intro zenon_Hf1 ]. % 119.80/120.09 exact (zenon_Hba gt_2_1). % 119.80/120.09 exact (zenon_Hee zenon_Hf1). % 119.80/120.09 apply zenon_H64. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L46_ *) % 119.80/120.09 assert (zenon_L47_ : ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(gt (loopcounter) (succ (loopcounter)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.80/120.09 do 0 intro. intros zenon_H155 zenon_H140 zenon_Hc2 zenon_H7d zenon_H67 zenon_Hf0 zenon_H66. % 119.80/120.09 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.80/120.09 elim (classic (gt (loopcounter) (n1))); [ zenon_intro zenon_Hf1 | zenon_intro zenon_Hee ]. % 119.80/120.09 elim (classic (gt (loopcounter) (succ (n0)))); [ zenon_intro zenon_Hef | zenon_intro zenon_Heb ]. % 119.80/120.09 cut ((gt (loopcounter) (succ (n0))) = (gt (loopcounter) (succ (loopcounter)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_Hf0. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_Hef. % 119.80/120.09 cut (((succ (n0)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H97]. % 119.80/120.09 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H7c. apply refl_equal. % 119.80/120.09 apply (zenon_L9_); trivial. % 119.80/120.09 cut ((gt (loopcounter) (n1)) = (gt (loopcounter) (succ (n0)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_Heb. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_Hf1. % 119.80/120.09 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.80/120.09 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H7c. apply refl_equal. % 119.80/120.09 exact (zenon_H88 zenon_Hd1). % 119.80/120.09 apply (zenon_L46_); trivial. % 119.80/120.09 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.80/120.09 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H88. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H8b. % 119.80/120.09 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.80/120.09 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H87 successor_1). % 119.80/120.09 apply zenon_H8c. apply refl_equal. % 119.80/120.09 apply zenon_H8c. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L47_ *) % 119.80/120.09 assert (zenon_L48_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (succ (loopcounter)))) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_Hdb zenon_Hc2 zenon_H7d zenon_H67 zenon_H155 zenon_H140. % 119.80/120.09 elim (classic (gt (loopcounter) (succ (loopcounter)))); [ zenon_intro zenon_Hf2 | zenon_intro zenon_Hf0 ]. % 119.80/120.09 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.80/120.09 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.80/120.09 generalize (zenon_Hf3 (succ (loopcounter))). zenon_intro zenon_Hf4. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_Hf4); [ zenon_intro zenon_H92 | zenon_intro zenon_Hf5 ]. % 119.80/120.09 exact (zenon_H92 zenon_H7d). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_Hf5); [ zenon_intro zenon_Hf0 | zenon_intro zenon_He3 ]. % 119.80/120.09 exact (zenon_Hf0 zenon_Hf2). % 119.80/120.09 exact (zenon_Hdb zenon_He3). % 119.80/120.09 apply (zenon_L47_); trivial. % 119.80/120.09 (* end of lemma zenon_L48_ *) % 119.80/120.09 assert (zenon_L49_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n0) (n0))) -> ((loopcounter) = (n0)) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> (~((n0) = (n1))) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_H12f zenon_H95 zenon_H67 zenon_H7d zenon_Hc2 zenon_H106. % 119.80/120.09 elim (classic (gt (n0) (loopcounter))); [ zenon_intro zenon_H130 | zenon_intro zenon_H131 ]. % 119.80/120.09 cut ((gt (n0) (loopcounter)) = (gt (n0) (n0))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H12f. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H130. % 119.80/120.09 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.80/120.09 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 exact (zenon_H132 zenon_H95). % 119.80/120.09 elim (classic ((n0) = (loopcounter))); [ zenon_intro zenon_H133 | zenon_intro zenon_H93 ]. % 119.80/120.09 elim (classic (gt (loopcounter) (loopcounter))); [ zenon_intro zenon_H134 | zenon_intro zenon_H135 ]. % 119.80/120.09 cut ((gt (loopcounter) (loopcounter)) = (gt (n0) (loopcounter))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H131. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H134. % 119.80/120.09 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.09 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.80/120.09 congruence. % 119.80/120.09 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.80/120.09 cut (((n0) = (n0)) = ((loopcounter) = (n0))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H132. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H136. % 119.80/120.09 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.09 cut (((n0) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H93]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H93 zenon_H133). % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 apply zenon_H7c. apply refl_equal. % 119.80/120.09 elim (classic ((~((loopcounter) = (n1)))/\(~(gt (loopcounter) (n1))))); [ zenon_intro zenon_H137 | zenon_intro zenon_H138 ]. % 119.80/120.09 apply (zenon_and_s _ _ zenon_H137). zenon_intro zenon_Hc4. zenon_intro zenon_Hee. % 119.80/120.09 apply (zenon_L45_); trivial. % 119.80/120.09 cut ((gt (n1) (loopcounter)) = (gt (loopcounter) (loopcounter))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H135. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H7d. % 119.80/120.09 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.09 cut (((n1) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_Hec]. % 119.80/120.09 congruence. % 119.80/120.09 apply (zenon_notand_s _ _ zenon_H138); [ zenon_intro zenon_H13a | zenon_intro zenon_H139 ]. % 119.80/120.09 apply zenon_H13a. zenon_intro zenon_Hca. % 119.80/120.09 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.80/120.09 cut (((loopcounter) = (loopcounter)) = ((n1) = (loopcounter))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_Hec. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_Hed. % 119.80/120.09 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.09 cut (((loopcounter) = (n1))); [idtac | apply NNPP; zenon_intro zenon_Hc4]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_Hc4 zenon_Hca). % 119.80/120.09 apply zenon_H7c. apply refl_equal. % 119.80/120.09 apply zenon_H7c. apply refl_equal. % 119.80/120.09 apply zenon_H139. zenon_intro zenon_Hf1. % 119.80/120.09 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.80/120.09 generalize (zenon_H13b (n1)). zenon_intro zenon_H13c. % 119.80/120.09 generalize (zenon_H13c (loopcounter)). zenon_intro zenon_H13d. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H13d); [ zenon_intro zenon_Hee | zenon_intro zenon_H13e ]. % 119.80/120.09 exact (zenon_Hee zenon_Hf1). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H13e); [ zenon_intro zenon_H92 | zenon_intro zenon_H134 ]. % 119.80/120.09 exact (zenon_H92 zenon_H7d). % 119.80/120.09 exact (zenon_H135 zenon_H134). % 119.80/120.09 apply zenon_H7c. apply refl_equal. % 119.80/120.09 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.80/120.09 cut (((loopcounter) = (loopcounter)) = ((n0) = (loopcounter))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H93. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_Hed. % 119.80/120.09 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.09 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H132 zenon_H95). % 119.80/120.09 apply zenon_H7c. apply refl_equal. % 119.80/120.09 apply zenon_H7c. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L49_ *) % 119.80/120.09 assert (zenon_L50_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((loopcounter) = (n1)) -> (~(gt (n0) (n1))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_Hca zenon_H13f zenon_H155 zenon_H140 zenon_Hc2 zenon_H7d zenon_H67. % 119.80/120.09 elim (classic (gt (n1) (n1))); [ zenon_intro zenon_He8 | zenon_intro zenon_Hdd ]. % 119.80/120.09 elim (classic (gt (loopcounter) (n1))); [ zenon_intro zenon_Hf1 | zenon_intro zenon_Hee ]. % 119.80/120.09 cut ((gt (loopcounter) (n1)) = (gt (n0) (n1))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H13f. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_Hf1. % 119.80/120.09 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.09 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.80/120.09 congruence. % 119.80/120.09 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.80/120.09 cut (((n0) = (n0)) = ((loopcounter) = (n0))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H132. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H136. % 119.80/120.09 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.09 cut (((n0) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H93]. % 119.80/120.09 congruence. % 119.80/120.09 apply (zenon_L8_); trivial. % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 apply zenon_H64. apply refl_equal. % 119.80/120.09 cut ((gt (n1) (n1)) = (gt (loopcounter) (n1))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_Hee. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_He8. % 119.80/120.09 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.80/120.09 cut (((n1) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_Hec]. % 119.80/120.09 congruence. % 119.80/120.09 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.80/120.09 cut (((loopcounter) = (loopcounter)) = ((n1) = (loopcounter))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_Hec. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_Hed. % 119.80/120.09 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.09 cut (((loopcounter) = (n1))); [idtac | apply NNPP; zenon_intro zenon_Hc4]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_Hc4 zenon_Hca). % 119.80/120.09 apply zenon_H7c. apply refl_equal. % 119.80/120.09 apply zenon_H7c. apply refl_equal. % 119.80/120.09 apply zenon_H64. apply refl_equal. % 119.80/120.09 apply (zenon_L43_); trivial. % 119.80/120.09 (* end of lemma zenon_L50_ *) % 119.80/120.09 assert (zenon_L51_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n2) (n2))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_H1a5 zenon_H67 zenon_H7d zenon_Hc2 zenon_H140 zenon_H155. % 119.80/120.09 elim (classic (gt (n1) (n2))); [ zenon_intro zenon_H183 | zenon_intro zenon_H181 ]. % 119.80/120.09 generalize (zenon_H66 (n2)). zenon_intro zenon_H1a6. % 119.80/120.09 generalize (zenon_H1a6 (n1)). zenon_intro zenon_H1a7. % 119.80/120.09 generalize (zenon_H1a7 (n2)). zenon_intro zenon_H1a8. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H1a8); [ zenon_intro zenon_Hba | zenon_intro zenon_H1a9 ]. % 119.80/120.09 exact (zenon_Hba gt_2_1). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H1a9); [ zenon_intro zenon_H181 | zenon_intro zenon_H1aa ]. % 119.80/120.09 exact (zenon_H181 zenon_H183). % 119.80/120.09 exact (zenon_H1a5 zenon_H1aa). % 119.80/120.09 apply (zenon_L40_); trivial. % 119.80/120.09 (* end of lemma zenon_L51_ *) % 119.80/120.09 assert (zenon_L52_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((loopcounter) = (n2)) -> (~(gt (n0) (n2))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_Hcc zenon_H1ab zenon_H155 zenon_H140 zenon_Hc2 zenon_H7d zenon_H67. % 119.80/120.09 elim (classic (gt (n2) (n2))); [ zenon_intro zenon_H1aa | zenon_intro zenon_H1a5 ]. % 119.80/120.09 elim (classic (gt (loopcounter) (n2))); [ zenon_intro zenon_H1a1 | zenon_intro zenon_H19d ]. % 119.80/120.09 cut ((gt (loopcounter) (n2)) = (gt (n0) (n2))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H1ab. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H1a1. % 119.80/120.09 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.80/120.09 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.80/120.09 congruence. % 119.80/120.09 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.80/120.09 cut (((n0) = (n0)) = ((loopcounter) = (n0))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H132. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H136. % 119.80/120.09 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.09 cut (((n0) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H93]. % 119.80/120.09 congruence. % 119.80/120.09 apply (zenon_L8_); trivial. % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 apply zenon_H63. apply refl_equal. % 119.80/120.09 cut ((gt (n2) (n2)) = (gt (loopcounter) (n2))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H19d. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H1aa. % 119.80/120.09 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.80/120.09 cut (((n2) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H19e]. % 119.80/120.09 congruence. % 119.80/120.09 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.80/120.09 cut (((loopcounter) = (loopcounter)) = ((n2) = (loopcounter))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H19e. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_Hed. % 119.80/120.09 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.80/120.09 cut (((loopcounter) = (n2))); [idtac | apply NNPP; zenon_intro zenon_Hc3]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_Hc3 zenon_Hcc). % 119.80/120.09 apply zenon_H7c. apply refl_equal. % 119.80/120.09 apply zenon_H7c. apply refl_equal. % 119.80/120.09 apply zenon_H63. apply refl_equal. % 119.80/120.09 apply (zenon_L51_); trivial. % 119.80/120.09 (* end of lemma zenon_L52_ *) % 119.80/120.09 assert (zenon_L53_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (n0) (n0))) -> (~((n0) = (n1))) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (~(gt (n0) (n1))) -> (~(gt (n0) (n2))) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_H12f zenon_H106 zenon_Hc2 zenon_H155 zenon_H140 zenon_H13f zenon_H1ab. % 119.80/120.09 generalize (finite_domain_3 (loopcounter)). zenon_intro zenon_Hc5. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_Hc5); [ zenon_intro zenon_Hc7 | zenon_intro zenon_Hc6 ]. % 119.80/120.09 apply (zenon_notand_s _ _ zenon_Hc7); [ zenon_intro zenon_H68 | zenon_intro zenon_Ha4 ]. % 119.80/120.09 apply (zenon_L5_); trivial. % 119.80/120.09 apply (zenon_L12_); trivial. % 119.80/120.09 apply (zenon_or_s _ _ zenon_Hc6); [ zenon_intro zenon_H95 | zenon_intro zenon_Hc8 ]. % 119.80/120.09 apply (zenon_L49_); trivial. % 119.80/120.09 apply (zenon_or_s _ _ zenon_Hc8); [ zenon_intro zenon_Hca | zenon_intro zenon_Hc9 ]. % 119.80/120.09 apply (zenon_L50_); trivial. % 119.80/120.09 apply (zenon_or_s _ _ zenon_Hc9); [ zenon_intro zenon_Hcc | zenon_intro zenon_Hcb ]. % 119.80/120.09 apply (zenon_L52_); trivial. % 119.80/120.09 exact (zenon_Hc2 zenon_Hcb). % 119.80/120.09 (* end of lemma zenon_L53_ *) % 119.80/120.09 assert (zenon_L54_ : (~(gt (n0) (n2))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n0) (n0))) -> False). % 119.80/120.09 do 0 intro. intros zenon_H1ab zenon_H140 zenon_H155 zenon_Hc2 zenon_H7d zenon_H67 zenon_H66 zenon_H12f. % 119.80/120.09 elim (classic ((~((n0) = (n1)))/\(~(gt (n0) (n1))))); [ zenon_intro zenon_H14a | zenon_intro zenon_H14b ]. % 119.80/120.09 apply (zenon_and_s _ _ zenon_H14a). zenon_intro zenon_H106. zenon_intro zenon_H13f. % 119.80/120.09 apply (zenon_L53_); trivial. % 119.80/120.09 cut ((gt (n1) (n0)) = (gt (n0) (n0))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H12f. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact gt_1_0. % 119.80/120.09 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.09 cut (((n1) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H14c]. % 119.80/120.09 congruence. % 119.80/120.09 apply (zenon_notand_s _ _ zenon_H14b); [ zenon_intro zenon_H14e | zenon_intro zenon_H14d ]. % 119.80/120.09 apply zenon_H14e. zenon_intro zenon_H14f. % 119.80/120.09 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.80/120.09 cut (((n0) = (n0)) = ((n1) = (n0))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H14c. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H136. % 119.80/120.09 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.09 cut (((n0) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H106]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H106 zenon_H14f). % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 apply zenon_H14d. zenon_intro zenon_H150. % 119.80/120.09 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.80/120.09 generalize (zenon_H142 (n1)). zenon_intro zenon_H151. % 119.80/120.09 generalize (zenon_H151 (n0)). zenon_intro zenon_H152. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H152); [ zenon_intro zenon_H13f | zenon_intro zenon_H153 ]. % 119.80/120.09 exact (zenon_H13f zenon_H150). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H153); [ zenon_intro zenon_H7b | zenon_intro zenon_H141 ]. % 119.80/120.09 exact (zenon_H7b gt_1_0). % 119.80/120.09 exact (zenon_H12f zenon_H141). % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L54_ *) % 119.80/120.09 assert (zenon_L55_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (~(gt (n0) (n2))) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_H154 zenon_H67 zenon_H7d zenon_Hc2 zenon_H155 zenon_H140 zenon_H1ab. % 119.80/120.09 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.80/120.09 cut ((gt (n0) (sum (n0) (tptp_minus_1) zenon_E)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H154. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H156. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.80/120.09 congruence. % 119.80/120.09 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H159. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H15a. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H15b zenon_H155). % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.80/120.09 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.80/120.09 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H157. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H141. % 119.80/120.09 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.80/120.09 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 exact (zenon_H159 zenon_H15c). % 119.80/120.09 apply (zenon_L54_); trivial. % 119.80/120.09 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H159. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H15a. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H15b zenon_H155). % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L55_ *) % 119.80/120.09 assert (zenon_L56_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (succ (loopcounter)))) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_Hdb zenon_Hc2 zenon_H7d zenon_H67 zenon_H155 zenon_H140. % 119.80/120.09 apply (zenon_L48_); trivial. % 119.80/120.09 (* end of lemma zenon_L56_ *) % 119.80/120.09 assert (zenon_L57_ : (~(gt (n0) (n2))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n0) (n0))) -> False). % 119.80/120.09 do 0 intro. intros zenon_H1ab zenon_H140 zenon_H155 zenon_Hc2 zenon_H7d zenon_H67 zenon_H66 zenon_H12f. % 119.80/120.09 apply (zenon_L54_); trivial. % 119.80/120.09 (* end of lemma zenon_L57_ *) % 119.80/120.09 assert (zenon_L58_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))) -> (~(gt (n0) (n2))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_H154 zenon_H1ab zenon_H140 zenon_H155 zenon_Hc2 zenon_H7d zenon_H67. % 119.80/120.09 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.80/120.09 cut ((gt (n0) (sum (n0) (tptp_minus_1) zenon_E)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H154. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H156. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.80/120.09 congruence. % 119.80/120.09 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H159. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H15a. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H15b zenon_H155). % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.80/120.09 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.80/120.09 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H157. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H141. % 119.80/120.09 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.80/120.09 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 exact (zenon_H159 zenon_H15c). % 119.80/120.09 apply (zenon_L57_); trivial. % 119.80/120.09 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H159. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H15a. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H15b zenon_H155). % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L58_ *) % 119.80/120.09 assert (zenon_L59_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (succ (loopcounter)))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_Hdb zenon_H140 zenon_H155 zenon_Hc2 zenon_H7d zenon_H67. % 119.80/120.09 apply (zenon_L56_); trivial. % 119.80/120.09 (* end of lemma zenon_L59_ *) % 119.80/120.09 assert (zenon_L60_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (succ (loopcounter)))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_Hdb zenon_H67 zenon_H7d zenon_Hc2 zenon_H155 zenon_H140. % 119.80/120.09 apply (zenon_L59_); trivial. % 119.80/120.09 (* end of lemma zenon_L60_ *) % 119.80/120.09 assert (zenon_L61_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (tptp_minus_1)) (succ (tptp_minus_1)))) -> (~(gt (n0) (n2))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_H168 zenon_H1ab zenon_H140 zenon_H155 zenon_Hc2 zenon_H7d zenon_H67. % 119.80/120.09 elim (classic (gt (n0) (succ (tptp_minus_1)))); [ zenon_intro zenon_H163 | zenon_intro zenon_H15d ]. % 119.80/120.09 cut ((gt (n0) (succ (tptp_minus_1))) = (gt (succ (tptp_minus_1)) (succ (tptp_minus_1)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H168. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H163. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.80/120.09 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.80/120.09 congruence. % 119.80/120.09 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H167. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H16a. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H16b succ_tptp_minus_1). % 119.80/120.09 apply zenon_H169. apply refl_equal. % 119.80/120.09 apply zenon_H169. apply refl_equal. % 119.80/120.09 apply zenon_H169. apply refl_equal. % 119.80/120.09 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.80/120.09 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.80/120.09 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.80/120.09 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (tptp_minus_1)))); [ zenon_intro zenon_H15e | zenon_intro zenon_H15f ]. % 119.80/120.09 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.80/120.09 generalize (zenon_H142 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H160. % 119.80/120.09 generalize (zenon_H160 (succ (tptp_minus_1))). zenon_intro zenon_H161. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H161); [ zenon_intro zenon_H157 | zenon_intro zenon_H162 ]. % 119.80/120.09 exact (zenon_H157 zenon_H156). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H162); [ zenon_intro zenon_H15f | zenon_intro zenon_H163 ]. % 119.80/120.09 exact (zenon_H15f zenon_H15e). % 119.80/120.09 exact (zenon_H15d zenon_H163). % 119.80/120.09 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H164 | zenon_intro zenon_H154 ]. % 119.80/120.09 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (n0))); [ zenon_intro zenon_H165 | zenon_intro zenon_H166 ]. % 119.80/120.09 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (n0)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (tptp_minus_1)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H15f. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H165. % 119.80/120.09 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H167. apply sym_equal. exact succ_tptp_minus_1. % 119.80/120.09 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (n0))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H166. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H164. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 exact (zenon_H15b zenon_H155). % 119.80/120.09 apply (zenon_L58_); trivial. % 119.80/120.09 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H157. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H141. % 119.80/120.09 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.80/120.09 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 exact (zenon_H159 zenon_H15c). % 119.80/120.09 apply (zenon_L57_); trivial. % 119.80/120.09 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H159. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H15a. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H15b zenon_H155). % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L61_ *) % 119.80/120.09 assert (zenon_L62_ : (~(gt (n0) (succ (loopcounter)))) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(gt (n1) (succ (loopcounter)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.80/120.09 do 0 intro. intros zenon_H140 zenon_Hc2 zenon_H7d zenon_H67 zenon_Hdb zenon_H66 zenon_H155. % 119.80/120.09 apply (zenon_L60_); trivial. % 119.80/120.09 (* end of lemma zenon_L62_ *) % 119.80/120.09 assert (zenon_L63_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (succ (loopcounter)))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_Hdb zenon_H67 zenon_H7d zenon_Hc2 zenon_H155 zenon_H140. % 119.80/120.09 apply (zenon_L62_); trivial. % 119.80/120.09 (* end of lemma zenon_L63_ *) % 119.80/120.09 assert (zenon_L64_ : (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n0) (n0))) -> False). % 119.80/120.09 do 0 intro. intros zenon_H140 zenon_H155 zenon_Hc2 zenon_H7d zenon_H67 zenon_H66 zenon_H12f. % 119.80/120.09 elim (classic ((~((n0) = (n2)))/\(~(gt (n0) (n2))))); [ zenon_intro zenon_H1ac | zenon_intro zenon_H1ad ]. % 119.80/120.09 apply (zenon_and_s _ _ zenon_H1ac). zenon_intro zenon_H1ae. zenon_intro zenon_H1ab. % 119.80/120.09 apply (zenon_L57_); trivial. % 119.80/120.09 cut ((gt (n2) (n0)) = (gt (n0) (n0))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H12f. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact gt_2_0. % 119.80/120.09 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.09 cut (((n2) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H1af]. % 119.80/120.09 congruence. % 119.80/120.09 apply (zenon_notand_s _ _ zenon_H1ad); [ zenon_intro zenon_H1b1 | zenon_intro zenon_H1b0 ]. % 119.80/120.09 apply zenon_H1b1. zenon_intro zenon_H1b2. % 119.80/120.09 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.80/120.09 cut (((n0) = (n0)) = ((n2) = (n0))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H1af. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H136. % 119.80/120.09 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.09 cut (((n0) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H1ae]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H1ae zenon_H1b2). % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 apply zenon_H1b0. zenon_intro zenon_H1b3. % 119.80/120.09 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.80/120.09 generalize (zenon_H142 (n2)). zenon_intro zenon_H1b4. % 119.80/120.09 generalize (zenon_H1b4 (n0)). zenon_intro zenon_H1b5. % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H1b5); [ zenon_intro zenon_H1ab | zenon_intro zenon_H1b6 ]. % 119.80/120.09 exact (zenon_H1ab zenon_H1b3). % 119.80/120.09 apply (zenon_imply_s _ _ zenon_H1b6); [ zenon_intro zenon_H1b7 | zenon_intro zenon_H141 ]. % 119.80/120.09 exact (zenon_H1b7 gt_2_0). % 119.80/120.09 exact (zenon_H12f zenon_H141). % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L64_ *) % 119.80/120.09 assert (zenon_L65_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_H154 zenon_H67 zenon_H7d zenon_Hc2 zenon_H155 zenon_H140. % 119.80/120.09 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.80/120.09 cut ((gt (n0) (sum (n0) (tptp_minus_1) zenon_E)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H154. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H156. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.80/120.09 congruence. % 119.80/120.09 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H159. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H15a. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H15b zenon_H155). % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.80/120.09 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.80/120.09 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H157. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H141. % 119.80/120.09 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.80/120.09 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.09 congruence. % 119.80/120.09 apply zenon_H65. apply refl_equal. % 119.80/120.09 exact (zenon_H159 zenon_H15c). % 119.80/120.09 apply (zenon_L64_); trivial. % 119.80/120.09 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H159. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H15a. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.09 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.80/120.09 congruence. % 119.80/120.09 exact (zenon_H15b zenon_H155). % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 apply zenon_H158. apply refl_equal. % 119.80/120.09 (* end of lemma zenon_L65_ *) % 119.80/120.09 assert (zenon_L66_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (tptp_minus_1)) (succ (tptp_minus_1)))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> False). % 119.80/120.09 do 0 intro. intros zenon_H66 zenon_H168 zenon_H67 zenon_H7d zenon_Hc2 zenon_H155 zenon_H140. % 119.80/120.09 elim (classic (gt (n0) (succ (tptp_minus_1)))); [ zenon_intro zenon_H163 | zenon_intro zenon_H15d ]. % 119.80/120.09 cut ((gt (n0) (succ (tptp_minus_1))) = (gt (succ (tptp_minus_1)) (succ (tptp_minus_1)))). % 119.80/120.09 intro zenon_D_pnotp. % 119.80/120.09 apply zenon_H168. % 119.80/120.09 rewrite <- zenon_D_pnotp. % 119.80/120.09 exact zenon_H163. % 119.80/120.09 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.80/120.10 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.80/120.10 congruence. % 119.80/120.10 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.80/120.10 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.80/120.10 intro zenon_D_pnotp. % 119.80/120.10 apply zenon_H167. % 119.80/120.10 rewrite <- zenon_D_pnotp. % 119.80/120.10 exact zenon_H16a. % 119.80/120.10 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.80/120.10 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.80/120.10 congruence. % 119.80/120.10 exact (zenon_H16b succ_tptp_minus_1). % 119.80/120.10 apply zenon_H169. apply refl_equal. % 119.80/120.10 apply zenon_H169. apply refl_equal. % 119.80/120.10 apply zenon_H169. apply refl_equal. % 119.80/120.10 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.80/120.10 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.80/120.10 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.80/120.10 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (tptp_minus_1)))); [ zenon_intro zenon_H15e | zenon_intro zenon_H15f ]. % 119.80/120.10 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.80/120.10 generalize (zenon_H142 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H160. % 119.80/120.10 generalize (zenon_H160 (succ (tptp_minus_1))). zenon_intro zenon_H161. % 119.80/120.10 apply (zenon_imply_s _ _ zenon_H161); [ zenon_intro zenon_H157 | zenon_intro zenon_H162 ]. % 119.80/120.10 exact (zenon_H157 zenon_H156). % 119.80/120.10 apply (zenon_imply_s _ _ zenon_H162); [ zenon_intro zenon_H15f | zenon_intro zenon_H163 ]. % 119.80/120.10 exact (zenon_H15f zenon_H15e). % 119.80/120.10 exact (zenon_H15d zenon_H163). % 119.80/120.10 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H164 | zenon_intro zenon_H154 ]. % 119.80/120.10 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (n0))); [ zenon_intro zenon_H165 | zenon_intro zenon_H166 ]. % 119.80/120.10 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (n0)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (tptp_minus_1)))). % 119.80/120.10 intro zenon_D_pnotp. % 119.80/120.10 apply zenon_H15f. % 119.80/120.10 rewrite <- zenon_D_pnotp. % 119.80/120.10 exact zenon_H165. % 119.80/120.10 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.80/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.10 congruence. % 119.80/120.10 apply zenon_H158. apply refl_equal. % 119.80/120.10 apply zenon_H167. apply sym_equal. exact succ_tptp_minus_1. % 119.80/120.10 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (n0))). % 119.80/120.10 intro zenon_D_pnotp. % 119.80/120.10 apply zenon_H166. % 119.80/120.10 rewrite <- zenon_D_pnotp. % 119.80/120.10 exact zenon_H164. % 119.80/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.80/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.10 congruence. % 119.80/120.10 apply zenon_H158. apply refl_equal. % 119.80/120.10 exact (zenon_H15b zenon_H155). % 119.80/120.10 apply (zenon_L65_); trivial. % 119.80/120.10 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.10 intro zenon_D_pnotp. % 119.80/120.10 apply zenon_H157. % 119.80/120.10 rewrite <- zenon_D_pnotp. % 119.80/120.10 exact zenon_H141. % 119.80/120.10 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.80/120.10 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.80/120.10 congruence. % 119.80/120.10 apply zenon_H65. apply refl_equal. % 119.80/120.10 exact (zenon_H159 zenon_H15c). % 119.80/120.10 apply (zenon_L64_); trivial. % 119.80/120.10 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.80/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.80/120.10 intro zenon_D_pnotp. % 119.80/120.10 apply zenon_H159. % 119.80/120.10 rewrite <- zenon_D_pnotp. % 119.80/120.10 exact zenon_H15a. % 119.80/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.80/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.80/120.10 congruence. % 119.80/120.10 exact (zenon_H15b zenon_H155). % 119.80/120.10 apply zenon_H158. apply refl_equal. % 119.80/120.10 apply zenon_H158. apply refl_equal. % 119.80/120.10 (* end of lemma zenon_L66_ *) % 119.85/120.10 assert (zenon_L67_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n1) (succ (loopcounter)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.10 do 0 intro. intros zenon_H67 zenon_H7d zenon_Hc2 zenon_H140 zenon_H155 zenon_Hdb zenon_H66. % 119.85/120.10 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.85/120.10 elim (classic (gt (succ (n0)) (succ (loopcounter)))); [ zenon_intro zenon_Hd6 | zenon_intro zenon_Hd0 ]. % 119.85/120.10 cut ((gt (succ (n0)) (succ (loopcounter))) = (gt (n1) (succ (loopcounter)))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_Hdb. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_Hd6. % 119.85/120.10 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.85/120.10 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.85/120.10 congruence. % 119.85/120.10 elim (classic ((n1) = (n1))); [ zenon_intro zenon_Hdc | zenon_intro zenon_H64 ]. % 119.85/120.10 cut (((n1) = (n1)) = ((succ (n0)) = (n1))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H87. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_Hdc. % 119.85/120.10 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.10 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H88 zenon_Hd1). % 119.85/120.10 apply zenon_H64. apply refl_equal. % 119.85/120.10 apply zenon_H64. apply refl_equal. % 119.85/120.10 apply zenon_H76. apply refl_equal. % 119.85/120.10 apply (zenon_L44_); trivial. % 119.85/120.10 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.85/120.10 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H88. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H8b. % 119.85/120.10 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.85/120.10 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H87 successor_1). % 119.85/120.10 apply zenon_H8c. apply refl_equal. % 119.85/120.10 apply zenon_H8c. apply refl_equal. % 119.85/120.10 (* end of lemma zenon_L67_ *) % 119.85/120.10 assert (zenon_L68_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (succ (n0)) (succ (succ (n0))))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.10 do 0 intro. intros zenon_H67 zenon_H7d zenon_Hc2 zenon_H140 zenon_H155 zenon_H1b8 zenon_H66. % 119.85/120.10 elim (classic ((n2) = (succ (succ (n0))))); [ zenon_intro zenon_H1b9 | zenon_intro zenon_H102 ]. % 119.85/120.10 elim (classic (gt (succ (n0)) (n2))); [ zenon_intro zenon_H186 | zenon_intro zenon_H182 ]. % 119.85/120.10 cut ((gt (succ (n0)) (n2)) = (gt (succ (n0)) (succ (succ (n0))))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H1b8. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H186. % 119.85/120.10 cut (((n2) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 119.85/120.10 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H8c. apply refl_equal. % 119.85/120.10 exact (zenon_H102 zenon_H1b9). % 119.85/120.10 apply (zenon_L42_); trivial. % 119.85/120.10 elim (classic ((succ (succ (n0))) = (succ (succ (n0))))); [ zenon_intro zenon_H103 | zenon_intro zenon_H104 ]. % 119.85/120.10 cut (((succ (succ (n0))) = (succ (succ (n0)))) = ((n2) = (succ (succ (n0))))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H102. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H103. % 119.85/120.10 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.85/120.10 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H105 successor_2). % 119.85/120.10 apply zenon_H104. apply refl_equal. % 119.85/120.10 apply zenon_H104. apply refl_equal. % 119.85/120.10 (* end of lemma zenon_L68_ *) % 119.85/120.10 assert (zenon_L69_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (~((n0) = (n1))) -> (~(gt (n0) (n1))) -> (~(gt (n0) (n2))) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_H140 zenon_H155 zenon_Hc2 zenon_H106 zenon_H13f zenon_H1ab. % 119.85/120.10 generalize (finite_domain_3 (loopcounter)). zenon_intro zenon_Hc5. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_Hc5); [ zenon_intro zenon_Hc7 | zenon_intro zenon_Hc6 ]. % 119.85/120.10 apply (zenon_notand_s _ _ zenon_Hc7); [ zenon_intro zenon_H68 | zenon_intro zenon_Ha4 ]. % 119.85/120.10 apply (zenon_L5_); trivial. % 119.85/120.10 apply (zenon_L12_); trivial. % 119.85/120.10 apply (zenon_or_s _ _ zenon_Hc6); [ zenon_intro zenon_H95 | zenon_intro zenon_Hc8 ]. % 119.85/120.10 elim (classic ((n0) = (loopcounter))); [ zenon_intro zenon_H133 | zenon_intro zenon_H93 ]. % 119.85/120.10 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.85/120.10 elim (classic (gt (n0) (loopcounter))); [ zenon_intro zenon_H130 | zenon_intro zenon_H131 ]. % 119.85/120.10 elim (classic (gt (loopcounter) (succ (loopcounter)))); [ zenon_intro zenon_Hf2 | zenon_intro zenon_Hf0 ]. % 119.85/120.10 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.85/120.10 generalize (zenon_H142 (loopcounter)). zenon_intro zenon_H143. % 119.85/120.10 generalize (zenon_H143 (succ (loopcounter))). zenon_intro zenon_H144. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H144); [ zenon_intro zenon_H131 | zenon_intro zenon_H145 ]. % 119.85/120.10 exact (zenon_H131 zenon_H130). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H145); [ zenon_intro zenon_Hf0 | zenon_intro zenon_H146 ]. % 119.85/120.10 exact (zenon_Hf0 zenon_Hf2). % 119.85/120.10 exact (zenon_H140 zenon_H146). % 119.85/120.10 apply (zenon_L47_); trivial. % 119.85/120.10 cut ((gt (n0) (n0)) = (gt (n0) (loopcounter))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H131. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H141. % 119.85/120.10 cut (((n0) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H93]. % 119.85/120.10 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H65. apply refl_equal. % 119.85/120.10 exact (zenon_H93 zenon_H133). % 119.85/120.10 apply (zenon_L49_); trivial. % 119.85/120.10 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.10 cut (((loopcounter) = (loopcounter)) = ((n0) = (loopcounter))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H93. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_Hed. % 119.85/120.10 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.10 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H132 zenon_H95). % 119.85/120.10 apply zenon_H7c. apply refl_equal. % 119.85/120.10 apply zenon_H7c. apply refl_equal. % 119.85/120.10 apply (zenon_or_s _ _ zenon_Hc8); [ zenon_intro zenon_Hca | zenon_intro zenon_Hc9 ]. % 119.85/120.10 apply (zenon_L50_); trivial. % 119.85/120.10 apply (zenon_or_s _ _ zenon_Hc9); [ zenon_intro zenon_Hcc | zenon_intro zenon_Hcb ]. % 119.85/120.10 apply (zenon_L52_); trivial. % 119.85/120.10 exact (zenon_Hc2 zenon_Hcb). % 119.85/120.10 (* end of lemma zenon_L69_ *) % 119.85/120.10 assert (zenon_L70_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (n1))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (~(gt (n0) (n2))) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_H1ba zenon_H67 zenon_H7d zenon_Hc2 zenon_H155 zenon_H140 zenon_H1ab. % 119.85/120.10 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H164 | zenon_intro zenon_H154 ]. % 119.85/120.10 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (n0))); [ zenon_intro zenon_H165 | zenon_intro zenon_H166 ]. % 119.85/120.10 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (n0)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (n1))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H1ba. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H165. % 119.85/120.10 cut (((n0) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H106]. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H158. apply refl_equal. % 119.85/120.10 elim (classic (gt (n0) (n1))); [ zenon_intro zenon_H150 | zenon_intro zenon_H13f ]. % 119.85/120.10 generalize (zenon_H66 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H1bb. % 119.85/120.10 generalize (zenon_H1bb (n0)). zenon_intro zenon_H1bc. % 119.85/120.10 generalize (zenon_H1bc (n1)). zenon_intro zenon_H1bd. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1bd); [ zenon_intro zenon_H166 | zenon_intro zenon_H1be ]. % 119.85/120.10 exact (zenon_H166 zenon_H165). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1be); [ zenon_intro zenon_H13f | zenon_intro zenon_H1bf ]. % 119.85/120.10 exact (zenon_H13f zenon_H150). % 119.85/120.10 exact (zenon_H1ba zenon_H1bf). % 119.85/120.10 apply (zenon_L69_); trivial. % 119.85/120.10 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (n0))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H166. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H164. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H158. apply refl_equal. % 119.85/120.10 exact (zenon_H15b zenon_H155). % 119.85/120.10 apply (zenon_L58_); trivial. % 119.85/120.10 (* end of lemma zenon_L70_ *) % 119.85/120.10 assert (zenon_L71_ : ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(gt (n0) (n2))) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (succ (succ (n0))))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.10 do 0 intro. intros zenon_H155 zenon_H140 zenon_Hc2 zenon_H7d zenon_H67 zenon_H1ab zenon_H1c0 zenon_H66. % 119.85/120.10 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.85/120.10 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (n1))); [ zenon_intro zenon_H1bf | zenon_intro zenon_H1ba ]. % 119.85/120.10 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (n0)))); [ zenon_intro zenon_H1c1 | zenon_intro zenon_H1c2 ]. % 119.85/120.10 elim (classic (gt (succ (n0)) (succ (succ (n0))))); [ zenon_intro zenon_H1c3 | zenon_intro zenon_H1b8 ]. % 119.85/120.10 generalize (zenon_H66 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H1bb. % 119.85/120.10 generalize (zenon_H1bb (succ (n0))). zenon_intro zenon_H1c4. % 119.85/120.10 generalize (zenon_H1c4 (succ (succ (n0)))). zenon_intro zenon_H1c5. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1c5); [ zenon_intro zenon_H1c2 | zenon_intro zenon_H1c6 ]. % 119.85/120.10 exact (zenon_H1c2 zenon_H1c1). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1c6); [ zenon_intro zenon_H1b8 | zenon_intro zenon_H1c7 ]. % 119.85/120.10 exact (zenon_H1b8 zenon_H1c3). % 119.85/120.10 exact (zenon_H1c0 zenon_H1c7). % 119.85/120.10 apply (zenon_L68_); trivial. % 119.85/120.10 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (n1)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (n0)))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H1c2. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H1bf. % 119.85/120.10 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H158. apply refl_equal. % 119.85/120.10 exact (zenon_H88 zenon_Hd1). % 119.85/120.10 apply (zenon_L70_); trivial. % 119.85/120.10 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.85/120.10 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H88. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H8b. % 119.85/120.10 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.85/120.10 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H87 successor_1). % 119.85/120.10 apply zenon_H8c. apply refl_equal. % 119.85/120.10 apply zenon_H8c. apply refl_equal. % 119.85/120.10 (* end of lemma zenon_L71_ *) % 119.85/120.10 assert (zenon_L72_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (n2))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (~(gt (n0) (n2))) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_H1c8 zenon_H67 zenon_H7d zenon_Hc2 zenon_H155 zenon_H140 zenon_H1ab. % 119.85/120.10 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (succ (n0))))); [ zenon_intro zenon_H1c7 | zenon_intro zenon_H1c0 ]. % 119.85/120.10 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (succ (succ (n0)))) = (gt (sum (n0) (tptp_minus_1) zenon_E) (n2))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H1c8. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H1c7. % 119.85/120.10 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H158. apply refl_equal. % 119.85/120.10 exact (zenon_H105 successor_2). % 119.85/120.10 apply (zenon_L71_); trivial. % 119.85/120.10 (* end of lemma zenon_L72_ *) % 119.85/120.10 assert (zenon_L73_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (n2))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_H1c8 zenon_H140 zenon_H155 zenon_Hc2 zenon_H7d zenon_H67. % 119.85/120.10 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H164 | zenon_intro zenon_H154 ]. % 119.85/120.10 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (n0))); [ zenon_intro zenon_H165 | zenon_intro zenon_H166 ]. % 119.85/120.10 elim (classic (gt (n0) (n2))); [ zenon_intro zenon_H1b3 | zenon_intro zenon_H1ab ]. % 119.85/120.10 generalize (zenon_H66 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H1bb. % 119.85/120.10 generalize (zenon_H1bb (n0)). zenon_intro zenon_H1bc. % 119.85/120.10 generalize (zenon_H1bc (n2)). zenon_intro zenon_H1c9. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1c9); [ zenon_intro zenon_H166 | zenon_intro zenon_H1ca ]. % 119.85/120.10 exact (zenon_H166 zenon_H165). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1ca); [ zenon_intro zenon_H1ab | zenon_intro zenon_H1cb ]. % 119.85/120.10 exact (zenon_H1ab zenon_H1b3). % 119.85/120.10 exact (zenon_H1c8 zenon_H1cb). % 119.85/120.10 apply (zenon_L72_); trivial. % 119.85/120.10 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (n0))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H166. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H164. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H158. apply refl_equal. % 119.85/120.10 exact (zenon_H15b zenon_H155). % 119.85/120.10 apply (zenon_L65_); trivial. % 119.85/120.10 (* end of lemma zenon_L73_ *) % 119.85/120.10 assert (zenon_L74_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> (~(gt (n0) (succ (loopcounter)))) -> (~(gt (n0) (succ (succ (n0))))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.10 do 0 intro. intros zenon_H67 zenon_H7d zenon_Hc2 zenon_H140 zenon_H1cc zenon_H66 zenon_H155. % 119.85/120.10 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.85/120.10 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.85/120.10 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.85/120.10 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (succ (n0))))); [ zenon_intro zenon_H1c7 | zenon_intro zenon_H1c0 ]. % 119.85/120.10 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.85/120.10 generalize (zenon_H142 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H160. % 119.85/120.10 generalize (zenon_H160 (succ (succ (n0)))). zenon_intro zenon_H1cd. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1cd); [ zenon_intro zenon_H157 | zenon_intro zenon_H1ce ]. % 119.85/120.10 exact (zenon_H157 zenon_H156). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1ce); [ zenon_intro zenon_H1c0 | zenon_intro zenon_H1cf ]. % 119.85/120.10 exact (zenon_H1c0 zenon_H1c7). % 119.85/120.10 exact (zenon_H1cc zenon_H1cf). % 119.85/120.10 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.85/120.10 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (n1))); [ zenon_intro zenon_H1bf | zenon_intro zenon_H1ba ]. % 119.85/120.10 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (n0)))); [ zenon_intro zenon_H1c1 | zenon_intro zenon_H1c2 ]. % 119.85/120.10 elim (classic (gt (succ (n0)) (succ (succ (n0))))); [ zenon_intro zenon_H1c3 | zenon_intro zenon_H1b8 ]. % 119.85/120.10 generalize (zenon_H66 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H1bb. % 119.85/120.10 generalize (zenon_H1bb (succ (n0))). zenon_intro zenon_H1c4. % 119.85/120.10 generalize (zenon_H1c4 (succ (succ (n0)))). zenon_intro zenon_H1c5. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1c5); [ zenon_intro zenon_H1c2 | zenon_intro zenon_H1c6 ]. % 119.85/120.10 exact (zenon_H1c2 zenon_H1c1). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1c6); [ zenon_intro zenon_H1b8 | zenon_intro zenon_H1c7 ]. % 119.85/120.10 exact (zenon_H1b8 zenon_H1c3). % 119.85/120.10 exact (zenon_H1c0 zenon_H1c7). % 119.85/120.10 apply (zenon_L68_); trivial. % 119.85/120.10 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (n1)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (n0)))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H1c2. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H1bf. % 119.85/120.10 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H158. apply refl_equal. % 119.85/120.10 exact (zenon_H88 zenon_Hd1). % 119.85/120.10 elim (classic ((~((sum (n0) (tptp_minus_1) zenon_E) = (n2)))/\(~(gt (sum (n0) (tptp_minus_1) zenon_E) (n2))))); [ zenon_intro zenon_H1d0 | zenon_intro zenon_H1d1 ]. % 119.85/120.10 apply (zenon_and_s _ _ zenon_H1d0). zenon_intro zenon_H1d2. zenon_intro zenon_H1c8. % 119.85/120.10 apply (zenon_L73_); trivial. % 119.85/120.10 cut ((gt (n2) (n1)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (n1))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H1ba. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact gt_2_1. % 119.85/120.10 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.10 cut (((n2) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H1d3]. % 119.85/120.10 congruence. % 119.85/120.10 apply (zenon_notand_s _ _ zenon_H1d1); [ zenon_intro zenon_H1d5 | zenon_intro zenon_H1d4 ]. % 119.85/120.10 apply zenon_H1d5. zenon_intro zenon_H1d6. % 119.85/120.10 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n2) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H1d3. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H15a. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H1d2]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H1d2 zenon_H1d6). % 119.85/120.10 apply zenon_H158. apply refl_equal. % 119.85/120.10 apply zenon_H158. apply refl_equal. % 119.85/120.10 apply zenon_H1d4. zenon_intro zenon_H1cb. % 119.85/120.10 generalize (zenon_H66 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H1bb. % 119.85/120.10 generalize (zenon_H1bb (n2)). zenon_intro zenon_H1d7. % 119.85/120.10 generalize (zenon_H1d7 (n1)). zenon_intro zenon_H1d8. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1d8); [ zenon_intro zenon_H1c8 | zenon_intro zenon_H1d9 ]. % 119.85/120.10 exact (zenon_H1c8 zenon_H1cb). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1d9); [ zenon_intro zenon_Hba | zenon_intro zenon_H1bf ]. % 119.85/120.10 exact (zenon_Hba gt_2_1). % 119.85/120.10 exact (zenon_H1ba zenon_H1bf). % 119.85/120.10 apply zenon_H64. apply refl_equal. % 119.85/120.10 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.85/120.10 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H88. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H8b. % 119.85/120.10 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.85/120.10 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H87 successor_1). % 119.85/120.10 apply zenon_H8c. apply refl_equal. % 119.85/120.10 apply zenon_H8c. apply refl_equal. % 119.85/120.10 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H157. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H141. % 119.85/120.10 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.85/120.10 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H65. apply refl_equal. % 119.85/120.10 exact (zenon_H159 zenon_H15c). % 119.85/120.10 apply (zenon_L64_); trivial. % 119.85/120.10 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H159. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H15a. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H15b zenon_H155). % 119.85/120.10 apply zenon_H158. apply refl_equal. % 119.85/120.10 apply zenon_H158. apply refl_equal. % 119.85/120.10 (* end of lemma zenon_L74_ *) % 119.85/120.10 assert (zenon_L75_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (tptp_minus_1)) (succ (succ (n0))))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_H1da zenon_H140 zenon_H155 zenon_Hc2 zenon_H7d zenon_H67. % 119.85/120.10 elim (classic (gt (succ (tptp_minus_1)) (succ (tptp_minus_1)))); [ zenon_intro zenon_H176 | zenon_intro zenon_H168 ]. % 119.85/120.10 elim (classic (gt (succ (tptp_minus_1)) (n0))); [ zenon_intro zenon_H177 | zenon_intro zenon_H178 ]. % 119.85/120.10 elim (classic (gt (n0) (succ (succ (n0))))); [ zenon_intro zenon_H1cf | zenon_intro zenon_H1cc ]. % 119.85/120.10 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.85/120.10 generalize (zenon_H171 (n0)). zenon_intro zenon_H179. % 119.85/120.10 generalize (zenon_H179 (succ (succ (n0)))). zenon_intro zenon_H1db. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1db); [ zenon_intro zenon_H178 | zenon_intro zenon_H1dc ]. % 119.85/120.10 exact (zenon_H178 zenon_H177). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1dc); [ zenon_intro zenon_H1cc | zenon_intro zenon_H1dd ]. % 119.85/120.10 exact (zenon_H1cc zenon_H1cf). % 119.85/120.10 exact (zenon_H1da zenon_H1dd). % 119.85/120.10 apply (zenon_L74_); trivial. % 119.85/120.10 cut ((gt (succ (tptp_minus_1)) (succ (tptp_minus_1))) = (gt (succ (tptp_minus_1)) (n0))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H178. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H176. % 119.85/120.10 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.10 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H169. apply refl_equal. % 119.85/120.10 exact (zenon_H16b succ_tptp_minus_1). % 119.85/120.10 apply (zenon_L66_); trivial. % 119.85/120.10 (* end of lemma zenon_L75_ *) % 119.85/120.10 assert (zenon_L76_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (tptp_minus_1)) (succ (n0)))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_H170 zenon_H140 zenon_H155 zenon_Hc2 zenon_H7d zenon_H67. % 119.85/120.10 elim (classic (gt (succ (tptp_minus_1)) (succ (succ (n0))))); [ zenon_intro zenon_H1dd | zenon_intro zenon_H1da ]. % 119.85/120.10 elim (classic (gt (succ (tptp_minus_1)) (n2))); [ zenon_intro zenon_H1de | zenon_intro zenon_H1df ]. % 119.85/120.10 elim (classic (gt (n2) (succ (n0)))); [ zenon_intro zenon_Hfc | zenon_intro zenon_Hf9 ]. % 119.85/120.10 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.85/120.10 generalize (zenon_H171 (n2)). zenon_intro zenon_H1e0. % 119.85/120.10 generalize (zenon_H1e0 (succ (n0))). zenon_intro zenon_H1e1. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1e1); [ zenon_intro zenon_H1df | zenon_intro zenon_H1e2 ]. % 119.85/120.10 exact (zenon_H1df zenon_H1de). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1e2); [ zenon_intro zenon_Hf9 | zenon_intro zenon_H16f ]. % 119.85/120.10 exact (zenon_Hf9 zenon_Hfc). % 119.85/120.10 exact (zenon_H170 zenon_H16f). % 119.85/120.10 apply (zenon_L25_); trivial. % 119.85/120.10 cut ((gt (succ (tptp_minus_1)) (succ (succ (n0)))) = (gt (succ (tptp_minus_1)) (n2))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H1df. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H1dd. % 119.85/120.10 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.85/120.10 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H169. apply refl_equal. % 119.85/120.10 exact (zenon_H105 successor_2). % 119.85/120.10 apply (zenon_L75_); trivial. % 119.85/120.10 (* end of lemma zenon_L76_ *) % 119.85/120.10 assert (zenon_L77_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (tptp_minus_1)) (succ (loopcounter)))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_H16c zenon_H140 zenon_H155 zenon_Hc2 zenon_H7d zenon_H67. % 119.85/120.10 elim (classic (gt (succ (tptp_minus_1)) (succ (n0)))); [ zenon_intro zenon_H16f | zenon_intro zenon_H170 ]. % 119.85/120.10 elim (classic (gt (succ (tptp_minus_1)) (n1))); [ zenon_intro zenon_H16d | zenon_intro zenon_H16e ]. % 119.85/120.10 elim (classic (gt (n1) (succ (loopcounter)))); [ zenon_intro zenon_He3 | zenon_intro zenon_Hdb ]. % 119.85/120.10 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.85/120.10 generalize (zenon_H171 (n1)). zenon_intro zenon_H1e3. % 119.85/120.10 generalize (zenon_H1e3 (succ (loopcounter))). zenon_intro zenon_H1e4. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1e4); [ zenon_intro zenon_H16e | zenon_intro zenon_H1e5 ]. % 119.85/120.10 exact (zenon_H16e zenon_H16d). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1e5); [ zenon_intro zenon_Hdb | zenon_intro zenon_H175 ]. % 119.85/120.10 exact (zenon_Hdb zenon_He3). % 119.85/120.10 exact (zenon_H16c zenon_H175). % 119.85/120.10 apply (zenon_L67_); trivial. % 119.85/120.10 cut ((gt (succ (tptp_minus_1)) (succ (n0))) = (gt (succ (tptp_minus_1)) (n1))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H16e. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H16f. % 119.85/120.10 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.85/120.10 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H169. apply refl_equal. % 119.85/120.10 exact (zenon_H87 successor_1). % 119.85/120.10 apply (zenon_L76_); trivial. % 119.85/120.10 (* end of lemma zenon_L77_ *) % 119.85/120.10 assert (zenon_L78_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> (~(gt (n0) (succ (loopcounter)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.10 do 0 intro. intros zenon_H67 zenon_H7d zenon_Hc2 zenon_H140 zenon_H66 zenon_H155. % 119.85/120.10 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.85/120.10 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.85/120.10 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.85/120.10 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (loopcounter)))); [ zenon_intro zenon_H17c | zenon_intro zenon_H17d ]. % 119.85/120.10 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.85/120.10 generalize (zenon_H142 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H160. % 119.85/120.10 generalize (zenon_H160 (succ (loopcounter))). zenon_intro zenon_H17e. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H17e); [ zenon_intro zenon_H157 | zenon_intro zenon_H17f ]. % 119.85/120.10 exact (zenon_H157 zenon_H156). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H17f); [ zenon_intro zenon_H17d | zenon_intro zenon_H146 ]. % 119.85/120.10 exact (zenon_H17d zenon_H17c). % 119.85/120.10 exact (zenon_H140 zenon_H146). % 119.85/120.10 elim (classic ((n0) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H180 | zenon_intro zenon_H167 ]. % 119.85/120.10 elim (classic (gt (succ (tptp_minus_1)) (succ (loopcounter)))); [ zenon_intro zenon_H175 | zenon_intro zenon_H16c ]. % 119.85/120.10 elim (classic (gt (n0) (succ (loopcounter)))); [ zenon_intro zenon_H146 | zenon_intro zenon_H140 ]. % 119.85/120.10 cut ((gt (n0) (succ (loopcounter))) = (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (loopcounter)))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H17d. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H146. % 119.85/120.10 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.85/120.10 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.85/120.10 congruence. % 119.85/120.10 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H159. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H15a. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H15b zenon_H155). % 119.85/120.10 apply zenon_H158. apply refl_equal. % 119.85/120.10 apply zenon_H158. apply refl_equal. % 119.85/120.10 apply zenon_H76. apply refl_equal. % 119.85/120.10 cut ((gt (succ (tptp_minus_1)) (succ (loopcounter))) = (gt (n0) (succ (loopcounter)))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H140. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H175. % 119.85/120.10 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.85/120.10 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.10 congruence. % 119.85/120.10 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.85/120.10 cut (((n0) = (n0)) = ((succ (tptp_minus_1)) = (n0))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H16b. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H136. % 119.85/120.10 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.10 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H167 zenon_H180). % 119.85/120.10 apply zenon_H65. apply refl_equal. % 119.85/120.10 apply zenon_H65. apply refl_equal. % 119.85/120.10 apply zenon_H76. apply refl_equal. % 119.85/120.10 apply (zenon_L77_); trivial. % 119.85/120.10 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.85/120.10 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H167. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H16a. % 119.85/120.10 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.10 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H16b succ_tptp_minus_1). % 119.85/120.10 apply zenon_H169. apply refl_equal. % 119.85/120.10 apply zenon_H169. apply refl_equal. % 119.85/120.10 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H157. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H141. % 119.85/120.10 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.85/120.10 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H65. apply refl_equal. % 119.85/120.10 exact (zenon_H159 zenon_H15c). % 119.85/120.10 apply (zenon_L64_); trivial. % 119.85/120.10 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H159. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H15a. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.10 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H15b zenon_H155). % 119.85/120.10 apply zenon_H158. apply refl_equal. % 119.85/120.10 apply zenon_H158. apply refl_equal. % 119.85/120.10 (* end of lemma zenon_L78_ *) % 119.85/120.10 assert (zenon_L79_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (n3))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_H1e6 zenon_H67 zenon_H7d zenon_H155 zenon_H140. % 119.85/120.10 elim (classic ((loopcounter) = (n3))); [ zenon_intro zenon_Hcb | zenon_intro zenon_Hc2 ]. % 119.85/120.10 cut ((gt (n1) (loopcounter)) = (gt (n1) (n3))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H1e6. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H7d. % 119.85/120.10 cut (((loopcounter) = (n3))); [idtac | apply NNPP; zenon_intro zenon_Hc2]. % 119.85/120.10 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H64. apply refl_equal. % 119.85/120.10 exact (zenon_Hc2 zenon_Hcb). % 119.85/120.10 apply (zenon_L78_); trivial. % 119.85/120.10 (* end of lemma zenon_L79_ *) % 119.85/120.10 assert (zenon_L80_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (n1))) -> False). % 119.85/120.10 do 0 intro. intros zenon_H67 zenon_H7d zenon_H155 zenon_H140 zenon_H66 zenon_Hdd. % 119.85/120.10 elim (classic ((~((n1) = (n3)))/\(~(gt (n1) (n3))))); [ zenon_intro zenon_H1e7 | zenon_intro zenon_H1e8 ]. % 119.85/120.10 apply (zenon_and_s _ _ zenon_H1e7). zenon_intro zenon_H1e9. zenon_intro zenon_H1e6. % 119.85/120.10 apply (zenon_L79_); trivial. % 119.85/120.10 cut ((gt (n3) (n1)) = (gt (n1) (n1))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_Hdd. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact gt_3_1. % 119.85/120.10 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.10 cut (((n3) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H1ea]. % 119.85/120.10 congruence. % 119.85/120.10 apply (zenon_notand_s _ _ zenon_H1e8); [ zenon_intro zenon_H1ec | zenon_intro zenon_H1eb ]. % 119.85/120.10 apply zenon_H1ec. zenon_intro zenon_H1ed. % 119.85/120.10 elim (classic ((n1) = (n1))); [ zenon_intro zenon_Hdc | zenon_intro zenon_H64 ]. % 119.85/120.10 cut (((n1) = (n1)) = ((n3) = (n1))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H1ea. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_Hdc. % 119.85/120.10 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.10 cut (((n1) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H1e9]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H1e9 zenon_H1ed). % 119.85/120.10 apply zenon_H64. apply refl_equal. % 119.85/120.10 apply zenon_H64. apply refl_equal. % 119.85/120.10 apply zenon_H1eb. zenon_intro zenon_H1ee. % 119.85/120.10 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.85/120.10 generalize (zenon_He4 (n3)). zenon_intro zenon_H1ef. % 119.85/120.10 generalize (zenon_H1ef (n1)). zenon_intro zenon_H1f0. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1f0); [ zenon_intro zenon_H1e6 | zenon_intro zenon_H1f1 ]. % 119.85/120.10 exact (zenon_H1e6 zenon_H1ee). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1f1); [ zenon_intro zenon_H1f2 | zenon_intro zenon_He8 ]. % 119.85/120.10 exact (zenon_H1f2 gt_3_1). % 119.85/120.10 exact (zenon_Hdd zenon_He8). % 119.85/120.10 apply zenon_H64. apply refl_equal. % 119.85/120.10 (* end of lemma zenon_L80_ *) % 119.85/120.10 assert (zenon_L81_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (loopcounter) (n1))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_Hee zenon_H67 zenon_H7d zenon_H155 zenon_H140. % 119.85/120.10 elim (classic ((~((loopcounter) = (n3)))/\(~(gt (loopcounter) (n3))))); [ zenon_intro zenon_H1f3 | zenon_intro zenon_H1f4 ]. % 119.85/120.10 apply (zenon_and_s _ _ zenon_H1f3). zenon_intro zenon_Hc2. zenon_intro zenon_H1f5. % 119.85/120.10 apply (zenon_L46_); trivial. % 119.85/120.10 cut ((gt (n3) (n1)) = (gt (loopcounter) (n1))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_Hee. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact gt_3_1. % 119.85/120.10 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.10 cut (((n3) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H1f6]. % 119.85/120.10 congruence. % 119.85/120.10 apply (zenon_notand_s _ _ zenon_H1f4); [ zenon_intro zenon_H1f8 | zenon_intro zenon_H1f7 ]. % 119.85/120.10 apply zenon_H1f8. zenon_intro zenon_Hcb. % 119.85/120.10 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.10 cut (((loopcounter) = (loopcounter)) = ((n3) = (loopcounter))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H1f6. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_Hed. % 119.85/120.10 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.10 cut (((loopcounter) = (n3))); [idtac | apply NNPP; zenon_intro zenon_Hc2]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_Hc2 zenon_Hcb). % 119.85/120.10 apply zenon_H7c. apply refl_equal. % 119.85/120.10 apply zenon_H7c. apply refl_equal. % 119.85/120.10 apply zenon_H1f7. zenon_intro zenon_H1f9. % 119.85/120.10 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.85/120.10 generalize (zenon_H13b (n3)). zenon_intro zenon_H1fa. % 119.85/120.10 generalize (zenon_H1fa (n1)). zenon_intro zenon_H1fb. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1fb); [ zenon_intro zenon_H1f5 | zenon_intro zenon_H1fc ]. % 119.85/120.10 exact (zenon_H1f5 zenon_H1f9). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1fc); [ zenon_intro zenon_H1f2 | zenon_intro zenon_Hf1 ]. % 119.85/120.10 exact (zenon_H1f2 gt_3_1). % 119.85/120.10 exact (zenon_Hee zenon_Hf1). % 119.85/120.10 apply zenon_H64. apply refl_equal. % 119.85/120.10 (* end of lemma zenon_L81_ *) % 119.85/120.10 assert (zenon_L82_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (loopcounter) (succ (loopcounter)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.10 do 0 intro. intros zenon_H67 zenon_H7d zenon_H140 zenon_H155 zenon_Hf0 zenon_H66. % 119.85/120.10 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.85/120.10 elim (classic (gt (loopcounter) (n1))); [ zenon_intro zenon_Hf1 | zenon_intro zenon_Hee ]. % 119.85/120.10 elim (classic (gt (loopcounter) (succ (n0)))); [ zenon_intro zenon_Hef | zenon_intro zenon_Heb ]. % 119.85/120.10 cut ((gt (loopcounter) (succ (n0))) = (gt (loopcounter) (succ (loopcounter)))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_Hf0. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_Hef. % 119.85/120.10 cut (((succ (n0)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H97]. % 119.85/120.10 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H7c. apply refl_equal. % 119.85/120.10 apply (zenon_L9_); trivial. % 119.85/120.10 cut ((gt (loopcounter) (n1)) = (gt (loopcounter) (succ (n0)))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_Heb. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_Hf1. % 119.85/120.10 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.85/120.10 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H7c. apply refl_equal. % 119.85/120.10 exact (zenon_H88 zenon_Hd1). % 119.85/120.10 apply (zenon_L81_); trivial. % 119.85/120.10 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.85/120.10 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H88. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H8b. % 119.85/120.10 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.85/120.10 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H87 successor_1). % 119.85/120.10 apply zenon_H8c. apply refl_equal. % 119.85/120.10 apply zenon_H8c. apply refl_equal. % 119.85/120.10 (* end of lemma zenon_L82_ *) % 119.85/120.10 assert (zenon_L83_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (succ (loopcounter)))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_Hdb zenon_H67 zenon_H7d zenon_H140 zenon_H155. % 119.85/120.10 elim (classic (gt (loopcounter) (succ (loopcounter)))); [ zenon_intro zenon_Hf2 | zenon_intro zenon_Hf0 ]. % 119.85/120.10 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.85/120.10 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.85/120.10 generalize (zenon_Hf3 (succ (loopcounter))). zenon_intro zenon_Hf4. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_Hf4); [ zenon_intro zenon_H92 | zenon_intro zenon_Hf5 ]. % 119.85/120.10 exact (zenon_H92 zenon_H7d). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_Hf5); [ zenon_intro zenon_Hf0 | zenon_intro zenon_He3 ]. % 119.85/120.10 exact (zenon_Hf0 zenon_Hf2). % 119.85/120.10 exact (zenon_Hdb zenon_He3). % 119.85/120.10 apply (zenon_L82_); trivial. % 119.85/120.10 (* end of lemma zenon_L83_ *) % 119.85/120.10 assert (zenon_L84_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n2) (succ (loopcounter)))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_H1fd zenon_H140 zenon_H155 zenon_H7d zenon_H67. % 119.85/120.10 elim (classic (gt (n1) (succ (loopcounter)))); [ zenon_intro zenon_He3 | zenon_intro zenon_Hdb ]. % 119.85/120.10 generalize (zenon_H66 (n2)). zenon_intro zenon_H1a6. % 119.85/120.10 generalize (zenon_H1a6 (n1)). zenon_intro zenon_H1a7. % 119.85/120.10 generalize (zenon_H1a7 (succ (loopcounter))). zenon_intro zenon_H1fe. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1fe); [ zenon_intro zenon_Hba | zenon_intro zenon_H1ff ]. % 119.85/120.10 exact (zenon_Hba gt_2_1). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H1ff); [ zenon_intro zenon_Hdb | zenon_intro zenon_H200 ]. % 119.85/120.10 exact (zenon_Hdb zenon_He3). % 119.85/120.10 exact (zenon_H1fd zenon_H200). % 119.85/120.10 apply (zenon_L83_); trivial. % 119.85/120.10 (* end of lemma zenon_L84_ *) % 119.85/120.10 assert (zenon_L85_ : (~((n3) = (n3))) -> False). % 119.85/120.10 do 0 intro. intros zenon_H201. % 119.85/120.10 apply zenon_H201. apply refl_equal. % 119.85/120.10 (* end of lemma zenon_L85_ *) % 119.85/120.10 assert (zenon_L86_ : (~(gt (n3) (succ (succ (n0))))) -> False). % 119.85/120.10 do 0 intro. intros zenon_H202. % 119.85/120.10 elim (classic ((n2) = (succ (succ (n0))))); [ zenon_intro zenon_H1b9 | zenon_intro zenon_H102 ]. % 119.85/120.10 cut ((gt (n3) (n2)) = (gt (n3) (succ (succ (n0))))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H202. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact gt_3_2. % 119.85/120.10 cut (((n2) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 119.85/120.10 cut (((n3) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H201]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H201. apply refl_equal. % 119.85/120.10 exact (zenon_H102 zenon_H1b9). % 119.85/120.10 apply zenon_H102. apply sym_equal. exact successor_2. % 119.85/120.10 (* end of lemma zenon_L86_ *) % 119.85/120.10 assert (zenon_L87_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n0)) (succ (loopcounter)))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_Hd0 zenon_H140 zenon_H155 zenon_H7d zenon_H67. % 119.85/120.10 elim (classic ((~((succ (n0)) = (succ (loopcounter))))/\(~(gt (succ (n0)) (succ (loopcounter)))))); [ zenon_intro zenon_Hce | zenon_intro zenon_Hcf ]. % 119.85/120.10 apply (zenon_and_s _ _ zenon_Hce). zenon_intro zenon_H97. zenon_intro zenon_Hd0. % 119.85/120.10 apply (zenon_L9_); trivial. % 119.85/120.10 elim (classic (gt (n1) (succ (loopcounter)))); [ zenon_intro zenon_He3 | zenon_intro zenon_Hdb ]. % 119.85/120.10 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.85/120.10 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.85/120.10 generalize (zenon_H78 (succ (loopcounter))). zenon_intro zenon_Hf6. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_Hf6); [ zenon_intro zenon_H6f | zenon_intro zenon_Hf7 ]. % 119.85/120.10 exact (zenon_H6f zenon_H67). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_Hf7); [ zenon_intro zenon_Hdb | zenon_intro zenon_Hf8 ]. % 119.85/120.10 exact (zenon_Hdb zenon_He3). % 119.85/120.10 cut ((gt (succ (loopcounter)) (succ (loopcounter))) = (gt (succ (n0)) (succ (loopcounter)))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_Hd0. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_Hf8. % 119.85/120.10 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.85/120.10 cut (((succ (loopcounter)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_Hd2]. % 119.85/120.10 congruence. % 119.85/120.10 apply (zenon_notand_s _ _ zenon_Hcf); [ zenon_intro zenon_Hd4 | zenon_intro zenon_Hd3 ]. % 119.85/120.10 apply zenon_Hd4. zenon_intro zenon_Hd5. % 119.85/120.10 apply zenon_Hd2. apply sym_equal. exact zenon_Hd5. % 119.85/120.10 exact (zenon_Hd3 zenon_Hd0). % 119.85/120.10 apply zenon_H76. apply refl_equal. % 119.85/120.10 apply (zenon_L83_); trivial. % 119.85/120.10 (* end of lemma zenon_L87_ *) % 119.85/120.10 assert (zenon_L88_ : (~(gt (succ (succ (n0))) (succ (n0)))) -> False). % 119.85/120.10 do 0 intro. intros zenon_Hfe. % 119.85/120.10 elim (classic (gt (n2) (succ (n0)))); [ zenon_intro zenon_Hfc | zenon_intro zenon_Hf9 ]. % 119.85/120.10 cut ((gt (n2) (succ (n0))) = (gt (succ (succ (n0))) (succ (n0)))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_Hfe. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_Hfc. % 119.85/120.10 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.85/120.10 cut (((n2) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 119.85/120.10 congruence. % 119.85/120.10 elim (classic ((succ (succ (n0))) = (succ (succ (n0))))); [ zenon_intro zenon_H103 | zenon_intro zenon_H104 ]. % 119.85/120.10 cut (((succ (succ (n0))) = (succ (succ (n0)))) = ((n2) = (succ (succ (n0))))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H102. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H103. % 119.85/120.10 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.85/120.10 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H105 successor_2). % 119.85/120.10 apply zenon_H104. apply refl_equal. % 119.85/120.10 apply zenon_H104. apply refl_equal. % 119.85/120.10 apply zenon_H8c. apply refl_equal. % 119.85/120.10 apply (zenon_L25_); trivial. % 119.85/120.10 (* end of lemma zenon_L88_ *) % 119.85/120.10 assert (zenon_L89_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (succ (n0))) (succ (loopcounter)))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_H203 zenon_H140 zenon_H155 zenon_H7d zenon_H67. % 119.85/120.10 elim (classic (gt (succ (succ (n0))) (succ (n0)))); [ zenon_intro zenon_Hfd | zenon_intro zenon_Hfe ]. % 119.85/120.10 elim (classic (gt (succ (succ (n0))) (n1))); [ zenon_intro zenon_H204 | zenon_intro zenon_H205 ]. % 119.85/120.10 elim (classic (gt (n1) (succ (loopcounter)))); [ zenon_intro zenon_He3 | zenon_intro zenon_Hdb ]. % 119.85/120.10 generalize (zenon_H66 (succ (succ (n0)))). zenon_intro zenon_H206. % 119.85/120.10 generalize (zenon_H206 (n1)). zenon_intro zenon_H207. % 119.85/120.10 generalize (zenon_H207 (succ (loopcounter))). zenon_intro zenon_H208. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H208); [ zenon_intro zenon_H205 | zenon_intro zenon_H209 ]. % 119.85/120.10 exact (zenon_H205 zenon_H204). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H209); [ zenon_intro zenon_Hdb | zenon_intro zenon_H20a ]. % 119.85/120.10 exact (zenon_Hdb zenon_He3). % 119.85/120.10 exact (zenon_H203 zenon_H20a). % 119.85/120.10 apply (zenon_L83_); trivial. % 119.85/120.10 cut ((gt (succ (succ (n0))) (succ (n0))) = (gt (succ (succ (n0))) (n1))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H205. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_Hfd. % 119.85/120.10 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.85/120.10 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H104. apply refl_equal. % 119.85/120.10 exact (zenon_H87 successor_1). % 119.85/120.10 apply (zenon_L88_); trivial. % 119.85/120.10 (* end of lemma zenon_L89_ *) % 119.85/120.10 assert (zenon_L90_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (succ (n0))) (n3))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_H20b zenon_H140 zenon_H155 zenon_H7d zenon_H67. % 119.85/120.10 elim (classic ((~((succ (succ (n0))) = (succ (loopcounter))))/\(~(gt (succ (succ (n0))) (succ (loopcounter)))))); [ zenon_intro zenon_H20c | zenon_intro zenon_H20d ]. % 119.85/120.10 apply (zenon_and_s _ _ zenon_H20c). zenon_intro zenon_H20e. zenon_intro zenon_H203. % 119.85/120.10 apply (zenon_L89_); trivial. % 119.85/120.10 elim (classic (gt (n1) (n3))); [ zenon_intro zenon_H1ee | zenon_intro zenon_H1e6 ]. % 119.85/120.10 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.85/120.10 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.85/120.10 generalize (zenon_H78 (n3)). zenon_intro zenon_H20f. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H20f); [ zenon_intro zenon_H6f | zenon_intro zenon_H210 ]. % 119.85/120.10 exact (zenon_H6f zenon_H67). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H210); [ zenon_intro zenon_H1e6 | zenon_intro zenon_H211 ]. % 119.85/120.10 exact (zenon_H1e6 zenon_H1ee). % 119.85/120.10 cut ((gt (succ (loopcounter)) (n3)) = (gt (succ (succ (n0))) (n3))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H20b. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H211. % 119.85/120.10 cut (((n3) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H201]. % 119.85/120.10 cut (((succ (loopcounter)) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H212]. % 119.85/120.10 congruence. % 119.85/120.10 apply (zenon_notand_s _ _ zenon_H20d); [ zenon_intro zenon_H214 | zenon_intro zenon_H213 ]. % 119.85/120.10 apply zenon_H214. zenon_intro zenon_H215. % 119.85/120.10 apply zenon_H212. apply sym_equal. exact zenon_H215. % 119.85/120.10 apply zenon_H213. zenon_intro zenon_H20a. % 119.85/120.10 generalize (zenon_H66 (succ (succ (n0)))). zenon_intro zenon_H206. % 119.85/120.10 generalize (zenon_H206 (succ (loopcounter))). zenon_intro zenon_H216. % 119.85/120.10 generalize (zenon_H216 (n3)). zenon_intro zenon_H217. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H217); [ zenon_intro zenon_H203 | zenon_intro zenon_H218 ]. % 119.85/120.10 exact (zenon_H203 zenon_H20a). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H218); [ zenon_intro zenon_H21a | zenon_intro zenon_H219 ]. % 119.85/120.10 exact (zenon_H21a zenon_H211). % 119.85/120.10 exact (zenon_H20b zenon_H219). % 119.85/120.10 apply zenon_H201. apply refl_equal. % 119.85/120.10 apply (zenon_L79_); trivial. % 119.85/120.10 (* end of lemma zenon_L90_ *) % 119.85/120.10 assert (zenon_L91_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (~(gt (succ (succ (n0))) (succ (succ (succ (n0)))))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.10 do 0 intro. intros zenon_H67 zenon_H7d zenon_H155 zenon_H140 zenon_H21b zenon_H66. % 119.85/120.10 elim (classic ((n3) = (succ (succ (succ (n0)))))); [ zenon_intro zenon_H21c | zenon_intro zenon_H99 ]. % 119.85/120.10 elim (classic (gt (succ (succ (n0))) (n3))); [ zenon_intro zenon_H219 | zenon_intro zenon_H20b ]. % 119.85/120.10 cut ((gt (succ (succ (n0))) (n3)) = (gt (succ (succ (n0))) (succ (succ (succ (n0)))))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H21b. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H219. % 119.85/120.10 cut (((n3) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H99]. % 119.85/120.10 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H104. apply refl_equal. % 119.85/120.10 exact (zenon_H99 zenon_H21c). % 119.85/120.10 apply (zenon_L90_); trivial. % 119.85/120.10 elim (classic ((succ (succ (succ (n0)))) = (succ (succ (succ (n0)))))); [ zenon_intro zenon_H21d | zenon_intro zenon_H21e ]. % 119.85/120.10 cut (((succ (succ (succ (n0)))) = (succ (succ (succ (n0))))) = ((n3) = (succ (succ (succ (n0)))))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H99. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H21d. % 119.85/120.10 cut (((succ (succ (succ (n0)))) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H21e]. % 119.85/120.10 cut (((succ (succ (succ (n0)))) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H21f]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H21f successor_3). % 119.85/120.10 apply zenon_H21e. apply refl_equal. % 119.85/120.10 apply zenon_H21e. apply refl_equal. % 119.85/120.10 (* end of lemma zenon_L91_ *) % 119.85/120.10 assert (zenon_L92_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n2) (n3))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_H220 zenon_H140 zenon_H155 zenon_H7d zenon_H67. % 119.85/120.10 elim (classic (gt (n1) (n3))); [ zenon_intro zenon_H1ee | zenon_intro zenon_H1e6 ]. % 119.85/120.10 generalize (zenon_H66 (n2)). zenon_intro zenon_H1a6. % 119.85/120.10 generalize (zenon_H1a6 (n1)). zenon_intro zenon_H1a7. % 119.85/120.10 generalize (zenon_H1a7 (n3)). zenon_intro zenon_H221. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H221); [ zenon_intro zenon_Hba | zenon_intro zenon_H222 ]. % 119.85/120.10 exact (zenon_Hba gt_2_1). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H222); [ zenon_intro zenon_H1e6 | zenon_intro zenon_H223 ]. % 119.85/120.10 exact (zenon_H1e6 zenon_H1ee). % 119.85/120.10 exact (zenon_H220 zenon_H223). % 119.85/120.10 apply (zenon_L79_); trivial. % 119.85/120.10 (* end of lemma zenon_L92_ *) % 119.85/120.10 assert (zenon_L93_ : (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n2) (n2))) -> False). % 119.85/120.10 do 0 intro. intros zenon_H140 zenon_H155 zenon_H7d zenon_H67 zenon_H66 zenon_H1a5. % 119.85/120.10 elim (classic ((~((n2) = (n3)))/\(~(gt (n2) (n3))))); [ zenon_intro zenon_H224 | zenon_intro zenon_H225 ]. % 119.85/120.10 apply (zenon_and_s _ _ zenon_H224). zenon_intro zenon_H226. zenon_intro zenon_H220. % 119.85/120.10 apply (zenon_L92_); trivial. % 119.85/120.10 cut ((gt (n3) (n2)) = (gt (n2) (n2))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H1a5. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact gt_3_2. % 119.85/120.10 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.10 cut (((n3) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H227]. % 119.85/120.10 congruence. % 119.85/120.10 apply (zenon_notand_s _ _ zenon_H225); [ zenon_intro zenon_H229 | zenon_intro zenon_H228 ]. % 119.85/120.10 apply zenon_H229. zenon_intro zenon_H22a. % 119.85/120.10 elim (classic ((n2) = (n2))); [ zenon_intro zenon_H22b | zenon_intro zenon_H63 ]. % 119.85/120.10 cut (((n2) = (n2)) = ((n3) = (n2))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H227. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H22b. % 119.85/120.10 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.10 cut (((n2) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H226]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H226 zenon_H22a). % 119.85/120.10 apply zenon_H63. apply refl_equal. % 119.85/120.10 apply zenon_H63. apply refl_equal. % 119.85/120.10 apply zenon_H228. zenon_intro zenon_H223. % 119.85/120.10 generalize (zenon_H66 (n2)). zenon_intro zenon_H1a6. % 119.85/120.10 generalize (zenon_H1a6 (n3)). zenon_intro zenon_H22c. % 119.85/120.10 generalize (zenon_H22c (n2)). zenon_intro zenon_H22d. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H22d); [ zenon_intro zenon_H220 | zenon_intro zenon_H22e ]. % 119.85/120.10 exact (zenon_H220 zenon_H223). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H22e); [ zenon_intro zenon_H22f | zenon_intro zenon_H1aa ]. % 119.85/120.10 exact (zenon_H22f gt_3_2). % 119.85/120.10 exact (zenon_H1a5 zenon_H1aa). % 119.85/120.10 apply zenon_H63. apply refl_equal. % 119.85/120.10 (* end of lemma zenon_L93_ *) % 119.85/120.10 assert (zenon_L94_ : (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(gt (succ (tptp_minus_1)) (succ (loopcounter)))) -> (~(gt (loopcounter) (succ (succ (succ (n0)))))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.10 do 0 intro. intros zenon_H140 zenon_H155 zenon_H7d zenon_H67 zenon_H16c zenon_H230 zenon_H66. % 119.85/120.10 elim (classic ((n2) = (succ (succ (n0))))); [ zenon_intro zenon_H1b9 | zenon_intro zenon_H102 ]. % 119.85/120.10 elim (classic (gt (loopcounter) (n2))); [ zenon_intro zenon_H1a1 | zenon_intro zenon_H19d ]. % 119.85/120.10 elim (classic (gt (loopcounter) (succ (succ (n0))))); [ zenon_intro zenon_H231 | zenon_intro zenon_H232 ]. % 119.85/120.10 elim (classic (gt (succ (succ (n0))) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H233 | zenon_intro zenon_H21b ]. % 119.85/120.10 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.85/120.10 generalize (zenon_H13b (succ (succ (n0)))). zenon_intro zenon_H234. % 119.85/120.10 generalize (zenon_H234 (succ (succ (succ (n0))))). zenon_intro zenon_H235. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H235); [ zenon_intro zenon_H232 | zenon_intro zenon_H236 ]. % 119.85/120.10 exact (zenon_H232 zenon_H231). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H236); [ zenon_intro zenon_H21b | zenon_intro zenon_H237 ]. % 119.85/120.10 exact (zenon_H21b zenon_H233). % 119.85/120.10 exact (zenon_H230 zenon_H237). % 119.85/120.10 apply (zenon_L91_); trivial. % 119.85/120.10 cut ((gt (loopcounter) (n2)) = (gt (loopcounter) (succ (succ (n0))))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H232. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H1a1. % 119.85/120.10 cut (((n2) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 119.85/120.10 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.10 congruence. % 119.85/120.10 apply zenon_H7c. apply refl_equal. % 119.85/120.10 exact (zenon_H102 zenon_H1b9). % 119.85/120.10 elim (classic (gt (succ (succ (n0))) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H233 | zenon_intro zenon_H21b ]. % 119.85/120.10 elim (classic (gt (n2) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H238 | zenon_intro zenon_H239 ]. % 119.85/120.10 cut ((gt (n2) (succ (succ (succ (n0))))) = (gt (loopcounter) (succ (succ (succ (n0)))))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H230. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H238. % 119.85/120.10 cut (((succ (succ (succ (n0)))) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H21e]. % 119.85/120.10 cut (((n2) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H19e]. % 119.85/120.10 congruence. % 119.85/120.10 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.10 cut (((loopcounter) = (loopcounter)) = ((n2) = (loopcounter))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H19e. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_Hed. % 119.85/120.10 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.10 cut (((loopcounter) = (n2))); [idtac | apply NNPP; zenon_intro zenon_Hc3]. % 119.85/120.10 congruence. % 119.85/120.10 elim (classic ((~((loopcounter) = (n3)))/\(~(gt (loopcounter) (n3))))); [ zenon_intro zenon_H1f3 | zenon_intro zenon_H1f4 ]. % 119.85/120.10 apply (zenon_and_s _ _ zenon_H1f3). zenon_intro zenon_Hc2. zenon_intro zenon_H1f5. % 119.85/120.10 apply (zenon_L38_); trivial. % 119.85/120.10 cut ((gt (n3) (n2)) = (gt (loopcounter) (n2))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H19d. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact gt_3_2. % 119.85/120.10 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.10 cut (((n3) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H1f6]. % 119.85/120.10 congruence. % 119.85/120.10 apply (zenon_notand_s _ _ zenon_H1f4); [ zenon_intro zenon_H1f8 | zenon_intro zenon_H1f7 ]. % 119.85/120.10 apply zenon_H1f8. zenon_intro zenon_Hcb. % 119.85/120.10 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.10 cut (((loopcounter) = (loopcounter)) = ((n3) = (loopcounter))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H1f6. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_Hed. % 119.85/120.10 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.10 cut (((loopcounter) = (n3))); [idtac | apply NNPP; zenon_intro zenon_Hc2]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_Hc2 zenon_Hcb). % 119.85/120.10 apply zenon_H7c. apply refl_equal. % 119.85/120.10 apply zenon_H7c. apply refl_equal. % 119.85/120.10 apply zenon_H1f7. zenon_intro zenon_H1f9. % 119.85/120.10 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.85/120.10 generalize (zenon_H13b (n3)). zenon_intro zenon_H1fa. % 119.85/120.10 generalize (zenon_H1fa (n2)). zenon_intro zenon_H23a. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H23a); [ zenon_intro zenon_H1f5 | zenon_intro zenon_H23b ]. % 119.85/120.10 exact (zenon_H1f5 zenon_H1f9). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H23b); [ zenon_intro zenon_H22f | zenon_intro zenon_H1a1 ]. % 119.85/120.10 exact (zenon_H22f gt_3_2). % 119.85/120.10 exact (zenon_H19d zenon_H1a1). % 119.85/120.10 apply zenon_H63. apply refl_equal. % 119.85/120.10 apply zenon_H7c. apply refl_equal. % 119.85/120.10 apply zenon_H7c. apply refl_equal. % 119.85/120.10 apply zenon_H21e. apply refl_equal. % 119.85/120.10 cut ((gt (succ (succ (n0))) (succ (succ (succ (n0))))) = (gt (n2) (succ (succ (succ (n0)))))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H239. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H233. % 119.85/120.10 cut (((succ (succ (succ (n0)))) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H21e]. % 119.85/120.10 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.85/120.10 congruence. % 119.85/120.10 elim (classic ((n2) = (n2))); [ zenon_intro zenon_H22b | zenon_intro zenon_H63 ]. % 119.85/120.10 cut (((n2) = (n2)) = ((succ (succ (n0))) = (n2))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H105. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H22b. % 119.85/120.10 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.10 cut (((n2) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H102 zenon_H1b9). % 119.85/120.10 apply zenon_H63. apply refl_equal. % 119.85/120.10 apply zenon_H63. apply refl_equal. % 119.85/120.10 apply zenon_H21e. apply refl_equal. % 119.85/120.10 apply (zenon_L91_); trivial. % 119.85/120.10 elim (classic ((succ (succ (n0))) = (succ (succ (n0))))); [ zenon_intro zenon_H103 | zenon_intro zenon_H104 ]. % 119.85/120.10 cut (((succ (succ (n0))) = (succ (succ (n0)))) = ((n2) = (succ (succ (n0))))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H102. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H103. % 119.85/120.10 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.85/120.10 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.85/120.10 congruence. % 119.85/120.10 exact (zenon_H105 successor_2). % 119.85/120.10 apply zenon_H104. apply refl_equal. % 119.85/120.10 apply zenon_H104. apply refl_equal. % 119.85/120.10 (* end of lemma zenon_L94_ *) % 119.85/120.10 assert (zenon_L95_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (succ (succ (succ (n0)))))) -> (~(gt (succ (tptp_minus_1)) (succ (loopcounter)))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_H23c zenon_H16c zenon_H67 zenon_H7d zenon_H155 zenon_H140. % 119.85/120.10 elim (classic (gt (loopcounter) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H237 | zenon_intro zenon_H230 ]. % 119.85/120.10 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.85/120.10 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.85/120.10 generalize (zenon_Hf3 (succ (succ (succ (n0))))). zenon_intro zenon_H23d. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H23d); [ zenon_intro zenon_H92 | zenon_intro zenon_H23e ]. % 119.85/120.10 exact (zenon_H92 zenon_H7d). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H23e); [ zenon_intro zenon_H230 | zenon_intro zenon_H23f ]. % 119.85/120.10 exact (zenon_H230 zenon_H237). % 119.85/120.10 exact (zenon_H23c zenon_H23f). % 119.85/120.10 apply (zenon_L94_); trivial. % 119.85/120.10 (* end of lemma zenon_L95_ *) % 119.85/120.10 assert (zenon_L96_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n0)) (succ (succ (succ (n0)))))) -> (~(gt (succ (tptp_minus_1)) (succ (loopcounter)))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.10 do 0 intro. intros zenon_H66 zenon_H240 zenon_H16c zenon_H140 zenon_H155 zenon_H7d zenon_H67. % 119.85/120.10 elim (classic ((~((succ (n0)) = (succ (loopcounter))))/\(~(gt (succ (n0)) (succ (loopcounter)))))); [ zenon_intro zenon_Hce | zenon_intro zenon_Hcf ]. % 119.85/120.10 apply (zenon_and_s _ _ zenon_Hce). zenon_intro zenon_H97. zenon_intro zenon_Hd0. % 119.85/120.10 apply (zenon_L87_); trivial. % 119.85/120.10 elim (classic (gt (n1) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H23f | zenon_intro zenon_H23c ]. % 119.85/120.10 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.85/120.10 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.85/120.10 generalize (zenon_H78 (succ (succ (succ (n0))))). zenon_intro zenon_H241. % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H241); [ zenon_intro zenon_H6f | zenon_intro zenon_H242 ]. % 119.85/120.10 exact (zenon_H6f zenon_H67). % 119.85/120.10 apply (zenon_imply_s _ _ zenon_H242); [ zenon_intro zenon_H23c | zenon_intro zenon_H243 ]. % 119.85/120.10 exact (zenon_H23c zenon_H23f). % 119.85/120.10 cut ((gt (succ (loopcounter)) (succ (succ (succ (n0))))) = (gt (succ (n0)) (succ (succ (succ (n0)))))). % 119.85/120.10 intro zenon_D_pnotp. % 119.85/120.10 apply zenon_H240. % 119.85/120.10 rewrite <- zenon_D_pnotp. % 119.85/120.10 exact zenon_H243. % 119.85/120.10 cut (((succ (succ (succ (n0)))) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H21e]. % 119.85/120.10 cut (((succ (loopcounter)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_Hd2]. % 119.85/120.11 congruence. % 119.85/120.11 apply (zenon_notand_s _ _ zenon_Hcf); [ zenon_intro zenon_Hd4 | zenon_intro zenon_Hd3 ]. % 119.85/120.11 apply zenon_Hd4. zenon_intro zenon_Hd5. % 119.85/120.11 apply zenon_Hd2. apply sym_equal. exact zenon_Hd5. % 119.85/120.11 apply zenon_Hd3. zenon_intro zenon_Hd6. % 119.85/120.11 generalize (zenon_H66 (succ (n0))). zenon_intro zenon_H8e. % 119.85/120.11 generalize (zenon_H8e (succ (loopcounter))). zenon_intro zenon_Hd7. % 119.85/120.11 generalize (zenon_Hd7 (succ (succ (succ (n0))))). zenon_intro zenon_H244. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H244); [ zenon_intro zenon_Hd0 | zenon_intro zenon_H245 ]. % 119.85/120.11 exact (zenon_Hd0 zenon_Hd6). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H245); [ zenon_intro zenon_H247 | zenon_intro zenon_H246 ]. % 119.85/120.11 exact (zenon_H247 zenon_H243). % 119.85/120.11 exact (zenon_H240 zenon_H246). % 119.85/120.11 apply zenon_H21e. apply refl_equal. % 119.85/120.11 apply (zenon_L95_); trivial. % 119.85/120.11 (* end of lemma zenon_L96_ *) % 119.85/120.11 assert (zenon_L97_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n0)) (succ (succ (n0))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (succ (tptp_minus_1)) (succ (loopcounter)))) -> False). % 119.85/120.11 do 0 intro. intros zenon_H66 zenon_H1b8 zenon_H155 zenon_H140 zenon_H67 zenon_H7d zenon_H16c. % 119.85/120.11 elim (classic (gt (succ (n0)) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H246 | zenon_intro zenon_H240 ]. % 119.85/120.11 elim (classic (gt (succ (n0)) (n3))); [ zenon_intro zenon_H248 | zenon_intro zenon_H249 ]. % 119.85/120.11 elim (classic (gt (n3) (succ (succ (n0))))); [ zenon_intro zenon_H24a | zenon_intro zenon_H202 ]. % 119.85/120.11 generalize (zenon_H66 (succ (n0))). zenon_intro zenon_H8e. % 119.85/120.11 generalize (zenon_H8e (n3)). zenon_intro zenon_H24b. % 119.85/120.11 generalize (zenon_H24b (succ (succ (n0)))). zenon_intro zenon_H24c. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H24c); [ zenon_intro zenon_H249 | zenon_intro zenon_H24d ]. % 119.85/120.11 exact (zenon_H249 zenon_H248). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H24d); [ zenon_intro zenon_H202 | zenon_intro zenon_H1c3 ]. % 119.85/120.11 exact (zenon_H202 zenon_H24a). % 119.85/120.11 exact (zenon_H1b8 zenon_H1c3). % 119.85/120.11 apply (zenon_L86_); trivial. % 119.85/120.11 cut ((gt (succ (n0)) (succ (succ (succ (n0))))) = (gt (succ (n0)) (n3))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H249. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H246. % 119.85/120.11 cut (((succ (succ (succ (n0)))) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H21f]. % 119.85/120.11 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.85/120.11 congruence. % 119.85/120.11 apply zenon_H8c. apply refl_equal. % 119.85/120.11 exact (zenon_H21f successor_3). % 119.85/120.11 apply (zenon_L96_); trivial. % 119.85/120.11 (* end of lemma zenon_L97_ *) % 119.85/120.11 assert (zenon_L98_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n3) (n3))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> False). % 119.85/120.11 do 0 intro. intros zenon_H66 zenon_H24e zenon_H67 zenon_H7d zenon_H155 zenon_H140. % 119.85/120.11 elim (classic (gt (n2) (n3))); [ zenon_intro zenon_H223 | zenon_intro zenon_H220 ]. % 119.85/120.11 generalize (zenon_H66 (n3)). zenon_intro zenon_H24f. % 119.85/120.11 generalize (zenon_H24f (n2)). zenon_intro zenon_H250. % 119.85/120.11 generalize (zenon_H250 (n3)). zenon_intro zenon_H251. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H251); [ zenon_intro zenon_H22f | zenon_intro zenon_H252 ]. % 119.85/120.11 exact (zenon_H22f gt_3_2). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H252); [ zenon_intro zenon_H220 | zenon_intro zenon_H253 ]. % 119.85/120.11 exact (zenon_H220 zenon_H223). % 119.85/120.11 exact (zenon_H24e zenon_H253). % 119.85/120.11 apply (zenon_L92_); trivial. % 119.85/120.11 (* end of lemma zenon_L98_ *) % 119.85/120.11 assert (zenon_L99_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n0) (n0))) -> ((loopcounter) = (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.11 do 0 intro. intros zenon_H66 zenon_H12f zenon_H95 zenon_H155 zenon_H140 zenon_H7d zenon_H67. % 119.85/120.11 elim (classic (gt (n0) (loopcounter))); [ zenon_intro zenon_H130 | zenon_intro zenon_H131 ]. % 119.85/120.11 cut ((gt (n0) (loopcounter)) = (gt (n0) (n0))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H12f. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H130. % 119.85/120.11 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 congruence. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 exact (zenon_H132 zenon_H95). % 119.85/120.11 elim (classic ((n0) = (loopcounter))); [ zenon_intro zenon_H133 | zenon_intro zenon_H93 ]. % 119.85/120.11 elim (classic (gt (loopcounter) (loopcounter))); [ zenon_intro zenon_H134 | zenon_intro zenon_H135 ]. % 119.85/120.11 cut ((gt (loopcounter) (loopcounter)) = (gt (n0) (loopcounter))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H131. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H134. % 119.85/120.11 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.11 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.85/120.11 congruence. % 119.85/120.11 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.85/120.11 cut (((n0) = (n0)) = ((loopcounter) = (n0))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H132. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H136. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 cut (((n0) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H93]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H93 zenon_H133). % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H7c. apply refl_equal. % 119.85/120.11 elim (classic ((~((loopcounter) = (n1)))/\(~(gt (loopcounter) (n1))))); [ zenon_intro zenon_H137 | zenon_intro zenon_H138 ]. % 119.85/120.11 apply (zenon_and_s _ _ zenon_H137). zenon_intro zenon_Hc4. zenon_intro zenon_Hee. % 119.85/120.11 apply (zenon_L81_); trivial. % 119.85/120.11 cut ((gt (n1) (loopcounter)) = (gt (loopcounter) (loopcounter))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H135. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H7d. % 119.85/120.11 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.11 cut (((n1) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_Hec]. % 119.85/120.11 congruence. % 119.85/120.11 apply (zenon_notand_s _ _ zenon_H138); [ zenon_intro zenon_H13a | zenon_intro zenon_H139 ]. % 119.85/120.11 apply zenon_H13a. zenon_intro zenon_Hca. % 119.85/120.11 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.11 cut (((loopcounter) = (loopcounter)) = ((n1) = (loopcounter))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_Hec. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_Hed. % 119.85/120.11 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.11 cut (((loopcounter) = (n1))); [idtac | apply NNPP; zenon_intro zenon_Hc4]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_Hc4 zenon_Hca). % 119.85/120.11 apply zenon_H7c. apply refl_equal. % 119.85/120.11 apply zenon_H7c. apply refl_equal. % 119.85/120.11 apply zenon_H139. zenon_intro zenon_Hf1. % 119.85/120.11 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.85/120.11 generalize (zenon_H13b (n1)). zenon_intro zenon_H13c. % 119.85/120.11 generalize (zenon_H13c (loopcounter)). zenon_intro zenon_H13d. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H13d); [ zenon_intro zenon_Hee | zenon_intro zenon_H13e ]. % 119.85/120.11 exact (zenon_Hee zenon_Hf1). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H13e); [ zenon_intro zenon_H92 | zenon_intro zenon_H134 ]. % 119.85/120.11 exact (zenon_H92 zenon_H7d). % 119.85/120.11 exact (zenon_H135 zenon_H134). % 119.85/120.11 apply zenon_H7c. apply refl_equal. % 119.85/120.11 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.11 cut (((loopcounter) = (loopcounter)) = ((n0) = (loopcounter))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H93. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_Hed. % 119.85/120.11 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.11 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H132 zenon_H95). % 119.85/120.11 apply zenon_H7c. apply refl_equal. % 119.85/120.11 apply zenon_H7c. apply refl_equal. % 119.85/120.11 (* end of lemma zenon_L99_ *) % 119.85/120.11 assert (zenon_L100_ : ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((loopcounter) = (n0)) -> False). % 119.85/120.11 do 0 intro. intros zenon_H155 zenon_H140 zenon_H7d zenon_H67 zenon_H66 zenon_H95. % 119.85/120.11 elim (classic ((n0) = (loopcounter))); [ zenon_intro zenon_H133 | zenon_intro zenon_H93 ]. % 119.85/120.11 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.85/120.11 elim (classic (gt (n0) (loopcounter))); [ zenon_intro zenon_H130 | zenon_intro zenon_H131 ]. % 119.85/120.11 elim (classic (gt (loopcounter) (succ (loopcounter)))); [ zenon_intro zenon_Hf2 | zenon_intro zenon_Hf0 ]. % 119.85/120.11 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.85/120.11 generalize (zenon_H142 (loopcounter)). zenon_intro zenon_H143. % 119.85/120.11 generalize (zenon_H143 (succ (loopcounter))). zenon_intro zenon_H144. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H144); [ zenon_intro zenon_H131 | zenon_intro zenon_H145 ]. % 119.85/120.11 exact (zenon_H131 zenon_H130). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H145); [ zenon_intro zenon_Hf0 | zenon_intro zenon_H146 ]. % 119.85/120.11 exact (zenon_Hf0 zenon_Hf2). % 119.85/120.11 exact (zenon_H140 zenon_H146). % 119.85/120.11 apply (zenon_L82_); trivial. % 119.85/120.11 cut ((gt (n0) (n0)) = (gt (n0) (loopcounter))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H131. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H141. % 119.85/120.11 cut (((n0) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H93]. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 congruence. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 exact (zenon_H93 zenon_H133). % 119.85/120.11 apply (zenon_L99_); trivial. % 119.85/120.11 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.11 cut (((loopcounter) = (loopcounter)) = ((n0) = (loopcounter))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H93. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_Hed. % 119.85/120.11 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.11 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H132 zenon_H95). % 119.85/120.11 apply zenon_H7c. apply refl_equal. % 119.85/120.11 apply zenon_H7c. apply refl_equal. % 119.85/120.11 (* end of lemma zenon_L100_ *) % 119.85/120.11 assert (zenon_L101_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((loopcounter) = (n1)) -> (~(gt (n0) (n1))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> False). % 119.85/120.11 do 0 intro. intros zenon_H66 zenon_Hca zenon_H13f zenon_H67 zenon_H7d zenon_H155 zenon_H140. % 119.85/120.11 elim (classic (gt (n1) (n1))); [ zenon_intro zenon_He8 | zenon_intro zenon_Hdd ]. % 119.85/120.11 elim (classic (gt (loopcounter) (n1))); [ zenon_intro zenon_Hf1 | zenon_intro zenon_Hee ]. % 119.85/120.11 cut ((gt (loopcounter) (n1)) = (gt (n0) (n1))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H13f. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_Hf1. % 119.85/120.11 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.11 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.85/120.11 congruence. % 119.85/120.11 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.85/120.11 cut (((n0) = (n0)) = ((loopcounter) = (n0))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H132. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H136. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 cut (((n0) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H93]. % 119.85/120.11 congruence. % 119.85/120.11 apply (zenon_L8_); trivial. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H64. apply refl_equal. % 119.85/120.11 cut ((gt (n1) (n1)) = (gt (loopcounter) (n1))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_Hee. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_He8. % 119.85/120.11 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.11 cut (((n1) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_Hec]. % 119.85/120.11 congruence. % 119.85/120.11 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.11 cut (((loopcounter) = (loopcounter)) = ((n1) = (loopcounter))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_Hec. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_Hed. % 119.85/120.11 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.11 cut (((loopcounter) = (n1))); [idtac | apply NNPP; zenon_intro zenon_Hc4]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_Hc4 zenon_Hca). % 119.85/120.11 apply zenon_H7c. apply refl_equal. % 119.85/120.11 apply zenon_H7c. apply refl_equal. % 119.85/120.11 apply zenon_H64. apply refl_equal. % 119.85/120.11 apply (zenon_L80_); trivial. % 119.85/120.11 (* end of lemma zenon_L101_ *) % 119.85/120.11 assert (zenon_L102_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((loopcounter) = (n2)) -> (~(gt (n0) (n2))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.11 do 0 intro. intros zenon_H66 zenon_Hcc zenon_H1ab zenon_H140 zenon_H155 zenon_H7d zenon_H67. % 119.85/120.11 elim (classic (gt (n2) (n2))); [ zenon_intro zenon_H1aa | zenon_intro zenon_H1a5 ]. % 119.85/120.11 elim (classic (gt (loopcounter) (n2))); [ zenon_intro zenon_H1a1 | zenon_intro zenon_H19d ]. % 119.85/120.11 cut ((gt (loopcounter) (n2)) = (gt (n0) (n2))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H1ab. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H1a1. % 119.85/120.11 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.11 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.85/120.11 congruence. % 119.85/120.11 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.85/120.11 cut (((n0) = (n0)) = ((loopcounter) = (n0))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H132. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H136. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 cut (((n0) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H93]. % 119.85/120.11 congruence. % 119.85/120.11 apply (zenon_L8_); trivial. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H63. apply refl_equal. % 119.85/120.11 cut ((gt (n2) (n2)) = (gt (loopcounter) (n2))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H19d. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H1aa. % 119.85/120.11 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.11 cut (((n2) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H19e]. % 119.85/120.11 congruence. % 119.85/120.11 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.11 cut (((loopcounter) = (loopcounter)) = ((n2) = (loopcounter))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H19e. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_Hed. % 119.85/120.11 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.11 cut (((loopcounter) = (n2))); [idtac | apply NNPP; zenon_intro zenon_Hc3]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_Hc3 zenon_Hcc). % 119.85/120.11 apply zenon_H7c. apply refl_equal. % 119.85/120.11 apply zenon_H7c. apply refl_equal. % 119.85/120.11 apply zenon_H63. apply refl_equal. % 119.85/120.11 apply (zenon_L93_); trivial. % 119.85/120.11 (* end of lemma zenon_L102_ *) % 119.85/120.11 assert (zenon_L103_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((loopcounter) = (n3)) -> (~(gt (n0) (n3))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.11 do 0 intro. intros zenon_H66 zenon_Hcb zenon_H254 zenon_H140 zenon_H155 zenon_H7d zenon_H67. % 119.85/120.11 elim (classic (gt (n3) (n3))); [ zenon_intro zenon_H253 | zenon_intro zenon_H24e ]. % 119.85/120.11 elim (classic (gt (loopcounter) (n3))); [ zenon_intro zenon_H1f9 | zenon_intro zenon_H1f5 ]. % 119.85/120.11 cut ((gt (loopcounter) (n3)) = (gt (n0) (n3))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H254. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H1f9. % 119.85/120.11 cut (((n3) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H201]. % 119.85/120.11 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.85/120.11 congruence. % 119.85/120.11 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.85/120.11 cut (((n0) = (n0)) = ((loopcounter) = (n0))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H132. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H136. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 cut (((n0) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H93]. % 119.85/120.11 congruence. % 119.85/120.11 apply (zenon_L8_); trivial. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H201. apply refl_equal. % 119.85/120.11 cut ((gt (n3) (n3)) = (gt (loopcounter) (n3))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H1f5. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H253. % 119.85/120.11 cut (((n3) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H201]. % 119.85/120.11 cut (((n3) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H1f6]. % 119.85/120.11 congruence. % 119.85/120.11 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.11 cut (((loopcounter) = (loopcounter)) = ((n3) = (loopcounter))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H1f6. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_Hed. % 119.85/120.11 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.11 cut (((loopcounter) = (n3))); [idtac | apply NNPP; zenon_intro zenon_Hc2]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_Hc2 zenon_Hcb). % 119.85/120.11 apply zenon_H7c. apply refl_equal. % 119.85/120.11 apply zenon_H7c. apply refl_equal. % 119.85/120.11 apply zenon_H201. apply refl_equal. % 119.85/120.11 apply (zenon_L98_); trivial. % 119.85/120.11 (* end of lemma zenon_L103_ *) % 119.85/120.11 assert (zenon_L104_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (~(gt (n0) (n1))) -> (~(gt (n0) (n2))) -> (~(gt (n0) (n3))) -> False). % 119.85/120.11 do 0 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_H155 zenon_H140 zenon_H13f zenon_H1ab zenon_H254. % 119.85/120.11 generalize (finite_domain_3 (loopcounter)). zenon_intro zenon_Hc5. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_Hc5); [ zenon_intro zenon_Hc7 | zenon_intro zenon_Hc6 ]. % 119.85/120.11 apply (zenon_notand_s _ _ zenon_Hc7); [ zenon_intro zenon_H68 | zenon_intro zenon_Ha4 ]. % 119.85/120.11 apply (zenon_L5_); trivial. % 119.85/120.11 apply (zenon_L12_); trivial. % 119.85/120.11 apply (zenon_or_s _ _ zenon_Hc6); [ zenon_intro zenon_H95 | zenon_intro zenon_Hc8 ]. % 119.85/120.11 apply (zenon_L100_); trivial. % 119.85/120.11 apply (zenon_or_s _ _ zenon_Hc8); [ zenon_intro zenon_Hca | zenon_intro zenon_Hc9 ]. % 119.85/120.11 apply (zenon_L101_); trivial. % 119.85/120.11 apply (zenon_or_s _ _ zenon_Hc9); [ zenon_intro zenon_Hcc | zenon_intro zenon_Hcb ]. % 119.85/120.11 apply (zenon_L102_); trivial. % 119.85/120.11 apply (zenon_L103_); trivial. % 119.85/120.11 (* end of lemma zenon_L104_ *) % 119.85/120.11 assert (zenon_L105_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (n0) (n0))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (n1))) -> (~(gt (n0) (n2))) -> (~(gt (n0) (n3))) -> False). % 119.85/120.11 do 0 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_H12f zenon_H140 zenon_H155 zenon_H13f zenon_H1ab zenon_H254. % 119.85/120.11 generalize (finite_domain_3 (loopcounter)). zenon_intro zenon_Hc5. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_Hc5); [ zenon_intro zenon_Hc7 | zenon_intro zenon_Hc6 ]. % 119.85/120.11 apply (zenon_notand_s _ _ zenon_Hc7); [ zenon_intro zenon_H68 | zenon_intro zenon_Ha4 ]. % 119.85/120.11 apply (zenon_L5_); trivial. % 119.85/120.11 apply (zenon_L12_); trivial. % 119.85/120.11 apply (zenon_or_s _ _ zenon_Hc6); [ zenon_intro zenon_H95 | zenon_intro zenon_Hc8 ]. % 119.85/120.11 apply (zenon_L99_); trivial. % 119.85/120.11 apply (zenon_or_s _ _ zenon_Hc8); [ zenon_intro zenon_Hca | zenon_intro zenon_Hc9 ]. % 119.85/120.11 apply (zenon_L101_); trivial. % 119.85/120.11 apply (zenon_or_s _ _ zenon_Hc9); [ zenon_intro zenon_Hcc | zenon_intro zenon_Hcb ]. % 119.85/120.11 apply (zenon_L102_); trivial. % 119.85/120.11 apply (zenon_L103_); trivial. % 119.85/120.11 (* end of lemma zenon_L105_ *) % 119.85/120.11 assert (zenon_L106_ : (~(gt (n0) (n3))) -> (~(gt (n0) (n2))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n0) (n0))) -> False). % 119.85/120.11 do 0 intro. intros zenon_H254 zenon_H1ab zenon_H155 zenon_H140 zenon_H7d zenon_H67 zenon_H66 zenon_H12f. % 119.85/120.11 elim (classic ((~((n0) = (n1)))/\(~(gt (n0) (n1))))); [ zenon_intro zenon_H14a | zenon_intro zenon_H14b ]. % 119.85/120.11 apply (zenon_and_s _ _ zenon_H14a). zenon_intro zenon_H106. zenon_intro zenon_H13f. % 119.85/120.11 apply (zenon_L105_); trivial. % 119.85/120.11 cut ((gt (n1) (n0)) = (gt (n0) (n0))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H12f. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact gt_1_0. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 cut (((n1) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H14c]. % 119.85/120.11 congruence. % 119.85/120.11 apply (zenon_notand_s _ _ zenon_H14b); [ zenon_intro zenon_H14e | zenon_intro zenon_H14d ]. % 119.85/120.11 apply zenon_H14e. zenon_intro zenon_H14f. % 119.85/120.11 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.85/120.11 cut (((n0) = (n0)) = ((n1) = (n0))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H14c. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H136. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 cut (((n0) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H106]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H106 zenon_H14f). % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H14d. zenon_intro zenon_H150. % 119.85/120.11 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.85/120.11 generalize (zenon_H142 (n1)). zenon_intro zenon_H151. % 119.85/120.11 generalize (zenon_H151 (n0)). zenon_intro zenon_H152. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H152); [ zenon_intro zenon_H13f | zenon_intro zenon_H153 ]. % 119.85/120.11 exact (zenon_H13f zenon_H150). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H153); [ zenon_intro zenon_H7b | zenon_intro zenon_H141 ]. % 119.85/120.11 exact (zenon_H7b gt_1_0). % 119.85/120.11 exact (zenon_H12f zenon_H141). % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 (* end of lemma zenon_L106_ *) % 119.85/120.11 assert (zenon_L107_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (n2))) -> (~(gt (n0) (n3))) -> False). % 119.85/120.11 do 0 intro. intros zenon_H66 zenon_H154 zenon_H67 zenon_H7d zenon_H140 zenon_H155 zenon_H1ab zenon_H254. % 119.85/120.11 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.85/120.11 cut ((gt (n0) (sum (n0) (tptp_minus_1) zenon_E)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H154. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H156. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.11 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.85/120.11 congruence. % 119.85/120.11 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H159. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H15a. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H15b zenon_H155). % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.85/120.11 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.85/120.11 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H157. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H141. % 119.85/120.11 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 congruence. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 exact (zenon_H159 zenon_H15c). % 119.85/120.11 apply (zenon_L106_); trivial. % 119.85/120.11 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H159. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H15a. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H15b zenon_H155). % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 (* end of lemma zenon_L107_ *) % 119.85/120.11 assert (zenon_L108_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (tptp_minus_1)) (succ (tptp_minus_1)))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (n2))) -> (~(gt (n0) (n3))) -> False). % 119.85/120.11 do 0 intro. intros zenon_H66 zenon_H168 zenon_H67 zenon_H7d zenon_H140 zenon_H155 zenon_H1ab zenon_H254. % 119.85/120.11 elim (classic (gt (n0) (succ (tptp_minus_1)))); [ zenon_intro zenon_H163 | zenon_intro zenon_H15d ]. % 119.85/120.11 cut ((gt (n0) (succ (tptp_minus_1))) = (gt (succ (tptp_minus_1)) (succ (tptp_minus_1)))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H168. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H163. % 119.85/120.11 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.11 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.85/120.11 congruence. % 119.85/120.11 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.85/120.11 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H167. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H16a. % 119.85/120.11 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.11 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H16b succ_tptp_minus_1). % 119.85/120.11 apply zenon_H169. apply refl_equal. % 119.85/120.11 apply zenon_H169. apply refl_equal. % 119.85/120.11 apply zenon_H169. apply refl_equal. % 119.85/120.11 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.85/120.11 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.85/120.11 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.85/120.11 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (tptp_minus_1)))); [ zenon_intro zenon_H15e | zenon_intro zenon_H15f ]. % 119.85/120.11 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.85/120.11 generalize (zenon_H142 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H160. % 119.85/120.11 generalize (zenon_H160 (succ (tptp_minus_1))). zenon_intro zenon_H161. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H161); [ zenon_intro zenon_H157 | zenon_intro zenon_H162 ]. % 119.85/120.11 exact (zenon_H157 zenon_H156). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H162); [ zenon_intro zenon_H15f | zenon_intro zenon_H163 ]. % 119.85/120.11 exact (zenon_H15f zenon_H15e). % 119.85/120.11 exact (zenon_H15d zenon_H163). % 119.85/120.11 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H164 | zenon_intro zenon_H154 ]. % 119.85/120.11 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (n0))); [ zenon_intro zenon_H165 | zenon_intro zenon_H166 ]. % 119.85/120.11 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (n0)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (tptp_minus_1)))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H15f. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H165. % 119.85/120.11 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.11 congruence. % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 apply zenon_H167. apply sym_equal. exact succ_tptp_minus_1. % 119.85/120.11 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (n0))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H166. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H164. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.11 congruence. % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 exact (zenon_H15b zenon_H155). % 119.85/120.11 apply (zenon_L107_); trivial. % 119.85/120.11 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H157. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H141. % 119.85/120.11 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 congruence. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 exact (zenon_H159 zenon_H15c). % 119.85/120.11 apply (zenon_L106_); trivial. % 119.85/120.11 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H159. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H15a. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H15b zenon_H155). % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 (* end of lemma zenon_L108_ *) % 119.85/120.11 assert (zenon_L109_ : ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (succ (tptp_minus_1)) (succ (loopcounter)))) -> (~(gt (n0) (n2))) -> (~(gt (n0) (n3))) -> (~(gt (succ (tptp_minus_1)) (succ (succ (succ (n0)))))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.11 do 0 intro. intros zenon_H155 zenon_H140 zenon_H67 zenon_H7d zenon_H16c zenon_H1ab zenon_H254 zenon_H255 zenon_H66. % 119.85/120.11 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.85/120.11 elim (classic (gt (succ (tptp_minus_1)) (n1))); [ zenon_intro zenon_H16d | zenon_intro zenon_H16e ]. % 119.85/120.11 elim (classic (gt (succ (tptp_minus_1)) (succ (n0)))); [ zenon_intro zenon_H16f | zenon_intro zenon_H170 ]. % 119.85/120.11 elim (classic (gt (succ (n0)) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H246 | zenon_intro zenon_H240 ]. % 119.85/120.11 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.85/120.11 generalize (zenon_H171 (succ (n0))). zenon_intro zenon_H172. % 119.85/120.11 generalize (zenon_H172 (succ (succ (succ (n0))))). zenon_intro zenon_H256. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H256); [ zenon_intro zenon_H170 | zenon_intro zenon_H257 ]. % 119.85/120.11 exact (zenon_H170 zenon_H16f). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H257); [ zenon_intro zenon_H240 | zenon_intro zenon_H258 ]. % 119.85/120.11 exact (zenon_H240 zenon_H246). % 119.85/120.11 exact (zenon_H255 zenon_H258). % 119.85/120.11 apply (zenon_L96_); trivial. % 119.85/120.11 cut ((gt (succ (tptp_minus_1)) (n1)) = (gt (succ (tptp_minus_1)) (succ (n0)))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H170. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H16d. % 119.85/120.11 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.85/120.11 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.11 congruence. % 119.85/120.11 apply zenon_H169. apply refl_equal. % 119.85/120.11 exact (zenon_H88 zenon_Hd1). % 119.85/120.11 elim (classic (gt (succ (tptp_minus_1)) (succ (tptp_minus_1)))); [ zenon_intro zenon_H176 | zenon_intro zenon_H168 ]. % 119.85/120.11 elim (classic (gt (succ (tptp_minus_1)) (n0))); [ zenon_intro zenon_H177 | zenon_intro zenon_H178 ]. % 119.85/120.11 elim (classic (gt (n0) (n1))); [ zenon_intro zenon_H150 | zenon_intro zenon_H13f ]. % 119.85/120.11 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.85/120.11 generalize (zenon_H171 (n0)). zenon_intro zenon_H179. % 119.85/120.11 generalize (zenon_H179 (n1)). zenon_intro zenon_H17a. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H17a); [ zenon_intro zenon_H178 | zenon_intro zenon_H17b ]. % 119.85/120.11 exact (zenon_H178 zenon_H177). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H17b); [ zenon_intro zenon_H13f | zenon_intro zenon_H16d ]. % 119.85/120.11 exact (zenon_H13f zenon_H150). % 119.85/120.11 exact (zenon_H16e zenon_H16d). % 119.85/120.11 apply (zenon_L104_); trivial. % 119.85/120.11 cut ((gt (succ (tptp_minus_1)) (succ (tptp_minus_1))) = (gt (succ (tptp_minus_1)) (n0))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H178. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H176. % 119.85/120.11 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.11 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.11 congruence. % 119.85/120.11 apply zenon_H169. apply refl_equal. % 119.85/120.11 exact (zenon_H16b succ_tptp_minus_1). % 119.85/120.11 apply (zenon_L108_); trivial. % 119.85/120.11 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.85/120.11 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H88. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H8b. % 119.85/120.11 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.85/120.11 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H87 successor_1). % 119.85/120.11 apply zenon_H8c. apply refl_equal. % 119.85/120.11 apply zenon_H8c. apply refl_equal. % 119.85/120.11 (* end of lemma zenon_L109_ *) % 119.85/120.11 assert (zenon_L110_ : (~(gt (succ (tptp_minus_1)) (succ (succ (succ (n0)))))) -> (~(gt (n0) (n3))) -> (~(gt (n0) (n2))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (tptp_minus_1)) (n2))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.11 do 0 intro. intros zenon_H255 zenon_H254 zenon_H1ab zenon_H66 zenon_H1df zenon_H140 zenon_H155 zenon_H7d zenon_H67. % 119.85/120.11 elim (classic ((~((succ (tptp_minus_1)) = (n3)))/\(~(gt (succ (tptp_minus_1)) (n3))))); [ zenon_intro zenon_H259 | zenon_intro zenon_H25a ]. % 119.85/120.11 apply (zenon_and_s _ _ zenon_H259). zenon_intro zenon_H25c. zenon_intro zenon_H25b. % 119.85/120.11 elim (classic ((~((succ (tptp_minus_1)) = (succ (loopcounter))))/\(~(gt (succ (tptp_minus_1)) (succ (loopcounter)))))); [ zenon_intro zenon_H25d | zenon_intro zenon_H25e ]. % 119.85/120.11 apply (zenon_and_s _ _ zenon_H25d). zenon_intro zenon_H25f. zenon_intro zenon_H16c. % 119.85/120.11 apply (zenon_L109_); trivial. % 119.85/120.11 elim (classic (gt (n1) (n3))); [ zenon_intro zenon_H1ee | zenon_intro zenon_H1e6 ]. % 119.85/120.11 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.85/120.11 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.85/120.11 generalize (zenon_H78 (n3)). zenon_intro zenon_H20f. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H20f); [ zenon_intro zenon_H6f | zenon_intro zenon_H210 ]. % 119.85/120.11 exact (zenon_H6f zenon_H67). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H210); [ zenon_intro zenon_H1e6 | zenon_intro zenon_H211 ]. % 119.85/120.11 exact (zenon_H1e6 zenon_H1ee). % 119.85/120.11 cut ((gt (succ (loopcounter)) (n3)) = (gt (succ (tptp_minus_1)) (n3))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H25b. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H211. % 119.85/120.11 cut (((n3) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H201]. % 119.85/120.11 cut (((succ (loopcounter)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H260]. % 119.85/120.11 congruence. % 119.85/120.11 apply (zenon_notand_s _ _ zenon_H25e); [ zenon_intro zenon_H262 | zenon_intro zenon_H261 ]. % 119.85/120.11 apply zenon_H262. zenon_intro zenon_H263. % 119.85/120.11 apply zenon_H260. apply sym_equal. exact zenon_H263. % 119.85/120.11 apply zenon_H261. zenon_intro zenon_H175. % 119.85/120.11 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.85/120.11 generalize (zenon_H171 (succ (loopcounter))). zenon_intro zenon_H264. % 119.85/120.11 generalize (zenon_H264 (n3)). zenon_intro zenon_H265. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H265); [ zenon_intro zenon_H16c | zenon_intro zenon_H266 ]. % 119.85/120.11 exact (zenon_H16c zenon_H175). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H266); [ zenon_intro zenon_H21a | zenon_intro zenon_H267 ]. % 119.85/120.11 exact (zenon_H21a zenon_H211). % 119.85/120.11 exact (zenon_H25b zenon_H267). % 119.85/120.11 apply zenon_H201. apply refl_equal. % 119.85/120.11 apply (zenon_L79_); trivial. % 119.85/120.11 cut ((gt (n3) (n2)) = (gt (succ (tptp_minus_1)) (n2))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H1df. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact gt_3_2. % 119.85/120.11 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.11 cut (((n3) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H268]. % 119.85/120.11 congruence. % 119.85/120.11 apply (zenon_notand_s _ _ zenon_H25a); [ zenon_intro zenon_H26a | zenon_intro zenon_H269 ]. % 119.85/120.11 apply zenon_H26a. zenon_intro zenon_H26b. % 119.85/120.11 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.85/120.11 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n3) = (succ (tptp_minus_1)))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H268. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H16a. % 119.85/120.11 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.11 cut (((succ (tptp_minus_1)) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H25c]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H25c zenon_H26b). % 119.85/120.11 apply zenon_H169. apply refl_equal. % 119.85/120.11 apply zenon_H169. apply refl_equal. % 119.85/120.11 apply zenon_H269. zenon_intro zenon_H267. % 119.85/120.11 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.85/120.11 generalize (zenon_H171 (n3)). zenon_intro zenon_H26c. % 119.85/120.11 generalize (zenon_H26c (n2)). zenon_intro zenon_H26d. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H26d); [ zenon_intro zenon_H25b | zenon_intro zenon_H26e ]. % 119.85/120.11 exact (zenon_H25b zenon_H267). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H26e); [ zenon_intro zenon_H22f | zenon_intro zenon_H1de ]. % 119.85/120.11 exact (zenon_H22f gt_3_2). % 119.85/120.11 exact (zenon_H1df zenon_H1de). % 119.85/120.11 apply zenon_H63. apply refl_equal. % 119.85/120.11 (* end of lemma zenon_L110_ *) % 119.85/120.11 assert (zenon_L111_ : (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(gt (succ (tptp_minus_1)) (succ (succ (succ (n0)))))) -> (~(gt (n0) (n3))) -> (~(gt (n0) (n2))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.11 do 0 intro. intros zenon_H140 zenon_H155 zenon_H7d zenon_H67 zenon_H255 zenon_H254 zenon_H1ab zenon_H66. % 119.85/120.11 elim (classic ((n2) = (succ (succ (n0))))); [ zenon_intro zenon_H1b9 | zenon_intro zenon_H102 ]. % 119.85/120.11 elim (classic (gt (succ (tptp_minus_1)) (n2))); [ zenon_intro zenon_H1de | zenon_intro zenon_H1df ]. % 119.85/120.11 elim (classic (gt (succ (tptp_minus_1)) (succ (succ (n0))))); [ zenon_intro zenon_H1dd | zenon_intro zenon_H1da ]. % 119.85/120.11 elim (classic (gt (succ (succ (n0))) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H233 | zenon_intro zenon_H21b ]. % 119.85/120.11 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.85/120.11 generalize (zenon_H171 (succ (succ (n0)))). zenon_intro zenon_H26f. % 119.85/120.11 generalize (zenon_H26f (succ (succ (succ (n0))))). zenon_intro zenon_H270. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H270); [ zenon_intro zenon_H1da | zenon_intro zenon_H271 ]. % 119.85/120.11 exact (zenon_H1da zenon_H1dd). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H271); [ zenon_intro zenon_H21b | zenon_intro zenon_H258 ]. % 119.85/120.11 exact (zenon_H21b zenon_H233). % 119.85/120.11 exact (zenon_H255 zenon_H258). % 119.85/120.11 apply (zenon_L91_); trivial. % 119.85/120.11 cut ((gt (succ (tptp_minus_1)) (n2)) = (gt (succ (tptp_minus_1)) (succ (succ (n0))))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H1da. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H1de. % 119.85/120.11 cut (((n2) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 119.85/120.11 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.11 congruence. % 119.85/120.11 apply zenon_H169. apply refl_equal. % 119.85/120.11 exact (zenon_H102 zenon_H1b9). % 119.85/120.11 apply (zenon_L110_); trivial. % 119.85/120.11 elim (classic ((succ (succ (n0))) = (succ (succ (n0))))); [ zenon_intro zenon_H103 | zenon_intro zenon_H104 ]. % 119.85/120.11 cut (((succ (succ (n0))) = (succ (succ (n0)))) = ((n2) = (succ (succ (n0))))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H102. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H103. % 119.85/120.11 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.85/120.11 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H105 successor_2). % 119.85/120.11 apply zenon_H104. apply refl_equal. % 119.85/120.11 apply zenon_H104. apply refl_equal. % 119.85/120.11 (* end of lemma zenon_L111_ *) % 119.85/120.11 assert (zenon_L112_ : (~(gt (n0) (n3))) -> (~(gt (n0) (n2))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (succ (succ (succ (n0)))))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.11 do 0 intro. intros zenon_H254 zenon_H1ab zenon_H155 zenon_H140 zenon_H7d zenon_H67 zenon_H272 zenon_H66. % 119.85/120.11 elim (classic ((n0) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H180 | zenon_intro zenon_H167 ]. % 119.85/120.11 elim (classic (gt (succ (tptp_minus_1)) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H258 | zenon_intro zenon_H255 ]. % 119.85/120.11 elim (classic (gt (n0) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H273 | zenon_intro zenon_H274 ]. % 119.85/120.11 cut ((gt (n0) (succ (succ (succ (n0))))) = (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (succ (succ (n0)))))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H272. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H273. % 119.85/120.11 cut (((succ (succ (succ (n0)))) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H21e]. % 119.85/120.11 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.85/120.11 congruence. % 119.85/120.11 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H159. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H15a. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H15b zenon_H155). % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 apply zenon_H21e. apply refl_equal. % 119.85/120.11 cut ((gt (succ (tptp_minus_1)) (succ (succ (succ (n0))))) = (gt (n0) (succ (succ (succ (n0)))))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H274. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H258. % 119.85/120.11 cut (((succ (succ (succ (n0)))) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H21e]. % 119.85/120.11 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.11 congruence. % 119.85/120.11 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.85/120.11 cut (((n0) = (n0)) = ((succ (tptp_minus_1)) = (n0))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H16b. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H136. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H167 zenon_H180). % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H21e. apply refl_equal. % 119.85/120.11 apply (zenon_L111_); trivial. % 119.85/120.11 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.85/120.11 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H167. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H16a. % 119.85/120.11 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.11 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H16b succ_tptp_minus_1). % 119.85/120.11 apply zenon_H169. apply refl_equal. % 119.85/120.11 apply zenon_H169. apply refl_equal. % 119.85/120.11 (* end of lemma zenon_L112_ *) % 119.85/120.11 assert (zenon_L113_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (n3))) -> (~(gt (n0) (n3))) -> (~(gt (n0) (n2))) -> (~(gt (n0) (succ (loopcounter)))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.11 do 0 intro. intros zenon_H66 zenon_H275 zenon_H254 zenon_H1ab zenon_H140 zenon_H7d zenon_H67 zenon_H155. % 119.85/120.11 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H276 | zenon_intro zenon_H272 ]. % 119.85/120.11 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (succ (succ (succ (n0))))) = (gt (sum (n0) (tptp_minus_1) zenon_E) (n3))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H275. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H276. % 119.85/120.11 cut (((succ (succ (succ (n0)))) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H21f]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.11 congruence. % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 exact (zenon_H21f successor_3). % 119.85/120.11 apply (zenon_L112_); trivial. % 119.85/120.11 (* end of lemma zenon_L113_ *) % 119.85/120.11 assert (zenon_L114_ : (~(gt (n0) (n3))) -> (~(gt (n0) (n2))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (n2))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.11 do 0 intro. intros zenon_H254 zenon_H1ab zenon_H66 zenon_H1c8 zenon_H140 zenon_H155 zenon_H7d zenon_H67. % 119.85/120.11 elim (classic ((~((sum (n0) (tptp_minus_1) zenon_E) = (n3)))/\(~(gt (sum (n0) (tptp_minus_1) zenon_E) (n3))))); [ zenon_intro zenon_H277 | zenon_intro zenon_H278 ]. % 119.85/120.11 apply (zenon_and_s _ _ zenon_H277). zenon_intro zenon_H279. zenon_intro zenon_H275. % 119.85/120.11 apply (zenon_L113_); trivial. % 119.85/120.11 cut ((gt (n3) (n2)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (n2))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H1c8. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact gt_3_2. % 119.85/120.11 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.11 cut (((n3) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H27a]. % 119.85/120.11 congruence. % 119.85/120.11 apply (zenon_notand_s _ _ zenon_H278); [ zenon_intro zenon_H27c | zenon_intro zenon_H27b ]. % 119.85/120.11 apply zenon_H27c. zenon_intro zenon_H27d. % 119.85/120.11 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n3) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H27a. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H15a. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H279]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H279 zenon_H27d). % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 apply zenon_H27b. zenon_intro zenon_H27e. % 119.85/120.11 generalize (zenon_H66 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H1bb. % 119.85/120.11 generalize (zenon_H1bb (n3)). zenon_intro zenon_H27f. % 119.85/120.11 generalize (zenon_H27f (n2)). zenon_intro zenon_H280. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H280); [ zenon_intro zenon_H275 | zenon_intro zenon_H281 ]. % 119.85/120.11 exact (zenon_H275 zenon_H27e). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H281); [ zenon_intro zenon_H22f | zenon_intro zenon_H1cb ]. % 119.85/120.11 exact (zenon_H22f gt_3_2). % 119.85/120.11 exact (zenon_H1c8 zenon_H1cb). % 119.85/120.11 apply zenon_H63. apply refl_equal. % 119.85/120.11 (* end of lemma zenon_L114_ *) % 119.85/120.11 assert (zenon_L115_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (n0) (succ (loopcounter)))) -> (~(gt (n0) (n2))) -> (~(gt (n0) (n3))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.11 do 0 intro. intros zenon_H67 zenon_H7d zenon_H140 zenon_H1ab zenon_H254 zenon_H66 zenon_H155. % 119.85/120.11 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.85/120.11 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.85/120.11 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.85/120.11 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (n2))); [ zenon_intro zenon_H1cb | zenon_intro zenon_H1c8 ]. % 119.85/120.11 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.85/120.11 generalize (zenon_H142 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H160. % 119.85/120.11 generalize (zenon_H160 (n2)). zenon_intro zenon_H282. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H282); [ zenon_intro zenon_H157 | zenon_intro zenon_H283 ]. % 119.85/120.11 exact (zenon_H157 zenon_H156). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H283); [ zenon_intro zenon_H1c8 | zenon_intro zenon_H1b3 ]. % 119.85/120.11 exact (zenon_H1c8 zenon_H1cb). % 119.85/120.11 exact (zenon_H1ab zenon_H1b3). % 119.85/120.11 apply (zenon_L114_); trivial. % 119.85/120.11 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H157. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H141. % 119.85/120.11 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 congruence. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 exact (zenon_H159 zenon_H15c). % 119.85/120.11 apply (zenon_L106_); trivial. % 119.85/120.11 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H159. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H15a. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H15b zenon_H155). % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 (* end of lemma zenon_L115_ *) % 119.85/120.11 assert (zenon_L116_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n0) (n2))) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.11 do 0 intro. intros zenon_H66 zenon_H1ab zenon_H140 zenon_H155 zenon_H7d zenon_H67. % 119.85/120.11 elim (classic ((~((n0) = (n3)))/\(~(gt (n0) (n3))))); [ zenon_intro zenon_H284 | zenon_intro zenon_H285 ]. % 119.85/120.11 apply (zenon_and_s _ _ zenon_H284). zenon_intro zenon_H286. zenon_intro zenon_H254. % 119.85/120.11 apply (zenon_L115_); trivial. % 119.85/120.11 cut ((gt (n3) (n2)) = (gt (n0) (n2))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H1ab. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact gt_3_2. % 119.85/120.11 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.11 cut (((n3) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H287]. % 119.85/120.11 congruence. % 119.85/120.11 apply (zenon_notand_s _ _ zenon_H285); [ zenon_intro zenon_H289 | zenon_intro zenon_H288 ]. % 119.85/120.11 apply zenon_H289. zenon_intro zenon_H28a. % 119.85/120.11 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.85/120.11 cut (((n0) = (n0)) = ((n3) = (n0))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H287. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H136. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 cut (((n0) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H286]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H286 zenon_H28a). % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H288. zenon_intro zenon_H28b. % 119.85/120.11 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.85/120.11 generalize (zenon_H142 (n3)). zenon_intro zenon_H28c. % 119.85/120.11 generalize (zenon_H28c (n2)). zenon_intro zenon_H28d. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H28d); [ zenon_intro zenon_H254 | zenon_intro zenon_H28e ]. % 119.85/120.11 exact (zenon_H254 zenon_H28b). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H28e); [ zenon_intro zenon_H22f | zenon_intro zenon_H1b3 ]. % 119.85/120.11 exact (zenon_H22f gt_3_2). % 119.85/120.11 exact (zenon_H1ab zenon_H1b3). % 119.85/120.11 apply zenon_H63. apply refl_equal. % 119.85/120.11 (* end of lemma zenon_L116_ *) % 119.85/120.11 assert (zenon_L117_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (n3))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n0) (n0))) -> False). % 119.85/120.11 do 0 intro. intros zenon_H67 zenon_H7d zenon_H140 zenon_H155 zenon_H254 zenon_H66 zenon_H12f. % 119.85/120.11 elim (classic ((~((n0) = (n2)))/\(~(gt (n0) (n2))))); [ zenon_intro zenon_H1ac | zenon_intro zenon_H1ad ]. % 119.85/120.11 apply (zenon_and_s _ _ zenon_H1ac). zenon_intro zenon_H1ae. zenon_intro zenon_H1ab. % 119.85/120.11 apply (zenon_L106_); trivial. % 119.85/120.11 cut ((gt (n2) (n0)) = (gt (n0) (n0))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H12f. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact gt_2_0. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 cut (((n2) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H1af]. % 119.85/120.11 congruence. % 119.85/120.11 apply (zenon_notand_s _ _ zenon_H1ad); [ zenon_intro zenon_H1b1 | zenon_intro zenon_H1b0 ]. % 119.85/120.11 apply zenon_H1b1. zenon_intro zenon_H1b2. % 119.85/120.11 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.85/120.11 cut (((n0) = (n0)) = ((n2) = (n0))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H1af. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H136. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 cut (((n0) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H1ae]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H1ae zenon_H1b2). % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H1b0. zenon_intro zenon_H1b3. % 119.85/120.11 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.85/120.11 generalize (zenon_H142 (n2)). zenon_intro zenon_H1b4. % 119.85/120.11 generalize (zenon_H1b4 (n0)). zenon_intro zenon_H1b5. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H1b5); [ zenon_intro zenon_H1ab | zenon_intro zenon_H1b6 ]. % 119.85/120.11 exact (zenon_H1ab zenon_H1b3). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H1b6); [ zenon_intro zenon_H1b7 | zenon_intro zenon_H141 ]. % 119.85/120.11 exact (zenon_H1b7 gt_2_0). % 119.85/120.11 exact (zenon_H12f zenon_H141). % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 (* end of lemma zenon_L117_ *) % 119.85/120.11 assert (zenon_L118_ : ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n0) (n0))) -> False). % 119.85/120.11 do 0 intro. intros zenon_H155 zenon_H140 zenon_H7d zenon_H67 zenon_H66 zenon_H12f. % 119.85/120.11 elim (classic ((~((n0) = (n3)))/\(~(gt (n0) (n3))))); [ zenon_intro zenon_H284 | zenon_intro zenon_H285 ]. % 119.85/120.11 apply (zenon_and_s _ _ zenon_H284). zenon_intro zenon_H286. zenon_intro zenon_H254. % 119.85/120.11 apply (zenon_L117_); trivial. % 119.85/120.11 cut ((gt (n3) (n0)) = (gt (n0) (n0))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H12f. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact gt_3_0. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 cut (((n3) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H287]. % 119.85/120.11 congruence. % 119.85/120.11 apply (zenon_notand_s _ _ zenon_H285); [ zenon_intro zenon_H289 | zenon_intro zenon_H288 ]. % 119.85/120.11 apply zenon_H289. zenon_intro zenon_H28a. % 119.85/120.11 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.85/120.11 cut (((n0) = (n0)) = ((n3) = (n0))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H287. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H136. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 cut (((n0) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H286]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H286 zenon_H28a). % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 apply zenon_H288. zenon_intro zenon_H28b. % 119.85/120.11 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.85/120.11 generalize (zenon_H142 (n3)). zenon_intro zenon_H28c. % 119.85/120.11 generalize (zenon_H28c (n0)). zenon_intro zenon_H28f. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H28f); [ zenon_intro zenon_H254 | zenon_intro zenon_H290 ]. % 119.85/120.11 exact (zenon_H254 zenon_H28b). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H290); [ zenon_intro zenon_H291 | zenon_intro zenon_H141 ]. % 119.85/120.11 exact (zenon_H291 gt_3_0). % 119.85/120.11 exact (zenon_H12f zenon_H141). % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 (* end of lemma zenon_L118_ *) % 119.85/120.11 assert (zenon_L119_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.11 do 0 intro. intros zenon_H66 zenon_H154 zenon_H67 zenon_H7d zenon_H140 zenon_H155. % 119.85/120.11 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.85/120.11 cut ((gt (n0) (sum (n0) (tptp_minus_1) zenon_E)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H154. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H156. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.11 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.85/120.11 congruence. % 119.85/120.11 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H159. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H15a. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H15b zenon_H155). % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.85/120.11 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.85/120.11 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H157. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H141. % 119.85/120.11 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.85/120.11 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.11 congruence. % 119.85/120.11 apply zenon_H65. apply refl_equal. % 119.85/120.11 exact (zenon_H159 zenon_H15c). % 119.85/120.11 apply (zenon_L118_); trivial. % 119.85/120.11 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H159. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H15a. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H15b zenon_H155). % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 (* end of lemma zenon_L119_ *) % 119.85/120.11 assert (zenon_L120_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (n2))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.11 do 0 intro. intros zenon_H66 zenon_H1c8 zenon_H155 zenon_H140 zenon_H7d zenon_H67. % 119.85/120.11 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H164 | zenon_intro zenon_H154 ]. % 119.85/120.11 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (n0))); [ zenon_intro zenon_H165 | zenon_intro zenon_H166 ]. % 119.85/120.11 elim (classic (gt (n0) (n2))); [ zenon_intro zenon_H1b3 | zenon_intro zenon_H1ab ]. % 119.85/120.11 generalize (zenon_H66 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H1bb. % 119.85/120.11 generalize (zenon_H1bb (n0)). zenon_intro zenon_H1bc. % 119.85/120.11 generalize (zenon_H1bc (n2)). zenon_intro zenon_H1c9. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H1c9); [ zenon_intro zenon_H166 | zenon_intro zenon_H1ca ]. % 119.85/120.11 exact (zenon_H166 zenon_H165). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H1ca); [ zenon_intro zenon_H1ab | zenon_intro zenon_H1cb ]. % 119.85/120.11 exact (zenon_H1ab zenon_H1b3). % 119.85/120.11 exact (zenon_H1c8 zenon_H1cb). % 119.85/120.11 apply (zenon_L116_); trivial. % 119.85/120.11 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (n0))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H166. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H164. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.11 congruence. % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 exact (zenon_H15b zenon_H155). % 119.85/120.11 apply (zenon_L119_); trivial. % 119.85/120.11 (* end of lemma zenon_L120_ *) % 119.85/120.11 assert (zenon_L121_ : (~(gt (succ (tptp_minus_1)) (succ (loopcounter)))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (succ (succ (n0))))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.11 do 0 intro. intros zenon_H16c zenon_H7d zenon_H67 zenon_H140 zenon_H155 zenon_H1c0 zenon_H66. % 119.85/120.11 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.85/120.11 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (n1))); [ zenon_intro zenon_H1bf | zenon_intro zenon_H1ba ]. % 119.85/120.11 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (n0)))); [ zenon_intro zenon_H1c1 | zenon_intro zenon_H1c2 ]. % 119.85/120.11 elim (classic (gt (succ (n0)) (succ (succ (n0))))); [ zenon_intro zenon_H1c3 | zenon_intro zenon_H1b8 ]. % 119.85/120.11 generalize (zenon_H66 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H1bb. % 119.85/120.11 generalize (zenon_H1bb (succ (n0))). zenon_intro zenon_H1c4. % 119.85/120.11 generalize (zenon_H1c4 (succ (succ (n0)))). zenon_intro zenon_H1c5. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H1c5); [ zenon_intro zenon_H1c2 | zenon_intro zenon_H1c6 ]. % 119.85/120.11 exact (zenon_H1c2 zenon_H1c1). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H1c6); [ zenon_intro zenon_H1b8 | zenon_intro zenon_H1c7 ]. % 119.85/120.11 exact (zenon_H1b8 zenon_H1c3). % 119.85/120.11 exact (zenon_H1c0 zenon_H1c7). % 119.85/120.11 apply (zenon_L97_); trivial. % 119.85/120.11 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (n1)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (n0)))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H1c2. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H1bf. % 119.85/120.11 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.11 congruence. % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 exact (zenon_H88 zenon_Hd1). % 119.85/120.11 elim (classic ((~((sum (n0) (tptp_minus_1) zenon_E) = (n2)))/\(~(gt (sum (n0) (tptp_minus_1) zenon_E) (n2))))); [ zenon_intro zenon_H1d0 | zenon_intro zenon_H1d1 ]. % 119.85/120.11 apply (zenon_and_s _ _ zenon_H1d0). zenon_intro zenon_H1d2. zenon_intro zenon_H1c8. % 119.85/120.11 apply (zenon_L120_); trivial. % 119.85/120.11 cut ((gt (n2) (n1)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (n1))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H1ba. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact gt_2_1. % 119.85/120.11 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.11 cut (((n2) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H1d3]. % 119.85/120.11 congruence. % 119.85/120.11 apply (zenon_notand_s _ _ zenon_H1d1); [ zenon_intro zenon_H1d5 | zenon_intro zenon_H1d4 ]. % 119.85/120.11 apply zenon_H1d5. zenon_intro zenon_H1d6. % 119.85/120.11 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n2) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H1d3. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H15a. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.11 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H1d2]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H1d2 zenon_H1d6). % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 apply zenon_H158. apply refl_equal. % 119.85/120.11 apply zenon_H1d4. zenon_intro zenon_H1cb. % 119.85/120.11 generalize (zenon_H66 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H1bb. % 119.85/120.11 generalize (zenon_H1bb (n2)). zenon_intro zenon_H1d7. % 119.85/120.11 generalize (zenon_H1d7 (n1)). zenon_intro zenon_H1d8. % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H1d8); [ zenon_intro zenon_H1c8 | zenon_intro zenon_H1d9 ]. % 119.85/120.11 exact (zenon_H1c8 zenon_H1cb). % 119.85/120.11 apply (zenon_imply_s _ _ zenon_H1d9); [ zenon_intro zenon_Hba | zenon_intro zenon_H1bf ]. % 119.85/120.11 exact (zenon_Hba gt_2_1). % 119.85/120.11 exact (zenon_H1ba zenon_H1bf). % 119.85/120.11 apply zenon_H64. apply refl_equal. % 119.85/120.11 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.85/120.11 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.85/120.11 intro zenon_D_pnotp. % 119.85/120.11 apply zenon_H88. % 119.85/120.11 rewrite <- zenon_D_pnotp. % 119.85/120.11 exact zenon_H8b. % 119.85/120.11 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.85/120.11 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.85/120.11 congruence. % 119.85/120.11 exact (zenon_H87 successor_1). % 119.85/120.11 apply zenon_H8c. apply refl_equal. % 119.85/120.11 apply zenon_H8c. apply refl_equal. % 119.85/120.11 (* end of lemma zenon_L121_ *) % 119.85/120.11 assert (zenon_L122_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (n0) (succ (loopcounter)))) -> (~(gt (n0) (succ (succ (n0))))) -> (~(gt (succ (tptp_minus_1)) (succ (loopcounter)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.12 do 0 intro. intros zenon_H67 zenon_H7d zenon_H140 zenon_H1cc zenon_H16c zenon_H66 zenon_H155. % 119.85/120.12 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.85/120.12 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.85/120.12 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.85/120.12 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (succ (n0))))); [ zenon_intro zenon_H1c7 | zenon_intro zenon_H1c0 ]. % 119.85/120.12 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.85/120.12 generalize (zenon_H142 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H160. % 119.85/120.12 generalize (zenon_H160 (succ (succ (n0)))). zenon_intro zenon_H1cd. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H1cd); [ zenon_intro zenon_H157 | zenon_intro zenon_H1ce ]. % 119.85/120.12 exact (zenon_H157 zenon_H156). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H1ce); [ zenon_intro zenon_H1c0 | zenon_intro zenon_H1cf ]. % 119.85/120.12 exact (zenon_H1c0 zenon_H1c7). % 119.85/120.12 exact (zenon_H1cc zenon_H1cf). % 119.85/120.12 apply (zenon_L121_); trivial. % 119.85/120.12 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H157. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H141. % 119.85/120.12 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.85/120.12 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.12 congruence. % 119.85/120.12 apply zenon_H65. apply refl_equal. % 119.85/120.12 exact (zenon_H159 zenon_H15c). % 119.85/120.12 apply (zenon_L118_); trivial. % 119.85/120.12 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.12 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H159. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H15a. % 119.85/120.12 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.12 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_H15b zenon_H155). % 119.85/120.12 apply zenon_H158. apply refl_equal. % 119.85/120.12 apply zenon_H158. apply refl_equal. % 119.85/120.12 (* end of lemma zenon_L122_ *) % 119.85/120.12 assert (zenon_L123_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (tptp_minus_1)) (succ (tptp_minus_1)))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_H168 zenon_H67 zenon_H7d zenon_H140 zenon_H155. % 119.85/120.12 elim (classic (gt (n0) (succ (tptp_minus_1)))); [ zenon_intro zenon_H163 | zenon_intro zenon_H15d ]. % 119.85/120.12 cut ((gt (n0) (succ (tptp_minus_1))) = (gt (succ (tptp_minus_1)) (succ (tptp_minus_1)))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H168. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H163. % 119.85/120.12 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.12 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.85/120.12 congruence. % 119.85/120.12 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.85/120.12 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H167. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H16a. % 119.85/120.12 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.12 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_H16b succ_tptp_minus_1). % 119.85/120.12 apply zenon_H169. apply refl_equal. % 119.85/120.12 apply zenon_H169. apply refl_equal. % 119.85/120.12 apply zenon_H169. apply refl_equal. % 119.85/120.12 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.85/120.12 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.85/120.12 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.85/120.12 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (tptp_minus_1)))); [ zenon_intro zenon_H15e | zenon_intro zenon_H15f ]. % 119.85/120.12 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.85/120.12 generalize (zenon_H142 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H160. % 119.85/120.12 generalize (zenon_H160 (succ (tptp_minus_1))). zenon_intro zenon_H161. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H161); [ zenon_intro zenon_H157 | zenon_intro zenon_H162 ]. % 119.85/120.12 exact (zenon_H157 zenon_H156). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H162); [ zenon_intro zenon_H15f | zenon_intro zenon_H163 ]. % 119.85/120.12 exact (zenon_H15f zenon_H15e). % 119.85/120.12 exact (zenon_H15d zenon_H163). % 119.85/120.12 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H164 | zenon_intro zenon_H154 ]. % 119.85/120.12 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (n0))); [ zenon_intro zenon_H165 | zenon_intro zenon_H166 ]. % 119.85/120.12 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (n0)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (tptp_minus_1)))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H15f. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H165. % 119.85/120.12 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.85/120.12 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.12 congruence. % 119.85/120.12 apply zenon_H158. apply refl_equal. % 119.85/120.12 apply zenon_H167. apply sym_equal. exact succ_tptp_minus_1. % 119.85/120.12 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (sum (n0) (tptp_minus_1) zenon_E)) = (gt (sum (n0) (tptp_minus_1) zenon_E) (n0))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H166. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H164. % 119.85/120.12 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.12 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.12 congruence. % 119.85/120.12 apply zenon_H158. apply refl_equal. % 119.85/120.12 exact (zenon_H15b zenon_H155). % 119.85/120.12 apply (zenon_L119_); trivial. % 119.85/120.12 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H157. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H141. % 119.85/120.12 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.85/120.12 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.12 congruence. % 119.85/120.12 apply zenon_H65. apply refl_equal. % 119.85/120.12 exact (zenon_H159 zenon_H15c). % 119.85/120.12 apply (zenon_L118_); trivial. % 119.85/120.12 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.12 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H159. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H15a. % 119.85/120.12 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.12 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_H15b zenon_H155). % 119.85/120.12 apply zenon_H158. apply refl_equal. % 119.85/120.12 apply zenon_H158. apply refl_equal. % 119.85/120.12 (* end of lemma zenon_L123_ *) % 119.85/120.12 assert (zenon_L124_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (tptp_minus_1)) (succ (loopcounter)))) -> (~(gt (succ (tptp_minus_1)) (succ (succ (n0))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_H16c zenon_H1da zenon_H155 zenon_H140 zenon_H7d zenon_H67. % 119.85/120.12 elim (classic (gt (succ (tptp_minus_1)) (succ (tptp_minus_1)))); [ zenon_intro zenon_H176 | zenon_intro zenon_H168 ]. % 119.85/120.12 elim (classic (gt (succ (tptp_minus_1)) (n0))); [ zenon_intro zenon_H177 | zenon_intro zenon_H178 ]. % 119.85/120.12 elim (classic (gt (n0) (succ (succ (n0))))); [ zenon_intro zenon_H1cf | zenon_intro zenon_H1cc ]. % 119.85/120.12 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.85/120.12 generalize (zenon_H171 (n0)). zenon_intro zenon_H179. % 119.85/120.12 generalize (zenon_H179 (succ (succ (n0)))). zenon_intro zenon_H1db. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H1db); [ zenon_intro zenon_H178 | zenon_intro zenon_H1dc ]. % 119.85/120.12 exact (zenon_H178 zenon_H177). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H1dc); [ zenon_intro zenon_H1cc | zenon_intro zenon_H1dd ]. % 119.85/120.12 exact (zenon_H1cc zenon_H1cf). % 119.85/120.12 exact (zenon_H1da zenon_H1dd). % 119.85/120.12 apply (zenon_L122_); trivial. % 119.85/120.12 cut ((gt (succ (tptp_minus_1)) (succ (tptp_minus_1))) = (gt (succ (tptp_minus_1)) (n0))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H178. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H176. % 119.85/120.12 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.12 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.12 congruence. % 119.85/120.12 apply zenon_H169. apply refl_equal. % 119.85/120.12 exact (zenon_H16b succ_tptp_minus_1). % 119.85/120.12 apply (zenon_L123_); trivial. % 119.85/120.12 (* end of lemma zenon_L124_ *) % 119.85/120.12 assert (zenon_L125_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (tptp_minus_1)) (succ (loopcounter)))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (succ (loopcounter)))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_H16c zenon_H67 zenon_H7d zenon_H155 zenon_H140. % 119.85/120.12 elim (classic (gt (succ (tptp_minus_1)) (succ (succ (n0))))); [ zenon_intro zenon_H1dd | zenon_intro zenon_H1da ]. % 119.85/120.12 elim (classic (gt (succ (tptp_minus_1)) (n2))); [ zenon_intro zenon_H1de | zenon_intro zenon_H1df ]. % 119.85/120.12 elim (classic (gt (n2) (succ (loopcounter)))); [ zenon_intro zenon_H200 | zenon_intro zenon_H1fd ]. % 119.85/120.12 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.85/120.12 generalize (zenon_H171 (n2)). zenon_intro zenon_H1e0. % 119.85/120.12 generalize (zenon_H1e0 (succ (loopcounter))). zenon_intro zenon_H292. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H292); [ zenon_intro zenon_H1df | zenon_intro zenon_H293 ]. % 119.85/120.12 exact (zenon_H1df zenon_H1de). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H293); [ zenon_intro zenon_H1fd | zenon_intro zenon_H175 ]. % 119.85/120.12 exact (zenon_H1fd zenon_H200). % 119.85/120.12 exact (zenon_H16c zenon_H175). % 119.85/120.12 apply (zenon_L84_); trivial. % 119.85/120.12 cut ((gt (succ (tptp_minus_1)) (succ (succ (n0)))) = (gt (succ (tptp_minus_1)) (n2))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H1df. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H1dd. % 119.85/120.12 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.85/120.12 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.12 congruence. % 119.85/120.12 apply zenon_H169. apply refl_equal. % 119.85/120.12 exact (zenon_H105 successor_2). % 119.85/120.12 apply (zenon_L124_); trivial. % 119.85/120.12 (* end of lemma zenon_L125_ *) % 119.85/120.12 assert (zenon_L126_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (n0) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (succ (loopcounter)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H67 zenon_H7d zenon_H140 zenon_H155 zenon_H17d zenon_H66. % 119.85/120.12 elim (classic ((n0) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H180 | zenon_intro zenon_H167 ]. % 119.85/120.12 elim (classic (gt (succ (tptp_minus_1)) (succ (loopcounter)))); [ zenon_intro zenon_H175 | zenon_intro zenon_H16c ]. % 119.85/120.12 elim (classic (gt (n0) (succ (loopcounter)))); [ zenon_intro zenon_H146 | zenon_intro zenon_H140 ]. % 119.85/120.12 cut ((gt (n0) (succ (loopcounter))) = (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (loopcounter)))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H17d. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H146. % 119.85/120.12 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.85/120.12 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.85/120.12 congruence. % 119.85/120.12 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.12 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H159. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H15a. % 119.85/120.12 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.12 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_H15b zenon_H155). % 119.85/120.12 apply zenon_H158. apply refl_equal. % 119.85/120.12 apply zenon_H158. apply refl_equal. % 119.85/120.12 apply zenon_H76. apply refl_equal. % 119.85/120.12 cut ((gt (succ (tptp_minus_1)) (succ (loopcounter))) = (gt (n0) (succ (loopcounter)))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H140. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H175. % 119.85/120.12 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.85/120.12 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.12 congruence. % 119.85/120.12 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.85/120.12 cut (((n0) = (n0)) = ((succ (tptp_minus_1)) = (n0))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H16b. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H136. % 119.85/120.12 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.12 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_H167 zenon_H180). % 119.85/120.12 apply zenon_H65. apply refl_equal. % 119.85/120.12 apply zenon_H65. apply refl_equal. % 119.85/120.12 apply zenon_H76. apply refl_equal. % 119.85/120.12 apply (zenon_L125_); trivial. % 119.85/120.12 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.85/120.12 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H167. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H16a. % 119.85/120.12 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.12 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_H16b succ_tptp_minus_1). % 119.85/120.12 apply zenon_H169. apply refl_equal. % 119.85/120.12 apply zenon_H169. apply refl_equal. % 119.85/120.12 (* end of lemma zenon_L126_ *) % 119.85/120.12 assert (zenon_L127_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (n0) (succ (loopcounter)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.12 do 0 intro. intros zenon_H67 zenon_H7d zenon_H140 zenon_H66 zenon_H155. % 119.85/120.12 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.85/120.12 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.85/120.12 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.85/120.12 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (loopcounter)))); [ zenon_intro zenon_H17c | zenon_intro zenon_H17d ]. % 119.85/120.12 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.85/120.12 generalize (zenon_H142 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H160. % 119.85/120.12 generalize (zenon_H160 (succ (loopcounter))). zenon_intro zenon_H17e. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H17e); [ zenon_intro zenon_H157 | zenon_intro zenon_H17f ]. % 119.85/120.12 exact (zenon_H157 zenon_H156). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H17f); [ zenon_intro zenon_H17d | zenon_intro zenon_H146 ]. % 119.85/120.12 exact (zenon_H17d zenon_H17c). % 119.85/120.12 exact (zenon_H140 zenon_H146). % 119.85/120.12 apply (zenon_L126_); trivial. % 119.85/120.12 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H157. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H141. % 119.85/120.12 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.85/120.12 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.12 congruence. % 119.85/120.12 apply zenon_H65. apply refl_equal. % 119.85/120.12 exact (zenon_H159 zenon_H15c). % 119.85/120.12 apply (zenon_L118_); trivial. % 119.85/120.12 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.85/120.12 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H159. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H15a. % 119.85/120.12 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.85/120.12 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_H15b zenon_H155). % 119.85/120.12 apply zenon_H158. apply refl_equal. % 119.85/120.12 apply zenon_H158. apply refl_equal. % 119.85/120.12 (* end of lemma zenon_L127_ *) % 119.85/120.12 assert (zenon_L128_ : (~((n4) = (n4))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H294. % 119.85/120.12 apply zenon_H294. apply refl_equal. % 119.85/120.12 (* end of lemma zenon_L128_ *) % 119.85/120.12 assert (zenon_L129_ : (~(gt (n1) (succ (tptp_minus_1)))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H295. % 119.85/120.12 elim (classic ((n0) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H180 | zenon_intro zenon_H167 ]. % 119.85/120.12 cut ((gt (n1) (n0)) = (gt (n1) (succ (tptp_minus_1)))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H295. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact gt_1_0. % 119.85/120.12 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.85/120.12 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.12 congruence. % 119.85/120.12 apply zenon_H64. apply refl_equal. % 119.85/120.12 exact (zenon_H167 zenon_H180). % 119.85/120.12 apply zenon_H167. apply sym_equal. exact succ_tptp_minus_1. % 119.85/120.12 (* end of lemma zenon_L129_ *) % 119.85/120.12 assert (zenon_L130_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n2) (succ (tptp_minus_1)))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_H296. % 119.85/120.12 elim (classic (gt (n1) (succ (tptp_minus_1)))); [ zenon_intro zenon_H297 | zenon_intro zenon_H295 ]. % 119.85/120.12 generalize (zenon_H66 (n2)). zenon_intro zenon_H1a6. % 119.85/120.12 generalize (zenon_H1a6 (n1)). zenon_intro zenon_H1a7. % 119.85/120.12 generalize (zenon_H1a7 (succ (tptp_minus_1))). zenon_intro zenon_H298. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H298); [ zenon_intro zenon_Hba | zenon_intro zenon_H299 ]. % 119.85/120.12 exact (zenon_Hba gt_2_1). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H299); [ zenon_intro zenon_H295 | zenon_intro zenon_H29a ]. % 119.85/120.12 exact (zenon_H295 zenon_H297). % 119.85/120.12 exact (zenon_H296 zenon_H29a). % 119.85/120.12 apply (zenon_L129_); trivial. % 119.85/120.12 (* end of lemma zenon_L130_ *) % 119.85/120.12 assert (zenon_L131_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n3) (succ (tptp_minus_1)))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_H29b. % 119.85/120.12 elim (classic (gt (n2) (succ (tptp_minus_1)))); [ zenon_intro zenon_H29a | zenon_intro zenon_H296 ]. % 119.85/120.12 generalize (zenon_H66 (n3)). zenon_intro zenon_H24f. % 119.85/120.12 generalize (zenon_H24f (n2)). zenon_intro zenon_H250. % 119.85/120.12 generalize (zenon_H250 (succ (tptp_minus_1))). zenon_intro zenon_H29c. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H29c); [ zenon_intro zenon_H22f | zenon_intro zenon_H29d ]. % 119.85/120.12 exact (zenon_H22f gt_3_2). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H29d); [ zenon_intro zenon_H296 | zenon_intro zenon_H29e ]. % 119.85/120.12 exact (zenon_H296 zenon_H29a). % 119.85/120.12 exact (zenon_H29b zenon_H29e). % 119.85/120.12 apply (zenon_L130_); trivial. % 119.85/120.12 (* end of lemma zenon_L131_ *) % 119.85/120.12 assert (zenon_L132_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n4) (succ (tptp_minus_1)))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_H29f. % 119.85/120.12 elim (classic (gt (n3) (succ (tptp_minus_1)))); [ zenon_intro zenon_H29e | zenon_intro zenon_H29b ]. % 119.85/120.12 generalize (zenon_H66 (n4)). zenon_intro zenon_H2a0. % 119.85/120.12 generalize (zenon_H2a0 (n3)). zenon_intro zenon_H2a1. % 119.85/120.12 generalize (zenon_H2a1 (succ (tptp_minus_1))). zenon_intro zenon_H2a2. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2a2); [ zenon_intro zenon_H2a4 | zenon_intro zenon_H2a3 ]. % 119.85/120.12 exact (zenon_H2a4 gt_4_3). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2a3); [ zenon_intro zenon_H29b | zenon_intro zenon_H2a5 ]. % 119.85/120.12 exact (zenon_H29b zenon_H29e). % 119.85/120.12 exact (zenon_H29f zenon_H2a5). % 119.85/120.12 apply (zenon_L131_); trivial. % 119.85/120.12 (* end of lemma zenon_L132_ *) % 119.85/120.12 assert (zenon_L133_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n3)) (succ (tptp_minus_1)))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_H2a6. % 119.85/120.12 elim (classic (gt (n4) (succ (tptp_minus_1)))); [ zenon_intro zenon_H2a5 | zenon_intro zenon_H29f ]. % 119.85/120.12 elim (classic (gt (succ (succ (succ (succ (n0))))) (succ (tptp_minus_1)))); [ zenon_intro zenon_H2a7 | zenon_intro zenon_H2a8 ]. % 119.85/120.12 cut ((gt (succ (succ (succ (succ (n0))))) (succ (tptp_minus_1))) = (gt (succ (n3)) (succ (tptp_minus_1)))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H2a6. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H2a7. % 119.85/120.12 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.12 cut (((succ (succ (succ (succ (n0))))) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H9d]. % 119.85/120.12 congruence. % 119.85/120.12 elim (classic ((succ (n3)) = (succ (n3)))); [ zenon_intro zenon_H9e | zenon_intro zenon_H9f ]. % 119.85/120.12 cut (((succ (n3)) = (succ (n3))) = ((succ (succ (succ (succ (n0))))) = (succ (n3)))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H9d. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H9e. % 119.85/120.12 cut (((succ (n3)) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H9f]. % 119.85/120.12 cut (((succ (n3)) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_H98]. % 119.85/120.12 congruence. % 119.85/120.12 apply (zenon_L10_); trivial. % 119.85/120.12 apply zenon_H9f. apply refl_equal. % 119.85/120.12 apply zenon_H9f. apply refl_equal. % 119.85/120.12 apply zenon_H169. apply refl_equal. % 119.85/120.12 cut ((gt (n4) (succ (tptp_minus_1))) = (gt (succ (succ (succ (succ (n0))))) (succ (tptp_minus_1)))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H2a8. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H2a5. % 119.85/120.12 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.12 cut (((n4) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_Ha0]. % 119.85/120.12 congruence. % 119.85/120.12 elim (classic ((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0))))))); [ zenon_intro zenon_Ha1 | zenon_intro zenon_Ha2 ]. % 119.85/120.12 cut (((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0)))))) = ((n4) = (succ (succ (succ (succ (n0))))))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_Ha0. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_Ha1. % 119.85/120.12 cut (((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_Ha2]. % 119.85/120.12 cut (((succ (succ (succ (succ (n0))))) = (n4))); [idtac | apply NNPP; zenon_intro zenon_Ha3]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_Ha3 successor_4). % 119.85/120.12 apply zenon_Ha2. apply refl_equal. % 119.85/120.12 apply zenon_Ha2. apply refl_equal. % 119.85/120.12 apply zenon_H169. apply refl_equal. % 119.85/120.12 apply (zenon_L132_); trivial. % 119.85/120.12 (* end of lemma zenon_L133_ *) % 119.85/120.12 assert (zenon_L134_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (succ (n3)) (succ (loopcounter)))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_H155 zenon_H2a9. % 119.85/120.12 elim (classic (gt (succ (n3)) (succ (tptp_minus_1)))); [ zenon_intro zenon_H2aa | zenon_intro zenon_H2a6 ]. % 119.85/120.12 elim (classic (gt (succ (n3)) (n0))); [ zenon_intro zenon_H2ab | zenon_intro zenon_H2ac ]. % 119.85/120.12 elim (classic (gt (n0) (succ (loopcounter)))); [ zenon_intro zenon_H146 | zenon_intro zenon_H140 ]. % 119.85/120.12 generalize (zenon_H66 (succ (n3))). zenon_intro zenon_Hb5. % 119.85/120.12 generalize (zenon_Hb5 (n0)). zenon_intro zenon_H2ad. % 119.85/120.12 generalize (zenon_H2ad (succ (loopcounter))). zenon_intro zenon_H2ae. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2ae); [ zenon_intro zenon_H2ac | zenon_intro zenon_H2af ]. % 119.85/120.12 exact (zenon_H2ac zenon_H2ab). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2af); [ zenon_intro zenon_H140 | zenon_intro zenon_H2b0 ]. % 119.85/120.12 exact (zenon_H140 zenon_H146). % 119.85/120.12 exact (zenon_H2a9 zenon_H2b0). % 119.85/120.12 apply (zenon_L127_); trivial. % 119.85/120.12 cut ((gt (succ (n3)) (succ (tptp_minus_1))) = (gt (succ (n3)) (n0))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H2ac. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H2aa. % 119.85/120.12 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.12 cut (((succ (n3)) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H9f]. % 119.85/120.12 congruence. % 119.85/120.12 apply zenon_H9f. apply refl_equal. % 119.85/120.12 exact (zenon_H16b succ_tptp_minus_1). % 119.85/120.12 apply (zenon_L133_); trivial. % 119.85/120.12 (* end of lemma zenon_L134_ *) % 119.85/120.12 assert (zenon_L135_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (succ (n0))) (succ (tptp_minus_1)))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_H2b1. % 119.85/120.12 elim (classic (gt (succ (succ (n0))) (succ (n0)))); [ zenon_intro zenon_Hfd | zenon_intro zenon_Hfe ]. % 119.85/120.12 elim (classic (gt (succ (succ (n0))) (n1))); [ zenon_intro zenon_H204 | zenon_intro zenon_H205 ]. % 119.85/120.12 elim (classic (gt (n1) (succ (tptp_minus_1)))); [ zenon_intro zenon_H297 | zenon_intro zenon_H295 ]. % 119.85/120.12 generalize (zenon_H66 (succ (succ (n0)))). zenon_intro zenon_H206. % 119.85/120.12 generalize (zenon_H206 (n1)). zenon_intro zenon_H207. % 119.85/120.12 generalize (zenon_H207 (succ (tptp_minus_1))). zenon_intro zenon_H2b2. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2b2); [ zenon_intro zenon_H205 | zenon_intro zenon_H2b3 ]. % 119.85/120.12 exact (zenon_H205 zenon_H204). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2b3); [ zenon_intro zenon_H295 | zenon_intro zenon_H2b4 ]. % 119.85/120.12 exact (zenon_H295 zenon_H297). % 119.85/120.12 exact (zenon_H2b1 zenon_H2b4). % 119.85/120.12 apply (zenon_L129_); trivial. % 119.85/120.12 cut ((gt (succ (succ (n0))) (succ (n0))) = (gt (succ (succ (n0))) (n1))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H205. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_Hfd. % 119.85/120.12 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.85/120.12 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.85/120.12 congruence. % 119.85/120.12 apply zenon_H104. apply refl_equal. % 119.85/120.12 exact (zenon_H87 successor_1). % 119.85/120.12 apply (zenon_L88_); trivial. % 119.85/120.12 (* end of lemma zenon_L135_ *) % 119.85/120.12 assert (zenon_L136_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (succ (succ (n0))) (succ (loopcounter)))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_H155 zenon_H203. % 119.85/120.12 elim (classic (gt (succ (succ (n0))) (succ (tptp_minus_1)))); [ zenon_intro zenon_H2b4 | zenon_intro zenon_H2b1 ]. % 119.85/120.12 elim (classic (gt (succ (succ (n0))) (n0))); [ zenon_intro zenon_H2b5 | zenon_intro zenon_H2b6 ]. % 119.85/120.12 elim (classic (gt (n0) (succ (loopcounter)))); [ zenon_intro zenon_H146 | zenon_intro zenon_H140 ]. % 119.85/120.12 generalize (zenon_H66 (succ (succ (n0)))). zenon_intro zenon_H206. % 119.85/120.12 generalize (zenon_H206 (n0)). zenon_intro zenon_H2b7. % 119.85/120.12 generalize (zenon_H2b7 (succ (loopcounter))). zenon_intro zenon_H2b8. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2b8); [ zenon_intro zenon_H2b6 | zenon_intro zenon_H2b9 ]. % 119.85/120.12 exact (zenon_H2b6 zenon_H2b5). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2b9); [ zenon_intro zenon_H140 | zenon_intro zenon_H20a ]. % 119.85/120.12 exact (zenon_H140 zenon_H146). % 119.85/120.12 exact (zenon_H203 zenon_H20a). % 119.85/120.12 apply (zenon_L89_); trivial. % 119.85/120.12 cut ((gt (succ (succ (n0))) (succ (tptp_minus_1))) = (gt (succ (succ (n0))) (n0))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H2b6. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H2b4. % 119.85/120.12 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.12 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.85/120.12 congruence. % 119.85/120.12 apply zenon_H104. apply refl_equal. % 119.85/120.12 exact (zenon_H16b succ_tptp_minus_1). % 119.85/120.12 apply (zenon_L135_); trivial. % 119.85/120.12 (* end of lemma zenon_L136_ *) % 119.85/120.12 assert (zenon_L137_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n1)) (succ (tptp_minus_1)))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_H2ba. % 119.85/120.12 elim (classic (gt (succ (n1)) (succ (n0)))); [ zenon_intro zenon_H118 | zenon_intro zenon_Hfb ]. % 119.85/120.12 elim (classic (gt (succ (n1)) (n1))); [ zenon_intro zenon_H119 | zenon_intro zenon_H112 ]. % 119.85/120.12 elim (classic (gt (n1) (succ (tptp_minus_1)))); [ zenon_intro zenon_H297 | zenon_intro zenon_H295 ]. % 119.85/120.12 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.85/120.12 generalize (zenon_H11a (n1)). zenon_intro zenon_H11b. % 119.85/120.12 generalize (zenon_H11b (succ (tptp_minus_1))). zenon_intro zenon_H2bb. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2bb); [ zenon_intro zenon_H112 | zenon_intro zenon_H2bc ]. % 119.85/120.12 exact (zenon_H112 zenon_H119). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2bc); [ zenon_intro zenon_H295 | zenon_intro zenon_H2bd ]. % 119.85/120.12 exact (zenon_H295 zenon_H297). % 119.85/120.12 exact (zenon_H2ba zenon_H2bd). % 119.85/120.12 apply (zenon_L129_); trivial. % 119.85/120.12 cut ((gt (succ (n1)) (succ (n0))) = (gt (succ (n1)) (n1))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H112. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H118. % 119.85/120.12 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.85/120.12 cut (((succ (n1)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H101]. % 119.85/120.12 congruence. % 119.85/120.12 apply zenon_H101. apply refl_equal. % 119.85/120.12 exact (zenon_H87 successor_1). % 119.85/120.12 apply (zenon_L27_); trivial. % 119.85/120.12 (* end of lemma zenon_L137_ *) % 119.85/120.12 assert (zenon_L138_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n1)) (succ (loopcounter)))) -> ((loopcounter) = (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_H116 zenon_H95 zenon_H155 zenon_H7d zenon_H67. % 119.85/120.12 elim (classic (gt (succ (n1)) (succ (tptp_minus_1)))); [ zenon_intro zenon_H2bd | zenon_intro zenon_H2ba ]. % 119.85/120.12 elim (classic (gt (succ (n1)) (n0))); [ zenon_intro zenon_H10d | zenon_intro zenon_H10f ]. % 119.85/120.12 elim (classic (gt (n0) (succ (loopcounter)))); [ zenon_intro zenon_H146 | zenon_intro zenon_H140 ]. % 119.85/120.12 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.85/120.12 generalize (zenon_H11a (n0)). zenon_intro zenon_H2be. % 119.85/120.12 generalize (zenon_H2be (succ (loopcounter))). zenon_intro zenon_H2bf. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2bf); [ zenon_intro zenon_H10f | zenon_intro zenon_H2c0 ]. % 119.85/120.12 exact (zenon_H10f zenon_H10d). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2c0); [ zenon_intro zenon_H140 | zenon_intro zenon_H11e ]. % 119.85/120.12 exact (zenon_H140 zenon_H146). % 119.85/120.12 exact (zenon_H116 zenon_H11e). % 119.85/120.12 apply (zenon_L100_); trivial. % 119.85/120.12 cut ((gt (succ (n1)) (succ (tptp_minus_1))) = (gt (succ (n1)) (n0))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H10f. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H2bd. % 119.85/120.12 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.12 cut (((succ (n1)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H101]. % 119.85/120.12 congruence. % 119.85/120.12 apply zenon_H101. apply refl_equal. % 119.85/120.12 exact (zenon_H16b succ_tptp_minus_1). % 119.85/120.12 apply (zenon_L137_); trivial. % 119.85/120.12 (* end of lemma zenon_L138_ *) % 119.85/120.12 assert (zenon_L139_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((loopcounter) = (n0)) -> (~(gt (loopcounter) (succ (loopcounter)))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_H95 zenon_Hf0 zenon_H67 zenon_H7d zenon_H155. % 119.85/120.12 elim (classic (gt (n0) (succ (loopcounter)))); [ zenon_intro zenon_H146 | zenon_intro zenon_H140 ]. % 119.85/120.12 cut ((gt (n0) (succ (loopcounter))) = (gt (loopcounter) (succ (loopcounter)))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_Hf0. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H146. % 119.85/120.12 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.85/120.12 cut (((n0) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H93]. % 119.85/120.12 congruence. % 119.85/120.12 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.12 cut (((loopcounter) = (loopcounter)) = ((n0) = (loopcounter))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H93. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_Hed. % 119.85/120.12 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.12 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_H132 zenon_H95). % 119.85/120.12 apply zenon_H7c. apply refl_equal. % 119.85/120.12 apply zenon_H7c. apply refl_equal. % 119.85/120.12 apply zenon_H76. apply refl_equal. % 119.85/120.12 apply (zenon_L82_); trivial. % 119.85/120.12 (* end of lemma zenon_L139_ *) % 119.85/120.12 assert (zenon_L140_ : ((loopcounter) = (n1)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (loopcounter) (loopcounter))) -> (gt (n1) (loopcounter)) -> False). % 119.85/120.12 do 0 intro. intros zenon_Hca zenon_H66 zenon_H135 zenon_H7d. % 119.85/120.12 elim (classic ((~((loopcounter) = (n1)))/\(~(gt (loopcounter) (n1))))); [ zenon_intro zenon_H137 | zenon_intro zenon_H138 ]. % 119.85/120.12 apply (zenon_and_s _ _ zenon_H137). zenon_intro zenon_Hc4. zenon_intro zenon_Hee. % 119.85/120.12 exact (zenon_Hc4 zenon_Hca). % 119.85/120.12 cut ((gt (n1) (loopcounter)) = (gt (loopcounter) (loopcounter))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H135. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H7d. % 119.85/120.12 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.12 cut (((n1) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_Hec]. % 119.85/120.12 congruence. % 119.85/120.12 apply (zenon_notand_s _ _ zenon_H138); [ zenon_intro zenon_H13a | zenon_intro zenon_H139 ]. % 119.85/120.12 apply zenon_H13a. zenon_intro zenon_Hca. % 119.85/120.12 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.12 cut (((loopcounter) = (loopcounter)) = ((n1) = (loopcounter))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_Hec. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_Hed. % 119.85/120.12 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.12 cut (((loopcounter) = (n1))); [idtac | apply NNPP; zenon_intro zenon_Hc4]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_Hc4 zenon_Hca). % 119.85/120.12 apply zenon_H7c. apply refl_equal. % 119.85/120.12 apply zenon_H7c. apply refl_equal. % 119.85/120.12 apply zenon_H139. zenon_intro zenon_Hf1. % 119.85/120.12 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.85/120.12 generalize (zenon_H13b (n1)). zenon_intro zenon_H13c. % 119.85/120.12 generalize (zenon_H13c (loopcounter)). zenon_intro zenon_H13d. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H13d); [ zenon_intro zenon_Hee | zenon_intro zenon_H13e ]. % 119.85/120.12 exact (zenon_Hee zenon_Hf1). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H13e); [ zenon_intro zenon_H92 | zenon_intro zenon_H134 ]. % 119.85/120.12 exact (zenon_H92 zenon_H7d). % 119.85/120.12 exact (zenon_H135 zenon_H134). % 119.85/120.12 apply zenon_H7c. apply refl_equal. % 119.85/120.12 (* end of lemma zenon_L140_ *) % 119.85/120.12 assert (zenon_L141_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((loopcounter) = (n1)) -> (gt (n1) (loopcounter)) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_Hca zenon_H7d. % 119.85/120.12 generalize (irreflexivity_gt (loopcounter)). zenon_intro zenon_H135. % 119.85/120.12 apply (zenon_L140_); trivial. % 119.85/120.12 (* end of lemma zenon_L141_ *) % 119.85/120.12 assert (zenon_L142_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n2))) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_Hc3 zenon_Hc2 zenon_H155. % 119.85/120.12 generalize (finite_domain_3 (loopcounter)). zenon_intro zenon_Hc5. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_Hc5); [ zenon_intro zenon_Hc7 | zenon_intro zenon_Hc6 ]. % 119.85/120.12 apply (zenon_notand_s _ _ zenon_Hc7); [ zenon_intro zenon_H68 | zenon_intro zenon_Ha4 ]. % 119.85/120.12 apply (zenon_L5_); trivial. % 119.85/120.12 apply (zenon_L12_); trivial. % 119.85/120.12 apply (zenon_or_s _ _ zenon_Hc6); [ zenon_intro zenon_H95 | zenon_intro zenon_Hc8 ]. % 119.85/120.12 generalize (irreflexivity_gt (loopcounter)). zenon_intro zenon_H135. % 119.85/120.12 elim (classic ((~((loopcounter) = (n1)))/\(~(gt (loopcounter) (n1))))); [ zenon_intro zenon_H137 | zenon_intro zenon_H138 ]. % 119.85/120.12 apply (zenon_and_s _ _ zenon_H137). zenon_intro zenon_Hc4. zenon_intro zenon_Hee. % 119.85/120.12 elim (classic ((~((loopcounter) = (succ (loopcounter))))/\(~(gt (loopcounter) (succ (loopcounter)))))); [ zenon_intro zenon_H2c1 | zenon_intro zenon_H2c2 ]. % 119.85/120.12 apply (zenon_and_s _ _ zenon_H2c1). zenon_intro zenon_H2c3. zenon_intro zenon_Hf0. % 119.85/120.12 apply (zenon_L139_); trivial. % 119.85/120.12 cut ((gt (succ (loopcounter)) (n1)) = (gt (loopcounter) (n1))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_Hee. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H67. % 119.85/120.12 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.12 cut (((succ (loopcounter)) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H2c4]. % 119.85/120.12 congruence. % 119.85/120.12 apply (zenon_notand_s _ _ zenon_H2c2); [ zenon_intro zenon_H2c6 | zenon_intro zenon_H2c5 ]. % 119.85/120.12 apply zenon_H2c6. zenon_intro zenon_H2c7. % 119.85/120.12 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.12 cut (((loopcounter) = (loopcounter)) = ((succ (loopcounter)) = (loopcounter))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H2c4. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_Hed. % 119.85/120.12 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.12 cut (((loopcounter) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H2c3]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_H2c3 zenon_H2c7). % 119.85/120.12 apply zenon_H7c. apply refl_equal. % 119.85/120.12 apply zenon_H7c. apply refl_equal. % 119.85/120.12 apply zenon_H2c5. zenon_intro zenon_Hf2. % 119.85/120.12 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.85/120.12 generalize (zenon_H13b (succ (loopcounter))). zenon_intro zenon_H2c8. % 119.85/120.12 generalize (zenon_H2c8 (n1)). zenon_intro zenon_H2c9. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2c9); [ zenon_intro zenon_Hf0 | zenon_intro zenon_H2ca ]. % 119.85/120.12 exact (zenon_Hf0 zenon_Hf2). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2ca); [ zenon_intro zenon_H6f | zenon_intro zenon_Hf1 ]. % 119.85/120.12 exact (zenon_H6f zenon_H67). % 119.85/120.12 exact (zenon_Hee zenon_Hf1). % 119.85/120.12 apply zenon_H64. apply refl_equal. % 119.85/120.12 cut ((gt (n1) (loopcounter)) = (gt (loopcounter) (loopcounter))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H135. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H7d. % 119.85/120.12 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.12 cut (((n1) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_Hec]. % 119.85/120.12 congruence. % 119.85/120.12 apply (zenon_notand_s _ _ zenon_H138); [ zenon_intro zenon_H13a | zenon_intro zenon_H139 ]. % 119.85/120.12 apply zenon_H13a. zenon_intro zenon_Hca. % 119.85/120.12 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.12 cut (((loopcounter) = (loopcounter)) = ((n1) = (loopcounter))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_Hec. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_Hed. % 119.85/120.12 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.12 cut (((loopcounter) = (n1))); [idtac | apply NNPP; zenon_intro zenon_Hc4]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_Hc4 zenon_Hca). % 119.85/120.12 apply zenon_H7c. apply refl_equal. % 119.85/120.12 apply zenon_H7c. apply refl_equal. % 119.85/120.12 apply zenon_H139. zenon_intro zenon_Hf1. % 119.85/120.12 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.85/120.12 generalize (zenon_H13b (n1)). zenon_intro zenon_H13c. % 119.85/120.12 generalize (zenon_H13c (loopcounter)). zenon_intro zenon_H13d. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H13d); [ zenon_intro zenon_Hee | zenon_intro zenon_H13e ]. % 119.85/120.12 exact (zenon_Hee zenon_Hf1). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H13e); [ zenon_intro zenon_H92 | zenon_intro zenon_H134 ]. % 119.85/120.12 exact (zenon_H92 zenon_H7d). % 119.85/120.12 exact (zenon_H135 zenon_H134). % 119.85/120.12 apply zenon_H7c. apply refl_equal. % 119.85/120.12 apply (zenon_or_s _ _ zenon_Hc8); [ zenon_intro zenon_Hca | zenon_intro zenon_Hc9 ]. % 119.85/120.12 apply (zenon_L141_); trivial. % 119.85/120.12 apply (zenon_or_s _ _ zenon_Hc9); [ zenon_intro zenon_Hcc | zenon_intro zenon_Hcb ]. % 119.85/120.12 exact (zenon_Hc3 zenon_Hcc). % 119.85/120.12 exact (zenon_Hc2 zenon_Hcb). % 119.85/120.12 (* end of lemma zenon_L142_ *) % 119.85/120.12 assert (zenon_L143_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (n2))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_H181 zenon_H67 zenon_H7d zenon_Hc2 zenon_H155. % 119.85/120.12 elim (classic ((loopcounter) = (n2))); [ zenon_intro zenon_Hcc | zenon_intro zenon_Hc3 ]. % 119.85/120.12 cut ((gt (n1) (loopcounter)) = (gt (n1) (n2))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H181. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H7d. % 119.85/120.12 cut (((loopcounter) = (n2))); [idtac | apply NNPP; zenon_intro zenon_Hc3]. % 119.85/120.12 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.12 congruence. % 119.85/120.12 apply zenon_H64. apply refl_equal. % 119.85/120.12 exact (zenon_Hc3 zenon_Hcc). % 119.85/120.12 apply (zenon_L142_); trivial. % 119.85/120.12 (* end of lemma zenon_L143_ *) % 119.85/120.12 assert (zenon_L144_ : (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n0) (n2))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n0) (n1))) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.12 do 0 intro. intros zenon_H7d zenon_H155 zenon_H1ab zenon_H66 zenon_H13f zenon_H67. % 119.85/120.12 elim (classic ((~((n0) = (succ (loopcounter))))/\(~(gt (n0) (succ (loopcounter)))))); [ zenon_intro zenon_H2cb | zenon_intro zenon_H2cc ]. % 119.85/120.12 apply (zenon_and_s _ _ zenon_H2cb). zenon_intro zenon_H2cd. zenon_intro zenon_H140. % 119.85/120.12 apply (zenon_L116_); trivial. % 119.85/120.12 cut ((gt (succ (loopcounter)) (n1)) = (gt (n0) (n1))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H13f. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H67. % 119.85/120.12 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.12 cut (((succ (loopcounter)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H2ce]. % 119.85/120.12 congruence. % 119.85/120.12 apply (zenon_notand_s _ _ zenon_H2cc); [ zenon_intro zenon_H2d0 | zenon_intro zenon_H2cf ]. % 119.85/120.12 apply zenon_H2d0. zenon_intro zenon_H2d1. % 119.85/120.12 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.85/120.12 cut (((n0) = (n0)) = ((succ (loopcounter)) = (n0))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H2ce. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H136. % 119.85/120.12 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.12 cut (((n0) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H2cd]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_H2cd zenon_H2d1). % 119.85/120.12 apply zenon_H65. apply refl_equal. % 119.85/120.12 apply zenon_H65. apply refl_equal. % 119.85/120.12 apply zenon_H2cf. zenon_intro zenon_H146. % 119.85/120.12 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.85/120.12 generalize (zenon_H142 (succ (loopcounter))). zenon_intro zenon_H2d2. % 119.85/120.12 generalize (zenon_H2d2 (n1)). zenon_intro zenon_H2d3. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2d3); [ zenon_intro zenon_H140 | zenon_intro zenon_H2d4 ]. % 119.85/120.12 exact (zenon_H140 zenon_H146). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2d4); [ zenon_intro zenon_H6f | zenon_intro zenon_H150 ]. % 119.85/120.12 exact (zenon_H6f zenon_H67). % 119.85/120.12 exact (zenon_H13f zenon_H150). % 119.85/120.12 apply zenon_H64. apply refl_equal. % 119.85/120.12 (* end of lemma zenon_L144_ *) % 119.85/120.12 assert (zenon_L145_ : (~(gt (n0) (n2))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n0) (n0))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H1ab zenon_H155 zenon_H7d zenon_H67 zenon_H66 zenon_H12f. % 119.85/120.12 elim (classic ((~((n0) = (n1)))/\(~(gt (n0) (n1))))); [ zenon_intro zenon_H14a | zenon_intro zenon_H14b ]. % 119.85/120.12 apply (zenon_and_s _ _ zenon_H14a). zenon_intro zenon_H106. zenon_intro zenon_H13f. % 119.85/120.12 apply (zenon_L144_); trivial. % 119.85/120.12 cut ((gt (n1) (n0)) = (gt (n0) (n0))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H12f. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact gt_1_0. % 119.85/120.12 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.12 cut (((n1) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H14c]. % 119.85/120.12 congruence. % 119.85/120.12 apply (zenon_notand_s _ _ zenon_H14b); [ zenon_intro zenon_H14e | zenon_intro zenon_H14d ]. % 119.85/120.12 apply zenon_H14e. zenon_intro zenon_H14f. % 119.85/120.12 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.85/120.12 cut (((n0) = (n0)) = ((n1) = (n0))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H14c. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H136. % 119.85/120.12 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.12 cut (((n0) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H106]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_H106 zenon_H14f). % 119.85/120.12 apply zenon_H65. apply refl_equal. % 119.85/120.12 apply zenon_H65. apply refl_equal. % 119.85/120.12 apply zenon_H14d. zenon_intro zenon_H150. % 119.85/120.12 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.85/120.12 generalize (zenon_H142 (n1)). zenon_intro zenon_H151. % 119.85/120.12 generalize (zenon_H151 (n0)). zenon_intro zenon_H152. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H152); [ zenon_intro zenon_H13f | zenon_intro zenon_H153 ]. % 119.85/120.12 exact (zenon_H13f zenon_H150). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H153); [ zenon_intro zenon_H7b | zenon_intro zenon_H141 ]. % 119.85/120.12 exact (zenon_H7b gt_1_0). % 119.85/120.12 exact (zenon_H12f zenon_H141). % 119.85/120.12 apply zenon_H65. apply refl_equal. % 119.85/120.12 (* end of lemma zenon_L145_ *) % 119.85/120.12 assert (zenon_L146_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n0) (n0))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H67 zenon_H7d zenon_H155 zenon_H66 zenon_H12f. % 119.85/120.12 elim (classic ((~((n0) = (n2)))/\(~(gt (n0) (n2))))); [ zenon_intro zenon_H1ac | zenon_intro zenon_H1ad ]. % 119.85/120.12 apply (zenon_and_s _ _ zenon_H1ac). zenon_intro zenon_H1ae. zenon_intro zenon_H1ab. % 119.85/120.12 apply (zenon_L145_); trivial. % 119.85/120.12 cut ((gt (n2) (n0)) = (gt (n0) (n0))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H12f. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact gt_2_0. % 119.85/120.12 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.12 cut (((n2) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H1af]. % 119.85/120.12 congruence. % 119.85/120.12 apply (zenon_notand_s _ _ zenon_H1ad); [ zenon_intro zenon_H1b1 | zenon_intro zenon_H1b0 ]. % 119.85/120.12 apply zenon_H1b1. zenon_intro zenon_H1b2. % 119.85/120.12 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.85/120.12 cut (((n0) = (n0)) = ((n2) = (n0))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H1af. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H136. % 119.85/120.12 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.12 cut (((n0) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H1ae]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_H1ae zenon_H1b2). % 119.85/120.12 apply zenon_H65. apply refl_equal. % 119.85/120.12 apply zenon_H65. apply refl_equal. % 119.85/120.12 apply zenon_H1b0. zenon_intro zenon_H1b3. % 119.85/120.12 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.85/120.12 generalize (zenon_H142 (n2)). zenon_intro zenon_H1b4. % 119.85/120.12 generalize (zenon_H1b4 (n0)). zenon_intro zenon_H1b5. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H1b5); [ zenon_intro zenon_H1ab | zenon_intro zenon_H1b6 ]. % 119.85/120.12 exact (zenon_H1ab zenon_H1b3). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H1b6); [ zenon_intro zenon_H1b7 | zenon_intro zenon_H141 ]. % 119.85/120.12 exact (zenon_H1b7 gt_2_0). % 119.85/120.12 exact (zenon_H12f zenon_H141). % 119.85/120.12 apply zenon_H65. apply refl_equal. % 119.85/120.12 (* end of lemma zenon_L146_ *) % 119.85/120.12 assert (zenon_L147_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~((loopcounter) = (n3))) -> ((loopcounter) = (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(leq (n0) (n1))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_Hc2 zenon_H95 zenon_H155 zenon_H7d zenon_H67 zenon_H10b. % 119.85/120.12 generalize (leq_succ_gt_equiv (n0)). zenon_intro zenon_H5f. % 119.85/120.12 generalize (zenon_H5f (n1)). zenon_intro zenon_H10c. % 119.85/120.12 apply (zenon_equiv_s _ _ zenon_H10c); [ zenon_intro zenon_H10b; zenon_intro zenon_H10f | zenon_intro zenon_H10e; zenon_intro zenon_H10d ]. % 119.85/120.12 elim (classic ((~((succ (n1)) = (n2)))/\(~(gt (succ (n1)) (n2))))); [ zenon_intro zenon_H2d5 | zenon_intro zenon_H2d6 ]. % 119.85/120.12 apply (zenon_and_s _ _ zenon_H2d5). zenon_intro zenon_H2d8. zenon_intro zenon_H2d7. % 119.85/120.12 elim (classic ((~((succ (n1)) = (succ (loopcounter))))/\(~(gt (succ (n1)) (succ (loopcounter)))))); [ zenon_intro zenon_H114 | zenon_intro zenon_H115 ]. % 119.85/120.12 apply (zenon_and_s _ _ zenon_H114). zenon_intro zenon_H117. zenon_intro zenon_H116. % 119.85/120.12 apply (zenon_L138_); trivial. % 119.85/120.12 elim (classic (gt (n1) (n2))); [ zenon_intro zenon_H183 | zenon_intro zenon_H181 ]. % 119.85/120.12 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.85/120.12 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.85/120.12 generalize (zenon_H78 (n2)). zenon_intro zenon_H2d9. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2d9); [ zenon_intro zenon_H6f | zenon_intro zenon_H2da ]. % 119.85/120.12 exact (zenon_H6f zenon_H67). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2da); [ zenon_intro zenon_H181 | zenon_intro zenon_H2db ]. % 119.85/120.12 exact (zenon_H181 zenon_H183). % 119.85/120.12 cut ((gt (succ (loopcounter)) (n2)) = (gt (succ (n1)) (n2))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H2d7. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H2db. % 119.85/120.12 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.12 cut (((succ (loopcounter)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H11f]. % 119.85/120.12 congruence. % 119.85/120.12 apply (zenon_notand_s _ _ zenon_H115); [ zenon_intro zenon_H121 | zenon_intro zenon_H120 ]. % 119.85/120.12 apply zenon_H121. zenon_intro zenon_H122. % 119.85/120.12 apply zenon_H11f. apply sym_equal. exact zenon_H122. % 119.85/120.12 apply zenon_H120. zenon_intro zenon_H11e. % 119.85/120.12 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.85/120.12 generalize (zenon_H11a (succ (loopcounter))). zenon_intro zenon_H123. % 119.85/120.12 generalize (zenon_H123 (n2)). zenon_intro zenon_H2dc. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2dc); [ zenon_intro zenon_H116 | zenon_intro zenon_H2dd ]. % 119.85/120.12 exact (zenon_H116 zenon_H11e). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2dd); [ zenon_intro zenon_H2df | zenon_intro zenon_H2de ]. % 119.85/120.12 exact (zenon_H2df zenon_H2db). % 119.85/120.12 exact (zenon_H2d7 zenon_H2de). % 119.85/120.12 apply zenon_H63. apply refl_equal. % 119.85/120.12 apply (zenon_L143_); trivial. % 119.85/120.12 cut ((gt (n2) (n0)) = (gt (succ (n1)) (n0))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H10f. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact gt_2_0. % 119.85/120.12 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.12 cut (((n2) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H2e0]. % 119.85/120.12 congruence. % 119.85/120.12 apply (zenon_notand_s _ _ zenon_H2d6); [ zenon_intro zenon_H2e2 | zenon_intro zenon_H2e1 ]. % 119.85/120.12 apply zenon_H2e2. zenon_intro zenon_H2e3. % 119.85/120.12 elim (classic ((succ (n1)) = (succ (n1)))); [ zenon_intro zenon_H100 | zenon_intro zenon_H101 ]. % 119.85/120.12 cut (((succ (n1)) = (succ (n1))) = ((n2) = (succ (n1)))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H2e0. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H100. % 119.85/120.12 cut (((succ (n1)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H101]. % 119.85/120.12 cut (((succ (n1)) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H2d8]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_H2d8 zenon_H2e3). % 119.85/120.12 apply zenon_H101. apply refl_equal. % 119.85/120.12 apply zenon_H101. apply refl_equal. % 119.85/120.12 apply zenon_H2e1. zenon_intro zenon_H2de. % 119.85/120.12 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.85/120.12 generalize (zenon_H11a (n2)). zenon_intro zenon_H2e4. % 119.85/120.12 generalize (zenon_H2e4 (n0)). zenon_intro zenon_H2e5. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2e5); [ zenon_intro zenon_H2d7 | zenon_intro zenon_H2e6 ]. % 119.85/120.12 exact (zenon_H2d7 zenon_H2de). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2e6); [ zenon_intro zenon_H1b7 | zenon_intro zenon_H10d ]. % 119.85/120.12 exact (zenon_H1b7 gt_2_0). % 119.85/120.12 exact (zenon_H10f zenon_H10d). % 119.85/120.12 apply zenon_H65. apply refl_equal. % 119.85/120.12 exact (zenon_H10b zenon_H10e). % 119.85/120.12 (* end of lemma zenon_L147_ *) % 119.85/120.12 assert (zenon_L148_ : (~((succ (loopcounter)) = (succ (n0)))) -> ((loopcounter) = (n0)) -> False). % 119.85/120.12 do 0 intro. intros zenon_Hd2 zenon_H95. % 119.85/120.12 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_H132 zenon_H95). % 119.85/120.12 (* end of lemma zenon_L148_ *) % 119.85/120.12 assert (zenon_L149_ : ((loopcounter) = (n0)) -> (gt (succ (loopcounter)) (n1)) -> (~(leq (n1) (n0))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H95 zenon_H67 zenon_H10a. % 119.85/120.12 generalize (leq_succ_gt_equiv (n1)). zenon_intro zenon_H12c. % 119.85/120.12 generalize (zenon_H12c (n0)). zenon_intro zenon_H12d. % 119.85/120.12 apply (zenon_equiv_s _ _ zenon_H12d); [ zenon_intro zenon_H10a; zenon_intro zenon_H86 | zenon_intro zenon_H12e; zenon_intro zenon_H8d ]. % 119.85/120.12 cut ((gt (succ (loopcounter)) (n1)) = (gt (succ (n0)) (n1))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H86. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H67. % 119.85/120.12 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.12 cut (((succ (loopcounter)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_Hd2]. % 119.85/120.12 congruence. % 119.85/120.12 apply (zenon_L148_); trivial. % 119.85/120.12 apply zenon_H64. apply refl_equal. % 119.85/120.12 exact (zenon_H10a zenon_H12e). % 119.85/120.12 (* end of lemma zenon_L149_ *) % 119.85/120.12 assert (zenon_L150_ : (~((succ (succ (n1))) = (succ (succ (succ (n0)))))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H2e7. % 119.85/120.12 cut (((succ (n1)) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_Hfa]. % 119.85/120.12 congruence. % 119.85/120.12 apply (zenon_L26_); trivial. % 119.85/120.12 (* end of lemma zenon_L150_ *) % 119.85/120.12 assert (zenon_L151_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (n1))) -> False). % 119.85/120.12 do 0 intro. intros zenon_H67 zenon_H7d zenon_Hc2 zenon_H155 zenon_H66 zenon_Hdd. % 119.85/120.12 elim (classic ((~((n1) = (n2)))/\(~(gt (n1) (n2))))); [ zenon_intro zenon_H187 | zenon_intro zenon_H188 ]. % 119.85/120.12 apply (zenon_and_s _ _ zenon_H187). zenon_intro zenon_H189. zenon_intro zenon_H181. % 119.85/120.12 apply (zenon_L143_); trivial. % 119.85/120.12 cut ((gt (n2) (n1)) = (gt (n1) (n1))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_Hdd. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact gt_2_1. % 119.85/120.12 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.12 cut (((n2) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H18a]. % 119.85/120.12 congruence. % 119.85/120.12 apply (zenon_notand_s _ _ zenon_H188); [ zenon_intro zenon_H18c | zenon_intro zenon_H18b ]. % 119.85/120.12 apply zenon_H18c. zenon_intro zenon_H18d. % 119.85/120.12 elim (classic ((n1) = (n1))); [ zenon_intro zenon_Hdc | zenon_intro zenon_H64 ]. % 119.85/120.12 cut (((n1) = (n1)) = ((n2) = (n1))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H18a. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_Hdc. % 119.85/120.12 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.12 cut (((n1) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H189]. % 119.85/120.12 congruence. % 119.85/120.12 exact (zenon_H189 zenon_H18d). % 119.85/120.12 apply zenon_H64. apply refl_equal. % 119.85/120.12 apply zenon_H64. apply refl_equal. % 119.85/120.12 apply zenon_H18b. zenon_intro zenon_H183. % 119.85/120.12 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.85/120.12 generalize (zenon_He4 (n2)). zenon_intro zenon_H18e. % 119.85/120.12 generalize (zenon_H18e (n1)). zenon_intro zenon_H18f. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H18f); [ zenon_intro zenon_H181 | zenon_intro zenon_H190 ]. % 119.85/120.12 exact (zenon_H181 zenon_H183). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H190); [ zenon_intro zenon_Hba | zenon_intro zenon_He8 ]. % 119.85/120.12 exact (zenon_Hba gt_2_1). % 119.85/120.12 exact (zenon_Hdd zenon_He8). % 119.85/120.12 apply zenon_H64. apply refl_equal. % 119.85/120.12 (* end of lemma zenon_L151_ *) % 119.85/120.12 assert (zenon_L152_ : (~((plus (n2) (n0)) = (plus (n2) (n1)))) -> ((n1) = (n0)) -> False). % 119.85/120.12 do 0 intro. intros zenon_H2e8 zenon_H108. % 119.85/120.12 cut (((n0) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H106]. % 119.85/120.12 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.12 congruence. % 119.85/120.12 apply zenon_H63. apply refl_equal. % 119.85/120.12 apply zenon_H106. apply sym_equal. exact zenon_H108. % 119.85/120.12 (* end of lemma zenon_L152_ *) % 119.85/120.12 assert (zenon_L153_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n0)) (n2))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.12 do 0 intro. intros zenon_H66 zenon_H182 zenon_H155 zenon_Hc2 zenon_H7d zenon_H67. % 119.85/120.12 elim (classic ((~((succ (n0)) = (succ (loopcounter))))/\(~(gt (succ (n0)) (succ (loopcounter)))))); [ zenon_intro zenon_Hce | zenon_intro zenon_Hcf ]. % 119.85/120.12 apply (zenon_and_s _ _ zenon_Hce). zenon_intro zenon_H97. zenon_intro zenon_Hd0. % 119.85/120.12 apply (zenon_L9_); trivial. % 119.85/120.12 elim (classic (gt (n1) (n2))); [ zenon_intro zenon_H183 | zenon_intro zenon_H181 ]. % 119.85/120.12 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.85/120.12 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.85/120.12 generalize (zenon_H78 (n2)). zenon_intro zenon_H2d9. % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2d9); [ zenon_intro zenon_H6f | zenon_intro zenon_H2da ]. % 119.85/120.12 exact (zenon_H6f zenon_H67). % 119.85/120.12 apply (zenon_imply_s _ _ zenon_H2da); [ zenon_intro zenon_H181 | zenon_intro zenon_H2db ]. % 119.85/120.12 exact (zenon_H181 zenon_H183). % 119.85/120.12 cut ((gt (succ (loopcounter)) (n2)) = (gt (succ (n0)) (n2))). % 119.85/120.12 intro zenon_D_pnotp. % 119.85/120.12 apply zenon_H182. % 119.85/120.12 rewrite <- zenon_D_pnotp. % 119.85/120.12 exact zenon_H2db. % 119.85/120.12 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.12 cut (((succ (loopcounter)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_Hd2]. % 119.85/120.12 congruence. % 119.85/120.12 apply (zenon_notand_s _ _ zenon_Hcf); [ zenon_intro zenon_Hd4 | zenon_intro zenon_Hd3 ]. % 119.85/120.12 apply zenon_Hd4. zenon_intro zenon_Hd5. % 119.85/120.12 apply zenon_Hd2. apply sym_equal. exact zenon_Hd5. % 119.85/120.12 apply zenon_Hd3. zenon_intro zenon_Hd6. % 119.85/120.12 generalize (zenon_H66 (succ (n0))). zenon_intro zenon_H8e. % 119.85/120.12 generalize (zenon_H8e (succ (loopcounter))). zenon_intro zenon_Hd7. % 119.85/120.13 generalize (zenon_Hd7 (n2)). zenon_intro zenon_H2e9. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H2e9); [ zenon_intro zenon_Hd0 | zenon_intro zenon_H2ea ]. % 119.85/120.13 exact (zenon_Hd0 zenon_Hd6). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H2ea); [ zenon_intro zenon_H2df | zenon_intro zenon_H186 ]. % 119.85/120.13 exact (zenon_H2df zenon_H2db). % 119.85/120.13 exact (zenon_H182 zenon_H186). % 119.85/120.13 apply zenon_H63. apply refl_equal. % 119.85/120.13 apply (zenon_L143_); trivial. % 119.85/120.13 (* end of lemma zenon_L153_ *) % 119.85/120.13 assert (zenon_L154_ : (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (~(gt (succ (n0)) (succ (succ (n0))))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.13 do 0 intro. intros zenon_H7d zenon_H67 zenon_H155 zenon_Hc2 zenon_H1b8 zenon_H66. % 119.85/120.13 elim (classic ((n2) = (succ (succ (n0))))); [ zenon_intro zenon_H1b9 | zenon_intro zenon_H102 ]. % 119.85/120.13 elim (classic (gt (succ (n0)) (n2))); [ zenon_intro zenon_H186 | zenon_intro zenon_H182 ]. % 119.85/120.13 cut ((gt (succ (n0)) (n2)) = (gt (succ (n0)) (succ (succ (n0))))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H1b8. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H186. % 119.85/120.13 cut (((n2) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 119.85/120.13 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H8c. apply refl_equal. % 119.85/120.13 exact (zenon_H102 zenon_H1b9). % 119.85/120.13 apply (zenon_L153_); trivial. % 119.85/120.13 elim (classic ((succ (succ (n0))) = (succ (succ (n0))))); [ zenon_intro zenon_H103 | zenon_intro zenon_H104 ]. % 119.85/120.13 cut (((succ (succ (n0))) = (succ (succ (n0)))) = ((n2) = (succ (succ (n0))))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H102. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H103. % 119.85/120.13 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.85/120.13 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.85/120.13 congruence. % 119.85/120.13 exact (zenon_H105 successor_2). % 119.85/120.13 apply zenon_H104. apply refl_equal. % 119.85/120.13 apply zenon_H104. apply refl_equal. % 119.85/120.13 (* end of lemma zenon_L154_ *) % 119.85/120.13 assert (zenon_L155_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (tptp_minus_1)) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.13 do 0 intro. intros zenon_H66 zenon_H16c zenon_H155 zenon_Hc2 zenon_H7d zenon_H67. % 119.85/120.13 elim (classic (gt (succ (tptp_minus_1)) (succ (tptp_minus_1)))); [ zenon_intro zenon_H176 | zenon_intro zenon_H168 ]. % 119.85/120.13 elim (classic (gt (succ (tptp_minus_1)) (n0))); [ zenon_intro zenon_H177 | zenon_intro zenon_H178 ]. % 119.85/120.13 elim (classic (gt (n0) (succ (loopcounter)))); [ zenon_intro zenon_H146 | zenon_intro zenon_H140 ]. % 119.85/120.13 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.85/120.13 generalize (zenon_H171 (n0)). zenon_intro zenon_H179. % 119.85/120.13 generalize (zenon_H179 (succ (loopcounter))). zenon_intro zenon_H2eb. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H2eb); [ zenon_intro zenon_H178 | zenon_intro zenon_H2ec ]. % 119.85/120.13 exact (zenon_H178 zenon_H177). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H2ec); [ zenon_intro zenon_H140 | zenon_intro zenon_H175 ]. % 119.85/120.13 exact (zenon_H140 zenon_H146). % 119.85/120.13 exact (zenon_H16c zenon_H175). % 119.85/120.13 apply (zenon_L125_); trivial. % 119.85/120.13 cut ((gt (succ (tptp_minus_1)) (succ (tptp_minus_1))) = (gt (succ (tptp_minus_1)) (n0))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H178. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H176. % 119.85/120.13 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.13 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H169. apply refl_equal. % 119.85/120.13 exact (zenon_H16b succ_tptp_minus_1). % 119.85/120.13 elim (classic (gt (n0) (succ (loopcounter)))); [ zenon_intro zenon_H146 | zenon_intro zenon_H140 ]. % 119.85/120.13 cut ((gt (n0) (succ (loopcounter))) = (gt (succ (tptp_minus_1)) (succ (loopcounter)))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H16c. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H146. % 119.85/120.13 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.85/120.13 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.85/120.13 congruence. % 119.85/120.13 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.85/120.13 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H167. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H16a. % 119.85/120.13 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.13 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.13 congruence. % 119.85/120.13 exact (zenon_H16b succ_tptp_minus_1). % 119.85/120.13 apply zenon_H169. apply refl_equal. % 119.85/120.13 apply zenon_H169. apply refl_equal. % 119.85/120.13 apply zenon_H76. apply refl_equal. % 119.85/120.13 apply (zenon_L66_); trivial. % 119.85/120.13 (* end of lemma zenon_L155_ *) % 119.85/120.13 assert (zenon_L156_ : (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (succ (tptp_minus_1)) (succ (succ (n0))))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.13 do 0 intro. intros zenon_Hc2 zenon_H155 zenon_H67 zenon_H7d zenon_H1da zenon_H66. % 119.85/120.13 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.85/120.13 elim (classic (gt (succ (tptp_minus_1)) (n1))); [ zenon_intro zenon_H16d | zenon_intro zenon_H16e ]. % 119.85/120.13 elim (classic (gt (succ (tptp_minus_1)) (succ (n0)))); [ zenon_intro zenon_H16f | zenon_intro zenon_H170 ]. % 119.85/120.13 elim (classic (gt (succ (n0)) (succ (succ (n0))))); [ zenon_intro zenon_H1c3 | zenon_intro zenon_H1b8 ]. % 119.85/120.13 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.85/120.13 generalize (zenon_H171 (succ (n0))). zenon_intro zenon_H172. % 119.85/120.13 generalize (zenon_H172 (succ (succ (n0)))). zenon_intro zenon_H2ed. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H2ed); [ zenon_intro zenon_H170 | zenon_intro zenon_H2ee ]. % 119.85/120.13 exact (zenon_H170 zenon_H16f). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H2ee); [ zenon_intro zenon_H1b8 | zenon_intro zenon_H1dd ]. % 119.85/120.13 exact (zenon_H1b8 zenon_H1c3). % 119.85/120.13 exact (zenon_H1da zenon_H1dd). % 119.85/120.13 apply (zenon_L154_); trivial. % 119.85/120.13 cut ((gt (succ (tptp_minus_1)) (n1)) = (gt (succ (tptp_minus_1)) (succ (n0)))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H170. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H16d. % 119.85/120.13 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.85/120.13 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H169. apply refl_equal. % 119.85/120.13 exact (zenon_H88 zenon_Hd1). % 119.85/120.13 elim (classic ((~((succ (tptp_minus_1)) = (n2)))/\(~(gt (succ (tptp_minus_1)) (n2))))); [ zenon_intro zenon_H2ef | zenon_intro zenon_H2f0 ]. % 119.85/120.13 apply (zenon_and_s _ _ zenon_H2ef). zenon_intro zenon_H2f1. zenon_intro zenon_H1df. % 119.85/120.13 elim (classic ((~((succ (tptp_minus_1)) = (succ (loopcounter))))/\(~(gt (succ (tptp_minus_1)) (succ (loopcounter)))))); [ zenon_intro zenon_H25d | zenon_intro zenon_H25e ]. % 119.85/120.13 apply (zenon_and_s _ _ zenon_H25d). zenon_intro zenon_H25f. zenon_intro zenon_H16c. % 119.85/120.13 apply (zenon_L155_); trivial. % 119.85/120.13 elim (classic (gt (n1) (n2))); [ zenon_intro zenon_H183 | zenon_intro zenon_H181 ]. % 119.85/120.13 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.85/120.13 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.85/120.13 generalize (zenon_H78 (n2)). zenon_intro zenon_H2d9. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H2d9); [ zenon_intro zenon_H6f | zenon_intro zenon_H2da ]. % 119.85/120.13 exact (zenon_H6f zenon_H67). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H2da); [ zenon_intro zenon_H181 | zenon_intro zenon_H2db ]. % 119.85/120.13 exact (zenon_H181 zenon_H183). % 119.85/120.13 cut ((gt (succ (loopcounter)) (n2)) = (gt (succ (tptp_minus_1)) (n2))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H1df. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H2db. % 119.85/120.13 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.13 cut (((succ (loopcounter)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H260]. % 119.85/120.13 congruence. % 119.85/120.13 apply (zenon_notand_s _ _ zenon_H25e); [ zenon_intro zenon_H262 | zenon_intro zenon_H261 ]. % 119.85/120.13 apply zenon_H262. zenon_intro zenon_H263. % 119.85/120.13 apply zenon_H260. apply sym_equal. exact zenon_H263. % 119.85/120.13 apply zenon_H261. zenon_intro zenon_H175. % 119.85/120.13 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.85/120.13 generalize (zenon_H171 (succ (loopcounter))). zenon_intro zenon_H264. % 119.85/120.13 generalize (zenon_H264 (n2)). zenon_intro zenon_H2f2. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H2f2); [ zenon_intro zenon_H16c | zenon_intro zenon_H2f3 ]. % 119.85/120.13 exact (zenon_H16c zenon_H175). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H2f3); [ zenon_intro zenon_H2df | zenon_intro zenon_H1de ]. % 119.85/120.13 exact (zenon_H2df zenon_H2db). % 119.85/120.13 exact (zenon_H1df zenon_H1de). % 119.85/120.13 apply zenon_H63. apply refl_equal. % 119.85/120.13 apply (zenon_L143_); trivial. % 119.85/120.13 cut ((gt (n2) (n1)) = (gt (succ (tptp_minus_1)) (n1))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H16e. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact gt_2_1. % 119.85/120.13 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.13 cut (((n2) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H2f4]. % 119.85/120.13 congruence. % 119.85/120.13 apply (zenon_notand_s _ _ zenon_H2f0); [ zenon_intro zenon_H2f6 | zenon_intro zenon_H2f5 ]. % 119.85/120.13 apply zenon_H2f6. zenon_intro zenon_H2f7. % 119.85/120.13 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.85/120.13 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n2) = (succ (tptp_minus_1)))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H2f4. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H16a. % 119.85/120.13 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.13 cut (((succ (tptp_minus_1)) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H2f1]. % 119.85/120.13 congruence. % 119.85/120.13 exact (zenon_H2f1 zenon_H2f7). % 119.85/120.13 apply zenon_H169. apply refl_equal. % 119.85/120.13 apply zenon_H169. apply refl_equal. % 119.85/120.13 apply zenon_H2f5. zenon_intro zenon_H1de. % 119.85/120.13 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.85/120.13 generalize (zenon_H171 (n2)). zenon_intro zenon_H1e0. % 119.85/120.13 generalize (zenon_H1e0 (n1)). zenon_intro zenon_H2f8. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H2f8); [ zenon_intro zenon_H1df | zenon_intro zenon_H2f9 ]. % 119.85/120.13 exact (zenon_H1df zenon_H1de). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H2f9); [ zenon_intro zenon_Hba | zenon_intro zenon_H16d ]. % 119.85/120.13 exact (zenon_Hba gt_2_1). % 119.85/120.13 exact (zenon_H16e zenon_H16d). % 119.85/120.13 apply zenon_H64. apply refl_equal. % 119.85/120.13 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.85/120.13 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H88. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H8b. % 119.85/120.13 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.85/120.13 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.85/120.13 congruence. % 119.85/120.13 exact (zenon_H87 successor_1). % 119.85/120.13 apply zenon_H8c. apply refl_equal. % 119.85/120.13 apply zenon_H8c. apply refl_equal. % 119.85/120.13 (* end of lemma zenon_L156_ *) % 119.85/120.13 assert (zenon_L157_ : (~((loopcounter) = (n3))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (loopcounter) (n0))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.13 do 0 intro. intros zenon_Hc2 zenon_H66 zenon_H2fa zenon_H67 zenon_H7d zenon_H155. % 119.85/120.13 elim (classic ((~((loopcounter) = (n2)))/\(~(gt (loopcounter) (n2))))); [ zenon_intro zenon_H19b | zenon_intro zenon_H19c ]. % 119.85/120.13 apply (zenon_and_s _ _ zenon_H19b). zenon_intro zenon_Hc3. zenon_intro zenon_H19d. % 119.85/120.13 apply (zenon_L142_); trivial. % 119.85/120.13 cut ((gt (n2) (n0)) = (gt (loopcounter) (n0))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H2fa. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact gt_2_0. % 119.85/120.13 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.13 cut (((n2) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H19e]. % 119.85/120.13 congruence. % 119.85/120.13 apply (zenon_notand_s _ _ zenon_H19c); [ zenon_intro zenon_H1a0 | zenon_intro zenon_H19f ]. % 119.85/120.13 apply zenon_H1a0. zenon_intro zenon_Hcc. % 119.85/120.13 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.13 cut (((loopcounter) = (loopcounter)) = ((n2) = (loopcounter))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H19e. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_Hed. % 119.85/120.13 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.13 cut (((loopcounter) = (n2))); [idtac | apply NNPP; zenon_intro zenon_Hc3]. % 119.85/120.13 congruence. % 119.85/120.13 exact (zenon_Hc3 zenon_Hcc). % 119.85/120.13 apply zenon_H7c. apply refl_equal. % 119.85/120.13 apply zenon_H7c. apply refl_equal. % 119.85/120.13 apply zenon_H19f. zenon_intro zenon_H1a1. % 119.85/120.13 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.85/120.13 generalize (zenon_H13b (n2)). zenon_intro zenon_H1a2. % 119.85/120.13 generalize (zenon_H1a2 (n0)). zenon_intro zenon_H2fb. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H2fb); [ zenon_intro zenon_H19d | zenon_intro zenon_H2fc ]. % 119.85/120.13 exact (zenon_H19d zenon_H1a1). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H2fc); [ zenon_intro zenon_H1b7 | zenon_intro zenon_H2fd ]. % 119.85/120.13 exact (zenon_H1b7 gt_2_0). % 119.85/120.13 exact (zenon_H2fa zenon_H2fd). % 119.85/120.13 apply zenon_H65. apply refl_equal. % 119.85/120.13 (* end of lemma zenon_L157_ *) % 119.85/120.13 assert (zenon_L158_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (loopcounter) (succ (succ (n0))))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.13 do 0 intro. intros zenon_H67 zenon_H7d zenon_Hc2 zenon_H155 zenon_H232 zenon_H66. % 119.85/120.13 elim (classic ((n0) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H180 | zenon_intro zenon_H167 ]. % 119.85/120.13 elim (classic (gt (loopcounter) (n0))); [ zenon_intro zenon_H2fd | zenon_intro zenon_H2fa ]. % 119.85/120.13 elim (classic (gt (loopcounter) (succ (tptp_minus_1)))); [ zenon_intro zenon_H2fe | zenon_intro zenon_H2ff ]. % 119.85/120.13 elim (classic (gt (succ (tptp_minus_1)) (succ (succ (n0))))); [ zenon_intro zenon_H1dd | zenon_intro zenon_H1da ]. % 119.85/120.13 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.85/120.13 generalize (zenon_H13b (succ (tptp_minus_1))). zenon_intro zenon_H300. % 119.85/120.13 generalize (zenon_H300 (succ (succ (n0)))). zenon_intro zenon_H301. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H301); [ zenon_intro zenon_H2ff | zenon_intro zenon_H302 ]. % 119.85/120.13 exact (zenon_H2ff zenon_H2fe). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H302); [ zenon_intro zenon_H1da | zenon_intro zenon_H231 ]. % 119.85/120.13 exact (zenon_H1da zenon_H1dd). % 119.85/120.13 exact (zenon_H232 zenon_H231). % 119.85/120.13 apply (zenon_L156_); trivial. % 119.85/120.13 cut ((gt (loopcounter) (n0)) = (gt (loopcounter) (succ (tptp_minus_1)))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H2ff. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H2fd. % 119.85/120.13 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.85/120.13 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H7c. apply refl_equal. % 119.85/120.13 exact (zenon_H167 zenon_H180). % 119.85/120.13 apply (zenon_L157_); trivial. % 119.85/120.13 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.85/120.13 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H167. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H16a. % 119.85/120.13 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.13 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.13 congruence. % 119.85/120.13 exact (zenon_H16b succ_tptp_minus_1). % 119.85/120.13 apply zenon_H169. apply refl_equal. % 119.85/120.13 apply zenon_H169. apply refl_equal. % 119.85/120.13 (* end of lemma zenon_L158_ *) % 119.85/120.13 assert (zenon_L159_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (plus (n2) (n1)))) -> ((plus (n2) (n0)) = (succ (succ (n0)))) -> ((n1) = (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.13 do 0 intro. intros zenon_H66 zenon_H303 zenon_H304 zenon_H108 zenon_H155 zenon_Hc2 zenon_H7d zenon_H67. % 119.85/120.13 elim (classic (gt (loopcounter) (plus (n2) (n1)))); [ zenon_intro zenon_H305 | zenon_intro zenon_H306 ]. % 119.85/120.13 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.85/120.13 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.85/120.13 generalize (zenon_Hf3 (plus (n2) (n1))). zenon_intro zenon_H307. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H307); [ zenon_intro zenon_H92 | zenon_intro zenon_H308 ]. % 119.85/120.13 exact (zenon_H92 zenon_H7d). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H308); [ zenon_intro zenon_H306 | zenon_intro zenon_H309 ]. % 119.85/120.13 exact (zenon_H306 zenon_H305). % 119.85/120.13 exact (zenon_H303 zenon_H309). % 119.85/120.13 elim (classic ((succ (succ (n0))) = (plus (n2) (n0)))); [ zenon_intro zenon_H30a | zenon_intro zenon_H30b ]. % 119.85/120.13 elim (classic (gt (loopcounter) (succ (succ (n0))))); [ zenon_intro zenon_H231 | zenon_intro zenon_H232 ]. % 119.85/120.13 elim (classic (gt (loopcounter) (plus (n2) (n0)))); [ zenon_intro zenon_H30c | zenon_intro zenon_H30d ]. % 119.85/120.13 cut ((gt (loopcounter) (plus (n2) (n0))) = (gt (loopcounter) (plus (n2) (n1)))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H306. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H30c. % 119.85/120.13 cut (((plus (n2) (n0)) = (plus (n2) (n1)))); [idtac | apply NNPP; zenon_intro zenon_H2e8]. % 119.85/120.13 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H7c. apply refl_equal. % 119.85/120.13 apply (zenon_L152_); trivial. % 119.85/120.13 cut ((gt (loopcounter) (succ (succ (n0)))) = (gt (loopcounter) (plus (n2) (n0)))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H30d. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H231. % 119.85/120.13 cut (((succ (succ (n0))) = (plus (n2) (n0)))); [idtac | apply NNPP; zenon_intro zenon_H30b]. % 119.85/120.13 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H7c. apply refl_equal. % 119.85/120.13 exact (zenon_H30b zenon_H30a). % 119.85/120.13 apply (zenon_L158_); trivial. % 119.85/120.13 elim (classic ((plus (n2) (n0)) = (plus (n2) (n0)))); [ zenon_intro zenon_H30e | zenon_intro zenon_H30f ]. % 119.85/120.13 cut (((plus (n2) (n0)) = (plus (n2) (n0))) = ((succ (succ (n0))) = (plus (n2) (n0)))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H30b. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H30e. % 119.85/120.13 cut (((plus (n2) (n0)) = (plus (n2) (n0)))); [idtac | apply NNPP; zenon_intro zenon_H30f]. % 119.85/120.13 cut (((plus (n2) (n0)) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H310]. % 119.85/120.13 congruence. % 119.85/120.13 exact (zenon_H310 zenon_H304). % 119.85/120.13 apply zenon_H30f. apply refl_equal. % 119.85/120.13 apply zenon_H30f. apply refl_equal. % 119.85/120.13 (* end of lemma zenon_L159_ *) % 119.85/120.13 assert (zenon_L160_ : (~((succ (succ (n0))) = (succ (succ (n1))))) -> ((n1) = (n0)) -> False). % 119.85/120.13 do 0 intro. intros zenon_H311 zenon_H108. % 119.85/120.13 cut (((succ (n0)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H312]. % 119.85/120.13 congruence. % 119.85/120.13 cut (((n0) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H106]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H106. apply sym_equal. exact zenon_H108. % 119.85/120.13 (* end of lemma zenon_L160_ *) % 119.85/120.13 assert (zenon_L161_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n2) (n2))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.13 do 0 intro. intros zenon_H66 zenon_H1a5 zenon_H155 zenon_Hc2 zenon_H7d zenon_H67. % 119.85/120.13 elim (classic (gt (n1) (n2))); [ zenon_intro zenon_H183 | zenon_intro zenon_H181 ]. % 119.85/120.13 generalize (zenon_H66 (n2)). zenon_intro zenon_H1a6. % 119.85/120.13 generalize (zenon_H1a6 (n1)). zenon_intro zenon_H1a7. % 119.85/120.13 generalize (zenon_H1a7 (n2)). zenon_intro zenon_H1a8. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H1a8); [ zenon_intro zenon_Hba | zenon_intro zenon_H1a9 ]. % 119.85/120.13 exact (zenon_Hba gt_2_1). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H1a9); [ zenon_intro zenon_H181 | zenon_intro zenon_H1aa ]. % 119.85/120.13 exact (zenon_H181 zenon_H183). % 119.85/120.13 exact (zenon_H1a5 zenon_H1aa). % 119.85/120.13 apply (zenon_L143_); trivial. % 119.85/120.13 (* end of lemma zenon_L161_ *) % 119.85/120.13 assert (zenon_L162_ : ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(gt (n2) (succ (succ (n1))))) -> ((n1) = (n0)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.13 do 0 intro. intros zenon_H155 zenon_Hc2 zenon_H7d zenon_H67 zenon_H313 zenon_H108 zenon_H66. % 119.85/120.13 elim (classic ((n2) = (succ (succ (n0))))); [ zenon_intro zenon_H1b9 | zenon_intro zenon_H102 ]. % 119.85/120.13 elim (classic (gt (n2) (n2))); [ zenon_intro zenon_H1aa | zenon_intro zenon_H1a5 ]. % 119.85/120.13 elim (classic (gt (n2) (succ (succ (n0))))); [ zenon_intro zenon_H314 | zenon_intro zenon_H315 ]. % 119.85/120.13 cut ((gt (n2) (succ (succ (n0)))) = (gt (n2) (succ (succ (n1))))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H313. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H314. % 119.85/120.13 cut (((succ (succ (n0))) = (succ (succ (n1))))); [idtac | apply NNPP; zenon_intro zenon_H311]. % 119.85/120.13 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H63. apply refl_equal. % 119.85/120.13 apply (zenon_L160_); trivial. % 119.85/120.13 cut ((gt (n2) (n2)) = (gt (n2) (succ (succ (n0))))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H315. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H1aa. % 119.85/120.13 cut (((n2) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 119.85/120.13 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H63. apply refl_equal. % 119.85/120.13 exact (zenon_H102 zenon_H1b9). % 119.85/120.13 apply (zenon_L161_); trivial. % 119.85/120.13 elim (classic ((succ (succ (n0))) = (succ (succ (n0))))); [ zenon_intro zenon_H103 | zenon_intro zenon_H104 ]. % 119.85/120.13 cut (((succ (succ (n0))) = (succ (succ (n0)))) = ((n2) = (succ (succ (n0))))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H102. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H103. % 119.85/120.13 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.85/120.13 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.85/120.13 congruence. % 119.85/120.13 exact (zenon_H105 successor_2). % 119.85/120.13 apply zenon_H104. apply refl_equal. % 119.85/120.13 apply zenon_H104. apply refl_equal. % 119.85/120.13 (* end of lemma zenon_L162_ *) % 119.85/120.13 assert (zenon_L163_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> ((n1) = (n0)) -> (~(gt (n2) (plus (n2) (n1)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((plus (n2) (n1)) = (succ (succ (n1)))) -> False). % 119.85/120.13 do 0 intro. intros zenon_H67 zenon_H7d zenon_Hc2 zenon_H155 zenon_H108 zenon_H316 zenon_H66 zenon_H317. % 119.85/120.13 elim (classic ((succ (succ (n1))) = (plus (n2) (n1)))); [ zenon_intro zenon_H318 | zenon_intro zenon_H319 ]. % 119.85/120.13 elim (classic (gt (n2) (succ (succ (n1))))); [ zenon_intro zenon_H31a | zenon_intro zenon_H313 ]. % 119.85/120.13 cut ((gt (n2) (succ (succ (n1)))) = (gt (n2) (plus (n2) (n1)))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H316. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H31a. % 119.85/120.13 cut (((succ (succ (n1))) = (plus (n2) (n1)))); [idtac | apply NNPP; zenon_intro zenon_H319]. % 119.85/120.13 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H63. apply refl_equal. % 119.85/120.13 exact (zenon_H319 zenon_H318). % 119.85/120.13 apply (zenon_L162_); trivial. % 119.85/120.13 elim (classic ((plus (n2) (n1)) = (plus (n2) (n1)))); [ zenon_intro zenon_H31b | zenon_intro zenon_H31c ]. % 119.85/120.13 cut (((plus (n2) (n1)) = (plus (n2) (n1))) = ((succ (succ (n1))) = (plus (n2) (n1)))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H319. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H31b. % 119.85/120.13 cut (((plus (n2) (n1)) = (plus (n2) (n1)))); [idtac | apply NNPP; zenon_intro zenon_H31c]. % 119.85/120.13 cut (((plus (n2) (n1)) = (succ (succ (n1))))); [idtac | apply NNPP; zenon_intro zenon_H31d]. % 119.85/120.13 congruence. % 119.85/120.13 exact (zenon_H31d zenon_H317). % 119.85/120.13 apply zenon_H31c. apply refl_equal. % 119.85/120.13 apply zenon_H31c. apply refl_equal. % 119.85/120.13 (* end of lemma zenon_L163_ *) % 119.85/120.13 assert (zenon_L164_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (plus (n2) (n1)))) -> ((loopcounter) = (n2)) -> ((n1) = (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> ((plus (n2) (n1)) = (succ (succ (n1)))) -> False). % 119.85/120.13 do 0 intro. intros zenon_H66 zenon_H303 zenon_Hcc zenon_H108 zenon_H155 zenon_Hc2 zenon_H7d zenon_H67 zenon_H317. % 119.85/120.13 elim (classic (gt (loopcounter) (plus (n2) (n1)))); [ zenon_intro zenon_H305 | zenon_intro zenon_H306 ]. % 119.85/120.13 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.85/120.13 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.85/120.13 generalize (zenon_Hf3 (plus (n2) (n1))). zenon_intro zenon_H307. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H307); [ zenon_intro zenon_H92 | zenon_intro zenon_H308 ]. % 119.85/120.13 exact (zenon_H92 zenon_H7d). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H308); [ zenon_intro zenon_H306 | zenon_intro zenon_H309 ]. % 119.85/120.13 exact (zenon_H306 zenon_H305). % 119.85/120.13 exact (zenon_H303 zenon_H309). % 119.85/120.13 elim (classic (gt (n2) (plus (n2) (n1)))); [ zenon_intro zenon_H31e | zenon_intro zenon_H316 ]. % 119.85/120.13 cut ((gt (n2) (plus (n2) (n1))) = (gt (loopcounter) (plus (n2) (n1)))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H306. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H31e. % 119.85/120.13 cut (((plus (n2) (n1)) = (plus (n2) (n1)))); [idtac | apply NNPP; zenon_intro zenon_H31c]. % 119.85/120.13 cut (((n2) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H19e]. % 119.85/120.13 congruence. % 119.85/120.13 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.13 cut (((loopcounter) = (loopcounter)) = ((n2) = (loopcounter))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H19e. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_Hed. % 119.85/120.13 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.13 cut (((loopcounter) = (n2))); [idtac | apply NNPP; zenon_intro zenon_Hc3]. % 119.85/120.13 congruence. % 119.85/120.13 exact (zenon_Hc3 zenon_Hcc). % 119.85/120.13 apply zenon_H7c. apply refl_equal. % 119.85/120.13 apply zenon_H7c. apply refl_equal. % 119.85/120.13 apply zenon_H31c. apply refl_equal. % 119.85/120.13 apply (zenon_L163_); trivial. % 119.85/120.13 (* end of lemma zenon_L164_ *) % 119.85/120.13 assert (zenon_L165_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (n1) (succ (succ (succ (n0)))))) -> False). % 119.85/120.13 do 0 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_Hc2 zenon_H155 zenon_H23c. % 119.85/120.13 generalize (finite_domain_3 (loopcounter)). zenon_intro zenon_Hc5. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_Hc5); [ zenon_intro zenon_Hc7 | zenon_intro zenon_Hc6 ]. % 119.85/120.13 apply (zenon_notand_s _ _ zenon_Hc7); [ zenon_intro zenon_H68 | zenon_intro zenon_Ha4 ]. % 119.85/120.13 apply (zenon_L5_); trivial. % 119.85/120.13 apply (zenon_L12_); trivial. % 119.85/120.13 apply (zenon_or_s _ _ zenon_Hc6); [ zenon_intro zenon_H95 | zenon_intro zenon_Hc8 ]. % 119.85/120.13 generalize (finite_domain_0 (n1)). zenon_intro zenon_H107. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H107); [ zenon_intro zenon_H109 | zenon_intro zenon_H108 ]. % 119.85/120.13 apply (zenon_notand_s _ _ zenon_H109); [ zenon_intro zenon_H10b | zenon_intro zenon_H10a ]. % 119.85/120.13 apply (zenon_L147_); trivial. % 119.85/120.13 apply (zenon_L149_); trivial. % 119.85/120.13 generalize (succ_plus_2_l (n0)). zenon_intro zenon_H304. % 119.85/120.13 generalize (succ_plus_2_l (n1)). zenon_intro zenon_H317. % 119.85/120.13 elim (classic (gt (n1) (plus (n2) (n1)))); [ zenon_intro zenon_H309 | zenon_intro zenon_H303 ]. % 119.85/120.13 elim (classic (gt (n1) (succ (succ (n1))))); [ zenon_intro zenon_H31f | zenon_intro zenon_H320 ]. % 119.85/120.13 cut ((gt (n1) (succ (succ (n1)))) = (gt (n1) (succ (succ (succ (n0)))))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H23c. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H31f. % 119.85/120.13 cut (((succ (succ (n1))) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H2e7]. % 119.85/120.13 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H64. apply refl_equal. % 119.85/120.13 apply (zenon_L150_); trivial. % 119.85/120.13 cut ((gt (n1) (plus (n2) (n1))) = (gt (n1) (succ (succ (n1))))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H320. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H309. % 119.85/120.13 cut (((plus (n2) (n1)) = (succ (succ (n1))))); [idtac | apply NNPP; zenon_intro zenon_H31d]. % 119.85/120.13 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H64. apply refl_equal. % 119.85/120.13 exact (zenon_H31d zenon_H317). % 119.85/120.13 apply (zenon_L159_); trivial. % 119.85/120.13 apply (zenon_or_s _ _ zenon_Hc8); [ zenon_intro zenon_Hca | zenon_intro zenon_Hc9 ]. % 119.85/120.13 apply (zenon_L141_); trivial. % 119.85/120.13 apply (zenon_or_s _ _ zenon_Hc9); [ zenon_intro zenon_Hcc | zenon_intro zenon_Hcb ]. % 119.85/120.13 generalize (finite_domain_0 (loopcounter)). zenon_intro zenon_H94. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H94); [ zenon_intro zenon_H96 | zenon_intro zenon_H95 ]. % 119.85/120.13 apply (zenon_notand_s _ _ zenon_H96); [ zenon_intro zenon_H68 | zenon_intro zenon_H7e ]. % 119.85/120.13 apply (zenon_L5_); trivial. % 119.85/120.13 apply (zenon_L7_); trivial. % 119.85/120.13 generalize (finite_domain_0 (n1)). zenon_intro zenon_H107. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H107); [ zenon_intro zenon_H109 | zenon_intro zenon_H108 ]. % 119.85/120.13 apply (zenon_notand_s _ _ zenon_H109); [ zenon_intro zenon_H10b | zenon_intro zenon_H10a ]. % 119.85/120.13 apply (zenon_L147_); trivial. % 119.85/120.13 apply (zenon_L149_); trivial. % 119.85/120.13 generalize (succ_plus_2_l (n1)). zenon_intro zenon_H317. % 119.85/120.13 elim (classic (gt (n1) (plus (n2) (n1)))); [ zenon_intro zenon_H309 | zenon_intro zenon_H303 ]. % 119.85/120.13 elim (classic (gt (n1) (succ (succ (n1))))); [ zenon_intro zenon_H31f | zenon_intro zenon_H320 ]. % 119.85/120.13 cut ((gt (n1) (succ (succ (n1)))) = (gt (n1) (succ (succ (succ (n0)))))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H23c. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H31f. % 119.85/120.13 cut (((succ (succ (n1))) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H2e7]. % 119.85/120.13 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H64. apply refl_equal. % 119.85/120.13 apply (zenon_L150_); trivial. % 119.85/120.13 cut ((gt (n1) (plus (n2) (n1))) = (gt (n1) (succ (succ (n1))))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H320. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H309. % 119.85/120.13 cut (((plus (n2) (n1)) = (succ (succ (n1))))); [idtac | apply NNPP; zenon_intro zenon_H31d]. % 119.85/120.13 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H64. apply refl_equal. % 119.85/120.13 exact (zenon_H31d zenon_H317). % 119.85/120.13 apply (zenon_L164_); trivial. % 119.85/120.13 exact (zenon_Hc2 zenon_Hcb). % 119.85/120.13 (* end of lemma zenon_L165_ *) % 119.85/120.13 assert (zenon_L166_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (succ (n0))) (succ (succ (succ (n0)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.13 do 0 intro. intros zenon_H66 zenon_H21b zenon_H67 zenon_H7d zenon_Hc2 zenon_H155. % 119.85/120.13 elim (classic ((~((succ (succ (n0))) = (succ (loopcounter))))/\(~(gt (succ (succ (n0))) (succ (loopcounter)))))); [ zenon_intro zenon_H20c | zenon_intro zenon_H20d ]. % 119.85/120.13 apply (zenon_and_s _ _ zenon_H20c). zenon_intro zenon_H20e. zenon_intro zenon_H203. % 119.85/120.13 apply (zenon_L136_); trivial. % 119.85/120.13 elim (classic (gt (n1) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H23f | zenon_intro zenon_H23c ]. % 119.85/120.13 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.85/120.13 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.85/120.13 generalize (zenon_H78 (succ (succ (succ (n0))))). zenon_intro zenon_H241. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H241); [ zenon_intro zenon_H6f | zenon_intro zenon_H242 ]. % 119.85/120.13 exact (zenon_H6f zenon_H67). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H242); [ zenon_intro zenon_H23c | zenon_intro zenon_H243 ]. % 119.85/120.13 exact (zenon_H23c zenon_H23f). % 119.85/120.13 cut ((gt (succ (loopcounter)) (succ (succ (succ (n0))))) = (gt (succ (succ (n0))) (succ (succ (succ (n0)))))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H21b. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H243. % 119.85/120.13 cut (((succ (succ (succ (n0)))) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H21e]. % 119.85/120.13 cut (((succ (loopcounter)) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H212]. % 119.85/120.13 congruence. % 119.85/120.13 apply (zenon_notand_s _ _ zenon_H20d); [ zenon_intro zenon_H214 | zenon_intro zenon_H213 ]. % 119.85/120.13 apply zenon_H214. zenon_intro zenon_H215. % 119.85/120.13 apply zenon_H212. apply sym_equal. exact zenon_H215. % 119.85/120.13 apply zenon_H213. zenon_intro zenon_H20a. % 119.85/120.13 generalize (zenon_H66 (succ (succ (n0)))). zenon_intro zenon_H206. % 119.85/120.13 generalize (zenon_H206 (succ (loopcounter))). zenon_intro zenon_H216. % 119.85/120.13 generalize (zenon_H216 (succ (succ (succ (n0))))). zenon_intro zenon_H321. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H321); [ zenon_intro zenon_H203 | zenon_intro zenon_H322 ]. % 119.85/120.13 exact (zenon_H203 zenon_H20a). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H322); [ zenon_intro zenon_H247 | zenon_intro zenon_H233 ]. % 119.85/120.13 exact (zenon_H247 zenon_H243). % 119.85/120.13 exact (zenon_H21b zenon_H233). % 119.85/120.13 apply zenon_H21e. apply refl_equal. % 119.85/120.13 apply (zenon_L165_); trivial. % 119.85/120.13 (* end of lemma zenon_L166_ *) % 119.85/120.13 assert (zenon_L167_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n3) (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~((loopcounter) = (n3))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.13 do 0 intro. intros zenon_H66 zenon_H24e zenon_H155 zenon_Hc2 zenon_H7d zenon_H67. % 119.85/120.13 elim (classic (gt (n2) (n3))); [ zenon_intro zenon_H223 | zenon_intro zenon_H220 ]. % 119.85/120.13 generalize (zenon_H66 (n3)). zenon_intro zenon_H24f. % 119.85/120.13 generalize (zenon_H24f (n2)). zenon_intro zenon_H250. % 119.85/120.13 generalize (zenon_H250 (n3)). zenon_intro zenon_H251. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H251); [ zenon_intro zenon_H22f | zenon_intro zenon_H252 ]. % 119.85/120.13 exact (zenon_H22f gt_3_2). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H252); [ zenon_intro zenon_H220 | zenon_intro zenon_H253 ]. % 119.85/120.13 exact (zenon_H220 zenon_H223). % 119.85/120.13 exact (zenon_H24e zenon_H253). % 119.85/120.13 elim (classic ((n2) = (succ (succ (n0))))); [ zenon_intro zenon_H1b9 | zenon_intro zenon_H102 ]. % 119.85/120.13 elim (classic (gt (n2) (n2))); [ zenon_intro zenon_H1aa | zenon_intro zenon_H1a5 ]. % 119.85/120.13 elim (classic (gt (n2) (succ (succ (n0))))); [ zenon_intro zenon_H314 | zenon_intro zenon_H315 ]. % 119.85/120.13 elim (classic (gt (succ (succ (n0))) (n3))); [ zenon_intro zenon_H219 | zenon_intro zenon_H20b ]. % 119.85/120.13 generalize (zenon_H66 (n2)). zenon_intro zenon_H1a6. % 119.85/120.13 generalize (zenon_H1a6 (succ (succ (n0)))). zenon_intro zenon_H323. % 119.85/120.13 generalize (zenon_H323 (n3)). zenon_intro zenon_H324. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H324); [ zenon_intro zenon_H315 | zenon_intro zenon_H325 ]. % 119.85/120.13 exact (zenon_H315 zenon_H314). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H325); [ zenon_intro zenon_H20b | zenon_intro zenon_H223 ]. % 119.85/120.13 exact (zenon_H20b zenon_H219). % 119.85/120.13 exact (zenon_H220 zenon_H223). % 119.85/120.13 elim (classic (gt (succ (succ (n0))) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H233 | zenon_intro zenon_H21b ]. % 119.85/120.13 cut ((gt (succ (succ (n0))) (succ (succ (succ (n0))))) = (gt (succ (succ (n0))) (n3))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H20b. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H233. % 119.85/120.13 cut (((succ (succ (succ (n0)))) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H21f]. % 119.85/120.13 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H104. apply refl_equal. % 119.85/120.13 exact (zenon_H21f successor_3). % 119.85/120.13 apply (zenon_L166_); trivial. % 119.85/120.13 cut ((gt (n2) (n2)) = (gt (n2) (succ (succ (n0))))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H315. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H1aa. % 119.85/120.13 cut (((n2) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 119.85/120.13 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H63. apply refl_equal. % 119.85/120.13 exact (zenon_H102 zenon_H1b9). % 119.85/120.13 apply (zenon_L161_); trivial. % 119.85/120.13 elim (classic ((succ (succ (n0))) = (succ (succ (n0))))); [ zenon_intro zenon_H103 | zenon_intro zenon_H104 ]. % 119.85/120.13 cut (((succ (succ (n0))) = (succ (succ (n0)))) = ((n2) = (succ (succ (n0))))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H102. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H103. % 119.85/120.13 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.85/120.13 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.85/120.13 congruence. % 119.85/120.13 exact (zenon_H105 successor_2). % 119.85/120.13 apply zenon_H104. apply refl_equal. % 119.85/120.13 apply zenon_H104. apply refl_equal. % 119.85/120.13 (* end of lemma zenon_L167_ *) % 119.85/120.13 assert (zenon_L168_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (tptp_minus_1)) (succ (succ (succ (n0)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.13 do 0 intro. intros zenon_H66 zenon_H255 zenon_H67 zenon_H7d zenon_Hc2 zenon_H155. % 119.85/120.13 elim (classic ((~((succ (tptp_minus_1)) = (succ (loopcounter))))/\(~(gt (succ (tptp_minus_1)) (succ (loopcounter)))))); [ zenon_intro zenon_H25d | zenon_intro zenon_H25e ]. % 119.85/120.13 apply (zenon_and_s _ _ zenon_H25d). zenon_intro zenon_H25f. zenon_intro zenon_H16c. % 119.85/120.13 apply (zenon_L155_); trivial. % 119.85/120.13 elim (classic (gt (n1) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H23f | zenon_intro zenon_H23c ]. % 119.85/120.13 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.85/120.13 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.85/120.13 generalize (zenon_H78 (succ (succ (succ (n0))))). zenon_intro zenon_H241. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H241); [ zenon_intro zenon_H6f | zenon_intro zenon_H242 ]. % 119.85/120.13 exact (zenon_H6f zenon_H67). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H242); [ zenon_intro zenon_H23c | zenon_intro zenon_H243 ]. % 119.85/120.13 exact (zenon_H23c zenon_H23f). % 119.85/120.13 cut ((gt (succ (loopcounter)) (succ (succ (succ (n0))))) = (gt (succ (tptp_minus_1)) (succ (succ (succ (n0)))))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H255. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H243. % 119.85/120.13 cut (((succ (succ (succ (n0)))) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H21e]. % 119.85/120.13 cut (((succ (loopcounter)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H260]. % 119.85/120.13 congruence. % 119.85/120.13 apply (zenon_notand_s _ _ zenon_H25e); [ zenon_intro zenon_H262 | zenon_intro zenon_H261 ]. % 119.85/120.13 apply zenon_H262. zenon_intro zenon_H263. % 119.85/120.13 apply zenon_H260. apply sym_equal. exact zenon_H263. % 119.85/120.13 apply zenon_H261. zenon_intro zenon_H175. % 119.85/120.13 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.85/120.13 generalize (zenon_H171 (succ (loopcounter))). zenon_intro zenon_H264. % 119.85/120.13 generalize (zenon_H264 (succ (succ (succ (n0))))). zenon_intro zenon_H326. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H326); [ zenon_intro zenon_H16c | zenon_intro zenon_H327 ]. % 119.85/120.13 exact (zenon_H16c zenon_H175). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H327); [ zenon_intro zenon_H247 | zenon_intro zenon_H258 ]. % 119.85/120.13 exact (zenon_H247 zenon_H243). % 119.85/120.13 exact (zenon_H255 zenon_H258). % 119.85/120.13 apply zenon_H21e. apply refl_equal. % 119.85/120.13 apply (zenon_L165_); trivial. % 119.85/120.13 (* end of lemma zenon_L168_ *) % 119.85/120.13 assert (zenon_L169_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (loopcounter) (n0))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.13 do 0 intro. intros zenon_H66 zenon_H2fa zenon_H67 zenon_H7d zenon_H155. % 119.85/120.13 elim (classic ((~((loopcounter) = (n3)))/\(~(gt (loopcounter) (n3))))); [ zenon_intro zenon_H1f3 | zenon_intro zenon_H1f4 ]. % 119.85/120.13 apply (zenon_and_s _ _ zenon_H1f3). zenon_intro zenon_Hc2. zenon_intro zenon_H1f5. % 119.85/120.13 apply (zenon_L157_); trivial. % 119.85/120.13 cut ((gt (n3) (n0)) = (gt (loopcounter) (n0))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H2fa. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact gt_3_0. % 119.85/120.13 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.13 cut (((n3) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H1f6]. % 119.85/120.13 congruence. % 119.85/120.13 apply (zenon_notand_s _ _ zenon_H1f4); [ zenon_intro zenon_H1f8 | zenon_intro zenon_H1f7 ]. % 119.85/120.13 apply zenon_H1f8. zenon_intro zenon_Hcb. % 119.85/120.13 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.85/120.13 cut (((loopcounter) = (loopcounter)) = ((n3) = (loopcounter))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H1f6. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_Hed. % 119.85/120.13 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.13 cut (((loopcounter) = (n3))); [idtac | apply NNPP; zenon_intro zenon_Hc2]. % 119.85/120.13 congruence. % 119.85/120.13 exact (zenon_Hc2 zenon_Hcb). % 119.85/120.13 apply zenon_H7c. apply refl_equal. % 119.85/120.13 apply zenon_H7c. apply refl_equal. % 119.85/120.13 apply zenon_H1f7. zenon_intro zenon_H1f9. % 119.85/120.13 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.85/120.13 generalize (zenon_H13b (n3)). zenon_intro zenon_H1fa. % 119.85/120.13 generalize (zenon_H1fa (n0)). zenon_intro zenon_H328. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H328); [ zenon_intro zenon_H1f5 | zenon_intro zenon_H329 ]. % 119.85/120.13 exact (zenon_H1f5 zenon_H1f9). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H329); [ zenon_intro zenon_H291 | zenon_intro zenon_H2fd ]. % 119.85/120.13 exact (zenon_H291 gt_3_0). % 119.85/120.13 exact (zenon_H2fa zenon_H2fd). % 119.85/120.13 apply zenon_H65. apply refl_equal. % 119.85/120.13 (* end of lemma zenon_L169_ *) % 119.85/120.13 assert (zenon_L170_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (loopcounter) (n3))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~((loopcounter) = (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.13 do 0 intro. intros zenon_H66 zenon_H1f5 zenon_H67 zenon_H7d zenon_Hc2 zenon_H155. % 119.85/120.13 elim (classic (gt (loopcounter) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H237 | zenon_intro zenon_H230 ]. % 119.85/120.13 cut ((gt (loopcounter) (succ (succ (succ (n0))))) = (gt (loopcounter) (n3))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H1f5. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H237. % 119.85/120.13 cut (((succ (succ (succ (n0)))) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H21f]. % 119.85/120.13 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H7c. apply refl_equal. % 119.85/120.13 exact (zenon_H21f successor_3). % 119.85/120.13 elim (classic ((n0) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H180 | zenon_intro zenon_H167 ]. % 119.85/120.13 elim (classic (gt (loopcounter) (n0))); [ zenon_intro zenon_H2fd | zenon_intro zenon_H2fa ]. % 119.85/120.13 elim (classic (gt (loopcounter) (succ (tptp_minus_1)))); [ zenon_intro zenon_H2fe | zenon_intro zenon_H2ff ]. % 119.85/120.13 elim (classic (gt (succ (tptp_minus_1)) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H258 | zenon_intro zenon_H255 ]. % 119.85/120.13 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.85/120.13 generalize (zenon_H13b (succ (tptp_minus_1))). zenon_intro zenon_H300. % 119.85/120.13 generalize (zenon_H300 (succ (succ (succ (n0))))). zenon_intro zenon_H32a. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H32a); [ zenon_intro zenon_H2ff | zenon_intro zenon_H32b ]. % 119.85/120.13 exact (zenon_H2ff zenon_H2fe). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H32b); [ zenon_intro zenon_H255 | zenon_intro zenon_H237 ]. % 119.85/120.13 exact (zenon_H255 zenon_H258). % 119.85/120.13 exact (zenon_H230 zenon_H237). % 119.85/120.13 apply (zenon_L168_); trivial. % 119.85/120.13 cut ((gt (loopcounter) (n0)) = (gt (loopcounter) (succ (tptp_minus_1)))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H2ff. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H2fd. % 119.85/120.13 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.85/120.13 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H7c. apply refl_equal. % 119.85/120.13 exact (zenon_H167 zenon_H180). % 119.85/120.13 apply (zenon_L169_); trivial. % 119.85/120.13 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.85/120.13 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H167. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H16a. % 119.85/120.13 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.85/120.13 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.85/120.13 congruence. % 119.85/120.13 exact (zenon_H16b succ_tptp_minus_1). % 119.85/120.13 apply zenon_H169. apply refl_equal. % 119.85/120.13 apply zenon_H169. apply refl_equal. % 119.85/120.13 (* end of lemma zenon_L170_ *) % 119.85/120.13 assert (zenon_L171_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (n3))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.13 do 0 intro. intros zenon_H66 zenon_H1e6 zenon_H67 zenon_H7d zenon_H155. % 119.85/120.13 elim (classic ((loopcounter) = (n3))); [ zenon_intro zenon_Hcb | zenon_intro zenon_Hc2 ]. % 119.85/120.13 cut ((gt (n1) (loopcounter)) = (gt (n1) (n3))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H1e6. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H7d. % 119.85/120.13 cut (((loopcounter) = (n3))); [idtac | apply NNPP; zenon_intro zenon_Hc2]. % 119.85/120.13 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H64. apply refl_equal. % 119.85/120.13 exact (zenon_Hc2 zenon_Hcb). % 119.85/120.13 elim (classic (gt (loopcounter) (n3))); [ zenon_intro zenon_H1f9 | zenon_intro zenon_H1f5 ]. % 119.85/120.13 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.85/120.13 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.85/120.13 generalize (zenon_Hf3 (n3)). zenon_intro zenon_H32c. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H32c); [ zenon_intro zenon_H92 | zenon_intro zenon_H32d ]. % 119.85/120.13 exact (zenon_H92 zenon_H7d). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H32d); [ zenon_intro zenon_H1f5 | zenon_intro zenon_H1ee ]. % 119.85/120.13 exact (zenon_H1f5 zenon_H1f9). % 119.85/120.13 exact (zenon_H1e6 zenon_H1ee). % 119.85/120.13 apply (zenon_L170_); trivial. % 119.85/120.13 (* end of lemma zenon_L171_ *) % 119.85/120.13 assert (zenon_L172_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (n1))) -> False). % 119.85/120.13 do 0 intro. intros zenon_H67 zenon_H7d zenon_H155 zenon_H66 zenon_Hdd. % 119.85/120.13 elim (classic ((~((n1) = (n3)))/\(~(gt (n1) (n3))))); [ zenon_intro zenon_H1e7 | zenon_intro zenon_H1e8 ]. % 119.85/120.13 apply (zenon_and_s _ _ zenon_H1e7). zenon_intro zenon_H1e9. zenon_intro zenon_H1e6. % 119.85/120.13 apply (zenon_L171_); trivial. % 119.85/120.13 cut ((gt (n3) (n1)) = (gt (n1) (n1))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_Hdd. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact gt_3_1. % 119.85/120.13 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.13 cut (((n3) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H1ea]. % 119.85/120.13 congruence. % 119.85/120.13 apply (zenon_notand_s _ _ zenon_H1e8); [ zenon_intro zenon_H1ec | zenon_intro zenon_H1eb ]. % 119.85/120.13 apply zenon_H1ec. zenon_intro zenon_H1ed. % 119.85/120.13 elim (classic ((n1) = (n1))); [ zenon_intro zenon_Hdc | zenon_intro zenon_H64 ]. % 119.85/120.13 cut (((n1) = (n1)) = ((n3) = (n1))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H1ea. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_Hdc. % 119.85/120.13 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.13 cut (((n1) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H1e9]. % 119.85/120.13 congruence. % 119.85/120.13 exact (zenon_H1e9 zenon_H1ed). % 119.85/120.13 apply zenon_H64. apply refl_equal. % 119.85/120.13 apply zenon_H64. apply refl_equal. % 119.85/120.13 apply zenon_H1eb. zenon_intro zenon_H1ee. % 119.85/120.13 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.85/120.13 generalize (zenon_He4 (n3)). zenon_intro zenon_H1ef. % 119.85/120.13 generalize (zenon_H1ef (n1)). zenon_intro zenon_H1f0. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H1f0); [ zenon_intro zenon_H1e6 | zenon_intro zenon_H1f1 ]. % 119.85/120.13 exact (zenon_H1e6 zenon_H1ee). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H1f1); [ zenon_intro zenon_H1f2 | zenon_intro zenon_He8 ]. % 119.85/120.13 exact (zenon_H1f2 gt_3_1). % 119.85/120.13 exact (zenon_Hdd zenon_He8). % 119.85/120.13 apply zenon_H64. apply refl_equal. % 119.85/120.13 (* end of lemma zenon_L172_ *) % 119.85/120.13 assert (zenon_L173_ : forall (zenon_TG_dq : zenon_U), (gt (succ (n4)) zenon_TG_dq) -> (~(leq zenon_TG_dq (n4))) -> False). % 119.85/120.13 do 1 intro. intros zenon_H32e zenon_H32f. % 119.85/120.13 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.85/120.13 generalize (zenon_H330 (n4)). zenon_intro zenon_H331. % 119.85/120.13 apply (zenon_equiv_s _ _ zenon_H331); [ zenon_intro zenon_H32f; zenon_intro zenon_H333 | zenon_intro zenon_H332; zenon_intro zenon_H32e ]. % 119.85/120.13 exact (zenon_H333 zenon_H32e). % 119.85/120.13 exact (zenon_H32f zenon_H332). % 119.85/120.13 (* end of lemma zenon_L173_ *) % 119.85/120.13 assert (zenon_L174_ : forall (zenon_TG_dq : zenon_U), (gt (succ zenon_TG_dq) (n0)) -> (gt (succ (n4)) zenon_TG_dq) -> (~((n0) = zenon_TG_dq)) -> (~((n1) = zenon_TG_dq)) -> (~((n2) = zenon_TG_dq)) -> (~((n3) = zenon_TG_dq)) -> (~((n4) = zenon_TG_dq)) -> False). % 119.85/120.13 do 1 intro. intros zenon_H5c zenon_H32e zenon_H334 zenon_H335 zenon_H336 zenon_H337 zenon_H338. % 119.85/120.13 generalize (finite_domain_4 zenon_TG_dq). zenon_intro zenon_H339. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H339); [ zenon_intro zenon_H33b | zenon_intro zenon_H33a ]. % 119.85/120.13 apply (zenon_notand_s _ _ zenon_H33b); [ zenon_intro zenon_H5d | zenon_intro zenon_H32f ]. % 119.85/120.13 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.85/120.13 apply (zenon_L173_ zenon_TG_dq); trivial. % 119.85/120.13 apply (zenon_or_s _ _ zenon_H33a); [ zenon_intro zenon_H33d | zenon_intro zenon_H33c ]. % 119.85/120.13 apply zenon_H334. apply sym_equal. exact zenon_H33d. % 119.85/120.13 apply (zenon_or_s _ _ zenon_H33c); [ zenon_intro zenon_H33f | zenon_intro zenon_H33e ]. % 119.85/120.13 apply zenon_H335. apply sym_equal. exact zenon_H33f. % 119.85/120.13 apply (zenon_or_s _ _ zenon_H33e); [ zenon_intro zenon_H341 | zenon_intro zenon_H340 ]. % 119.85/120.13 apply zenon_H336. apply sym_equal. exact zenon_H341. % 119.85/120.13 apply (zenon_or_s _ _ zenon_H340); [ zenon_intro zenon_H343 | zenon_intro zenon_H342 ]. % 119.85/120.13 apply zenon_H337. apply sym_equal. exact zenon_H343. % 119.85/120.13 apply zenon_H338. apply sym_equal. exact zenon_H342. % 119.85/120.13 (* end of lemma zenon_L174_ *) % 119.85/120.13 assert (zenon_L175_ : forall (zenon_TG_dq : zenon_U), (~(gt (n4) zenon_TG_dq)) -> (gt (succ zenon_TG_dq) (n0)) -> (gt (succ (n4)) zenon_TG_dq) -> (~((n0) = zenon_TG_dq)) -> (~((n1) = zenon_TG_dq)) -> (~((n2) = zenon_TG_dq)) -> (~((n4) = zenon_TG_dq)) -> False). % 119.85/120.13 do 1 intro. intros zenon_H344 zenon_H5c zenon_H32e zenon_H334 zenon_H335 zenon_H336 zenon_H338. % 119.85/120.13 elim (classic ((n3) = zenon_TG_dq)); [ zenon_intro zenon_H345 | zenon_intro zenon_H337 ]. % 119.85/120.13 cut ((gt (n4) (n3)) = (gt (n4) zenon_TG_dq)). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H344. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact gt_4_3. % 119.85/120.13 cut (((n3) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H337]. % 119.85/120.13 cut (((n4) = (n4))); [idtac | apply NNPP; zenon_intro zenon_H294]. % 119.85/120.13 congruence. % 119.85/120.13 apply zenon_H294. apply refl_equal. % 119.85/120.13 exact (zenon_H337 zenon_H345). % 119.85/120.13 apply (zenon_L174_ zenon_TG_dq); trivial. % 119.85/120.13 (* end of lemma zenon_L175_ *) % 119.85/120.13 assert (zenon_L176_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((loopcounter) = (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(leq (n0) (n1))) -> False). % 119.85/120.13 do 0 intro. intros zenon_H66 zenon_H95 zenon_H155 zenon_H7d zenon_H67 zenon_H10b. % 119.85/120.13 generalize (leq_succ_gt_equiv (n0)). zenon_intro zenon_H5f. % 119.85/120.13 generalize (zenon_H5f (n1)). zenon_intro zenon_H10c. % 119.85/120.13 apply (zenon_equiv_s _ _ zenon_H10c); [ zenon_intro zenon_H10b; zenon_intro zenon_H10f | zenon_intro zenon_H10e; zenon_intro zenon_H10d ]. % 119.85/120.13 elim (classic ((~((succ (n1)) = (n3)))/\(~(gt (succ (n1)) (n3))))); [ zenon_intro zenon_H346 | zenon_intro zenon_H347 ]. % 119.85/120.13 apply (zenon_and_s _ _ zenon_H346). zenon_intro zenon_H349. zenon_intro zenon_H348. % 119.85/120.13 elim (classic ((~((succ (n1)) = (succ (loopcounter))))/\(~(gt (succ (n1)) (succ (loopcounter)))))); [ zenon_intro zenon_H114 | zenon_intro zenon_H115 ]. % 119.85/120.13 apply (zenon_and_s _ _ zenon_H114). zenon_intro zenon_H117. zenon_intro zenon_H116. % 119.85/120.13 apply (zenon_L138_); trivial. % 119.85/120.13 elim (classic (gt (n1) (n3))); [ zenon_intro zenon_H1ee | zenon_intro zenon_H1e6 ]. % 119.85/120.13 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.85/120.13 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.85/120.13 generalize (zenon_H78 (n3)). zenon_intro zenon_H20f. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H20f); [ zenon_intro zenon_H6f | zenon_intro zenon_H210 ]. % 119.85/120.13 exact (zenon_H6f zenon_H67). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H210); [ zenon_intro zenon_H1e6 | zenon_intro zenon_H211 ]. % 119.85/120.13 exact (zenon_H1e6 zenon_H1ee). % 119.85/120.13 cut ((gt (succ (loopcounter)) (n3)) = (gt (succ (n1)) (n3))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H348. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H211. % 119.85/120.13 cut (((n3) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H201]. % 119.85/120.13 cut (((succ (loopcounter)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H11f]. % 119.85/120.13 congruence. % 119.85/120.13 apply (zenon_notand_s _ _ zenon_H115); [ zenon_intro zenon_H121 | zenon_intro zenon_H120 ]. % 119.85/120.13 apply zenon_H121. zenon_intro zenon_H122. % 119.85/120.13 apply zenon_H11f. apply sym_equal. exact zenon_H122. % 119.85/120.13 apply zenon_H120. zenon_intro zenon_H11e. % 119.85/120.13 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.85/120.13 generalize (zenon_H11a (succ (loopcounter))). zenon_intro zenon_H123. % 119.85/120.13 generalize (zenon_H123 (n3)). zenon_intro zenon_H34a. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H34a); [ zenon_intro zenon_H116 | zenon_intro zenon_H34b ]. % 119.85/120.13 exact (zenon_H116 zenon_H11e). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H34b); [ zenon_intro zenon_H21a | zenon_intro zenon_H34c ]. % 119.85/120.13 exact (zenon_H21a zenon_H211). % 119.85/120.13 exact (zenon_H348 zenon_H34c). % 119.85/120.13 apply zenon_H201. apply refl_equal. % 119.85/120.13 apply (zenon_L171_); trivial. % 119.85/120.13 cut ((gt (n3) (n0)) = (gt (succ (n1)) (n0))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H10f. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact gt_3_0. % 119.85/120.13 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.85/120.13 cut (((n3) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H34d]. % 119.85/120.13 congruence. % 119.85/120.13 apply (zenon_notand_s _ _ zenon_H347); [ zenon_intro zenon_H34f | zenon_intro zenon_H34e ]. % 119.85/120.13 apply zenon_H34f. zenon_intro zenon_H350. % 119.85/120.13 elim (classic ((succ (n1)) = (succ (n1)))); [ zenon_intro zenon_H100 | zenon_intro zenon_H101 ]. % 119.85/120.13 cut (((succ (n1)) = (succ (n1))) = ((n3) = (succ (n1)))). % 119.85/120.13 intro zenon_D_pnotp. % 119.85/120.13 apply zenon_H34d. % 119.85/120.13 rewrite <- zenon_D_pnotp. % 119.85/120.13 exact zenon_H100. % 119.85/120.13 cut (((succ (n1)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H101]. % 119.85/120.13 cut (((succ (n1)) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H349]. % 119.85/120.13 congruence. % 119.85/120.13 exact (zenon_H349 zenon_H350). % 119.85/120.13 apply zenon_H101. apply refl_equal. % 119.85/120.13 apply zenon_H101. apply refl_equal. % 119.85/120.13 apply zenon_H34e. zenon_intro zenon_H34c. % 119.85/120.13 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.85/120.13 generalize (zenon_H11a (n3)). zenon_intro zenon_H351. % 119.85/120.13 generalize (zenon_H351 (n0)). zenon_intro zenon_H352. % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H352); [ zenon_intro zenon_H348 | zenon_intro zenon_H353 ]. % 119.85/120.13 exact (zenon_H348 zenon_H34c). % 119.85/120.13 apply (zenon_imply_s _ _ zenon_H353); [ zenon_intro zenon_H291 | zenon_intro zenon_H10d ]. % 119.85/120.13 exact (zenon_H291 gt_3_0). % 119.85/120.13 exact (zenon_H10f zenon_H10d). % 119.85/120.13 apply zenon_H65. apply refl_equal. % 119.85/120.13 exact (zenon_H10b zenon_H10e). % 119.85/120.13 (* end of lemma zenon_L176_ *) % 119.85/120.13 assert (zenon_L177_ : forall (zenon_TG_dq : zenon_U), (~((succ zenon_TG_dq) = (succ (n4)))) -> (zenon_TG_dq = (n4)) -> False). % 119.85/120.13 do 1 intro. intros zenon_H354 zenon_H342. % 119.85/120.13 cut ((zenon_TG_dq = (n4))); [idtac | apply NNPP; zenon_intro zenon_H355]. % 119.85/120.13 congruence. % 119.85/120.13 exact (zenon_H355 zenon_H342). % 119.85/120.13 (* end of lemma zenon_L177_ *) % 119.85/120.13 assert (zenon_L178_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ zenon_TG_dq) (n4))) -> (gt (succ (n4)) zenon_TG_dq) -> (zenon_TG_dq = (n4)) -> False). % 119.85/120.14 do 1 intro. intros zenon_H66 zenon_H356 zenon_H32e zenon_H342. % 119.85/120.14 elim (classic ((~((succ zenon_TG_dq) = (succ (n4))))/\(~(gt (succ zenon_TG_dq) (succ (n4)))))); [ zenon_intro zenon_H357 | zenon_intro zenon_H358 ]. % 119.85/120.14 apply (zenon_and_s _ _ zenon_H357). zenon_intro zenon_H354. zenon_intro zenon_H359. % 119.85/120.14 apply (zenon_L177_ zenon_TG_dq); trivial. % 119.85/120.14 cut ((gt (succ (n4)) zenon_TG_dq) = (gt (succ zenon_TG_dq) (n4))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H356. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H32e. % 119.85/120.14 cut ((zenon_TG_dq = (n4))); [idtac | apply NNPP; zenon_intro zenon_H355]. % 119.85/120.14 cut (((succ (n4)) = (succ zenon_TG_dq))); [idtac | apply NNPP; zenon_intro zenon_H35a]. % 119.85/120.14 congruence. % 119.85/120.14 apply (zenon_notand_s _ _ zenon_H358); [ zenon_intro zenon_H35c | zenon_intro zenon_H35b ]. % 119.85/120.14 apply zenon_H35c. zenon_intro zenon_H35d. % 119.85/120.14 elim (classic ((succ zenon_TG_dq) = (succ zenon_TG_dq))); [ zenon_intro zenon_H35e | zenon_intro zenon_H35f ]. % 119.85/120.14 cut (((succ zenon_TG_dq) = (succ zenon_TG_dq)) = ((succ (n4)) = (succ zenon_TG_dq))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H35a. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H35e. % 119.85/120.14 cut (((succ zenon_TG_dq) = (succ zenon_TG_dq))); [idtac | apply NNPP; zenon_intro zenon_H35f]. % 119.85/120.14 cut (((succ zenon_TG_dq) = (succ (n4)))); [idtac | apply NNPP; zenon_intro zenon_H354]. % 119.85/120.14 congruence. % 119.85/120.14 exact (zenon_H354 zenon_H35d). % 119.85/120.14 apply zenon_H35f. apply refl_equal. % 119.85/120.14 apply zenon_H35f. apply refl_equal. % 119.85/120.14 apply zenon_H35b. zenon_intro zenon_H360. % 119.85/120.14 generalize (zenon_H66 (succ zenon_TG_dq)). zenon_intro zenon_H361. % 119.85/120.14 generalize (zenon_H361 (succ (n4))). zenon_intro zenon_H362. % 119.85/120.14 generalize (zenon_H362 zenon_TG_dq). zenon_intro zenon_H363. % 119.85/120.14 apply (zenon_imply_s _ _ zenon_H363); [ zenon_intro zenon_H359 | zenon_intro zenon_H364 ]. % 119.85/120.14 exact (zenon_H359 zenon_H360). % 119.85/120.14 apply (zenon_imply_s _ _ zenon_H364); [ zenon_intro zenon_H333 | zenon_intro zenon_H365 ]. % 119.85/120.14 exact (zenon_H333 zenon_H32e). % 119.85/120.14 cut ((gt (succ zenon_TG_dq) zenon_TG_dq) = (gt (succ zenon_TG_dq) (n4))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H356. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H365. % 119.85/120.14 cut ((zenon_TG_dq = (n4))); [idtac | apply NNPP; zenon_intro zenon_H355]. % 119.85/120.14 cut (((succ zenon_TG_dq) = (succ zenon_TG_dq))); [idtac | apply NNPP; zenon_intro zenon_H35f]. % 119.85/120.14 congruence. % 119.85/120.14 apply zenon_H35f. apply refl_equal. % 119.85/120.14 exact (zenon_H355 zenon_H342). % 119.85/120.14 exact (zenon_H355 zenon_H342). % 119.85/120.14 (* end of lemma zenon_L178_ *) % 119.85/120.14 assert (zenon_L179_ : forall (zenon_TG_dq : zenon_U), (zenon_TG_dq = (n4)) -> (gt (succ (n4)) zenon_TG_dq) -> (~(gt (succ zenon_TG_dq) (succ (succ (succ (succ (n0))))))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.14 do 1 intro. intros zenon_H342 zenon_H32e zenon_H366 zenon_H66. % 119.85/120.14 elim (classic ((n4) = (succ (succ (succ (succ (n0))))))); [ zenon_intro zenon_H367 | zenon_intro zenon_Ha0 ]. % 119.85/120.14 elim (classic (gt (succ zenon_TG_dq) (n4))); [ zenon_intro zenon_H368 | zenon_intro zenon_H356 ]. % 119.85/120.14 cut ((gt (succ zenon_TG_dq) (n4)) = (gt (succ zenon_TG_dq) (succ (succ (succ (succ (n0))))))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H366. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H368. % 119.85/120.14 cut (((n4) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_Ha0]. % 119.85/120.14 cut (((succ zenon_TG_dq) = (succ zenon_TG_dq))); [idtac | apply NNPP; zenon_intro zenon_H35f]. % 119.85/120.14 congruence. % 119.85/120.14 apply zenon_H35f. apply refl_equal. % 119.85/120.14 exact (zenon_Ha0 zenon_H367). % 119.85/120.14 apply (zenon_L178_ zenon_TG_dq); trivial. % 119.85/120.14 elim (classic ((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0))))))); [ zenon_intro zenon_Ha1 | zenon_intro zenon_Ha2 ]. % 119.85/120.14 cut (((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0)))))) = ((n4) = (succ (succ (succ (succ (n0))))))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_Ha0. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_Ha1. % 119.85/120.14 cut (((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_Ha2]. % 119.85/120.14 cut (((succ (succ (succ (succ (n0))))) = (n4))); [idtac | apply NNPP; zenon_intro zenon_Ha3]. % 119.85/120.14 congruence. % 119.85/120.14 exact (zenon_Ha3 successor_4). % 119.85/120.14 apply zenon_Ha2. apply refl_equal. % 119.85/120.14 apply zenon_Ha2. apply refl_equal. % 119.85/120.14 (* end of lemma zenon_L179_ *) % 119.85/120.14 assert (zenon_L180_ : forall (zenon_TG_dq : zenon_U), (gt (succ (n4)) zenon_TG_dq) -> (zenon_TG_dq = (n4)) -> (~(gt (succ zenon_TG_dq) (plus (n4) (n0)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((plus (n4) (n0)) = (succ (succ (succ (succ (n0)))))) -> False). % 119.85/120.14 do 1 intro. intros zenon_H32e zenon_H342 zenon_H369 zenon_H66 zenon_H36a. % 119.85/120.14 elim (classic ((succ (succ (succ (succ (n0))))) = (plus (n4) (n0)))); [ zenon_intro zenon_H36b | zenon_intro zenon_H36c ]. % 119.85/120.14 elim (classic (gt (succ zenon_TG_dq) (succ (succ (succ (succ (n0))))))); [ zenon_intro zenon_H36d | zenon_intro zenon_H366 ]. % 119.85/120.14 cut ((gt (succ zenon_TG_dq) (succ (succ (succ (succ (n0)))))) = (gt (succ zenon_TG_dq) (plus (n4) (n0)))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H369. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H36d. % 119.85/120.14 cut (((succ (succ (succ (succ (n0))))) = (plus (n4) (n0)))); [idtac | apply NNPP; zenon_intro zenon_H36c]. % 119.85/120.14 cut (((succ zenon_TG_dq) = (succ zenon_TG_dq))); [idtac | apply NNPP; zenon_intro zenon_H35f]. % 119.85/120.14 congruence. % 119.85/120.14 apply zenon_H35f. apply refl_equal. % 119.85/120.14 exact (zenon_H36c zenon_H36b). % 119.85/120.14 apply (zenon_L179_ zenon_TG_dq); trivial. % 119.85/120.14 elim (classic ((plus (n4) (n0)) = (plus (n4) (n0)))); [ zenon_intro zenon_H36e | zenon_intro zenon_H36f ]. % 119.85/120.14 cut (((plus (n4) (n0)) = (plus (n4) (n0))) = ((succ (succ (succ (succ (n0))))) = (plus (n4) (n0)))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H36c. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H36e. % 119.85/120.14 cut (((plus (n4) (n0)) = (plus (n4) (n0)))); [idtac | apply NNPP; zenon_intro zenon_H36f]. % 119.85/120.14 cut (((plus (n4) (n0)) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_H370]. % 119.85/120.14 congruence. % 119.85/120.14 exact (zenon_H370 zenon_H36a). % 119.85/120.14 apply zenon_H36f. apply refl_equal. % 119.85/120.14 apply zenon_H36f. apply refl_equal. % 119.85/120.14 (* end of lemma zenon_L180_ *) % 119.85/120.14 assert (zenon_L181_ : forall (zenon_TG_dq : zenon_U), ((plus zenon_TG_dq (n1)) = (succ zenon_TG_dq)) -> (gt (succ (n4)) zenon_TG_dq) -> ((plus (n4) (n0)) = (succ (succ (succ (succ (n0)))))) -> (zenon_TG_dq = (n4)) -> ((n1) = (n0)) -> (~(gt (n4) (plus (n4) (n0)))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.14 do 1 intro. intros zenon_H371 zenon_H32e zenon_H36a zenon_H342 zenon_H108 zenon_H372 zenon_H66. % 119.85/120.14 elim (classic ((n4) = (succ (succ (succ (succ (n0))))))); [ zenon_intro zenon_H367 | zenon_intro zenon_Ha0 ]. % 119.85/120.14 elim (classic (gt (succ (succ (succ (succ (n0))))) (plus (n4) (n0)))); [ zenon_intro zenon_H373 | zenon_intro zenon_H374 ]. % 119.85/120.14 cut ((gt (succ (succ (succ (succ (n0))))) (plus (n4) (n0))) = (gt (n4) (plus (n4) (n0)))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H372. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H373. % 119.85/120.14 cut (((plus (n4) (n0)) = (plus (n4) (n0)))); [idtac | apply NNPP; zenon_intro zenon_H36f]. % 119.85/120.14 cut (((succ (succ (succ (succ (n0))))) = (n4))); [idtac | apply NNPP; zenon_intro zenon_Ha3]. % 119.85/120.14 congruence. % 119.85/120.14 elim (classic ((n4) = (n4))); [ zenon_intro zenon_H375 | zenon_intro zenon_H294 ]. % 119.85/120.14 cut (((n4) = (n4)) = ((succ (succ (succ (succ (n0))))) = (n4))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_Ha3. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H375. % 119.85/120.14 cut (((n4) = (n4))); [idtac | apply NNPP; zenon_intro zenon_H294]. % 119.85/120.14 cut (((n4) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_Ha0]. % 119.85/120.14 congruence. % 119.85/120.14 exact (zenon_Ha0 zenon_H367). % 119.85/120.14 apply zenon_H294. apply refl_equal. % 119.85/120.14 apply zenon_H294. apply refl_equal. % 119.85/120.14 apply zenon_H36f. apply refl_equal. % 119.85/120.14 elim (classic ((succ (succ (succ (succ (n0))))) = (plus (n4) (n0)))); [ zenon_intro zenon_H36b | zenon_intro zenon_H36c ]. % 119.85/120.14 elim (classic (gt (plus (n4) (n0)) (plus (n4) (n0)))); [ zenon_intro zenon_H376 | zenon_intro zenon_H377 ]. % 119.85/120.14 cut ((gt (plus (n4) (n0)) (plus (n4) (n0))) = (gt (succ (succ (succ (succ (n0))))) (plus (n4) (n0)))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H374. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H376. % 119.85/120.14 cut (((plus (n4) (n0)) = (plus (n4) (n0)))); [idtac | apply NNPP; zenon_intro zenon_H36f]. % 119.85/120.14 cut (((plus (n4) (n0)) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_H370]. % 119.85/120.14 congruence. % 119.85/120.14 elim (classic ((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0))))))); [ zenon_intro zenon_Ha1 | zenon_intro zenon_Ha2 ]. % 119.85/120.14 cut (((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0)))))) = ((plus (n4) (n0)) = (succ (succ (succ (succ (n0))))))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H370. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_Ha1. % 119.85/120.14 cut (((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_Ha2]. % 119.85/120.14 cut (((succ (succ (succ (succ (n0))))) = (plus (n4) (n0)))); [idtac | apply NNPP; zenon_intro zenon_H36c]. % 119.85/120.14 congruence. % 119.85/120.14 exact (zenon_H36c zenon_H36b). % 119.85/120.14 apply zenon_Ha2. apply refl_equal. % 119.85/120.14 apply zenon_Ha2. apply refl_equal. % 119.85/120.14 apply zenon_H36f. apply refl_equal. % 119.85/120.14 elim (classic (gt (succ zenon_TG_dq) (plus (n4) (n0)))); [ zenon_intro zenon_H378 | zenon_intro zenon_H369 ]. % 119.85/120.14 elim (classic (gt (plus zenon_TG_dq (n1)) (plus (n4) (n0)))); [ zenon_intro zenon_H379 | zenon_intro zenon_H37a ]. % 119.85/120.14 cut ((gt (plus zenon_TG_dq (n1)) (plus (n4) (n0))) = (gt (plus (n4) (n0)) (plus (n4) (n0)))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H377. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H379. % 119.85/120.14 cut (((plus (n4) (n0)) = (plus (n4) (n0)))); [idtac | apply NNPP; zenon_intro zenon_H36f]. % 119.85/120.14 cut (((plus zenon_TG_dq (n1)) = (plus (n4) (n0)))); [idtac | apply NNPP; zenon_intro zenon_H37b]. % 119.85/120.14 congruence. % 119.85/120.14 elim (classic ((plus (n4) (n0)) = (plus (n4) (n0)))); [ zenon_intro zenon_H36e | zenon_intro zenon_H36f ]. % 119.85/120.14 cut (((plus (n4) (n0)) = (plus (n4) (n0))) = ((plus zenon_TG_dq (n1)) = (plus (n4) (n0)))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H37b. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H36e. % 119.85/120.14 cut (((plus (n4) (n0)) = (plus (n4) (n0)))); [idtac | apply NNPP; zenon_intro zenon_H36f]. % 119.85/120.14 cut (((plus (n4) (n0)) = (plus zenon_TG_dq (n1)))); [idtac | apply NNPP; zenon_intro zenon_H37c]. % 119.85/120.14 congruence. % 119.85/120.14 cut (((n0) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H106]. % 119.85/120.14 cut (((n4) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H338]. % 119.85/120.14 congruence. % 119.85/120.14 apply zenon_H338. apply sym_equal. exact zenon_H342. % 119.85/120.14 apply zenon_H106. apply sym_equal. exact zenon_H108. % 119.85/120.14 apply zenon_H36f. apply refl_equal. % 119.85/120.14 apply zenon_H36f. apply refl_equal. % 119.85/120.14 apply zenon_H36f. apply refl_equal. % 119.85/120.14 cut ((gt (succ zenon_TG_dq) (plus (n4) (n0))) = (gt (plus zenon_TG_dq (n1)) (plus (n4) (n0)))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H37a. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H378. % 119.85/120.14 cut (((plus (n4) (n0)) = (plus (n4) (n0)))); [idtac | apply NNPP; zenon_intro zenon_H36f]. % 119.85/120.14 cut (((succ zenon_TG_dq) = (plus zenon_TG_dq (n1)))); [idtac | apply NNPP; zenon_intro zenon_H37d]. % 119.85/120.14 congruence. % 119.85/120.14 elim (classic ((plus zenon_TG_dq (n1)) = (plus zenon_TG_dq (n1)))); [ zenon_intro zenon_H37e | zenon_intro zenon_H37f ]. % 119.85/120.14 cut (((plus zenon_TG_dq (n1)) = (plus zenon_TG_dq (n1))) = ((succ zenon_TG_dq) = (plus zenon_TG_dq (n1)))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H37d. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H37e. % 119.85/120.14 cut (((plus zenon_TG_dq (n1)) = (plus zenon_TG_dq (n1)))); [idtac | apply NNPP; zenon_intro zenon_H37f]. % 119.85/120.14 cut (((plus zenon_TG_dq (n1)) = (succ zenon_TG_dq))); [idtac | apply NNPP; zenon_intro zenon_H380]. % 119.85/120.14 congruence. % 119.85/120.14 exact (zenon_H380 zenon_H371). % 119.85/120.14 apply zenon_H37f. apply refl_equal. % 119.85/120.14 apply zenon_H37f. apply refl_equal. % 119.85/120.14 apply zenon_H36f. apply refl_equal. % 119.85/120.14 apply (zenon_L180_ zenon_TG_dq); trivial. % 119.85/120.14 elim (classic ((plus (n4) (n0)) = (plus (n4) (n0)))); [ zenon_intro zenon_H36e | zenon_intro zenon_H36f ]. % 119.85/120.14 cut (((plus (n4) (n0)) = (plus (n4) (n0))) = ((succ (succ (succ (succ (n0))))) = (plus (n4) (n0)))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H36c. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H36e. % 119.85/120.14 cut (((plus (n4) (n0)) = (plus (n4) (n0)))); [idtac | apply NNPP; zenon_intro zenon_H36f]. % 119.85/120.14 cut (((plus (n4) (n0)) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_H370]. % 119.85/120.14 congruence. % 119.85/120.14 exact (zenon_H370 zenon_H36a). % 119.85/120.14 apply zenon_H36f. apply refl_equal. % 119.85/120.14 apply zenon_H36f. apply refl_equal. % 119.85/120.14 elim (classic ((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0))))))); [ zenon_intro zenon_Ha1 | zenon_intro zenon_Ha2 ]. % 119.85/120.14 cut (((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0)))))) = ((n4) = (succ (succ (succ (succ (n0))))))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_Ha0. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_Ha1. % 119.85/120.14 cut (((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_Ha2]. % 119.85/120.14 cut (((succ (succ (succ (succ (n0))))) = (n4))); [idtac | apply NNPP; zenon_intro zenon_Ha3]. % 119.85/120.14 congruence. % 119.85/120.14 exact (zenon_Ha3 successor_4). % 119.85/120.14 apply zenon_Ha2. apply refl_equal. % 119.85/120.14 apply zenon_Ha2. apply refl_equal. % 119.85/120.14 (* end of lemma zenon_L181_ *) % 119.85/120.14 assert (zenon_L182_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n3)) (plus (n4) (n0)))) -> ((plus zenon_TG_dq (n1)) = (succ zenon_TG_dq)) -> (gt (succ (n4)) zenon_TG_dq) -> ((plus (n4) (n0)) = (succ (succ (succ (succ (n0)))))) -> (zenon_TG_dq = (n4)) -> ((n1) = (n0)) -> False). % 119.85/120.14 do 1 intro. intros zenon_H66 zenon_H381 zenon_H371 zenon_H32e zenon_H36a zenon_H342 zenon_H108. % 119.85/120.14 elim (classic (gt (n4) (plus (n4) (n0)))); [ zenon_intro zenon_H382 | zenon_intro zenon_H372 ]. % 119.85/120.14 elim (classic (gt (succ (succ (succ (succ (n0))))) (plus (n4) (n0)))); [ zenon_intro zenon_H373 | zenon_intro zenon_H374 ]. % 119.85/120.14 cut ((gt (succ (succ (succ (succ (n0))))) (plus (n4) (n0))) = (gt (succ (n3)) (plus (n4) (n0)))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H381. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H373. % 119.85/120.14 cut (((plus (n4) (n0)) = (plus (n4) (n0)))); [idtac | apply NNPP; zenon_intro zenon_H36f]. % 119.85/120.14 cut (((succ (succ (succ (succ (n0))))) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H9d]. % 119.85/120.14 congruence. % 119.85/120.14 elim (classic ((succ (n3)) = (succ (n3)))); [ zenon_intro zenon_H9e | zenon_intro zenon_H9f ]. % 119.85/120.14 cut (((succ (n3)) = (succ (n3))) = ((succ (succ (succ (succ (n0))))) = (succ (n3)))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H9d. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H9e. % 119.85/120.14 cut (((succ (n3)) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H9f]. % 119.85/120.14 cut (((succ (n3)) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_H98]. % 119.85/120.14 congruence. % 119.85/120.14 apply (zenon_L10_); trivial. % 119.85/120.14 apply zenon_H9f. apply refl_equal. % 119.85/120.14 apply zenon_H9f. apply refl_equal. % 119.85/120.14 apply zenon_H36f. apply refl_equal. % 119.85/120.14 cut ((gt (n4) (plus (n4) (n0))) = (gt (succ (succ (succ (succ (n0))))) (plus (n4) (n0)))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H374. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H382. % 119.85/120.14 cut (((plus (n4) (n0)) = (plus (n4) (n0)))); [idtac | apply NNPP; zenon_intro zenon_H36f]. % 119.85/120.14 cut (((n4) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_Ha0]. % 119.85/120.14 congruence. % 119.85/120.14 elim (classic ((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0))))))); [ zenon_intro zenon_Ha1 | zenon_intro zenon_Ha2 ]. % 119.85/120.14 cut (((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0)))))) = ((n4) = (succ (succ (succ (succ (n0))))))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_Ha0. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_Ha1. % 119.85/120.14 cut (((succ (succ (succ (succ (n0))))) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_Ha2]. % 119.85/120.14 cut (((succ (succ (succ (succ (n0))))) = (n4))); [idtac | apply NNPP; zenon_intro zenon_Ha3]. % 119.85/120.14 congruence. % 119.85/120.14 exact (zenon_Ha3 successor_4). % 119.85/120.14 apply zenon_Ha2. apply refl_equal. % 119.85/120.14 apply zenon_Ha2. apply refl_equal. % 119.85/120.14 apply zenon_H36f. apply refl_equal. % 119.85/120.14 apply (zenon_L181_ zenon_TG_dq); trivial. % 119.85/120.14 (* end of lemma zenon_L182_ *) % 119.85/120.14 assert (zenon_L183_ : forall (zenon_TG_dq : zenon_U), (((leq (n0) (n1))/\(leq (n1) (n0)))->((n1) = (n0))) -> (gt (succ (loopcounter)) (n1)) -> ((loopcounter) = (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n3)) (succ (succ (succ (succ (n0))))))) -> (gt (succ (n4)) zenon_TG_dq) -> (zenon_TG_dq = (n4)) -> False). % 119.85/120.14 do 1 intro. intros zenon_H107 zenon_H67 zenon_H95 zenon_H155 zenon_H7d zenon_H66 zenon_H383 zenon_H32e zenon_H342. % 119.85/120.14 apply (zenon_imply_s _ _ zenon_H107); [ zenon_intro zenon_H109 | zenon_intro zenon_H108 ]. % 119.85/120.14 apply (zenon_notand_s _ _ zenon_H109); [ zenon_intro zenon_H10b | zenon_intro zenon_H10a ]. % 119.85/120.14 apply (zenon_L176_); trivial. % 119.85/120.14 apply (zenon_L149_); trivial. % 119.85/120.14 generalize (succ_plus_1_r zenon_TG_dq). zenon_intro zenon_H371. % 119.85/120.14 generalize (succ_plus_4_l (n0)). zenon_intro zenon_H36a. % 119.85/120.14 elim (classic (gt (succ (n3)) (plus (n4) (n0)))); [ zenon_intro zenon_H384 | zenon_intro zenon_H381 ]. % 119.85/120.14 cut ((gt (succ (n3)) (plus (n4) (n0))) = (gt (succ (n3)) (succ (succ (succ (succ (n0))))))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H383. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H384. % 119.85/120.14 cut (((plus (n4) (n0)) = (succ (succ (succ (succ (n0))))))); [idtac | apply NNPP; zenon_intro zenon_H370]. % 119.85/120.14 cut (((succ (n3)) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H9f]. % 119.85/120.14 congruence. % 119.85/120.14 apply zenon_H9f. apply refl_equal. % 119.85/120.14 exact (zenon_H370 zenon_H36a). % 119.85/120.14 apply (zenon_L182_ zenon_TG_dq); trivial. % 119.85/120.14 (* end of lemma zenon_L183_ *) % 119.85/120.14 assert (zenon_L184_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.14 do 0 intro. intros zenon_H66 zenon_Hdb zenon_H155 zenon_H7d zenon_H67. % 119.85/120.14 elim (classic (gt (n0) (succ (loopcounter)))); [ zenon_intro zenon_H146 | zenon_intro zenon_H140 ]. % 119.85/120.14 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.85/120.14 generalize (zenon_He4 (n0)). zenon_intro zenon_H385. % 119.85/120.14 generalize (zenon_H385 (succ (loopcounter))). zenon_intro zenon_H386. % 119.85/120.14 apply (zenon_imply_s _ _ zenon_H386); [ zenon_intro zenon_H7b | zenon_intro zenon_H387 ]. % 119.85/120.14 exact (zenon_H7b gt_1_0). % 119.85/120.14 apply (zenon_imply_s _ _ zenon_H387); [ zenon_intro zenon_H140 | zenon_intro zenon_He3 ]. % 119.85/120.14 exact (zenon_H140 zenon_H146). % 119.85/120.14 exact (zenon_Hdb zenon_He3). % 119.85/120.14 apply (zenon_L83_); trivial. % 119.85/120.14 (* end of lemma zenon_L184_ *) % 119.85/120.14 assert (zenon_L185_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n0)) (succ (loopcounter)))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.85/120.14 do 0 intro. intros zenon_H66 zenon_Hd0 zenon_H67 zenon_H7d zenon_H155. % 119.85/120.14 elim (classic ((~((succ (n0)) = (succ (loopcounter))))/\(~(gt (succ (n0)) (succ (loopcounter)))))); [ zenon_intro zenon_Hce | zenon_intro zenon_Hcf ]. % 119.85/120.14 apply (zenon_and_s _ _ zenon_Hce). zenon_intro zenon_H97. zenon_intro zenon_Hd0. % 119.85/120.14 apply (zenon_L9_); trivial. % 119.85/120.14 elim (classic (gt (n1) (succ (loopcounter)))); [ zenon_intro zenon_He3 | zenon_intro zenon_Hdb ]. % 119.85/120.14 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.85/120.14 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.85/120.14 generalize (zenon_H78 (succ (loopcounter))). zenon_intro zenon_Hf6. % 119.85/120.14 apply (zenon_imply_s _ _ zenon_Hf6); [ zenon_intro zenon_H6f | zenon_intro zenon_Hf7 ]. % 119.85/120.14 exact (zenon_H6f zenon_H67). % 119.85/120.14 apply (zenon_imply_s _ _ zenon_Hf7); [ zenon_intro zenon_Hdb | zenon_intro zenon_Hf8 ]. % 119.85/120.14 exact (zenon_Hdb zenon_He3). % 119.85/120.14 cut ((gt (succ (loopcounter)) (succ (loopcounter))) = (gt (succ (n0)) (succ (loopcounter)))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_Hd0. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_Hf8. % 119.85/120.14 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.85/120.14 cut (((succ (loopcounter)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_Hd2]. % 119.85/120.14 congruence. % 119.85/120.14 apply (zenon_notand_s _ _ zenon_Hcf); [ zenon_intro zenon_Hd4 | zenon_intro zenon_Hd3 ]. % 119.85/120.14 apply zenon_Hd4. zenon_intro zenon_Hd5. % 119.85/120.14 apply zenon_Hd2. apply sym_equal. exact zenon_Hd5. % 119.85/120.14 exact (zenon_Hd3 zenon_Hd0). % 119.85/120.14 apply zenon_H76. apply refl_equal. % 119.85/120.14 apply (zenon_L184_); trivial. % 119.85/120.14 (* end of lemma zenon_L185_ *) % 119.85/120.14 assert (zenon_L186_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n0)) (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.14 do 0 intro. intros zenon_H66 zenon_H249 zenon_H155 zenon_H7d zenon_H67. % 119.85/120.14 elim (classic ((~((succ (n0)) = (succ (loopcounter))))/\(~(gt (succ (n0)) (succ (loopcounter)))))); [ zenon_intro zenon_Hce | zenon_intro zenon_Hcf ]. % 119.85/120.14 apply (zenon_and_s _ _ zenon_Hce). zenon_intro zenon_H97. zenon_intro zenon_Hd0. % 119.85/120.14 apply (zenon_L185_); trivial. % 119.85/120.14 elim (classic (gt (n1) (n3))); [ zenon_intro zenon_H1ee | zenon_intro zenon_H1e6 ]. % 119.85/120.14 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.85/120.14 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.85/120.14 generalize (zenon_H78 (n3)). zenon_intro zenon_H20f. % 119.85/120.14 apply (zenon_imply_s _ _ zenon_H20f); [ zenon_intro zenon_H6f | zenon_intro zenon_H210 ]. % 119.85/120.14 exact (zenon_H6f zenon_H67). % 119.85/120.14 apply (zenon_imply_s _ _ zenon_H210); [ zenon_intro zenon_H1e6 | zenon_intro zenon_H211 ]. % 119.85/120.14 exact (zenon_H1e6 zenon_H1ee). % 119.85/120.14 cut ((gt (succ (loopcounter)) (n3)) = (gt (succ (n0)) (n3))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H249. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H211. % 119.85/120.14 cut (((n3) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H201]. % 119.85/120.14 cut (((succ (loopcounter)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_Hd2]. % 119.85/120.14 congruence. % 119.85/120.14 apply (zenon_notand_s _ _ zenon_Hcf); [ zenon_intro zenon_Hd4 | zenon_intro zenon_Hd3 ]. % 119.85/120.14 apply zenon_Hd4. zenon_intro zenon_Hd5. % 119.85/120.14 apply zenon_Hd2. apply sym_equal. exact zenon_Hd5. % 119.85/120.14 apply zenon_Hd3. zenon_intro zenon_Hd6. % 119.85/120.14 generalize (zenon_H66 (succ (n0))). zenon_intro zenon_H8e. % 119.85/120.14 generalize (zenon_H8e (succ (loopcounter))). zenon_intro zenon_Hd7. % 119.85/120.14 generalize (zenon_Hd7 (n3)). zenon_intro zenon_H388. % 119.85/120.14 apply (zenon_imply_s _ _ zenon_H388); [ zenon_intro zenon_Hd0 | zenon_intro zenon_H389 ]. % 119.85/120.14 exact (zenon_Hd0 zenon_Hd6). % 119.85/120.14 apply (zenon_imply_s _ _ zenon_H389); [ zenon_intro zenon_H21a | zenon_intro zenon_H248 ]. % 119.85/120.14 exact (zenon_H21a zenon_H211). % 119.85/120.14 exact (zenon_H249 zenon_H248). % 119.85/120.14 apply zenon_H201. apply refl_equal. % 119.85/120.14 apply (zenon_L171_); trivial. % 119.85/120.14 (* end of lemma zenon_L186_ *) % 119.85/120.14 assert (zenon_L187_ : ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> (~(gt (succ (n0)) (succ (succ (succ (n0)))))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.14 do 0 intro. intros zenon_H155 zenon_H67 zenon_H7d zenon_H240 zenon_H66. % 119.85/120.14 elim (classic ((n3) = (succ (succ (succ (n0)))))); [ zenon_intro zenon_H21c | zenon_intro zenon_H99 ]. % 119.85/120.14 elim (classic (gt (succ (n0)) (n3))); [ zenon_intro zenon_H248 | zenon_intro zenon_H249 ]. % 119.85/120.14 cut ((gt (succ (n0)) (n3)) = (gt (succ (n0)) (succ (succ (succ (n0)))))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H240. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H248. % 119.85/120.14 cut (((n3) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H99]. % 119.85/120.14 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.85/120.14 congruence. % 119.85/120.14 apply zenon_H8c. apply refl_equal. % 119.85/120.14 exact (zenon_H99 zenon_H21c). % 119.85/120.14 apply (zenon_L186_); trivial. % 119.85/120.14 elim (classic ((succ (succ (succ (n0)))) = (succ (succ (succ (n0)))))); [ zenon_intro zenon_H21d | zenon_intro zenon_H21e ]. % 119.85/120.14 cut (((succ (succ (succ (n0)))) = (succ (succ (succ (n0))))) = ((n3) = (succ (succ (succ (n0)))))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H99. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H21d. % 119.85/120.14 cut (((succ (succ (succ (n0)))) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H21e]. % 119.85/120.14 cut (((succ (succ (succ (n0)))) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H21f]. % 119.85/120.14 congruence. % 119.85/120.14 exact (zenon_H21f successor_3). % 119.85/120.14 apply zenon_H21e. apply refl_equal. % 119.85/120.14 apply zenon_H21e. apply refl_equal. % 119.85/120.14 (* end of lemma zenon_L187_ *) % 119.85/120.14 assert (zenon_L188_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (succ (n0))) (n1))) -> False). % 119.85/120.14 do 0 intro. intros zenon_H66 zenon_H205. % 119.85/120.14 elim (classic ((~((succ (succ (n0))) = (n2)))/\(~(gt (succ (succ (n0))) (n2))))); [ zenon_intro zenon_H38a | zenon_intro zenon_H38b ]. % 119.85/120.14 apply (zenon_and_s _ _ zenon_H38a). zenon_intro zenon_H105. zenon_intro zenon_H38c. % 119.85/120.14 exact (zenon_H105 successor_2). % 119.85/120.14 cut ((gt (n2) (n1)) = (gt (succ (succ (n0))) (n1))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H205. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact gt_2_1. % 119.85/120.14 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.85/120.14 cut (((n2) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 119.85/120.14 congruence. % 119.85/120.14 apply (zenon_notand_s _ _ zenon_H38b); [ zenon_intro zenon_H38e | zenon_intro zenon_H38d ]. % 119.85/120.14 apply zenon_H38e. zenon_intro successor_2. % 119.85/120.14 elim (classic ((succ (succ (n0))) = (succ (succ (n0))))); [ zenon_intro zenon_H103 | zenon_intro zenon_H104 ]. % 119.85/120.14 cut (((succ (succ (n0))) = (succ (succ (n0)))) = ((n2) = (succ (succ (n0))))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H102. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H103. % 119.85/120.14 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.85/120.14 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.85/120.14 congruence. % 119.85/120.14 exact (zenon_H105 successor_2). % 119.85/120.14 apply zenon_H104. apply refl_equal. % 119.85/120.14 apply zenon_H104. apply refl_equal. % 119.85/120.14 apply zenon_H38d. zenon_intro zenon_H38f. % 119.85/120.14 generalize (zenon_H66 (succ (succ (n0)))). zenon_intro zenon_H206. % 119.85/120.14 generalize (zenon_H206 (n2)). zenon_intro zenon_H390. % 119.85/120.14 generalize (zenon_H390 (n1)). zenon_intro zenon_H391. % 119.85/120.14 apply (zenon_imply_s _ _ zenon_H391); [ zenon_intro zenon_H38c | zenon_intro zenon_H392 ]. % 119.85/120.14 exact (zenon_H38c zenon_H38f). % 119.85/120.14 apply (zenon_imply_s _ _ zenon_H392); [ zenon_intro zenon_Hba | zenon_intro zenon_H204 ]. % 119.85/120.14 exact (zenon_Hba gt_2_1). % 119.85/120.14 exact (zenon_H205 zenon_H204). % 119.85/120.14 apply zenon_H64. apply refl_equal. % 119.85/120.14 (* end of lemma zenon_L188_ *) % 119.85/120.14 assert (zenon_L189_ : (~(gt (succ (succ (n0))) (succ (succ (succ (n0)))))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.85/120.14 do 0 intro. intros zenon_H21b zenon_H7d zenon_H67 zenon_H155 zenon_H66. % 119.85/120.14 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.85/120.14 elim (classic (gt (succ (succ (n0))) (n1))); [ zenon_intro zenon_H204 | zenon_intro zenon_H205 ]. % 119.85/120.14 elim (classic (gt (succ (succ (n0))) (succ (n0)))); [ zenon_intro zenon_Hfd | zenon_intro zenon_Hfe ]. % 119.85/120.14 elim (classic (gt (succ (n0)) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H246 | zenon_intro zenon_H240 ]. % 119.85/120.14 generalize (zenon_H66 (succ (succ (n0)))). zenon_intro zenon_H206. % 119.85/120.14 generalize (zenon_H206 (succ (n0))). zenon_intro zenon_H393. % 119.85/120.14 generalize (zenon_H393 (succ (succ (succ (n0))))). zenon_intro zenon_H394. % 119.85/120.14 apply (zenon_imply_s _ _ zenon_H394); [ zenon_intro zenon_Hfe | zenon_intro zenon_H395 ]. % 119.85/120.14 exact (zenon_Hfe zenon_Hfd). % 119.85/120.14 apply (zenon_imply_s _ _ zenon_H395); [ zenon_intro zenon_H240 | zenon_intro zenon_H233 ]. % 119.85/120.14 exact (zenon_H240 zenon_H246). % 119.85/120.14 exact (zenon_H21b zenon_H233). % 119.85/120.14 apply (zenon_L187_); trivial. % 119.85/120.14 cut ((gt (succ (succ (n0))) (n1)) = (gt (succ (succ (n0))) (succ (n0)))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_Hfe. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H204. % 119.85/120.14 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.85/120.14 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.85/120.14 congruence. % 119.85/120.14 apply zenon_H104. apply refl_equal. % 119.85/120.14 exact (zenon_H88 zenon_Hd1). % 119.85/120.14 apply (zenon_L188_); trivial. % 119.85/120.14 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.85/120.14 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H88. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact zenon_H8b. % 119.85/120.14 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.85/120.14 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.85/120.14 congruence. % 119.85/120.14 exact (zenon_H87 successor_1). % 119.85/120.14 apply zenon_H8c. apply refl_equal. % 119.85/120.14 apply zenon_H8c. apply refl_equal. % 119.85/120.14 (* end of lemma zenon_L189_ *) % 119.85/120.14 assert (zenon_L190_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n2) (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.85/120.14 do 0 intro. intros zenon_H66 zenon_H220 zenon_H155 zenon_H7d zenon_H67. % 119.85/120.14 elim (classic (gt (n1) (n3))); [ zenon_intro zenon_H1ee | zenon_intro zenon_H1e6 ]. % 119.85/120.14 generalize (zenon_H66 (n2)). zenon_intro zenon_H1a6. % 119.85/120.14 generalize (zenon_H1a6 (n1)). zenon_intro zenon_H1a7. % 119.85/120.14 generalize (zenon_H1a7 (n3)). zenon_intro zenon_H221. % 119.85/120.14 apply (zenon_imply_s _ _ zenon_H221); [ zenon_intro zenon_Hba | zenon_intro zenon_H222 ]. % 119.85/120.14 exact (zenon_Hba gt_2_1). % 119.85/120.14 apply (zenon_imply_s _ _ zenon_H222); [ zenon_intro zenon_H1e6 | zenon_intro zenon_H223 ]. % 119.85/120.14 exact (zenon_H1e6 zenon_H1ee). % 119.85/120.14 exact (zenon_H220 zenon_H223). % 119.85/120.14 apply (zenon_L171_); trivial. % 119.85/120.14 (* end of lemma zenon_L190_ *) % 119.85/120.14 assert (zenon_L191_ : ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n2) (n2))) -> False). % 119.85/120.14 do 0 intro. intros zenon_H155 zenon_H7d zenon_H67 zenon_H66 zenon_H1a5. % 119.85/120.14 elim (classic ((~((n2) = (n3)))/\(~(gt (n2) (n3))))); [ zenon_intro zenon_H224 | zenon_intro zenon_H225 ]. % 119.85/120.14 apply (zenon_and_s _ _ zenon_H224). zenon_intro zenon_H226. zenon_intro zenon_H220. % 119.85/120.14 apply (zenon_L190_); trivial. % 119.85/120.14 cut ((gt (n3) (n2)) = (gt (n2) (n2))). % 119.85/120.14 intro zenon_D_pnotp. % 119.85/120.14 apply zenon_H1a5. % 119.85/120.14 rewrite <- zenon_D_pnotp. % 119.85/120.14 exact gt_3_2. % 119.85/120.14 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.85/120.14 cut (((n3) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H227]. % 119.85/120.14 congruence. % 119.85/120.14 apply (zenon_notand_s _ _ zenon_H225); [ zenon_intro zenon_H229 | zenon_intro zenon_H228 ]. % 119.90/120.14 apply zenon_H229. zenon_intro zenon_H22a. % 119.90/120.14 elim (classic ((n2) = (n2))); [ zenon_intro zenon_H22b | zenon_intro zenon_H63 ]. % 119.90/120.14 cut (((n2) = (n2)) = ((n3) = (n2))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H227. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H22b. % 119.90/120.14 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.90/120.14 cut (((n2) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H226]. % 119.90/120.14 congruence. % 119.90/120.14 exact (zenon_H226 zenon_H22a). % 119.90/120.14 apply zenon_H63. apply refl_equal. % 119.90/120.14 apply zenon_H63. apply refl_equal. % 119.90/120.14 apply zenon_H228. zenon_intro zenon_H223. % 119.90/120.14 generalize (zenon_H66 (n2)). zenon_intro zenon_H1a6. % 119.90/120.14 generalize (zenon_H1a6 (n3)). zenon_intro zenon_H22c. % 119.90/120.14 generalize (zenon_H22c (n2)). zenon_intro zenon_H22d. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H22d); [ zenon_intro zenon_H220 | zenon_intro zenon_H22e ]. % 119.90/120.14 exact (zenon_H220 zenon_H223). % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H22e); [ zenon_intro zenon_H22f | zenon_intro zenon_H1aa ]. % 119.90/120.14 exact (zenon_H22f gt_3_2). % 119.90/120.14 exact (zenon_H1a5 zenon_H1aa). % 119.90/120.14 apply zenon_H63. apply refl_equal. % 119.90/120.14 (* end of lemma zenon_L191_ *) % 119.90/120.14 assert (zenon_L192_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (tptp_minus_1)) (succ (loopcounter)))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.90/120.14 do 0 intro. intros zenon_H66 zenon_H16c zenon_H155 zenon_H7d zenon_H67. % 119.90/120.14 elim (classic (gt (succ (tptp_minus_1)) (succ (tptp_minus_1)))); [ zenon_intro zenon_H176 | zenon_intro zenon_H168 ]. % 119.90/120.14 elim (classic (gt (succ (tptp_minus_1)) (n0))); [ zenon_intro zenon_H177 | zenon_intro zenon_H178 ]. % 119.90/120.14 elim (classic (gt (n0) (succ (loopcounter)))); [ zenon_intro zenon_H146 | zenon_intro zenon_H140 ]. % 119.90/120.14 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.90/120.14 generalize (zenon_H171 (n0)). zenon_intro zenon_H179. % 119.90/120.14 generalize (zenon_H179 (succ (loopcounter))). zenon_intro zenon_H2eb. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H2eb); [ zenon_intro zenon_H178 | zenon_intro zenon_H2ec ]. % 119.90/120.14 exact (zenon_H178 zenon_H177). % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H2ec); [ zenon_intro zenon_H140 | zenon_intro zenon_H175 ]. % 119.90/120.14 exact (zenon_H140 zenon_H146). % 119.90/120.14 exact (zenon_H16c zenon_H175). % 119.90/120.14 apply (zenon_L125_); trivial. % 119.90/120.14 cut ((gt (succ (tptp_minus_1)) (succ (tptp_minus_1))) = (gt (succ (tptp_minus_1)) (n0))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H178. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H176. % 119.90/120.14 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.90/120.14 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.90/120.14 congruence. % 119.90/120.14 apply zenon_H169. apply refl_equal. % 119.90/120.14 exact (zenon_H16b succ_tptp_minus_1). % 119.90/120.14 elim (classic (gt (n0) (succ (loopcounter)))); [ zenon_intro zenon_H146 | zenon_intro zenon_H140 ]. % 119.90/120.14 cut ((gt (n0) (succ (loopcounter))) = (gt (succ (tptp_minus_1)) (succ (loopcounter)))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H16c. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H146. % 119.90/120.14 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.90/120.14 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.90/120.14 congruence. % 119.90/120.14 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.90/120.14 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H167. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H16a. % 119.90/120.14 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.90/120.14 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.90/120.14 congruence. % 119.90/120.14 exact (zenon_H16b succ_tptp_minus_1). % 119.90/120.14 apply zenon_H169. apply refl_equal. % 119.90/120.14 apply zenon_H169. apply refl_equal. % 119.90/120.14 apply zenon_H76. apply refl_equal. % 119.90/120.14 apply (zenon_L123_); trivial. % 119.90/120.14 (* end of lemma zenon_L192_ *) % 119.90/120.14 assert (zenon_L193_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (loopcounter) (n1))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.90/120.14 do 0 intro. intros zenon_H66 zenon_Hee zenon_H67 zenon_H7d zenon_H155. % 119.90/120.14 elim (classic ((~((loopcounter) = (n3)))/\(~(gt (loopcounter) (n3))))); [ zenon_intro zenon_H1f3 | zenon_intro zenon_H1f4 ]. % 119.90/120.14 apply (zenon_and_s _ _ zenon_H1f3). zenon_intro zenon_Hc2. zenon_intro zenon_H1f5. % 119.90/120.14 apply (zenon_L170_); trivial. % 119.90/120.14 cut ((gt (n3) (n1)) = (gt (loopcounter) (n1))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_Hee. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact gt_3_1. % 119.90/120.14 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.90/120.14 cut (((n3) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H1f6]. % 119.90/120.14 congruence. % 119.90/120.14 apply (zenon_notand_s _ _ zenon_H1f4); [ zenon_intro zenon_H1f8 | zenon_intro zenon_H1f7 ]. % 119.90/120.14 apply zenon_H1f8. zenon_intro zenon_Hcb. % 119.90/120.14 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.90/120.14 cut (((loopcounter) = (loopcounter)) = ((n3) = (loopcounter))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H1f6. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_Hed. % 119.90/120.14 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.14 cut (((loopcounter) = (n3))); [idtac | apply NNPP; zenon_intro zenon_Hc2]. % 119.90/120.14 congruence. % 119.90/120.14 exact (zenon_Hc2 zenon_Hcb). % 119.90/120.14 apply zenon_H7c. apply refl_equal. % 119.90/120.14 apply zenon_H7c. apply refl_equal. % 119.90/120.14 apply zenon_H1f7. zenon_intro zenon_H1f9. % 119.90/120.14 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.90/120.14 generalize (zenon_H13b (n3)). zenon_intro zenon_H1fa. % 119.90/120.14 generalize (zenon_H1fa (n1)). zenon_intro zenon_H1fb. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H1fb); [ zenon_intro zenon_H1f5 | zenon_intro zenon_H1fc ]. % 119.90/120.14 exact (zenon_H1f5 zenon_H1f9). % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H1fc); [ zenon_intro zenon_H1f2 | zenon_intro zenon_Hf1 ]. % 119.90/120.14 exact (zenon_H1f2 gt_3_1). % 119.90/120.14 exact (zenon_Hee zenon_Hf1). % 119.90/120.14 apply zenon_H64. apply refl_equal. % 119.90/120.14 (* end of lemma zenon_L193_ *) % 119.90/120.14 assert (zenon_L194_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) (succ (succ (succ (n0)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.90/120.14 do 0 intro. intros zenon_H66 zenon_H23c zenon_H67 zenon_H7d zenon_H155. % 119.90/120.14 elim (classic (gt (loopcounter) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H237 | zenon_intro zenon_H230 ]. % 119.90/120.14 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.90/120.14 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.90/120.14 generalize (zenon_Hf3 (succ (succ (succ (n0))))). zenon_intro zenon_H23d. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H23d); [ zenon_intro zenon_H92 | zenon_intro zenon_H23e ]. % 119.90/120.14 exact (zenon_H92 zenon_H7d). % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H23e); [ zenon_intro zenon_H230 | zenon_intro zenon_H23f ]. % 119.90/120.14 exact (zenon_H230 zenon_H237). % 119.90/120.14 exact (zenon_H23c zenon_H23f). % 119.90/120.14 elim (classic ((n1) = (succ (n0)))); [ zenon_intro zenon_Hd1 | zenon_intro zenon_H88 ]. % 119.90/120.14 elim (classic (gt (loopcounter) (n1))); [ zenon_intro zenon_Hf1 | zenon_intro zenon_Hee ]. % 119.90/120.14 elim (classic (gt (loopcounter) (succ (n0)))); [ zenon_intro zenon_Hef | zenon_intro zenon_Heb ]. % 119.90/120.14 elim (classic (gt (succ (n0)) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H246 | zenon_intro zenon_H240 ]. % 119.90/120.14 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.90/120.14 generalize (zenon_H13b (succ (n0))). zenon_intro zenon_H147. % 119.90/120.14 generalize (zenon_H147 (succ (succ (succ (n0))))). zenon_intro zenon_H396. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H396); [ zenon_intro zenon_Heb | zenon_intro zenon_H397 ]. % 119.90/120.14 exact (zenon_Heb zenon_Hef). % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H397); [ zenon_intro zenon_H240 | zenon_intro zenon_H237 ]. % 119.90/120.14 exact (zenon_H240 zenon_H246). % 119.90/120.14 exact (zenon_H230 zenon_H237). % 119.90/120.14 apply (zenon_L187_); trivial. % 119.90/120.14 cut ((gt (loopcounter) (n1)) = (gt (loopcounter) (succ (n0)))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_Heb. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_Hf1. % 119.90/120.14 cut (((n1) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H88]. % 119.90/120.14 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.14 congruence. % 119.90/120.14 apply zenon_H7c. apply refl_equal. % 119.90/120.14 exact (zenon_H88 zenon_Hd1). % 119.90/120.14 apply (zenon_L193_); trivial. % 119.90/120.14 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.90/120.14 cut (((succ (n0)) = (succ (n0))) = ((n1) = (succ (n0)))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H88. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H8b. % 119.90/120.14 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.90/120.14 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.90/120.14 congruence. % 119.90/120.14 exact (zenon_H87 successor_1). % 119.90/120.14 apply zenon_H8c. apply refl_equal. % 119.90/120.14 apply zenon_H8c. apply refl_equal. % 119.90/120.14 (* end of lemma zenon_L194_ *) % 119.90/120.14 assert (zenon_L195_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (tptp_minus_1)) (succ (succ (succ (n0)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.90/120.14 do 0 intro. intros zenon_H66 zenon_H255 zenon_H155 zenon_H7d zenon_H67. % 119.90/120.14 elim (classic ((~((succ (tptp_minus_1)) = (succ (loopcounter))))/\(~(gt (succ (tptp_minus_1)) (succ (loopcounter)))))); [ zenon_intro zenon_H25d | zenon_intro zenon_H25e ]. % 119.90/120.14 apply (zenon_and_s _ _ zenon_H25d). zenon_intro zenon_H25f. zenon_intro zenon_H16c. % 119.90/120.14 apply (zenon_L192_); trivial. % 119.90/120.14 elim (classic (gt (n1) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H23f | zenon_intro zenon_H23c ]. % 119.90/120.14 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.14 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.14 generalize (zenon_H78 (succ (succ (succ (n0))))). zenon_intro zenon_H241. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H241); [ zenon_intro zenon_H6f | zenon_intro zenon_H242 ]. % 119.90/120.14 exact (zenon_H6f zenon_H67). % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H242); [ zenon_intro zenon_H23c | zenon_intro zenon_H243 ]. % 119.90/120.14 exact (zenon_H23c zenon_H23f). % 119.90/120.14 cut ((gt (succ (loopcounter)) (succ (succ (succ (n0))))) = (gt (succ (tptp_minus_1)) (succ (succ (succ (n0)))))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H255. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H243. % 119.90/120.14 cut (((succ (succ (succ (n0)))) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H21e]. % 119.90/120.14 cut (((succ (loopcounter)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H260]. % 119.90/120.14 congruence. % 119.90/120.14 apply (zenon_notand_s _ _ zenon_H25e); [ zenon_intro zenon_H262 | zenon_intro zenon_H261 ]. % 119.90/120.14 apply zenon_H262. zenon_intro zenon_H263. % 119.90/120.14 apply zenon_H260. apply sym_equal. exact zenon_H263. % 119.90/120.14 apply zenon_H261. zenon_intro zenon_H175. % 119.90/120.14 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.90/120.14 generalize (zenon_H171 (succ (loopcounter))). zenon_intro zenon_H264. % 119.90/120.14 generalize (zenon_H264 (succ (succ (succ (n0))))). zenon_intro zenon_H326. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H326); [ zenon_intro zenon_H16c | zenon_intro zenon_H327 ]. % 119.90/120.14 exact (zenon_H16c zenon_H175). % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H327); [ zenon_intro zenon_H247 | zenon_intro zenon_H258 ]. % 119.90/120.14 exact (zenon_H247 zenon_H243). % 119.90/120.14 exact (zenon_H255 zenon_H258). % 119.90/120.14 apply zenon_H21e. apply refl_equal. % 119.90/120.14 apply (zenon_L194_); trivial. % 119.90/120.14 (* end of lemma zenon_L195_ *) % 119.90/120.14 assert (zenon_L196_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (tptp_minus_1)) (succ (succ (n0))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.90/120.14 do 0 intro. intros zenon_H66 zenon_H1da zenon_H67 zenon_H7d zenon_H155. % 119.90/120.14 elim (classic (gt (succ (tptp_minus_1)) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H258 | zenon_intro zenon_H255 ]. % 119.90/120.14 elim (classic (gt (succ (tptp_minus_1)) (n3))); [ zenon_intro zenon_H267 | zenon_intro zenon_H25b ]. % 119.90/120.14 elim (classic (gt (n3) (succ (succ (n0))))); [ zenon_intro zenon_H24a | zenon_intro zenon_H202 ]. % 119.90/120.14 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.90/120.14 generalize (zenon_H171 (n3)). zenon_intro zenon_H26c. % 119.90/120.14 generalize (zenon_H26c (succ (succ (n0)))). zenon_intro zenon_H398. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H398); [ zenon_intro zenon_H25b | zenon_intro zenon_H399 ]. % 119.90/120.14 exact (zenon_H25b zenon_H267). % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H399); [ zenon_intro zenon_H202 | zenon_intro zenon_H1dd ]. % 119.90/120.14 exact (zenon_H202 zenon_H24a). % 119.90/120.14 exact (zenon_H1da zenon_H1dd). % 119.90/120.14 apply (zenon_L86_); trivial. % 119.90/120.14 cut ((gt (succ (tptp_minus_1)) (succ (succ (succ (n0))))) = (gt (succ (tptp_minus_1)) (n3))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H25b. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H258. % 119.90/120.14 cut (((succ (succ (succ (n0)))) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H21f]. % 119.90/120.14 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.90/120.14 congruence. % 119.90/120.14 apply zenon_H169. apply refl_equal. % 119.90/120.14 exact (zenon_H21f successor_3). % 119.90/120.14 apply (zenon_L195_); trivial. % 119.90/120.14 (* end of lemma zenon_L196_ *) % 119.90/120.14 assert (zenon_L197_ : forall (zenon_TG_dq : zenon_U), ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(gt (n0) zenon_TG_dq)) -> (~(gt (succ (n3)) zenon_TG_dq)) -> (gt (succ zenon_TG_dq) (n0)) -> (gt (succ (n4)) zenon_TG_dq) -> (~((n0) = zenon_TG_dq)) -> (~((n1) = zenon_TG_dq)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.90/120.14 do 1 intro. intros zenon_H155 zenon_H7d zenon_H67 zenon_H39a zenon_H39b zenon_H5c zenon_H32e zenon_H334 zenon_H335 zenon_H66. % 119.90/120.14 elim (classic ((n0) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H180 | zenon_intro zenon_H167 ]. % 119.90/120.14 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.90/120.14 elim (classic (gt (n0) (succ (tptp_minus_1)))); [ zenon_intro zenon_H163 | zenon_intro zenon_H15d ]. % 119.90/120.14 elim (classic (gt (succ (tptp_minus_1)) zenon_TG_dq)); [ zenon_intro zenon_H39c | zenon_intro zenon_H39d ]. % 119.90/120.14 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.90/120.14 generalize (zenon_H142 (succ (tptp_minus_1))). zenon_intro zenon_H39e. % 119.90/120.14 generalize (zenon_H39e zenon_TG_dq). zenon_intro zenon_H39f. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H39f); [ zenon_intro zenon_H15d | zenon_intro zenon_H3a0 ]. % 119.90/120.14 exact (zenon_H15d zenon_H163). % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H3a0); [ zenon_intro zenon_H39d | zenon_intro zenon_H3a1 ]. % 119.90/120.14 exact (zenon_H39d zenon_H39c). % 119.90/120.14 exact (zenon_H39a zenon_H3a1). % 119.90/120.14 elim (classic (gt (succ (tptp_minus_1)) (succ (succ (n0))))); [ zenon_intro zenon_H1dd | zenon_intro zenon_H1da ]. % 119.90/120.14 elim (classic (gt (succ (tptp_minus_1)) (n2))); [ zenon_intro zenon_H1de | zenon_intro zenon_H1df ]. % 119.90/120.14 cut ((gt (succ (tptp_minus_1)) (n2)) = (gt (succ (tptp_minus_1)) zenon_TG_dq)). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H39d. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H1de. % 119.90/120.14 cut (((n2) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H336]. % 119.90/120.14 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.90/120.14 congruence. % 119.90/120.14 apply zenon_H169. apply refl_equal. % 119.90/120.14 elim (classic (gt (n2) zenon_TG_dq)); [ zenon_intro zenon_H3a2 | zenon_intro zenon_H3a3 ]. % 119.90/120.14 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.90/120.14 generalize (zenon_H171 (n2)). zenon_intro zenon_H1e0. % 119.90/120.14 generalize (zenon_H1e0 zenon_TG_dq). zenon_intro zenon_H3a4. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H3a4); [ zenon_intro zenon_H1df | zenon_intro zenon_H3a5 ]. % 119.90/120.14 exact (zenon_H1df zenon_H1de). % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H3a5); [ zenon_intro zenon_H3a3 | zenon_intro zenon_H39c ]. % 119.90/120.14 exact (zenon_H3a3 zenon_H3a2). % 119.90/120.14 exact (zenon_H39d zenon_H39c). % 119.90/120.14 elim (classic ((n2) = (succ (succ (n0))))); [ zenon_intro zenon_H1b9 | zenon_intro zenon_H102 ]. % 119.90/120.14 elim (classic (gt (n2) (n2))); [ zenon_intro zenon_H1aa | zenon_intro zenon_H1a5 ]. % 119.90/120.14 elim (classic (gt (n2) (succ (succ (n0))))); [ zenon_intro zenon_H314 | zenon_intro zenon_H315 ]. % 119.90/120.14 elim (classic (gt (succ (succ (n0))) zenon_TG_dq)); [ zenon_intro zenon_H3a6 | zenon_intro zenon_H3a7 ]. % 119.90/120.14 generalize (zenon_H66 (n2)). zenon_intro zenon_H1a6. % 119.90/120.14 generalize (zenon_H1a6 (succ (succ (n0)))). zenon_intro zenon_H323. % 119.90/120.14 generalize (zenon_H323 zenon_TG_dq). zenon_intro zenon_H3a8. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H3a8); [ zenon_intro zenon_H315 | zenon_intro zenon_H3a9 ]. % 119.90/120.14 exact (zenon_H315 zenon_H314). % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H3a9); [ zenon_intro zenon_H3a7 | zenon_intro zenon_H3a2 ]. % 119.90/120.14 exact (zenon_H3a7 zenon_H3a6). % 119.90/120.14 exact (zenon_H3a3 zenon_H3a2). % 119.90/120.14 elim (classic (gt (succ (succ (n0))) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H233 | zenon_intro zenon_H21b ]. % 119.90/120.14 elim (classic (gt (succ (succ (n0))) (n3))); [ zenon_intro zenon_H219 | zenon_intro zenon_H20b ]. % 119.90/120.14 cut ((gt (succ (succ (n0))) (n3)) = (gt (succ (succ (n0))) zenon_TG_dq)). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H3a7. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H219. % 119.90/120.14 cut (((n3) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H337]. % 119.90/120.14 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.90/120.14 congruence. % 119.90/120.14 apply zenon_H104. apply refl_equal. % 119.90/120.14 elim (classic (gt (succ (n3)) (succ (succ (succ (succ (n0))))))); [ zenon_intro zenon_H3aa | zenon_intro zenon_H383 ]. % 119.90/120.14 elim (classic (gt (succ (n3)) (n4))); [ zenon_intro zenon_H3ab | zenon_intro zenon_H3ac ]. % 119.90/120.14 cut ((gt (succ (n3)) (n4)) = (gt (succ (n3)) zenon_TG_dq)). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H39b. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H3ab. % 119.90/120.14 cut (((n4) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H338]. % 119.90/120.14 cut (((succ (n3)) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H9f]. % 119.90/120.14 congruence. % 119.90/120.14 apply zenon_H9f. apply refl_equal. % 119.90/120.14 elim (classic (gt (n4) zenon_TG_dq)); [ zenon_intro zenon_H3ad | zenon_intro zenon_H344 ]. % 119.90/120.14 generalize (zenon_H66 (succ (n3))). zenon_intro zenon_Hb5. % 119.90/120.14 generalize (zenon_Hb5 (n4)). zenon_intro zenon_H3ae. % 119.90/120.14 generalize (zenon_H3ae zenon_TG_dq). zenon_intro zenon_H3af. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H3af); [ zenon_intro zenon_H3ac | zenon_intro zenon_H3b0 ]. % 119.90/120.14 exact (zenon_H3ac zenon_H3ab). % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H3b0); [ zenon_intro zenon_H344 | zenon_intro zenon_H3b1 ]. % 119.90/120.14 exact (zenon_H344 zenon_H3ad). % 119.90/120.14 exact (zenon_H39b zenon_H3b1). % 119.90/120.14 apply (zenon_L175_ zenon_TG_dq); trivial. % 119.90/120.14 cut ((gt (succ (n3)) (succ (succ (succ (succ (n0)))))) = (gt (succ (n3)) (n4))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H3ac. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H3aa. % 119.90/120.14 cut (((succ (succ (succ (succ (n0))))) = (n4))); [idtac | apply NNPP; zenon_intro zenon_Ha3]. % 119.90/120.14 cut (((succ (n3)) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H9f]. % 119.90/120.14 congruence. % 119.90/120.14 apply zenon_H9f. apply refl_equal. % 119.90/120.14 exact (zenon_Ha3 successor_4). % 119.90/120.14 generalize (finite_domain_0 (loopcounter)). zenon_intro zenon_H94. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H94); [ zenon_intro zenon_H96 | zenon_intro zenon_H95 ]. % 119.90/120.14 apply (zenon_notand_s _ _ zenon_H96); [ zenon_intro zenon_H68 | zenon_intro zenon_H7e ]. % 119.90/120.14 apply (zenon_L5_); trivial. % 119.90/120.14 apply (zenon_L7_); trivial. % 119.90/120.14 generalize (finite_domain_0 (n1)). zenon_intro zenon_H107. % 119.90/120.14 generalize (finite_domain_4 zenon_TG_dq). zenon_intro zenon_H339. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H339); [ zenon_intro zenon_H33b | zenon_intro zenon_H33a ]. % 119.90/120.14 apply (zenon_notand_s _ _ zenon_H33b); [ zenon_intro zenon_H5d | zenon_intro zenon_H32f ]. % 119.90/120.14 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.14 apply (zenon_L173_ zenon_TG_dq); trivial. % 119.90/120.14 apply (zenon_or_s _ _ zenon_H33a); [ zenon_intro zenon_H33d | zenon_intro zenon_H33c ]. % 119.90/120.14 apply zenon_H334. apply sym_equal. exact zenon_H33d. % 119.90/120.14 apply (zenon_or_s _ _ zenon_H33c); [ zenon_intro zenon_H33f | zenon_intro zenon_H33e ]. % 119.90/120.14 apply zenon_H335. apply sym_equal. exact zenon_H33f. % 119.90/120.14 apply (zenon_or_s _ _ zenon_H33e); [ zenon_intro zenon_H341 | zenon_intro zenon_H340 ]. % 119.90/120.14 apply zenon_H336. apply sym_equal. exact zenon_H341. % 119.90/120.14 apply (zenon_or_s _ _ zenon_H340); [ zenon_intro zenon_H343 | zenon_intro zenon_H342 ]. % 119.90/120.14 apply zenon_H337. apply sym_equal. exact zenon_H343. % 119.90/120.14 apply (zenon_L183_ zenon_TG_dq); trivial. % 119.90/120.14 cut ((gt (succ (succ (n0))) (succ (succ (succ (n0))))) = (gt (succ (succ (n0))) (n3))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H20b. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H233. % 119.90/120.14 cut (((succ (succ (succ (n0)))) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H21f]. % 119.90/120.14 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.90/120.14 congruence. % 119.90/120.14 apply zenon_H104. apply refl_equal. % 119.90/120.14 exact (zenon_H21f successor_3). % 119.90/120.14 apply (zenon_L189_); trivial. % 119.90/120.14 cut ((gt (n2) (n2)) = (gt (n2) (succ (succ (n0))))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H315. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H1aa. % 119.90/120.14 cut (((n2) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 119.90/120.14 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.90/120.14 congruence. % 119.90/120.14 apply zenon_H63. apply refl_equal. % 119.90/120.14 exact (zenon_H102 zenon_H1b9). % 119.90/120.14 apply (zenon_L191_); trivial. % 119.90/120.14 elim (classic ((succ (succ (n0))) = (succ (succ (n0))))); [ zenon_intro zenon_H103 | zenon_intro zenon_H104 ]. % 119.90/120.14 cut (((succ (succ (n0))) = (succ (succ (n0)))) = ((n2) = (succ (succ (n0))))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H102. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H103. % 119.90/120.14 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.90/120.14 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.90/120.14 congruence. % 119.90/120.14 exact (zenon_H105 successor_2). % 119.90/120.14 apply zenon_H104. apply refl_equal. % 119.90/120.14 apply zenon_H104. apply refl_equal. % 119.90/120.14 cut ((gt (succ (tptp_minus_1)) (succ (succ (n0)))) = (gt (succ (tptp_minus_1)) (n2))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H1df. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H1dd. % 119.90/120.14 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.90/120.14 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.90/120.14 congruence. % 119.90/120.14 apply zenon_H169. apply refl_equal. % 119.90/120.14 exact (zenon_H105 successor_2). % 119.90/120.14 apply (zenon_L196_); trivial. % 119.90/120.14 cut ((gt (n0) (n0)) = (gt (n0) (succ (tptp_minus_1)))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H15d. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H141. % 119.90/120.14 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.90/120.14 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.90/120.14 congruence. % 119.90/120.14 apply zenon_H65. apply refl_equal. % 119.90/120.14 exact (zenon_H167 zenon_H180). % 119.90/120.14 apply (zenon_L146_); trivial. % 119.90/120.14 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.90/120.14 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H167. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H16a. % 119.90/120.14 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.90/120.14 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.90/120.14 congruence. % 119.90/120.14 exact (zenon_H16b succ_tptp_minus_1). % 119.90/120.14 apply zenon_H169. apply refl_equal. % 119.90/120.14 apply zenon_H169. apply refl_equal. % 119.90/120.14 (* end of lemma zenon_L197_ *) % 119.90/120.14 assert (zenon_L198_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(leq (n0) (tptp_minus_1))) -> False). % 119.90/120.14 do 0 intro. intros zenon_H66 zenon_H155 zenon_H7d zenon_H67 zenon_H3b2. % 119.90/120.14 generalize (leq_succ_gt_equiv (n0)). zenon_intro zenon_H5f. % 119.90/120.14 generalize (zenon_H5f (tptp_minus_1)). zenon_intro zenon_H3b3. % 119.90/120.14 apply (zenon_equiv_s _ _ zenon_H3b3); [ zenon_intro zenon_H3b2; zenon_intro zenon_H178 | zenon_intro zenon_H3b4; zenon_intro zenon_H177 ]. % 119.90/120.14 elim (classic ((~((succ (tptp_minus_1)) = (n3)))/\(~(gt (succ (tptp_minus_1)) (n3))))); [ zenon_intro zenon_H259 | zenon_intro zenon_H25a ]. % 119.90/120.14 apply (zenon_and_s _ _ zenon_H259). zenon_intro zenon_H25c. zenon_intro zenon_H25b. % 119.90/120.14 elim (classic ((~((succ (tptp_minus_1)) = (succ (loopcounter))))/\(~(gt (succ (tptp_minus_1)) (succ (loopcounter)))))); [ zenon_intro zenon_H25d | zenon_intro zenon_H25e ]. % 119.90/120.14 apply (zenon_and_s _ _ zenon_H25d). zenon_intro zenon_H25f. zenon_intro zenon_H16c. % 119.90/120.14 apply (zenon_L192_); trivial. % 119.90/120.14 elim (classic (gt (n1) (n3))); [ zenon_intro zenon_H1ee | zenon_intro zenon_H1e6 ]. % 119.90/120.14 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.14 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.14 generalize (zenon_H78 (n3)). zenon_intro zenon_H20f. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H20f); [ zenon_intro zenon_H6f | zenon_intro zenon_H210 ]. % 119.90/120.14 exact (zenon_H6f zenon_H67). % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H210); [ zenon_intro zenon_H1e6 | zenon_intro zenon_H211 ]. % 119.90/120.14 exact (zenon_H1e6 zenon_H1ee). % 119.90/120.14 cut ((gt (succ (loopcounter)) (n3)) = (gt (succ (tptp_minus_1)) (n3))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H25b. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H211. % 119.90/120.14 cut (((n3) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H201]. % 119.90/120.14 cut (((succ (loopcounter)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H260]. % 119.90/120.14 congruence. % 119.90/120.14 apply (zenon_notand_s _ _ zenon_H25e); [ zenon_intro zenon_H262 | zenon_intro zenon_H261 ]. % 119.90/120.14 apply zenon_H262. zenon_intro zenon_H263. % 119.90/120.14 apply zenon_H260. apply sym_equal. exact zenon_H263. % 119.90/120.14 apply zenon_H261. zenon_intro zenon_H175. % 119.90/120.14 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.90/120.14 generalize (zenon_H171 (succ (loopcounter))). zenon_intro zenon_H264. % 119.90/120.14 generalize (zenon_H264 (n3)). zenon_intro zenon_H265. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H265); [ zenon_intro zenon_H16c | zenon_intro zenon_H266 ]. % 119.90/120.14 exact (zenon_H16c zenon_H175). % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H266); [ zenon_intro zenon_H21a | zenon_intro zenon_H267 ]. % 119.90/120.14 exact (zenon_H21a zenon_H211). % 119.90/120.14 exact (zenon_H25b zenon_H267). % 119.90/120.14 apply zenon_H201. apply refl_equal. % 119.90/120.14 apply (zenon_L171_); trivial. % 119.90/120.14 cut ((gt (n3) (n0)) = (gt (succ (tptp_minus_1)) (n0))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H178. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact gt_3_0. % 119.90/120.14 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.90/120.14 cut (((n3) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H268]. % 119.90/120.14 congruence. % 119.90/120.14 apply (zenon_notand_s _ _ zenon_H25a); [ zenon_intro zenon_H26a | zenon_intro zenon_H269 ]. % 119.90/120.14 apply zenon_H26a. zenon_intro zenon_H26b. % 119.90/120.14 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.90/120.14 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n3) = (succ (tptp_minus_1)))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H268. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H16a. % 119.90/120.14 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.90/120.14 cut (((succ (tptp_minus_1)) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H25c]. % 119.90/120.14 congruence. % 119.90/120.14 exact (zenon_H25c zenon_H26b). % 119.90/120.14 apply zenon_H169. apply refl_equal. % 119.90/120.14 apply zenon_H169. apply refl_equal. % 119.90/120.14 apply zenon_H269. zenon_intro zenon_H267. % 119.90/120.14 generalize (zenon_H66 (succ (tptp_minus_1))). zenon_intro zenon_H171. % 119.90/120.14 generalize (zenon_H171 (n3)). zenon_intro zenon_H26c. % 119.90/120.14 generalize (zenon_H26c (n0)). zenon_intro zenon_H3b5. % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H3b5); [ zenon_intro zenon_H25b | zenon_intro zenon_H3b6 ]. % 119.90/120.14 exact (zenon_H25b zenon_H267). % 119.90/120.14 apply (zenon_imply_s _ _ zenon_H3b6); [ zenon_intro zenon_H291 | zenon_intro zenon_H177 ]. % 119.90/120.14 exact (zenon_H291 gt_3_0). % 119.90/120.14 exact (zenon_H178 zenon_H177). % 119.90/120.14 apply zenon_H65. apply refl_equal. % 119.90/120.14 exact (zenon_H3b2 zenon_H3b4). % 119.90/120.14 (* end of lemma zenon_L198_ *) % 119.90/120.14 assert (zenon_L199_ : (~((tptp_minus_1) = (tptp_minus_1))) -> False). % 119.90/120.14 do 0 intro. intros zenon_H3b7. % 119.90/120.14 apply zenon_H3b7. apply refl_equal. % 119.90/120.14 (* end of lemma zenon_L199_ *) % 119.90/120.14 assert (zenon_L200_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(leq (tptp_minus_1) (n3))) -> False). % 119.90/120.14 do 0 intro. intros zenon_H66 zenon_H3b8. % 119.90/120.14 generalize (leq_succ_gt_equiv (tptp_minus_1)). zenon_intro zenon_H3b9. % 119.90/120.14 generalize (zenon_H3b9 (n3)). zenon_intro zenon_H3ba. % 119.90/120.14 apply (zenon_equiv_s _ _ zenon_H3ba); [ zenon_intro zenon_H3b8; zenon_intro zenon_H3bd | zenon_intro zenon_H3bc; zenon_intro zenon_H3bb ]. % 119.90/120.14 elim (classic ((~((succ (n3)) = (n2)))/\(~(gt (succ (n3)) (n2))))); [ zenon_intro zenon_Had | zenon_intro zenon_Hae ]. % 119.90/120.14 apply (zenon_and_s _ _ zenon_Had). zenon_intro zenon_Haf. zenon_intro zenon_H9a. % 119.90/120.14 apply (zenon_L11_); trivial. % 119.90/120.14 cut ((gt (n2) (tptp_minus_1)) = (gt (succ (n3)) (tptp_minus_1))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_H3bd. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact gt_2_tptp_minus_1. % 119.90/120.14 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.14 cut (((n2) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_Hb0]. % 119.90/120.14 congruence. % 119.90/120.14 apply (zenon_notand_s _ _ zenon_Hae); [ zenon_intro zenon_Hb2 | zenon_intro zenon_Hb1 ]. % 119.90/120.14 apply zenon_Hb2. zenon_intro zenon_Hb3. % 119.90/120.14 elim (classic ((succ (n3)) = (succ (n3)))); [ zenon_intro zenon_H9e | zenon_intro zenon_H9f ]. % 119.90/120.14 cut (((succ (n3)) = (succ (n3))) = ((n2) = (succ (n3)))). % 119.90/120.14 intro zenon_D_pnotp. % 119.90/120.14 apply zenon_Hb0. % 119.90/120.14 rewrite <- zenon_D_pnotp. % 119.90/120.14 exact zenon_H9e. % 119.90/120.14 cut (((succ (n3)) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H9f]. % 119.90/120.14 cut (((succ (n3)) = (n2))); [idtac | apply NNPP; zenon_intro zenon_Haf]. % 119.90/120.14 congruence. % 119.90/120.14 exact (zenon_Haf zenon_Hb3). % 119.90/120.14 apply zenon_H9f. apply refl_equal. % 119.90/120.14 apply zenon_H9f. apply refl_equal. % 119.90/120.15 apply zenon_Hb1. zenon_intro zenon_Hb4. % 119.90/120.15 generalize (zenon_H66 (succ (n3))). zenon_intro zenon_Hb5. % 119.90/120.15 generalize (zenon_Hb5 (n2)). zenon_intro zenon_Hb6. % 119.90/120.15 generalize (zenon_Hb6 (tptp_minus_1)). zenon_intro zenon_H3be. % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3be); [ zenon_intro zenon_H9a | zenon_intro zenon_H3bf ]. % 119.90/120.15 exact (zenon_H9a zenon_Hb4). % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3bf); [ zenon_intro zenon_H3c0 | zenon_intro zenon_H3bb ]. % 119.90/120.15 exact (zenon_H3c0 gt_2_tptp_minus_1). % 119.90/120.15 exact (zenon_H3bd zenon_H3bb). % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 exact (zenon_H3b8 zenon_H3bc). % 119.90/120.15 (* end of lemma zenon_L200_ *) % 119.90/120.15 assert (zenon_L201_ : ((tptp_minus_1) = (n0)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (tptp_minus_1) (tptp_minus_1))) -> False). % 119.90/120.15 do 0 intro. intros zenon_H3c1 zenon_H66 zenon_H3c2. % 119.90/120.15 elim (classic ((~((tptp_minus_1) = (n0)))/\(~(gt (tptp_minus_1) (n0))))); [ zenon_intro zenon_H3c3 | zenon_intro zenon_H3c4 ]. % 119.90/120.15 apply (zenon_and_s _ _ zenon_H3c3). zenon_intro zenon_H3c6. zenon_intro zenon_H3c5. % 119.90/120.15 exact (zenon_H3c6 zenon_H3c1). % 119.90/120.15 cut ((gt (n0) (tptp_minus_1)) = (gt (tptp_minus_1) (tptp_minus_1))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3c2. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact gt_0_tptp_minus_1. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.15 cut (((n0) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3c7]. % 119.90/120.15 congruence. % 119.90/120.15 apply (zenon_notand_s _ _ zenon_H3c4); [ zenon_intro zenon_H3c9 | zenon_intro zenon_H3c8 ]. % 119.90/120.15 apply zenon_H3c9. zenon_intro zenon_H3c1. % 119.90/120.15 elim (classic ((tptp_minus_1) = (tptp_minus_1))); [ zenon_intro zenon_H3ca | zenon_intro zenon_H3b7 ]. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1)) = ((n0) = (tptp_minus_1))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3c7. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H3ca. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.15 cut (((tptp_minus_1) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H3c6]. % 119.90/120.15 congruence. % 119.90/120.15 exact (zenon_H3c6 zenon_H3c1). % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 apply zenon_H3c8. zenon_intro zenon_H3cb. % 119.90/120.15 generalize (zenon_H66 (tptp_minus_1)). zenon_intro zenon_H3cc. % 119.90/120.15 generalize (zenon_H3cc (n0)). zenon_intro zenon_H3cd. % 119.90/120.15 generalize (zenon_H3cd (tptp_minus_1)). zenon_intro zenon_H3ce. % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3ce); [ zenon_intro zenon_H3c5 | zenon_intro zenon_H3cf ]. % 119.90/120.15 exact (zenon_H3c5 zenon_H3cb). % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3cf); [ zenon_intro zenon_H3d1 | zenon_intro zenon_H3d0 ]. % 119.90/120.15 exact (zenon_H3d1 gt_0_tptp_minus_1). % 119.90/120.15 exact (zenon_H3c2 zenon_H3d0). % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 (* end of lemma zenon_L201_ *) % 119.90/120.15 assert (zenon_L202_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt zenon_TG_dq zenon_TG_dq)) -> ((tptp_minus_1) = (n0)) -> (zenon_TG_dq = (n0)) -> False). % 119.90/120.15 do 1 intro. intros zenon_H66 zenon_H3d2 zenon_H3c1 zenon_H33d. % 119.90/120.15 elim (classic (gt (n0) zenon_TG_dq)); [ zenon_intro zenon_H3a1 | zenon_intro zenon_H39a ]. % 119.90/120.15 cut ((gt (n0) zenon_TG_dq) = (gt zenon_TG_dq zenon_TG_dq)). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3d2. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H3a1. % 119.90/120.15 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.15 cut (((n0) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H334]. % 119.90/120.15 congruence. % 119.90/120.15 elim (classic (zenon_TG_dq = zenon_TG_dq)); [ zenon_intro zenon_H3d4 | zenon_intro zenon_H3d3 ]. % 119.90/120.15 cut ((zenon_TG_dq = zenon_TG_dq) = ((n0) = zenon_TG_dq)). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H334. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H3d4. % 119.90/120.15 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.15 cut ((zenon_TG_dq = (n0))); [idtac | apply NNPP; zenon_intro zenon_H3d5]. % 119.90/120.15 congruence. % 119.90/120.15 exact (zenon_H3d5 zenon_H33d). % 119.90/120.15 apply zenon_H3d3. apply refl_equal. % 119.90/120.15 apply zenon_H3d3. apply refl_equal. % 119.90/120.15 apply zenon_H3d3. apply refl_equal. % 119.90/120.15 elim (classic (gt (tptp_minus_1) zenon_TG_dq)); [ zenon_intro zenon_H3d6 | zenon_intro zenon_H3d7 ]. % 119.90/120.15 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.90/120.15 generalize (zenon_H142 (tptp_minus_1)). zenon_intro zenon_H3d8. % 119.90/120.15 generalize (zenon_H3d8 zenon_TG_dq). zenon_intro zenon_H3d9. % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3d9); [ zenon_intro zenon_H3d1 | zenon_intro zenon_H3da ]. % 119.90/120.15 exact (zenon_H3d1 gt_0_tptp_minus_1). % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3da); [ zenon_intro zenon_H3d7 | zenon_intro zenon_H3a1 ]. % 119.90/120.15 exact (zenon_H3d7 zenon_H3d6). % 119.90/120.15 exact (zenon_H39a zenon_H3a1). % 119.90/120.15 elim (classic (gt (tptp_minus_1) (tptp_minus_1))); [ zenon_intro zenon_H3d0 | zenon_intro zenon_H3c2 ]. % 119.90/120.15 elim (classic (gt (tptp_minus_1) (n0))); [ zenon_intro zenon_H3cb | zenon_intro zenon_H3c5 ]. % 119.90/120.15 cut ((gt (tptp_minus_1) (n0)) = (gt (tptp_minus_1) zenon_TG_dq)). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3d7. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H3cb. % 119.90/120.15 cut (((n0) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H334]. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.15 congruence. % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 apply zenon_H334. apply sym_equal. exact zenon_H33d. % 119.90/120.15 cut ((gt (tptp_minus_1) (tptp_minus_1)) = (gt (tptp_minus_1) (n0))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3c5. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H3d0. % 119.90/120.15 cut (((tptp_minus_1) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H3c6]. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.15 congruence. % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 exact (zenon_H3c6 zenon_H3c1). % 119.90/120.15 apply (zenon_L201_); trivial. % 119.90/120.15 (* end of lemma zenon_L202_ *) % 119.90/120.15 assert (zenon_L203_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((tptp_minus_1) = (n0)) -> (zenon_TG_dq = (n0)) -> False). % 119.90/120.15 do 1 intro. intros zenon_H66 zenon_H3c1 zenon_H33d. % 119.90/120.15 generalize (irreflexivity_gt zenon_TG_dq). zenon_intro zenon_H3d2. % 119.90/120.15 apply (zenon_L202_ zenon_TG_dq); trivial. % 119.90/120.15 (* end of lemma zenon_L203_ *) % 119.90/120.15 assert (zenon_L204_ : ((tptp_minus_1) = (n1)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (tptp_minus_1) (tptp_minus_1))) -> False). % 119.90/120.15 do 0 intro. intros zenon_H3db zenon_H66 zenon_H3c2. % 119.90/120.15 elim (classic ((~((tptp_minus_1) = (n1)))/\(~(gt (tptp_minus_1) (n1))))); [ zenon_intro zenon_H3dc | zenon_intro zenon_H3dd ]. % 119.90/120.15 apply (zenon_and_s _ _ zenon_H3dc). zenon_intro zenon_H3df. zenon_intro zenon_H3de. % 119.90/120.15 exact (zenon_H3df zenon_H3db). % 119.90/120.15 cut ((gt (n1) (tptp_minus_1)) = (gt (tptp_minus_1) (tptp_minus_1))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3c2. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact gt_1_tptp_minus_1. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.15 cut (((n1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3e0]. % 119.90/120.15 congruence. % 119.90/120.15 apply (zenon_notand_s _ _ zenon_H3dd); [ zenon_intro zenon_H3e2 | zenon_intro zenon_H3e1 ]. % 119.90/120.15 apply zenon_H3e2. zenon_intro zenon_H3db. % 119.90/120.15 elim (classic ((tptp_minus_1) = (tptp_minus_1))); [ zenon_intro zenon_H3ca | zenon_intro zenon_H3b7 ]. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1)) = ((n1) = (tptp_minus_1))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3e0. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H3ca. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.15 cut (((tptp_minus_1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H3df]. % 119.90/120.15 congruence. % 119.90/120.15 exact (zenon_H3df zenon_H3db). % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 apply zenon_H3e1. zenon_intro zenon_H3e3. % 119.90/120.15 generalize (zenon_H66 (tptp_minus_1)). zenon_intro zenon_H3cc. % 119.90/120.15 generalize (zenon_H3cc (n1)). zenon_intro zenon_H3e4. % 119.90/120.15 generalize (zenon_H3e4 (tptp_minus_1)). zenon_intro zenon_H3e5. % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3e5); [ zenon_intro zenon_H3de | zenon_intro zenon_H3e6 ]. % 119.90/120.15 exact (zenon_H3de zenon_H3e3). % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3e6); [ zenon_intro zenon_H3e7 | zenon_intro zenon_H3d0 ]. % 119.90/120.15 exact (zenon_H3e7 gt_1_tptp_minus_1). % 119.90/120.15 exact (zenon_H3c2 zenon_H3d0). % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 (* end of lemma zenon_L204_ *) % 119.90/120.15 assert (zenon_L205_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(leq (tptp_minus_1) (n0))) -> False). % 119.90/120.15 do 0 intro. intros zenon_H66 zenon_H7d zenon_H67 zenon_H155 zenon_H3e8. % 119.90/120.15 generalize (leq_succ_gt_equiv (tptp_minus_1)). zenon_intro zenon_H3b9. % 119.90/120.15 generalize (zenon_H3b9 (n0)). zenon_intro zenon_H3e9. % 119.90/120.15 apply (zenon_equiv_s _ _ zenon_H3e9); [ zenon_intro zenon_H3e8; zenon_intro zenon_H3ec | zenon_intro zenon_H3eb; zenon_intro zenon_H3ea ]. % 119.90/120.15 elim (classic ((~((succ (n0)) = (n3)))/\(~(gt (succ (n0)) (n3))))); [ zenon_intro zenon_H3ed | zenon_intro zenon_H3ee ]. % 119.90/120.15 apply (zenon_and_s _ _ zenon_H3ed). zenon_intro zenon_H3ef. zenon_intro zenon_H249. % 119.90/120.15 apply (zenon_L186_); trivial. % 119.90/120.15 cut ((gt (n3) (tptp_minus_1)) = (gt (succ (n0)) (tptp_minus_1))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3ec. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact gt_3_tptp_minus_1. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.15 cut (((n3) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H3f0]. % 119.90/120.15 congruence. % 119.90/120.15 apply (zenon_notand_s _ _ zenon_H3ee); [ zenon_intro zenon_H3f2 | zenon_intro zenon_H3f1 ]. % 119.90/120.15 apply zenon_H3f2. zenon_intro zenon_H3f3. % 119.90/120.15 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.90/120.15 cut (((succ (n0)) = (succ (n0))) = ((n3) = (succ (n0)))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3f0. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H8b. % 119.90/120.15 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.90/120.15 cut (((succ (n0)) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H3ef]. % 119.90/120.15 congruence. % 119.90/120.15 exact (zenon_H3ef zenon_H3f3). % 119.90/120.15 apply zenon_H8c. apply refl_equal. % 119.90/120.15 apply zenon_H8c. apply refl_equal. % 119.90/120.15 apply zenon_H3f1. zenon_intro zenon_H248. % 119.90/120.15 generalize (zenon_H66 (succ (n0))). zenon_intro zenon_H8e. % 119.90/120.15 generalize (zenon_H8e (n3)). zenon_intro zenon_H24b. % 119.90/120.15 generalize (zenon_H24b (tptp_minus_1)). zenon_intro zenon_H3f4. % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3f4); [ zenon_intro zenon_H249 | zenon_intro zenon_H3f5 ]. % 119.90/120.15 exact (zenon_H249 zenon_H248). % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3f5); [ zenon_intro zenon_H3f6 | zenon_intro zenon_H3ea ]. % 119.90/120.15 exact (zenon_H3f6 gt_3_tptp_minus_1). % 119.90/120.15 exact (zenon_H3ec zenon_H3ea). % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 exact (zenon_H3e8 zenon_H3eb). % 119.90/120.15 (* end of lemma zenon_L205_ *) % 119.90/120.15 assert (zenon_L206_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt zenon_TG_dq zenon_TG_dq)) -> ((tptp_minus_1) = (n1)) -> (zenon_TG_dq = (n0)) -> ((tptp_minus_1) = (n0)) -> False). % 119.90/120.15 do 1 intro. intros zenon_H66 zenon_H3d2 zenon_H3db zenon_H33d zenon_H3c1. % 119.90/120.15 elim (classic (gt (n0) zenon_TG_dq)); [ zenon_intro zenon_H3a1 | zenon_intro zenon_H39a ]. % 119.90/120.15 cut ((gt (n0) zenon_TG_dq) = (gt zenon_TG_dq zenon_TG_dq)). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3d2. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H3a1. % 119.90/120.15 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.15 cut (((n0) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H334]. % 119.90/120.15 congruence. % 119.90/120.15 elim (classic (zenon_TG_dq = zenon_TG_dq)); [ zenon_intro zenon_H3d4 | zenon_intro zenon_H3d3 ]. % 119.90/120.15 cut ((zenon_TG_dq = zenon_TG_dq) = ((n0) = zenon_TG_dq)). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H334. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H3d4. % 119.90/120.15 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.15 cut ((zenon_TG_dq = (n0))); [idtac | apply NNPP; zenon_intro zenon_H3d5]. % 119.90/120.15 congruence. % 119.90/120.15 exact (zenon_H3d5 zenon_H33d). % 119.90/120.15 apply zenon_H3d3. apply refl_equal. % 119.90/120.15 apply zenon_H3d3. apply refl_equal. % 119.90/120.15 apply zenon_H3d3. apply refl_equal. % 119.90/120.15 elim (classic (gt (tptp_minus_1) zenon_TG_dq)); [ zenon_intro zenon_H3d6 | zenon_intro zenon_H3d7 ]. % 119.90/120.15 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.90/120.15 generalize (zenon_H142 (tptp_minus_1)). zenon_intro zenon_H3d8. % 119.90/120.15 generalize (zenon_H3d8 zenon_TG_dq). zenon_intro zenon_H3d9. % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3d9); [ zenon_intro zenon_H3d1 | zenon_intro zenon_H3da ]. % 119.90/120.15 exact (zenon_H3d1 gt_0_tptp_minus_1). % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3da); [ zenon_intro zenon_H3d7 | zenon_intro zenon_H3a1 ]. % 119.90/120.15 exact (zenon_H3d7 zenon_H3d6). % 119.90/120.15 exact (zenon_H39a zenon_H3a1). % 119.90/120.15 elim (classic (gt (tptp_minus_1) (tptp_minus_1))); [ zenon_intro zenon_H3d0 | zenon_intro zenon_H3c2 ]. % 119.90/120.15 elim (classic (gt (tptp_minus_1) (n0))); [ zenon_intro zenon_H3cb | zenon_intro zenon_H3c5 ]. % 119.90/120.15 cut ((gt (tptp_minus_1) (n0)) = (gt (tptp_minus_1) zenon_TG_dq)). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3d7. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H3cb. % 119.90/120.15 cut (((n0) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H334]. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.15 congruence. % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 apply zenon_H334. apply sym_equal. exact zenon_H33d. % 119.90/120.15 cut ((gt (tptp_minus_1) (tptp_minus_1)) = (gt (tptp_minus_1) (n0))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3c5. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H3d0. % 119.90/120.15 cut (((tptp_minus_1) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H3c6]. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.15 congruence. % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 exact (zenon_H3c6 zenon_H3c1). % 119.90/120.15 apply (zenon_L204_); trivial. % 119.90/120.15 (* end of lemma zenon_L206_ *) % 119.90/120.15 assert (zenon_L207_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((tptp_minus_1) = (n1)) -> (zenon_TG_dq = (n0)) -> ((tptp_minus_1) = (n0)) -> False). % 119.90/120.15 do 1 intro. intros zenon_H66 zenon_H3db zenon_H33d zenon_H3c1. % 119.90/120.15 generalize (irreflexivity_gt zenon_TG_dq). zenon_intro zenon_H3d2. % 119.90/120.15 apply (zenon_L206_ zenon_TG_dq); trivial. % 119.90/120.15 (* end of lemma zenon_L207_ *) % 119.90/120.15 assert (zenon_L208_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> ((tptp_minus_1) = (n1)) -> (zenon_TG_dq = (n0)) -> False). % 119.90/120.15 do 1 intro. intros zenon_H66 zenon_H155 zenon_H7d zenon_H67 zenon_H3db zenon_H33d. % 119.90/120.15 generalize (finite_domain_0 (tptp_minus_1)). zenon_intro zenon_H3f7. % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3f7); [ zenon_intro zenon_H3f8 | zenon_intro zenon_H3c1 ]. % 119.90/120.15 apply (zenon_notand_s _ _ zenon_H3f8); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H3e8 ]. % 119.90/120.15 apply (zenon_L198_); trivial. % 119.90/120.15 apply (zenon_L205_); trivial. % 119.90/120.15 apply (zenon_L207_ zenon_TG_dq); trivial. % 119.90/120.15 (* end of lemma zenon_L208_ *) % 119.90/120.15 assert (zenon_L209_ : ((tptp_minus_1) = (n2)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (tptp_minus_1) (tptp_minus_1))) -> False). % 119.90/120.15 do 0 intro. intros zenon_H3f9 zenon_H66 zenon_H3c2. % 119.90/120.15 elim (classic ((~((tptp_minus_1) = (n2)))/\(~(gt (tptp_minus_1) (n2))))); [ zenon_intro zenon_H3fa | zenon_intro zenon_H3fb ]. % 119.90/120.15 apply (zenon_and_s _ _ zenon_H3fa). zenon_intro zenon_H3fd. zenon_intro zenon_H3fc. % 119.90/120.15 exact (zenon_H3fd zenon_H3f9). % 119.90/120.15 cut ((gt (n2) (tptp_minus_1)) = (gt (tptp_minus_1) (tptp_minus_1))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3c2. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact gt_2_tptp_minus_1. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.15 cut (((n2) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3fe]. % 119.90/120.15 congruence. % 119.90/120.15 apply (zenon_notand_s _ _ zenon_H3fb); [ zenon_intro zenon_H400 | zenon_intro zenon_H3ff ]. % 119.90/120.15 apply zenon_H400. zenon_intro zenon_H3f9. % 119.90/120.15 elim (classic ((tptp_minus_1) = (tptp_minus_1))); [ zenon_intro zenon_H3ca | zenon_intro zenon_H3b7 ]. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1)) = ((n2) = (tptp_minus_1))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3fe. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H3ca. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.15 cut (((tptp_minus_1) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H3fd]. % 119.90/120.15 congruence. % 119.90/120.15 exact (zenon_H3fd zenon_H3f9). % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 apply zenon_H3ff. zenon_intro zenon_H401. % 119.90/120.15 generalize (zenon_H66 (tptp_minus_1)). zenon_intro zenon_H3cc. % 119.90/120.15 generalize (zenon_H3cc (n2)). zenon_intro zenon_H402. % 119.90/120.15 generalize (zenon_H402 (tptp_minus_1)). zenon_intro zenon_H403. % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H403); [ zenon_intro zenon_H3fc | zenon_intro zenon_H404 ]. % 119.90/120.15 exact (zenon_H3fc zenon_H401). % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H404); [ zenon_intro zenon_H3c0 | zenon_intro zenon_H3d0 ]. % 119.90/120.15 exact (zenon_H3c0 gt_2_tptp_minus_1). % 119.90/120.15 exact (zenon_H3c2 zenon_H3d0). % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 (* end of lemma zenon_L209_ *) % 119.90/120.15 assert (zenon_L210_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(leq (tptp_minus_1) (n0))) -> False). % 119.90/120.15 do 0 intro. intros zenon_H66 zenon_H7d zenon_H67 zenon_H155 zenon_H3e8. % 119.90/120.15 generalize (leq_succ_gt_equiv (tptp_minus_1)). zenon_intro zenon_H3b9. % 119.90/120.15 generalize (zenon_H3b9 (n0)). zenon_intro zenon_H3e9. % 119.90/120.15 apply (zenon_equiv_s _ _ zenon_H3e9); [ zenon_intro zenon_H3e8; zenon_intro zenon_H3ec | zenon_intro zenon_H3eb; zenon_intro zenon_H3ea ]. % 119.90/120.15 elim (classic ((~((succ (n0)) = (n3)))/\(~(gt (succ (n0)) (n3))))); [ zenon_intro zenon_H3ed | zenon_intro zenon_H3ee ]. % 119.90/120.15 apply (zenon_and_s _ _ zenon_H3ed). zenon_intro zenon_H3ef. zenon_intro zenon_H249. % 119.90/120.15 apply (zenon_L186_); trivial. % 119.90/120.15 cut ((gt (n3) (tptp_minus_1)) = (gt (succ (n0)) (tptp_minus_1))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3ec. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact gt_3_tptp_minus_1. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.15 cut (((n3) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H3f0]. % 119.90/120.15 congruence. % 119.90/120.15 apply (zenon_notand_s _ _ zenon_H3ee); [ zenon_intro zenon_H3f2 | zenon_intro zenon_H3f1 ]. % 119.90/120.15 apply zenon_H3f2. zenon_intro zenon_H3f3. % 119.90/120.15 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.90/120.15 cut (((succ (n0)) = (succ (n0))) = ((n3) = (succ (n0)))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3f0. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H8b. % 119.90/120.15 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.90/120.15 cut (((succ (n0)) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H3ef]. % 119.90/120.15 congruence. % 119.90/120.15 exact (zenon_H3ef zenon_H3f3). % 119.90/120.15 apply zenon_H8c. apply refl_equal. % 119.90/120.15 apply zenon_H8c. apply refl_equal. % 119.90/120.15 apply zenon_H3f1. zenon_intro zenon_H248. % 119.90/120.15 generalize (zenon_H66 (succ (n0))). zenon_intro zenon_H8e. % 119.90/120.15 generalize (zenon_H8e (n3)). zenon_intro zenon_H24b. % 119.90/120.15 generalize (zenon_H24b (tptp_minus_1)). zenon_intro zenon_H3f4. % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3f4); [ zenon_intro zenon_H249 | zenon_intro zenon_H3f5 ]. % 119.90/120.15 exact (zenon_H249 zenon_H248). % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3f5); [ zenon_intro zenon_H3f6 | zenon_intro zenon_H3ea ]. % 119.90/120.15 exact (zenon_H3f6 gt_3_tptp_minus_1). % 119.90/120.15 exact (zenon_H3ec zenon_H3ea). % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 exact (zenon_H3e8 zenon_H3eb). % 119.90/120.15 (* end of lemma zenon_L210_ *) % 119.90/120.15 assert (zenon_L211_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt zenon_TG_dq zenon_TG_dq)) -> ((tptp_minus_1) = (n2)) -> (zenon_TG_dq = (n0)) -> ((tptp_minus_1) = (n0)) -> False). % 119.90/120.15 do 1 intro. intros zenon_H66 zenon_H3d2 zenon_H3f9 zenon_H33d zenon_H3c1. % 119.90/120.15 elim (classic (gt (n0) zenon_TG_dq)); [ zenon_intro zenon_H3a1 | zenon_intro zenon_H39a ]. % 119.90/120.15 cut ((gt (n0) zenon_TG_dq) = (gt zenon_TG_dq zenon_TG_dq)). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3d2. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H3a1. % 119.90/120.15 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.15 cut (((n0) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H334]. % 119.90/120.15 congruence. % 119.90/120.15 elim (classic (zenon_TG_dq = zenon_TG_dq)); [ zenon_intro zenon_H3d4 | zenon_intro zenon_H3d3 ]. % 119.90/120.15 cut ((zenon_TG_dq = zenon_TG_dq) = ((n0) = zenon_TG_dq)). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H334. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H3d4. % 119.90/120.15 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.15 cut ((zenon_TG_dq = (n0))); [idtac | apply NNPP; zenon_intro zenon_H3d5]. % 119.90/120.15 congruence. % 119.90/120.15 exact (zenon_H3d5 zenon_H33d). % 119.90/120.15 apply zenon_H3d3. apply refl_equal. % 119.90/120.15 apply zenon_H3d3. apply refl_equal. % 119.90/120.15 apply zenon_H3d3. apply refl_equal. % 119.90/120.15 elim (classic (gt (tptp_minus_1) zenon_TG_dq)); [ zenon_intro zenon_H3d6 | zenon_intro zenon_H3d7 ]. % 119.90/120.15 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.90/120.15 generalize (zenon_H142 (tptp_minus_1)). zenon_intro zenon_H3d8. % 119.90/120.15 generalize (zenon_H3d8 zenon_TG_dq). zenon_intro zenon_H3d9. % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3d9); [ zenon_intro zenon_H3d1 | zenon_intro zenon_H3da ]. % 119.90/120.15 exact (zenon_H3d1 gt_0_tptp_minus_1). % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3da); [ zenon_intro zenon_H3d7 | zenon_intro zenon_H3a1 ]. % 119.90/120.15 exact (zenon_H3d7 zenon_H3d6). % 119.90/120.15 exact (zenon_H39a zenon_H3a1). % 119.90/120.15 elim (classic (gt (tptp_minus_1) (tptp_minus_1))); [ zenon_intro zenon_H3d0 | zenon_intro zenon_H3c2 ]. % 119.90/120.15 elim (classic (gt (tptp_minus_1) (n0))); [ zenon_intro zenon_H3cb | zenon_intro zenon_H3c5 ]. % 119.90/120.15 cut ((gt (tptp_minus_1) (n0)) = (gt (tptp_minus_1) zenon_TG_dq)). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3d7. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H3cb. % 119.90/120.15 cut (((n0) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H334]. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.15 congruence. % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 apply zenon_H334. apply sym_equal. exact zenon_H33d. % 119.90/120.15 cut ((gt (tptp_minus_1) (tptp_minus_1)) = (gt (tptp_minus_1) (n0))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H3c5. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H3d0. % 119.90/120.15 cut (((tptp_minus_1) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H3c6]. % 119.90/120.15 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.15 congruence. % 119.90/120.15 apply zenon_H3b7. apply refl_equal. % 119.90/120.15 exact (zenon_H3c6 zenon_H3c1). % 119.90/120.15 apply (zenon_L209_); trivial. % 119.90/120.15 (* end of lemma zenon_L211_ *) % 119.90/120.15 assert (zenon_L212_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((tptp_minus_1) = (n2)) -> (zenon_TG_dq = (n0)) -> ((tptp_minus_1) = (n0)) -> False). % 119.90/120.15 do 1 intro. intros zenon_H66 zenon_H3f9 zenon_H33d zenon_H3c1. % 119.90/120.15 generalize (irreflexivity_gt zenon_TG_dq). zenon_intro zenon_H3d2. % 119.90/120.15 apply (zenon_L211_ zenon_TG_dq); trivial. % 119.90/120.15 (* end of lemma zenon_L212_ *) % 119.90/120.15 assert (zenon_L213_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> ((tptp_minus_1) = (n2)) -> (zenon_TG_dq = (n0)) -> False). % 119.90/120.15 do 1 intro. intros zenon_H66 zenon_H155 zenon_H7d zenon_H67 zenon_H3f9 zenon_H33d. % 119.90/120.15 generalize (finite_domain_0 (tptp_minus_1)). zenon_intro zenon_H3f7. % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H3f7); [ zenon_intro zenon_H3f8 | zenon_intro zenon_H3c1 ]. % 119.90/120.15 apply (zenon_notand_s _ _ zenon_H3f8); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H3e8 ]. % 119.90/120.15 apply (zenon_L198_); trivial. % 119.90/120.15 apply (zenon_L210_); trivial. % 119.90/120.15 apply (zenon_L212_ zenon_TG_dq); trivial. % 119.90/120.15 (* end of lemma zenon_L213_ *) % 119.90/120.15 assert (zenon_L214_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n2)) (succ (loopcounter)))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.90/120.15 do 0 intro. intros zenon_H66 zenon_H405 zenon_H67 zenon_H7d zenon_H155. % 119.90/120.15 elim (classic (gt (succ (n2)) (succ (tptp_minus_1)))); [ zenon_intro zenon_H406 | zenon_intro zenon_H407 ]. % 119.90/120.15 elim (classic (gt (succ (n2)) (n0))); [ zenon_intro zenon_H408 | zenon_intro zenon_H409 ]. % 119.90/120.15 elim (classic (gt (n0) (succ (loopcounter)))); [ zenon_intro zenon_H146 | zenon_intro zenon_H140 ]. % 119.90/120.15 generalize (zenon_H66 (succ (n2))). zenon_intro zenon_H40a. % 119.90/120.15 generalize (zenon_H40a (n0)). zenon_intro zenon_H40b. % 119.90/120.15 generalize (zenon_H40b (succ (loopcounter))). zenon_intro zenon_H40c. % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H40c); [ zenon_intro zenon_H409 | zenon_intro zenon_H40d ]. % 119.90/120.15 exact (zenon_H409 zenon_H408). % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H40d); [ zenon_intro zenon_H140 | zenon_intro zenon_H40e ]. % 119.90/120.15 exact (zenon_H140 zenon_H146). % 119.90/120.15 exact (zenon_H405 zenon_H40e). % 119.90/120.15 apply (zenon_L127_); trivial. % 119.90/120.15 cut ((gt (succ (n2)) (succ (tptp_minus_1))) = (gt (succ (n2)) (n0))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H409. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H406. % 119.90/120.15 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.90/120.15 cut (((succ (n2)) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H40f]. % 119.90/120.15 congruence. % 119.90/120.15 apply zenon_H40f. apply refl_equal. % 119.90/120.15 exact (zenon_H16b succ_tptp_minus_1). % 119.90/120.15 elim (classic (gt (succ (n2)) (succ (n0)))); [ zenon_intro zenon_H410 | zenon_intro zenon_H411 ]. % 119.90/120.15 elim (classic (gt (succ (n2)) (n1))); [ zenon_intro zenon_H412 | zenon_intro zenon_H413 ]. % 119.90/120.15 elim (classic (gt (n1) (succ (tptp_minus_1)))); [ zenon_intro zenon_H297 | zenon_intro zenon_H295 ]. % 119.90/120.15 generalize (zenon_H66 (succ (n2))). zenon_intro zenon_H40a. % 119.90/120.15 generalize (zenon_H40a (n1)). zenon_intro zenon_H414. % 119.90/120.15 generalize (zenon_H414 (succ (tptp_minus_1))). zenon_intro zenon_H415. % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H415); [ zenon_intro zenon_H413 | zenon_intro zenon_H416 ]. % 119.90/120.15 exact (zenon_H413 zenon_H412). % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H416); [ zenon_intro zenon_H295 | zenon_intro zenon_H406 ]. % 119.90/120.15 exact (zenon_H295 zenon_H297). % 119.90/120.15 exact (zenon_H407 zenon_H406). % 119.90/120.15 apply (zenon_L129_); trivial. % 119.90/120.15 cut ((gt (succ (n2)) (succ (n0))) = (gt (succ (n2)) (n1))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H413. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H410. % 119.90/120.15 cut (((succ (n0)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H87]. % 119.90/120.15 cut (((succ (n2)) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H40f]. % 119.90/120.15 congruence. % 119.90/120.15 apply zenon_H40f. apply refl_equal. % 119.90/120.15 exact (zenon_H87 successor_1). % 119.90/120.15 elim (classic (gt (succ (n2)) (succ (succ (n0))))); [ zenon_intro zenon_H417 | zenon_intro zenon_H418 ]. % 119.90/120.15 elim (classic (gt (succ (n2)) (n2))); [ zenon_intro zenon_H419 | zenon_intro zenon_H41a ]. % 119.90/120.15 elim (classic (gt (n2) (succ (n0)))); [ zenon_intro zenon_Hfc | zenon_intro zenon_Hf9 ]. % 119.90/120.15 generalize (zenon_H66 (succ (n2))). zenon_intro zenon_H40a. % 119.90/120.15 generalize (zenon_H40a (n2)). zenon_intro zenon_H41b. % 119.90/120.15 generalize (zenon_H41b (succ (n0))). zenon_intro zenon_H41c. % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H41c); [ zenon_intro zenon_H41a | zenon_intro zenon_H41d ]. % 119.90/120.15 exact (zenon_H41a zenon_H419). % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H41d); [ zenon_intro zenon_Hf9 | zenon_intro zenon_H410 ]. % 119.90/120.15 exact (zenon_Hf9 zenon_Hfc). % 119.90/120.15 exact (zenon_H411 zenon_H410). % 119.90/120.15 apply (zenon_L25_); trivial. % 119.90/120.15 cut ((gt (succ (n2)) (succ (succ (n0)))) = (gt (succ (n2)) (n2))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H41a. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H417. % 119.90/120.15 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.90/120.15 cut (((succ (n2)) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H40f]. % 119.90/120.15 congruence. % 119.90/120.15 apply zenon_H40f. apply refl_equal. % 119.90/120.15 exact (zenon_H105 successor_2). % 119.90/120.15 elim (classic (gt (n3) (succ (succ (n0))))); [ zenon_intro zenon_H24a | zenon_intro zenon_H202 ]. % 119.90/120.15 elim (classic (gt (succ (succ (succ (n0)))) (succ (succ (n0))))); [ zenon_intro zenon_H41e | zenon_intro zenon_H41f ]. % 119.90/120.15 cut ((gt (succ (succ (succ (n0)))) (succ (succ (n0)))) = (gt (succ (n2)) (succ (succ (n0))))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H418. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H41e. % 119.90/120.15 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.90/120.15 cut (((succ (succ (succ (n0)))) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H420]. % 119.90/120.15 congruence. % 119.90/120.15 elim (classic ((succ (n2)) = (succ (n2)))); [ zenon_intro zenon_H421 | zenon_intro zenon_H40f ]. % 119.90/120.15 cut (((succ (n2)) = (succ (n2))) = ((succ (succ (succ (n0)))) = (succ (n2)))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H420. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H421. % 119.90/120.15 cut (((succ (n2)) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H40f]. % 119.90/120.15 cut (((succ (n2)) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H422]. % 119.90/120.15 congruence. % 119.90/120.15 cut (((n2) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 119.90/120.15 congruence. % 119.90/120.15 apply zenon_H102. apply sym_equal. exact successor_2. % 119.90/120.15 apply zenon_H40f. apply refl_equal. % 119.90/120.15 apply zenon_H40f. apply refl_equal. % 119.90/120.15 apply zenon_H104. apply refl_equal. % 119.90/120.15 cut ((gt (n3) (succ (succ (n0)))) = (gt (succ (succ (succ (n0)))) (succ (succ (n0))))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H41f. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H24a. % 119.90/120.15 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.90/120.15 cut (((n3) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H99]. % 119.90/120.15 congruence. % 119.90/120.15 elim (classic ((succ (succ (succ (n0)))) = (succ (succ (succ (n0)))))); [ zenon_intro zenon_H21d | zenon_intro zenon_H21e ]. % 119.90/120.15 cut (((succ (succ (succ (n0)))) = (succ (succ (succ (n0))))) = ((n3) = (succ (succ (succ (n0)))))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H99. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H21d. % 119.90/120.15 cut (((succ (succ (succ (n0)))) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H21e]. % 119.90/120.15 cut (((succ (succ (succ (n0)))) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H21f]. % 119.90/120.15 congruence. % 119.90/120.15 exact (zenon_H21f successor_3). % 119.90/120.15 apply zenon_H21e. apply refl_equal. % 119.90/120.15 apply zenon_H21e. apply refl_equal. % 119.90/120.15 apply zenon_H104. apply refl_equal. % 119.90/120.15 apply (zenon_L86_); trivial. % 119.90/120.15 (* end of lemma zenon_L214_ *) % 119.90/120.15 assert (zenon_L215_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n2)) (n3))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.90/120.15 do 0 intro. intros zenon_H66 zenon_H423 zenon_H155 zenon_H7d zenon_H67. % 119.90/120.15 elim (classic ((~((succ (n2)) = (succ (loopcounter))))/\(~(gt (succ (n2)) (succ (loopcounter)))))); [ zenon_intro zenon_H424 | zenon_intro zenon_H425 ]. % 119.90/120.15 apply (zenon_and_s _ _ zenon_H424). zenon_intro zenon_H426. zenon_intro zenon_H405. % 119.90/120.15 apply (zenon_L214_); trivial. % 119.90/120.15 elim (classic (gt (n1) (n3))); [ zenon_intro zenon_H1ee | zenon_intro zenon_H1e6 ]. % 119.90/120.15 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.15 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.15 generalize (zenon_H78 (n3)). zenon_intro zenon_H20f. % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H20f); [ zenon_intro zenon_H6f | zenon_intro zenon_H210 ]. % 119.90/120.15 exact (zenon_H6f zenon_H67). % 119.90/120.15 apply (zenon_imply_s _ _ zenon_H210); [ zenon_intro zenon_H1e6 | zenon_intro zenon_H211 ]. % 119.90/120.15 exact (zenon_H1e6 zenon_H1ee). % 119.90/120.15 cut ((gt (succ (loopcounter)) (n3)) = (gt (succ (n2)) (n3))). % 119.90/120.15 intro zenon_D_pnotp. % 119.90/120.15 apply zenon_H423. % 119.90/120.15 rewrite <- zenon_D_pnotp. % 119.90/120.15 exact zenon_H211. % 119.90/120.15 cut (((n3) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H201]. % 119.90/120.16 cut (((succ (loopcounter)) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H427]. % 119.90/120.16 congruence. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H425); [ zenon_intro zenon_H429 | zenon_intro zenon_H428 ]. % 119.90/120.16 apply zenon_H429. zenon_intro zenon_H42a. % 119.90/120.16 apply zenon_H427. apply sym_equal. exact zenon_H42a. % 119.90/120.16 apply zenon_H428. zenon_intro zenon_H40e. % 119.90/120.16 generalize (zenon_H66 (succ (n2))). zenon_intro zenon_H40a. % 119.90/120.16 generalize (zenon_H40a (succ (loopcounter))). zenon_intro zenon_H42b. % 119.90/120.16 generalize (zenon_H42b (n3)). zenon_intro zenon_H42c. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H42c); [ zenon_intro zenon_H405 | zenon_intro zenon_H42d ]. % 119.90/120.16 exact (zenon_H405 zenon_H40e). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H42d); [ zenon_intro zenon_H21a | zenon_intro zenon_H42e ]. % 119.90/120.16 exact (zenon_H21a zenon_H211). % 119.90/120.16 exact (zenon_H423 zenon_H42e). % 119.90/120.16 apply zenon_H201. apply refl_equal. % 119.90/120.16 apply (zenon_L171_); trivial. % 119.90/120.16 (* end of lemma zenon_L215_ *) % 119.90/120.16 assert (zenon_L216_ : ((tptp_minus_1) = (n3)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (tptp_minus_1) (tptp_minus_1))) -> False). % 119.90/120.16 do 0 intro. intros zenon_H42f zenon_H66 zenon_H3c2. % 119.90/120.16 elim (classic ((~((tptp_minus_1) = (n3)))/\(~(gt (tptp_minus_1) (n3))))); [ zenon_intro zenon_H430 | zenon_intro zenon_H431 ]. % 119.90/120.16 apply (zenon_and_s _ _ zenon_H430). zenon_intro zenon_H433. zenon_intro zenon_H432. % 119.90/120.16 exact (zenon_H433 zenon_H42f). % 119.90/120.16 cut ((gt (n3) (tptp_minus_1)) = (gt (tptp_minus_1) (tptp_minus_1))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H3c2. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact gt_3_tptp_minus_1. % 119.90/120.16 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.16 cut (((n3) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H434]. % 119.90/120.16 congruence. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H431); [ zenon_intro zenon_H436 | zenon_intro zenon_H435 ]. % 119.90/120.16 apply zenon_H436. zenon_intro zenon_H42f. % 119.90/120.16 elim (classic ((tptp_minus_1) = (tptp_minus_1))); [ zenon_intro zenon_H3ca | zenon_intro zenon_H3b7 ]. % 119.90/120.16 cut (((tptp_minus_1) = (tptp_minus_1)) = ((n3) = (tptp_minus_1))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H434. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H3ca. % 119.90/120.16 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.16 cut (((tptp_minus_1) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H433]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_H433 zenon_H42f). % 119.90/120.16 apply zenon_H3b7. apply refl_equal. % 119.90/120.16 apply zenon_H3b7. apply refl_equal. % 119.90/120.16 apply zenon_H435. zenon_intro zenon_H437. % 119.90/120.16 generalize (zenon_H66 (tptp_minus_1)). zenon_intro zenon_H3cc. % 119.90/120.16 generalize (zenon_H3cc (n3)). zenon_intro zenon_H438. % 119.90/120.16 generalize (zenon_H438 (tptp_minus_1)). zenon_intro zenon_H439. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H439); [ zenon_intro zenon_H432 | zenon_intro zenon_H43a ]. % 119.90/120.16 exact (zenon_H432 zenon_H437). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H43a); [ zenon_intro zenon_H3f6 | zenon_intro zenon_H3d0 ]. % 119.90/120.16 exact (zenon_H3f6 gt_3_tptp_minus_1). % 119.90/120.16 exact (zenon_H3c2 zenon_H3d0). % 119.90/120.16 apply zenon_H3b7. apply refl_equal. % 119.90/120.16 (* end of lemma zenon_L216_ *) % 119.90/120.16 assert (zenon_L217_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(leq (tptp_minus_1) (n2))) -> False). % 119.90/120.16 do 0 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_H155 zenon_H43b. % 119.90/120.16 generalize (leq_succ_gt_equiv (tptp_minus_1)). zenon_intro zenon_H3b9. % 119.90/120.16 generalize (zenon_H3b9 (n2)). zenon_intro zenon_H43c. % 119.90/120.16 apply (zenon_equiv_s _ _ zenon_H43c); [ zenon_intro zenon_H43b; zenon_intro zenon_H43f | zenon_intro zenon_H43e; zenon_intro zenon_H43d ]. % 119.90/120.16 elim (classic ((~((succ (n2)) = (n3)))/\(~(gt (succ (n2)) (n3))))); [ zenon_intro zenon_H440 | zenon_intro zenon_H441 ]. % 119.90/120.16 apply (zenon_and_s _ _ zenon_H440). zenon_intro zenon_H442. zenon_intro zenon_H423. % 119.90/120.16 apply (zenon_L215_); trivial. % 119.90/120.16 cut ((gt (n3) (tptp_minus_1)) = (gt (succ (n2)) (tptp_minus_1))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H43f. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact gt_3_tptp_minus_1. % 119.90/120.16 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.16 cut (((n3) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H443]. % 119.90/120.16 congruence. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H441); [ zenon_intro zenon_H445 | zenon_intro zenon_H444 ]. % 119.90/120.16 apply zenon_H445. zenon_intro zenon_H446. % 119.90/120.16 elim (classic ((succ (n2)) = (succ (n2)))); [ zenon_intro zenon_H421 | zenon_intro zenon_H40f ]. % 119.90/120.16 cut (((succ (n2)) = (succ (n2))) = ((n3) = (succ (n2)))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H443. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H421. % 119.90/120.16 cut (((succ (n2)) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H40f]. % 119.90/120.16 cut (((succ (n2)) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H442]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_H442 zenon_H446). % 119.90/120.16 apply zenon_H40f. apply refl_equal. % 119.90/120.16 apply zenon_H40f. apply refl_equal. % 119.90/120.16 apply zenon_H444. zenon_intro zenon_H42e. % 119.90/120.16 generalize (zenon_H66 (succ (n2))). zenon_intro zenon_H40a. % 119.90/120.16 generalize (zenon_H40a (n3)). zenon_intro zenon_H447. % 119.90/120.16 generalize (zenon_H447 (tptp_minus_1)). zenon_intro zenon_H448. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H448); [ zenon_intro zenon_H423 | zenon_intro zenon_H449 ]. % 119.90/120.16 exact (zenon_H423 zenon_H42e). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H449); [ zenon_intro zenon_H3f6 | zenon_intro zenon_H43d ]. % 119.90/120.16 exact (zenon_H3f6 gt_3_tptp_minus_1). % 119.90/120.16 exact (zenon_H43f zenon_H43d). % 119.90/120.16 apply zenon_H3b7. apply refl_equal. % 119.90/120.16 exact (zenon_H43b zenon_H43e). % 119.90/120.16 (* end of lemma zenon_L217_ *) % 119.90/120.16 assert (zenon_L218_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt zenon_TG_dq zenon_TG_dq)) -> ((tptp_minus_1) = (n3)) -> (zenon_TG_dq = (n0)) -> ((tptp_minus_1) = (n0)) -> False). % 119.90/120.16 do 1 intro. intros zenon_H66 zenon_H3d2 zenon_H42f zenon_H33d zenon_H3c1. % 119.90/120.16 elim (classic (gt (n0) zenon_TG_dq)); [ zenon_intro zenon_H3a1 | zenon_intro zenon_H39a ]. % 119.90/120.16 cut ((gt (n0) zenon_TG_dq) = (gt zenon_TG_dq zenon_TG_dq)). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H3d2. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H3a1. % 119.90/120.16 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.16 cut (((n0) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H334]. % 119.90/120.16 congruence. % 119.90/120.16 elim (classic (zenon_TG_dq = zenon_TG_dq)); [ zenon_intro zenon_H3d4 | zenon_intro zenon_H3d3 ]. % 119.90/120.16 cut ((zenon_TG_dq = zenon_TG_dq) = ((n0) = zenon_TG_dq)). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H334. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H3d4. % 119.90/120.16 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.16 cut ((zenon_TG_dq = (n0))); [idtac | apply NNPP; zenon_intro zenon_H3d5]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_H3d5 zenon_H33d). % 119.90/120.16 apply zenon_H3d3. apply refl_equal. % 119.90/120.16 apply zenon_H3d3. apply refl_equal. % 119.90/120.16 apply zenon_H3d3. apply refl_equal. % 119.90/120.16 elim (classic (gt (tptp_minus_1) zenon_TG_dq)); [ zenon_intro zenon_H3d6 | zenon_intro zenon_H3d7 ]. % 119.90/120.16 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.90/120.16 generalize (zenon_H142 (tptp_minus_1)). zenon_intro zenon_H3d8. % 119.90/120.16 generalize (zenon_H3d8 zenon_TG_dq). zenon_intro zenon_H3d9. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H3d9); [ zenon_intro zenon_H3d1 | zenon_intro zenon_H3da ]. % 119.90/120.16 exact (zenon_H3d1 gt_0_tptp_minus_1). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H3da); [ zenon_intro zenon_H3d7 | zenon_intro zenon_H3a1 ]. % 119.90/120.16 exact (zenon_H3d7 zenon_H3d6). % 119.90/120.16 exact (zenon_H39a zenon_H3a1). % 119.90/120.16 elim (classic (gt (tptp_minus_1) (tptp_minus_1))); [ zenon_intro zenon_H3d0 | zenon_intro zenon_H3c2 ]. % 119.90/120.16 elim (classic (gt (tptp_minus_1) (n0))); [ zenon_intro zenon_H3cb | zenon_intro zenon_H3c5 ]. % 119.90/120.16 cut ((gt (tptp_minus_1) (n0)) = (gt (tptp_minus_1) zenon_TG_dq)). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H3d7. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H3cb. % 119.90/120.16 cut (((n0) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H334]. % 119.90/120.16 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.16 congruence. % 119.90/120.16 apply zenon_H3b7. apply refl_equal. % 119.90/120.16 apply zenon_H334. apply sym_equal. exact zenon_H33d. % 119.90/120.16 cut ((gt (tptp_minus_1) (tptp_minus_1)) = (gt (tptp_minus_1) (n0))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H3c5. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H3d0. % 119.90/120.16 cut (((tptp_minus_1) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H3c6]. % 119.90/120.16 cut (((tptp_minus_1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3b7]. % 119.90/120.16 congruence. % 119.90/120.16 apply zenon_H3b7. apply refl_equal. % 119.90/120.16 exact (zenon_H3c6 zenon_H3c1). % 119.90/120.16 apply (zenon_L216_); trivial. % 119.90/120.16 (* end of lemma zenon_L218_ *) % 119.90/120.16 assert (zenon_L219_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((tptp_minus_1) = (n3)) -> (zenon_TG_dq = (n0)) -> ((tptp_minus_1) = (n0)) -> False). % 119.90/120.16 do 1 intro. intros zenon_H66 zenon_H42f zenon_H33d zenon_H3c1. % 119.90/120.16 generalize (irreflexivity_gt zenon_TG_dq). zenon_intro zenon_H3d2. % 119.90/120.16 apply (zenon_L218_ zenon_TG_dq); trivial. % 119.90/120.16 (* end of lemma zenon_L219_ *) % 119.90/120.16 assert (zenon_L220_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n0)) -> False). % 119.90/120.16 do 1 intro. intros zenon_H66 zenon_H155 zenon_H7d zenon_H67 zenon_H33d. % 119.90/120.16 generalize (finite_domain_3 (tptp_minus_1)). zenon_intro zenon_H44a. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H44a); [ zenon_intro zenon_H44c | zenon_intro zenon_H44b ]. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H44c); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H3b8 ]. % 119.90/120.16 apply (zenon_L198_); trivial. % 119.90/120.16 apply (zenon_L200_); trivial. % 119.90/120.16 apply (zenon_or_s _ _ zenon_H44b); [ zenon_intro zenon_H3c1 | zenon_intro zenon_H44d ]. % 119.90/120.16 apply (zenon_L203_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_or_s _ _ zenon_H44d); [ zenon_intro zenon_H3db | zenon_intro zenon_H44e ]. % 119.90/120.16 apply (zenon_L208_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_or_s _ _ zenon_H44e); [ zenon_intro zenon_H3f9 | zenon_intro zenon_H42f ]. % 119.90/120.16 apply (zenon_L213_ zenon_TG_dq); trivial. % 119.90/120.16 generalize (finite_domain_2 (tptp_minus_1)). zenon_intro zenon_H44f. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H44f); [ zenon_intro zenon_H451 | zenon_intro zenon_H450 ]. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H451); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H43b ]. % 119.90/120.16 apply (zenon_L198_); trivial. % 119.90/120.16 apply (zenon_L217_); trivial. % 119.90/120.16 apply (zenon_or_s _ _ zenon_H450); [ zenon_intro zenon_H3c1 | zenon_intro zenon_H452 ]. % 119.90/120.16 apply (zenon_L219_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_or_s _ _ zenon_H452); [ zenon_intro zenon_H3db | zenon_intro zenon_H3f9 ]. % 119.90/120.16 apply (zenon_L208_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_L213_ zenon_TG_dq); trivial. % 119.90/120.16 (* end of lemma zenon_L220_ *) % 119.90/120.16 assert (zenon_L221_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n1)) -> (~(leq zenon_TG_dq (n0))) -> False). % 119.90/120.16 do 1 intro. intros zenon_H66 zenon_H7d zenon_H67 zenon_H33f zenon_H453. % 119.90/120.16 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.16 generalize (zenon_H330 (n0)). zenon_intro zenon_H454. % 119.90/120.16 apply (zenon_equiv_s _ _ zenon_H454); [ zenon_intro zenon_H453; zenon_intro zenon_H457 | zenon_intro zenon_H456; zenon_intro zenon_H455 ]. % 119.90/120.16 elim (classic ((~((succ (n0)) = (succ (loopcounter))))/\(~(gt (succ (n0)) (succ (loopcounter)))))); [ zenon_intro zenon_Hce | zenon_intro zenon_Hcf ]. % 119.90/120.16 apply (zenon_and_s _ _ zenon_Hce). zenon_intro zenon_H97. zenon_intro zenon_Hd0. % 119.90/120.16 apply (zenon_L9_); trivial. % 119.90/120.16 elim (classic ((n1) = zenon_TG_dq)); [ zenon_intro zenon_H458 | zenon_intro zenon_H335 ]. % 119.90/120.16 cut ((gt (succ (loopcounter)) (n1)) = (gt (succ (n0)) zenon_TG_dq)). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H457. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H67. % 119.90/120.16 cut (((n1) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H335]. % 119.90/120.16 cut (((succ (loopcounter)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_Hd2]. % 119.90/120.16 congruence. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_Hcf); [ zenon_intro zenon_Hd4 | zenon_intro zenon_Hd3 ]. % 119.90/120.16 apply zenon_Hd4. zenon_intro zenon_Hd5. % 119.90/120.16 elim (classic ((succ (n0)) = (succ (n0)))); [ zenon_intro zenon_H8b | zenon_intro zenon_H8c ]. % 119.90/120.16 cut (((succ (n0)) = (succ (n0))) = ((succ (loopcounter)) = (succ (n0)))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_Hd2. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H8b. % 119.90/120.16 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.90/120.16 cut (((succ (n0)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H97]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_H97 zenon_Hd5). % 119.90/120.16 apply zenon_H8c. apply refl_equal. % 119.90/120.16 apply zenon_H8c. apply refl_equal. % 119.90/120.16 apply zenon_Hd3. zenon_intro zenon_Hd6. % 119.90/120.16 generalize (zenon_H66 (succ (n0))). zenon_intro zenon_H8e. % 119.90/120.16 generalize (zenon_H8e (succ (loopcounter))). zenon_intro zenon_Hd7. % 119.90/120.16 generalize (zenon_Hd7 (n1)). zenon_intro zenon_Hd8. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_Hd8); [ zenon_intro zenon_Hd0 | zenon_intro zenon_Hd9 ]. % 119.90/120.16 exact (zenon_Hd0 zenon_Hd6). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_Hd9); [ zenon_intro zenon_H6f | zenon_intro zenon_H8d ]. % 119.90/120.16 exact (zenon_H6f zenon_H67). % 119.90/120.16 cut ((gt (succ (n0)) (n1)) = (gt (succ (n0)) zenon_TG_dq)). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H457. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H8d. % 119.90/120.16 cut (((n1) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H335]. % 119.90/120.16 cut (((succ (n0)) = (succ (n0)))); [idtac | apply NNPP; zenon_intro zenon_H8c]. % 119.90/120.16 congruence. % 119.90/120.16 apply zenon_H8c. apply refl_equal. % 119.90/120.16 exact (zenon_H335 zenon_H458). % 119.90/120.16 exact (zenon_H335 zenon_H458). % 119.90/120.16 apply zenon_H335. apply sym_equal. exact zenon_H33f. % 119.90/120.16 exact (zenon_H453 zenon_H456). % 119.90/120.16 (* end of lemma zenon_L221_ *) % 119.90/120.16 assert (zenon_L222_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ zenon_TG_dq) (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n1)) -> ((tptp_minus_1) = (n0)) -> False). % 119.90/120.16 do 1 intro. intros zenon_H66 zenon_H5c zenon_H7d zenon_H67 zenon_H33f zenon_H3c1. % 119.90/120.16 generalize (finite_domain_0 zenon_TG_dq). zenon_intro zenon_H459. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H459); [ zenon_intro zenon_H45a | zenon_intro zenon_H33d ]. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H45a); [ zenon_intro zenon_H5d | zenon_intro zenon_H453 ]. % 119.90/120.16 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_L221_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_L203_ zenon_TG_dq); trivial. % 119.90/120.16 (* end of lemma zenon_L222_ *) % 119.90/120.16 assert (zenon_L223_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> ((tptp_minus_1) = (n1)) -> (gt (succ zenon_TG_dq) (n0)) -> (zenon_TG_dq = (n1)) -> False). % 119.90/120.16 do 1 intro. intros zenon_H66 zenon_H155 zenon_H7d zenon_H67 zenon_H3db zenon_H5c zenon_H33f. % 119.90/120.16 generalize (finite_domain_0 (tptp_minus_1)). zenon_intro zenon_H3f7. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H3f7); [ zenon_intro zenon_H3f8 | zenon_intro zenon_H3c1 ]. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H3f8); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H3e8 ]. % 119.90/120.16 apply (zenon_L198_); trivial. % 119.90/120.16 apply (zenon_L205_); trivial. % 119.90/120.16 generalize (finite_domain_0 zenon_TG_dq). zenon_intro zenon_H459. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H459); [ zenon_intro zenon_H45a | zenon_intro zenon_H33d ]. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H45a); [ zenon_intro zenon_H5d | zenon_intro zenon_H453 ]. % 119.90/120.16 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_L221_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_L207_ zenon_TG_dq); trivial. % 119.90/120.16 (* end of lemma zenon_L223_ *) % 119.90/120.16 assert (zenon_L224_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> ((tptp_minus_1) = (n2)) -> (gt (succ zenon_TG_dq) (n0)) -> (zenon_TG_dq = (n1)) -> False). % 119.90/120.16 do 1 intro. intros zenon_H66 zenon_H155 zenon_H7d zenon_H67 zenon_H3f9 zenon_H5c zenon_H33f. % 119.90/120.16 generalize (finite_domain_0 (tptp_minus_1)). zenon_intro zenon_H3f7. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H3f7); [ zenon_intro zenon_H3f8 | zenon_intro zenon_H3c1 ]. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H3f8); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H3e8 ]. % 119.90/120.16 apply (zenon_L198_); trivial. % 119.90/120.16 apply (zenon_L210_); trivial. % 119.90/120.16 generalize (finite_domain_0 zenon_TG_dq). zenon_intro zenon_H459. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H459); [ zenon_intro zenon_H45a | zenon_intro zenon_H33d ]. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H45a); [ zenon_intro zenon_H5d | zenon_intro zenon_H453 ]. % 119.90/120.16 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_L221_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_L212_ zenon_TG_dq); trivial. % 119.90/120.16 (* end of lemma zenon_L224_ *) % 119.90/120.16 assert (zenon_L225_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ zenon_TG_dq) (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n1)) -> ((tptp_minus_1) = (n3)) -> ((tptp_minus_1) = (n0)) -> False). % 119.90/120.16 do 1 intro. intros zenon_H66 zenon_H5c zenon_H7d zenon_H67 zenon_H33f zenon_H42f zenon_H3c1. % 119.90/120.16 generalize (finite_domain_0 zenon_TG_dq). zenon_intro zenon_H459. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H459); [ zenon_intro zenon_H45a | zenon_intro zenon_H33d ]. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H45a); [ zenon_intro zenon_H5d | zenon_intro zenon_H453 ]. % 119.90/120.16 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_L221_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_L219_ zenon_TG_dq); trivial. % 119.90/120.16 (* end of lemma zenon_L225_ *) % 119.90/120.16 assert (zenon_L226_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (gt (succ zenon_TG_dq) (n0)) -> (zenon_TG_dq = (n1)) -> False). % 119.90/120.16 do 1 intro. intros zenon_H66 zenon_H155 zenon_H7d zenon_H67 zenon_H5c zenon_H33f. % 119.90/120.16 generalize (finite_domain_3 (tptp_minus_1)). zenon_intro zenon_H44a. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H44a); [ zenon_intro zenon_H44c | zenon_intro zenon_H44b ]. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H44c); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H3b8 ]. % 119.90/120.16 apply (zenon_L198_); trivial. % 119.90/120.16 apply (zenon_L200_); trivial. % 119.90/120.16 apply (zenon_or_s _ _ zenon_H44b); [ zenon_intro zenon_H3c1 | zenon_intro zenon_H44d ]. % 119.90/120.16 apply (zenon_L222_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_or_s _ _ zenon_H44d); [ zenon_intro zenon_H3db | zenon_intro zenon_H44e ]. % 119.90/120.16 apply (zenon_L223_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_or_s _ _ zenon_H44e); [ zenon_intro zenon_H3f9 | zenon_intro zenon_H42f ]. % 119.90/120.16 apply (zenon_L224_ zenon_TG_dq); trivial. % 119.90/120.16 generalize (finite_domain_2 (tptp_minus_1)). zenon_intro zenon_H44f. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H44f); [ zenon_intro zenon_H451 | zenon_intro zenon_H450 ]. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H451); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H43b ]. % 119.90/120.16 apply (zenon_L198_); trivial. % 119.90/120.16 apply (zenon_L217_); trivial. % 119.90/120.16 apply (zenon_or_s _ _ zenon_H450); [ zenon_intro zenon_H3c1 | zenon_intro zenon_H452 ]. % 119.90/120.16 apply (zenon_L225_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_or_s _ _ zenon_H452); [ zenon_intro zenon_H3db | zenon_intro zenon_H3f9 ]. % 119.90/120.16 apply (zenon_L223_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_L224_ zenon_TG_dq); trivial. % 119.90/120.16 (* end of lemma zenon_L226_ *) % 119.90/120.16 assert (zenon_L227_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n3) (n3))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.90/120.16 do 0 intro. intros zenon_H66 zenon_H24e zenon_H67 zenon_H7d zenon_H155. % 119.90/120.16 elim (classic (gt (n2) (n3))); [ zenon_intro zenon_H223 | zenon_intro zenon_H220 ]. % 119.90/120.16 generalize (zenon_H66 (n3)). zenon_intro zenon_H24f. % 119.90/120.16 generalize (zenon_H24f (n2)). zenon_intro zenon_H250. % 119.90/120.16 generalize (zenon_H250 (n3)). zenon_intro zenon_H251. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H251); [ zenon_intro zenon_H22f | zenon_intro zenon_H252 ]. % 119.90/120.16 exact (zenon_H22f gt_3_2). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H252); [ zenon_intro zenon_H220 | zenon_intro zenon_H253 ]. % 119.90/120.16 exact (zenon_H220 zenon_H223). % 119.90/120.16 exact (zenon_H24e zenon_H253). % 119.90/120.16 apply (zenon_L190_); trivial. % 119.90/120.16 (* end of lemma zenon_L227_ *) % 119.90/120.16 assert (zenon_L228_ : (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (sum (n0) (tptp_minus_1) zenon_E) (succ (succ (succ (n0)))))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> False). % 119.90/120.16 do 0 intro. intros zenon_H67 zenon_H7d zenon_H155 zenon_H272 zenon_H66. % 119.90/120.16 elim (classic ((n0) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H180 | zenon_intro zenon_H167 ]. % 119.90/120.16 elim (classic (gt (succ (tptp_minus_1)) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H258 | zenon_intro zenon_H255 ]. % 119.90/120.16 elim (classic (gt (n0) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H273 | zenon_intro zenon_H274 ]. % 119.90/120.16 cut ((gt (n0) (succ (succ (succ (n0))))) = (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (succ (succ (n0)))))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H272. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H273. % 119.90/120.16 cut (((succ (succ (succ (n0)))) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H21e]. % 119.90/120.16 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.90/120.16 congruence. % 119.90/120.16 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.90/120.16 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H159. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H15a. % 119.90/120.16 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.90/120.16 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_H15b zenon_H155). % 119.90/120.16 apply zenon_H158. apply refl_equal. % 119.90/120.16 apply zenon_H158. apply refl_equal. % 119.90/120.16 apply zenon_H21e. apply refl_equal. % 119.90/120.16 cut ((gt (succ (tptp_minus_1)) (succ (succ (succ (n0))))) = (gt (n0) (succ (succ (succ (n0)))))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H274. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H258. % 119.90/120.16 cut (((succ (succ (succ (n0)))) = (succ (succ (succ (n0)))))); [idtac | apply NNPP; zenon_intro zenon_H21e]. % 119.90/120.16 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.90/120.16 congruence. % 119.90/120.16 elim (classic ((n0) = (n0))); [ zenon_intro zenon_H136 | zenon_intro zenon_H65 ]. % 119.90/120.16 cut (((n0) = (n0)) = ((succ (tptp_minus_1)) = (n0))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H16b. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H136. % 119.90/120.16 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.90/120.16 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_H167 zenon_H180). % 119.90/120.16 apply zenon_H65. apply refl_equal. % 119.90/120.16 apply zenon_H65. apply refl_equal. % 119.90/120.16 apply zenon_H21e. apply refl_equal. % 119.90/120.16 apply (zenon_L195_); trivial. % 119.90/120.16 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.90/120.16 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H167. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H16a. % 119.90/120.16 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.90/120.16 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_H16b succ_tptp_minus_1). % 119.90/120.16 apply zenon_H169. apply refl_equal. % 119.90/120.16 apply zenon_H169. apply refl_equal. % 119.90/120.16 (* end of lemma zenon_L228_ *) % 119.90/120.16 assert (zenon_L229_ : (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(gt (n0) (n3))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.90/120.16 do 0 intro. intros zenon_H7d zenon_H67 zenon_H254 zenon_H66 zenon_H155. % 119.90/120.16 elim (classic ((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15c | zenon_intro zenon_H159 ]. % 119.90/120.16 elim (classic (gt (n0) (n0))); [ zenon_intro zenon_H141 | zenon_intro zenon_H12f ]. % 119.90/120.16 elim (classic (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H156 | zenon_intro zenon_H157 ]. % 119.90/120.16 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (n3))); [ zenon_intro zenon_H27e | zenon_intro zenon_H275 ]. % 119.90/120.16 generalize (zenon_H66 (n0)). zenon_intro zenon_H142. % 119.90/120.16 generalize (zenon_H142 (sum (n0) (tptp_minus_1) zenon_E)). zenon_intro zenon_H160. % 119.90/120.16 generalize (zenon_H160 (n3)). zenon_intro zenon_H45b. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H45b); [ zenon_intro zenon_H157 | zenon_intro zenon_H45c ]. % 119.90/120.16 exact (zenon_H157 zenon_H156). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H45c); [ zenon_intro zenon_H275 | zenon_intro zenon_H28b ]. % 119.90/120.16 exact (zenon_H275 zenon_H27e). % 119.90/120.16 exact (zenon_H254 zenon_H28b). % 119.90/120.16 elim (classic (gt (sum (n0) (tptp_minus_1) zenon_E) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H276 | zenon_intro zenon_H272 ]. % 119.90/120.16 cut ((gt (sum (n0) (tptp_minus_1) zenon_E) (succ (succ (succ (n0))))) = (gt (sum (n0) (tptp_minus_1) zenon_E) (n3))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H275. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H276. % 119.90/120.16 cut (((succ (succ (succ (n0)))) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H21f]. % 119.90/120.16 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.90/120.16 congruence. % 119.90/120.16 apply zenon_H158. apply refl_equal. % 119.90/120.16 exact (zenon_H21f successor_3). % 119.90/120.16 apply (zenon_L228_); trivial. % 119.90/120.16 cut ((gt (n0) (n0)) = (gt (n0) (sum (n0) (tptp_minus_1) zenon_E))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H157. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H141. % 119.90/120.16 cut (((n0) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H159]. % 119.90/120.16 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.90/120.16 congruence. % 119.90/120.16 apply zenon_H65. apply refl_equal. % 119.90/120.16 exact (zenon_H159 zenon_H15c). % 119.90/120.16 apply (zenon_L146_); trivial. % 119.90/120.16 elim (classic ((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [ zenon_intro zenon_H15a | zenon_intro zenon_H158 ]. % 119.90/120.16 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E)) = ((n0) = (sum (n0) (tptp_minus_1) zenon_E))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H159. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H15a. % 119.90/120.16 cut (((sum (n0) (tptp_minus_1) zenon_E) = (sum (n0) (tptp_minus_1) zenon_E))); [idtac | apply NNPP; zenon_intro zenon_H158]. % 119.90/120.16 cut (((sum (n0) (tptp_minus_1) zenon_E) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H15b]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_H15b zenon_H155). % 119.90/120.16 apply zenon_H158. apply refl_equal. % 119.90/120.16 apply zenon_H158. apply refl_equal. % 119.90/120.16 (* end of lemma zenon_L229_ *) % 119.90/120.16 assert (zenon_L230_ : (gt (succ (loopcounter)) (n1)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (loopcounter) (loopcounter))) -> (gt (n1) (loopcounter)) -> False). % 119.90/120.16 do 0 intro. intros zenon_H67 zenon_H155 zenon_H66 zenon_H135 zenon_H7d. % 119.90/120.16 elim (classic ((~((loopcounter) = (n1)))/\(~(gt (loopcounter) (n1))))); [ zenon_intro zenon_H137 | zenon_intro zenon_H138 ]. % 119.90/120.16 apply (zenon_and_s _ _ zenon_H137). zenon_intro zenon_Hc4. zenon_intro zenon_Hee. % 119.90/120.16 apply (zenon_L193_); trivial. % 119.90/120.16 cut ((gt (n1) (loopcounter)) = (gt (loopcounter) (loopcounter))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H135. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H7d. % 119.90/120.16 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.16 cut (((n1) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_Hec]. % 119.90/120.16 congruence. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H138); [ zenon_intro zenon_H13a | zenon_intro zenon_H139 ]. % 119.90/120.16 apply zenon_H13a. zenon_intro zenon_Hca. % 119.90/120.16 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.90/120.16 cut (((loopcounter) = (loopcounter)) = ((n1) = (loopcounter))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_Hec. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_Hed. % 119.90/120.16 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.16 cut (((loopcounter) = (n1))); [idtac | apply NNPP; zenon_intro zenon_Hc4]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_Hc4 zenon_Hca). % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 apply zenon_H139. zenon_intro zenon_Hf1. % 119.90/120.16 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.90/120.16 generalize (zenon_H13b (n1)). zenon_intro zenon_H13c. % 119.90/120.16 generalize (zenon_H13c (loopcounter)). zenon_intro zenon_H13d. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H13d); [ zenon_intro zenon_Hee | zenon_intro zenon_H13e ]. % 119.90/120.16 exact (zenon_Hee zenon_Hf1). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H13e); [ zenon_intro zenon_H92 | zenon_intro zenon_H134 ]. % 119.90/120.16 exact (zenon_H92 zenon_H7d). % 119.90/120.16 exact (zenon_H135 zenon_H134). % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 (* end of lemma zenon_L230_ *) % 119.90/120.16 assert (zenon_L231_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((loopcounter) = (n0)) -> (~(gt (loopcounter) (n3))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.90/120.16 do 0 intro. intros zenon_H66 zenon_H95 zenon_H1f5 zenon_H67 zenon_H7d zenon_H155. % 119.90/120.16 elim (classic (gt (loopcounter) (loopcounter))); [ zenon_intro zenon_H134 | zenon_intro zenon_H135 ]. % 119.90/120.16 elim (classic (gt (loopcounter) (n0))); [ zenon_intro zenon_H2fd | zenon_intro zenon_H2fa ]. % 119.90/120.16 elim (classic (gt (n0) (n3))); [ zenon_intro zenon_H28b | zenon_intro zenon_H254 ]. % 119.90/120.16 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.90/120.16 generalize (zenon_H13b (n0)). zenon_intro zenon_H45d. % 119.90/120.16 generalize (zenon_H45d (n3)). zenon_intro zenon_H45e. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H45e); [ zenon_intro zenon_H2fa | zenon_intro zenon_H45f ]. % 119.90/120.16 exact (zenon_H2fa zenon_H2fd). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H45f); [ zenon_intro zenon_H254 | zenon_intro zenon_H1f9 ]. % 119.90/120.16 exact (zenon_H254 zenon_H28b). % 119.90/120.16 exact (zenon_H1f5 zenon_H1f9). % 119.90/120.16 apply (zenon_L229_); trivial. % 119.90/120.16 cut ((gt (loopcounter) (loopcounter)) = (gt (loopcounter) (n0))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H2fa. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H134. % 119.90/120.16 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.90/120.16 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.16 congruence. % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 exact (zenon_H132 zenon_H95). % 119.90/120.16 apply (zenon_L230_); trivial. % 119.90/120.16 (* end of lemma zenon_L231_ *) % 119.90/120.16 assert (zenon_L232_ : ((loopcounter) = (n0)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (loopcounter) (n2))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.90/120.16 do 0 intro. intros zenon_H95 zenon_H66 zenon_H19d zenon_H155 zenon_H7d zenon_H67. % 119.90/120.16 elim (classic ((~((loopcounter) = (n3)))/\(~(gt (loopcounter) (n3))))); [ zenon_intro zenon_H1f3 | zenon_intro zenon_H1f4 ]. % 119.90/120.16 apply (zenon_and_s _ _ zenon_H1f3). zenon_intro zenon_Hc2. zenon_intro zenon_H1f5. % 119.90/120.16 apply (zenon_L231_); trivial. % 119.90/120.16 cut ((gt (n3) (n2)) = (gt (loopcounter) (n2))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H19d. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact gt_3_2. % 119.90/120.16 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.90/120.16 cut (((n3) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H1f6]. % 119.90/120.16 congruence. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H1f4); [ zenon_intro zenon_H1f8 | zenon_intro zenon_H1f7 ]. % 119.90/120.16 apply zenon_H1f8. zenon_intro zenon_Hcb. % 119.90/120.16 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.90/120.16 cut (((loopcounter) = (loopcounter)) = ((n3) = (loopcounter))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H1f6. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_Hed. % 119.90/120.16 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.16 cut (((loopcounter) = (n3))); [idtac | apply NNPP; zenon_intro zenon_Hc2]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_Hc2 zenon_Hcb). % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 apply zenon_H1f7. zenon_intro zenon_H1f9. % 119.90/120.16 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.90/120.16 generalize (zenon_H13b (n3)). zenon_intro zenon_H1fa. % 119.90/120.16 generalize (zenon_H1fa (n2)). zenon_intro zenon_H23a. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H23a); [ zenon_intro zenon_H1f5 | zenon_intro zenon_H23b ]. % 119.90/120.16 exact (zenon_H1f5 zenon_H1f9). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H23b); [ zenon_intro zenon_H22f | zenon_intro zenon_H1a1 ]. % 119.90/120.16 exact (zenon_H22f gt_3_2). % 119.90/120.16 exact (zenon_H19d zenon_H1a1). % 119.90/120.16 apply zenon_H63. apply refl_equal. % 119.90/120.16 (* end of lemma zenon_L232_ *) % 119.90/120.16 assert (zenon_L233_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> ((loopcounter) = (n0)) -> (zenon_TG_dq = (n2)) -> (~(leq zenon_TG_dq (n1))) -> False). % 119.90/120.16 do 1 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_H155 zenon_H95 zenon_H341 zenon_H460. % 119.90/120.16 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.16 generalize (zenon_H330 (n1)). zenon_intro zenon_H461. % 119.90/120.16 apply (zenon_equiv_s _ _ zenon_H461); [ zenon_intro zenon_H460; zenon_intro zenon_H464 | zenon_intro zenon_H463; zenon_intro zenon_H462 ]. % 119.90/120.16 elim (classic ((~((succ (n1)) = (succ (loopcounter))))/\(~(gt (succ (n1)) (succ (loopcounter)))))); [ zenon_intro zenon_H114 | zenon_intro zenon_H115 ]. % 119.90/120.16 apply (zenon_and_s _ _ zenon_H114). zenon_intro zenon_H117. zenon_intro zenon_H116. % 119.90/120.16 apply (zenon_L138_); trivial. % 119.90/120.16 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.16 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.16 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.16 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.16 exact (zenon_H6f zenon_H67). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.16 exact (zenon_H466 zenon_H465). % 119.90/120.16 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n1)) zenon_TG_dq)). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H464. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H469. % 119.90/120.16 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.16 cut (((succ (loopcounter)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H11f]. % 119.90/120.16 congruence. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H115); [ zenon_intro zenon_H121 | zenon_intro zenon_H120 ]. % 119.90/120.16 apply zenon_H121. zenon_intro zenon_H122. % 119.90/120.16 apply zenon_H11f. apply sym_equal. exact zenon_H122. % 119.90/120.16 apply zenon_H120. zenon_intro zenon_H11e. % 119.90/120.16 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.90/120.16 generalize (zenon_H11a (succ (loopcounter))). zenon_intro zenon_H123. % 119.90/120.16 generalize (zenon_H123 zenon_TG_dq). zenon_intro zenon_H46a. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H46a); [ zenon_intro zenon_H116 | zenon_intro zenon_H46b ]. % 119.90/120.16 exact (zenon_H116 zenon_H11e). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H46b); [ zenon_intro zenon_H46c | zenon_intro zenon_H462 ]. % 119.90/120.16 exact (zenon_H46c zenon_H469). % 119.90/120.16 exact (zenon_H464 zenon_H462). % 119.90/120.16 apply zenon_H3d3. apply refl_equal. % 119.90/120.16 elim (classic (gt (loopcounter) zenon_TG_dq)); [ zenon_intro zenon_H46d | zenon_intro zenon_H46e ]. % 119.90/120.16 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.90/120.16 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.90/120.16 generalize (zenon_Hf3 zenon_TG_dq). zenon_intro zenon_H46f. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H46f); [ zenon_intro zenon_H92 | zenon_intro zenon_H470 ]. % 119.90/120.16 exact (zenon_H92 zenon_H7d). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H470); [ zenon_intro zenon_H46e | zenon_intro zenon_H465 ]. % 119.90/120.16 exact (zenon_H46e zenon_H46d). % 119.90/120.16 exact (zenon_H466 zenon_H465). % 119.90/120.16 elim (classic ((n2) = zenon_TG_dq)); [ zenon_intro zenon_H471 | zenon_intro zenon_H336 ]. % 119.90/120.16 elim (classic (gt (loopcounter) (n2))); [ zenon_intro zenon_H1a1 | zenon_intro zenon_H19d ]. % 119.90/120.16 cut ((gt (loopcounter) (n2)) = (gt (loopcounter) zenon_TG_dq)). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H46e. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H1a1. % 119.90/120.16 cut (((n2) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H336]. % 119.90/120.16 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.16 congruence. % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 exact (zenon_H336 zenon_H471). % 119.90/120.16 apply (zenon_L232_); trivial. % 119.90/120.16 elim (classic (zenon_TG_dq = zenon_TG_dq)); [ zenon_intro zenon_H3d4 | zenon_intro zenon_H3d3 ]. % 119.90/120.16 cut ((zenon_TG_dq = zenon_TG_dq) = ((n2) = zenon_TG_dq)). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H336. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H3d4. % 119.90/120.16 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.16 cut ((zenon_TG_dq = (n2))); [idtac | apply NNPP; zenon_intro zenon_H472]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_H472 zenon_H341). % 119.90/120.16 apply zenon_H3d3. apply refl_equal. % 119.90/120.16 apply zenon_H3d3. apply refl_equal. % 119.90/120.16 exact (zenon_H460 zenon_H463). % 119.90/120.16 (* end of lemma zenon_L233_ *) % 119.90/120.16 assert (zenon_L234_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (~(gt (succ (n1)) (succ (loopcounter)))) -> False). % 119.90/120.16 do 0 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_H155 zenon_H116. % 119.90/120.16 elim (classic (gt (succ (n1)) (succ (tptp_minus_1)))); [ zenon_intro zenon_H2bd | zenon_intro zenon_H2ba ]. % 119.90/120.16 elim (classic (gt (succ (n1)) (n0))); [ zenon_intro zenon_H10d | zenon_intro zenon_H10f ]. % 119.90/120.16 elim (classic (gt (n0) (succ (loopcounter)))); [ zenon_intro zenon_H146 | zenon_intro zenon_H140 ]. % 119.90/120.16 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.90/120.16 generalize (zenon_H11a (n0)). zenon_intro zenon_H2be. % 119.90/120.16 generalize (zenon_H2be (succ (loopcounter))). zenon_intro zenon_H2bf. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H2bf); [ zenon_intro zenon_H10f | zenon_intro zenon_H2c0 ]. % 119.90/120.16 exact (zenon_H10f zenon_H10d). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H2c0); [ zenon_intro zenon_H140 | zenon_intro zenon_H11e ]. % 119.90/120.16 exact (zenon_H140 zenon_H146). % 119.90/120.16 exact (zenon_H116 zenon_H11e). % 119.90/120.16 apply (zenon_L127_); trivial. % 119.90/120.16 cut ((gt (succ (n1)) (succ (tptp_minus_1))) = (gt (succ (n1)) (n0))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H10f. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H2bd. % 119.90/120.16 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.90/120.16 cut (((succ (n1)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H101]. % 119.90/120.16 congruence. % 119.90/120.16 apply zenon_H101. apply refl_equal. % 119.90/120.16 exact (zenon_H16b succ_tptp_minus_1). % 119.90/120.16 apply (zenon_L137_); trivial. % 119.90/120.16 (* end of lemma zenon_L234_ *) % 119.90/120.16 assert (zenon_L235_ : (~(gt (n0) (n2))) -> ((tptp_minus_1) = (n2)) -> False). % 119.90/120.16 do 0 intro. intros zenon_H1ab zenon_H3f9. % 119.90/120.16 cut ((gt (n0) (tptp_minus_1)) = (gt (n0) (n2))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H1ab. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact gt_0_tptp_minus_1. % 119.90/120.16 cut (((tptp_minus_1) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H3fd]. % 119.90/120.16 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.90/120.16 congruence. % 119.90/120.16 apply zenon_H65. apply refl_equal. % 119.90/120.16 exact (zenon_H3fd zenon_H3f9). % 119.90/120.16 (* end of lemma zenon_L235_ *) % 119.90/120.16 assert (zenon_L236_ : ((loopcounter) = (n0)) -> (~(gt (loopcounter) (n2))) -> ((tptp_minus_1) = (n2)) -> False). % 119.90/120.16 do 0 intro. intros zenon_H95 zenon_H19d zenon_H3f9. % 119.90/120.16 elim (classic (gt (n0) (n2))); [ zenon_intro zenon_H1b3 | zenon_intro zenon_H1ab ]. % 119.90/120.16 cut ((gt (n0) (n2)) = (gt (loopcounter) (n2))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H19d. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H1b3. % 119.90/120.16 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.90/120.16 cut (((n0) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H93]. % 119.90/120.16 congruence. % 119.90/120.16 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.90/120.16 cut (((loopcounter) = (loopcounter)) = ((n0) = (loopcounter))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H93. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_Hed. % 119.90/120.16 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.16 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_H132 zenon_H95). % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 apply zenon_H63. apply refl_equal. % 119.90/120.16 apply (zenon_L235_); trivial. % 119.90/120.16 (* end of lemma zenon_L236_ *) % 119.90/120.16 assert (zenon_L237_ : forall (zenon_TG_dq : zenon_U), ((tptp_minus_1) = (n2)) -> ((loopcounter) = (n0)) -> (~(gt (loopcounter) zenon_TG_dq)) -> (zenon_TG_dq = (n2)) -> False). % 119.90/120.16 do 1 intro. intros zenon_H3f9 zenon_H95 zenon_H46e zenon_H341. % 119.90/120.16 elim (classic ((n2) = zenon_TG_dq)); [ zenon_intro zenon_H471 | zenon_intro zenon_H336 ]. % 119.90/120.16 elim (classic (gt (loopcounter) (n2))); [ zenon_intro zenon_H1a1 | zenon_intro zenon_H19d ]. % 119.90/120.16 cut ((gt (loopcounter) (n2)) = (gt (loopcounter) zenon_TG_dq)). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H46e. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H1a1. % 119.90/120.16 cut (((n2) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H336]. % 119.90/120.16 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.16 congruence. % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 exact (zenon_H336 zenon_H471). % 119.90/120.16 apply (zenon_L236_); trivial. % 119.90/120.16 elim (classic (zenon_TG_dq = zenon_TG_dq)); [ zenon_intro zenon_H3d4 | zenon_intro zenon_H3d3 ]. % 119.90/120.16 cut ((zenon_TG_dq = zenon_TG_dq) = ((n2) = zenon_TG_dq)). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H336. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H3d4. % 119.90/120.16 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.16 cut ((zenon_TG_dq = (n2))); [idtac | apply NNPP; zenon_intro zenon_H472]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_H472 zenon_H341). % 119.90/120.16 apply zenon_H3d3. apply refl_equal. % 119.90/120.16 apply zenon_H3d3. apply refl_equal. % 119.90/120.16 (* end of lemma zenon_L237_ *) % 119.90/120.16 assert (zenon_L238_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> ((loopcounter) = (n0)) -> ((tptp_minus_1) = (n2)) -> (zenon_TG_dq = (n2)) -> (~(leq zenon_TG_dq (n1))) -> False). % 119.90/120.16 do 1 intro. intros zenon_H66 zenon_H155 zenon_H7d zenon_H67 zenon_H95 zenon_H3f9 zenon_H341 zenon_H460. % 119.90/120.16 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.16 generalize (zenon_H330 (n1)). zenon_intro zenon_H461. % 119.90/120.16 apply (zenon_equiv_s _ _ zenon_H461); [ zenon_intro zenon_H460; zenon_intro zenon_H464 | zenon_intro zenon_H463; zenon_intro zenon_H462 ]. % 119.90/120.16 elim (classic ((~((succ (n1)) = (succ (loopcounter))))/\(~(gt (succ (n1)) (succ (loopcounter)))))); [ zenon_intro zenon_H114 | zenon_intro zenon_H115 ]. % 119.90/120.16 apply (zenon_and_s _ _ zenon_H114). zenon_intro zenon_H117. zenon_intro zenon_H116. % 119.90/120.16 apply (zenon_L234_); trivial. % 119.90/120.16 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.16 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.16 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.16 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.16 exact (zenon_H6f zenon_H67). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.16 exact (zenon_H466 zenon_H465). % 119.90/120.16 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n1)) zenon_TG_dq)). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H464. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H469. % 119.90/120.16 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.16 cut (((succ (loopcounter)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H11f]. % 119.90/120.16 congruence. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H115); [ zenon_intro zenon_H121 | zenon_intro zenon_H120 ]. % 119.90/120.16 apply zenon_H121. zenon_intro zenon_H122. % 119.90/120.16 apply zenon_H11f. apply sym_equal. exact zenon_H122. % 119.90/120.16 apply zenon_H120. zenon_intro zenon_H11e. % 119.90/120.16 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.90/120.16 generalize (zenon_H11a (succ (loopcounter))). zenon_intro zenon_H123. % 119.90/120.16 generalize (zenon_H123 zenon_TG_dq). zenon_intro zenon_H46a. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H46a); [ zenon_intro zenon_H116 | zenon_intro zenon_H46b ]. % 119.90/120.16 exact (zenon_H116 zenon_H11e). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H46b); [ zenon_intro zenon_H46c | zenon_intro zenon_H462 ]. % 119.90/120.16 exact (zenon_H46c zenon_H469). % 119.90/120.16 exact (zenon_H464 zenon_H462). % 119.90/120.16 apply zenon_H3d3. apply refl_equal. % 119.90/120.16 elim (classic (gt (loopcounter) zenon_TG_dq)); [ zenon_intro zenon_H46d | zenon_intro zenon_H46e ]. % 119.90/120.16 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.90/120.16 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.90/120.16 generalize (zenon_Hf3 zenon_TG_dq). zenon_intro zenon_H46f. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H46f); [ zenon_intro zenon_H92 | zenon_intro zenon_H470 ]. % 119.90/120.16 exact (zenon_H92 zenon_H7d). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H470); [ zenon_intro zenon_H46e | zenon_intro zenon_H465 ]. % 119.90/120.16 exact (zenon_H46e zenon_H46d). % 119.90/120.16 exact (zenon_H466 zenon_H465). % 119.90/120.16 apply (zenon_L237_ zenon_TG_dq); trivial. % 119.90/120.16 exact (zenon_H460 zenon_H463). % 119.90/120.16 (* end of lemma zenon_L238_ *) % 119.90/120.16 assert (zenon_L239_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ zenon_TG_dq) (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> ((loopcounter) = (n0)) -> ((tptp_minus_1) = (n2)) -> (zenon_TG_dq = (n2)) -> False). % 119.90/120.16 do 1 intro. intros zenon_H66 zenon_H5c zenon_H155 zenon_H7d zenon_H67 zenon_H95 zenon_H3f9 zenon_H341. % 119.90/120.16 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.16 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_L238_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.16 apply (zenon_L213_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_L224_ zenon_TG_dq); trivial. % 119.90/120.16 (* end of lemma zenon_L239_ *) % 119.90/120.16 assert (zenon_L240_ : (~(gt (n0) (n3))) -> ((tptp_minus_1) = (n3)) -> False). % 119.90/120.16 do 0 intro. intros zenon_H254 zenon_H42f. % 119.90/120.16 cut ((gt (n0) (tptp_minus_1)) = (gt (n0) (n3))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H254. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact gt_0_tptp_minus_1. % 119.90/120.16 cut (((tptp_minus_1) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H433]. % 119.90/120.16 cut (((n0) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H65]. % 119.90/120.16 congruence. % 119.90/120.16 apply zenon_H65. apply refl_equal. % 119.90/120.16 exact (zenon_H433 zenon_H42f). % 119.90/120.16 (* end of lemma zenon_L240_ *) % 119.90/120.16 assert (zenon_L241_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((tptp_minus_1) = (n3)) -> ((loopcounter) = (n0)) -> (~(gt (loopcounter) (n3))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.90/120.16 do 0 intro. intros zenon_H66 zenon_H42f zenon_H95 zenon_H1f5 zenon_H67 zenon_H7d zenon_H155. % 119.90/120.16 elim (classic (gt (loopcounter) (loopcounter))); [ zenon_intro zenon_H134 | zenon_intro zenon_H135 ]. % 119.90/120.16 elim (classic (gt (loopcounter) (n0))); [ zenon_intro zenon_H2fd | zenon_intro zenon_H2fa ]. % 119.90/120.16 elim (classic (gt (n0) (n3))); [ zenon_intro zenon_H28b | zenon_intro zenon_H254 ]. % 119.90/120.16 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.90/120.16 generalize (zenon_H13b (n0)). zenon_intro zenon_H45d. % 119.90/120.16 generalize (zenon_H45d (n3)). zenon_intro zenon_H45e. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H45e); [ zenon_intro zenon_H2fa | zenon_intro zenon_H45f ]. % 119.90/120.16 exact (zenon_H2fa zenon_H2fd). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H45f); [ zenon_intro zenon_H254 | zenon_intro zenon_H1f9 ]. % 119.90/120.16 exact (zenon_H254 zenon_H28b). % 119.90/120.16 exact (zenon_H1f5 zenon_H1f9). % 119.90/120.16 apply (zenon_L240_); trivial. % 119.90/120.16 cut ((gt (loopcounter) (loopcounter)) = (gt (loopcounter) (n0))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H2fa. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H134. % 119.90/120.16 cut (((loopcounter) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H132]. % 119.90/120.16 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.16 congruence. % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 exact (zenon_H132 zenon_H95). % 119.90/120.16 apply (zenon_L230_); trivial. % 119.90/120.16 (* end of lemma zenon_L241_ *) % 119.90/120.16 assert (zenon_L242_ : ((tptp_minus_1) = (n3)) -> ((loopcounter) = (n0)) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (loopcounter) (n2))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.90/120.16 do 0 intro. intros zenon_H42f zenon_H95 zenon_H66 zenon_H19d zenon_H155 zenon_H7d zenon_H67. % 119.90/120.16 elim (classic ((~((loopcounter) = (n3)))/\(~(gt (loopcounter) (n3))))); [ zenon_intro zenon_H1f3 | zenon_intro zenon_H1f4 ]. % 119.90/120.16 apply (zenon_and_s _ _ zenon_H1f3). zenon_intro zenon_Hc2. zenon_intro zenon_H1f5. % 119.90/120.16 apply (zenon_L241_); trivial. % 119.90/120.16 cut ((gt (n3) (n2)) = (gt (loopcounter) (n2))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H19d. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact gt_3_2. % 119.90/120.16 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.90/120.16 cut (((n3) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H1f6]. % 119.90/120.16 congruence. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H1f4); [ zenon_intro zenon_H1f8 | zenon_intro zenon_H1f7 ]. % 119.90/120.16 apply zenon_H1f8. zenon_intro zenon_Hcb. % 119.90/120.16 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.90/120.16 cut (((loopcounter) = (loopcounter)) = ((n3) = (loopcounter))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H1f6. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_Hed. % 119.90/120.16 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.16 cut (((loopcounter) = (n3))); [idtac | apply NNPP; zenon_intro zenon_Hc2]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_Hc2 zenon_Hcb). % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 apply zenon_H1f7. zenon_intro zenon_H1f9. % 119.90/120.16 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.90/120.16 generalize (zenon_H13b (n3)). zenon_intro zenon_H1fa. % 119.90/120.16 generalize (zenon_H1fa (n2)). zenon_intro zenon_H23a. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H23a); [ zenon_intro zenon_H1f5 | zenon_intro zenon_H23b ]. % 119.90/120.16 exact (zenon_H1f5 zenon_H1f9). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H23b); [ zenon_intro zenon_H22f | zenon_intro zenon_H1a1 ]. % 119.90/120.16 exact (zenon_H22f gt_3_2). % 119.90/120.16 exact (zenon_H19d zenon_H1a1). % 119.90/120.16 apply zenon_H63. apply refl_equal. % 119.90/120.16 (* end of lemma zenon_L242_ *) % 119.90/120.16 assert (zenon_L243_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) zenon_TG_dq)) -> (zenon_TG_dq = (n2)) -> ((loopcounter) = (n0)) -> ((tptp_minus_1) = (n3)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.90/120.16 do 1 intro. intros zenon_H66 zenon_H466 zenon_H341 zenon_H95 zenon_H42f zenon_H155 zenon_H7d zenon_H67. % 119.90/120.16 elim (classic (gt (loopcounter) zenon_TG_dq)); [ zenon_intro zenon_H46d | zenon_intro zenon_H46e ]. % 119.90/120.16 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.90/120.16 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.90/120.16 generalize (zenon_Hf3 zenon_TG_dq). zenon_intro zenon_H46f. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H46f); [ zenon_intro zenon_H92 | zenon_intro zenon_H470 ]. % 119.90/120.16 exact (zenon_H92 zenon_H7d). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H470); [ zenon_intro zenon_H46e | zenon_intro zenon_H465 ]. % 119.90/120.16 exact (zenon_H46e zenon_H46d). % 119.90/120.16 exact (zenon_H466 zenon_H465). % 119.90/120.16 elim (classic ((n2) = zenon_TG_dq)); [ zenon_intro zenon_H471 | zenon_intro zenon_H336 ]. % 119.90/120.16 elim (classic (gt (loopcounter) (n2))); [ zenon_intro zenon_H1a1 | zenon_intro zenon_H19d ]. % 119.90/120.16 cut ((gt (loopcounter) (n2)) = (gt (loopcounter) zenon_TG_dq)). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H46e. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H1a1. % 119.90/120.16 cut (((n2) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H336]. % 119.90/120.16 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.16 congruence. % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 exact (zenon_H336 zenon_H471). % 119.90/120.16 apply (zenon_L242_); trivial. % 119.90/120.16 elim (classic (zenon_TG_dq = zenon_TG_dq)); [ zenon_intro zenon_H3d4 | zenon_intro zenon_H3d3 ]. % 119.90/120.16 cut ((zenon_TG_dq = zenon_TG_dq) = ((n2) = zenon_TG_dq)). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H336. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H3d4. % 119.90/120.16 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.16 cut ((zenon_TG_dq = (n2))); [idtac | apply NNPP; zenon_intro zenon_H472]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_H472 zenon_H341). % 119.90/120.16 apply zenon_H3d3. apply refl_equal. % 119.90/120.16 apply zenon_H3d3. apply refl_equal. % 119.90/120.16 (* end of lemma zenon_L243_ *) % 119.90/120.16 assert (zenon_L244_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n1)) (succ (loopcounter)))) -> ((tptp_minus_1) = (n1)) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> False). % 119.90/120.16 do 0 intro. intros zenon_H66 zenon_H116 zenon_H3db zenon_H67 zenon_H7d zenon_H155. % 119.90/120.16 elim (classic (gt (n0) (succ (loopcounter)))); [ zenon_intro zenon_H146 | zenon_intro zenon_H140 ]. % 119.90/120.16 elim (classic (gt (succ (tptp_minus_1)) (succ (loopcounter)))); [ zenon_intro zenon_H175 | zenon_intro zenon_H16c ]. % 119.90/120.16 cut ((gt (succ (tptp_minus_1)) (succ (loopcounter))) = (gt (succ (n1)) (succ (loopcounter)))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H116. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H175. % 119.90/120.16 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.90/120.16 cut (((succ (tptp_minus_1)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H476]. % 119.90/120.16 congruence. % 119.90/120.16 elim (classic ((succ (n1)) = (succ (n1)))); [ zenon_intro zenon_H100 | zenon_intro zenon_H101 ]. % 119.90/120.16 cut (((succ (n1)) = (succ (n1))) = ((succ (tptp_minus_1)) = (succ (n1)))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H476. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H100. % 119.90/120.16 cut (((succ (n1)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H101]. % 119.90/120.16 cut (((succ (n1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H477]. % 119.90/120.16 congruence. % 119.90/120.16 cut (((n1) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3e0]. % 119.90/120.16 congruence. % 119.90/120.16 apply zenon_H3e0. apply sym_equal. exact zenon_H3db. % 119.90/120.16 apply zenon_H101. apply refl_equal. % 119.90/120.16 apply zenon_H101. apply refl_equal. % 119.90/120.16 apply zenon_H76. apply refl_equal. % 119.90/120.16 cut ((gt (n0) (succ (loopcounter))) = (gt (succ (tptp_minus_1)) (succ (loopcounter)))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H16c. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H146. % 119.90/120.16 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.90/120.16 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.90/120.16 congruence. % 119.90/120.16 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.90/120.16 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H167. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H16a. % 119.90/120.16 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.90/120.16 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_H16b succ_tptp_minus_1). % 119.90/120.16 apply zenon_H169. apply refl_equal. % 119.90/120.16 apply zenon_H169. apply refl_equal. % 119.90/120.16 apply zenon_H76. apply refl_equal. % 119.90/120.16 apply (zenon_L127_); trivial. % 119.90/120.16 (* end of lemma zenon_L244_ *) % 119.90/120.16 assert (zenon_L245_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (~(leq (loopcounter) (n2))) -> False). % 119.90/120.16 do 0 intro. intros zenon_H66 zenon_H155 zenon_H7d zenon_H67 zenon_H478. % 119.90/120.16 generalize (leq_succ_gt_equiv (loopcounter)). zenon_intro zenon_H7f. % 119.90/120.16 generalize (zenon_H7f (n2)). zenon_intro zenon_H479. % 119.90/120.16 apply (zenon_equiv_s _ _ zenon_H479); [ zenon_intro zenon_H478; zenon_intro zenon_H47c | zenon_intro zenon_H47b; zenon_intro zenon_H47a ]. % 119.90/120.16 elim (classic ((~((succ (n2)) = (n1)))/\(~(gt (succ (n2)) (n1))))); [ zenon_intro zenon_H47d | zenon_intro zenon_H47e ]. % 119.90/120.16 apply (zenon_and_s _ _ zenon_H47d). zenon_intro zenon_H47f. zenon_intro zenon_H413. % 119.90/120.16 elim (classic ((~((succ (n2)) = (n3)))/\(~(gt (succ (n2)) (n3))))); [ zenon_intro zenon_H440 | zenon_intro zenon_H441 ]. % 119.90/120.16 apply (zenon_and_s _ _ zenon_H440). zenon_intro zenon_H442. zenon_intro zenon_H423. % 119.90/120.16 apply (zenon_L215_); trivial. % 119.90/120.16 cut ((gt (n3) (n1)) = (gt (succ (n2)) (n1))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H413. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact gt_3_1. % 119.90/120.16 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.90/120.16 cut (((n3) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H443]. % 119.90/120.16 congruence. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H441); [ zenon_intro zenon_H445 | zenon_intro zenon_H444 ]. % 119.90/120.16 apply zenon_H445. zenon_intro zenon_H446. % 119.90/120.16 elim (classic ((succ (n2)) = (succ (n2)))); [ zenon_intro zenon_H421 | zenon_intro zenon_H40f ]. % 119.90/120.16 cut (((succ (n2)) = (succ (n2))) = ((n3) = (succ (n2)))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H443. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H421. % 119.90/120.16 cut (((succ (n2)) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H40f]. % 119.90/120.16 cut (((succ (n2)) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H442]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_H442 zenon_H446). % 119.90/120.16 apply zenon_H40f. apply refl_equal. % 119.90/120.16 apply zenon_H40f. apply refl_equal. % 119.90/120.16 apply zenon_H444. zenon_intro zenon_H42e. % 119.90/120.16 generalize (zenon_H66 (succ (n2))). zenon_intro zenon_H40a. % 119.90/120.16 generalize (zenon_H40a (n3)). zenon_intro zenon_H447. % 119.90/120.16 generalize (zenon_H447 (n1)). zenon_intro zenon_H480. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H480); [ zenon_intro zenon_H423 | zenon_intro zenon_H481 ]. % 119.90/120.16 exact (zenon_H423 zenon_H42e). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H481); [ zenon_intro zenon_H1f2 | zenon_intro zenon_H412 ]. % 119.90/120.16 exact (zenon_H1f2 gt_3_1). % 119.90/120.16 exact (zenon_H413 zenon_H412). % 119.90/120.16 apply zenon_H64. apply refl_equal. % 119.90/120.16 cut ((gt (n1) (loopcounter)) = (gt (succ (n2)) (loopcounter))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H47c. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H7d. % 119.90/120.16 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.16 cut (((n1) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H482]. % 119.90/120.16 congruence. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H47e); [ zenon_intro zenon_H484 | zenon_intro zenon_H483 ]. % 119.90/120.16 apply zenon_H484. zenon_intro zenon_H485. % 119.90/120.16 elim (classic ((succ (n2)) = (succ (n2)))); [ zenon_intro zenon_H421 | zenon_intro zenon_H40f ]. % 119.90/120.16 cut (((succ (n2)) = (succ (n2))) = ((n1) = (succ (n2)))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H482. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H421. % 119.90/120.16 cut (((succ (n2)) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H40f]. % 119.90/120.16 cut (((succ (n2)) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H47f]. % 119.90/120.16 congruence. % 119.90/120.16 exact (zenon_H47f zenon_H485). % 119.90/120.16 apply zenon_H40f. apply refl_equal. % 119.90/120.16 apply zenon_H40f. apply refl_equal. % 119.90/120.16 apply zenon_H483. zenon_intro zenon_H412. % 119.90/120.16 generalize (zenon_H66 (succ (n2))). zenon_intro zenon_H40a. % 119.90/120.16 generalize (zenon_H40a (n1)). zenon_intro zenon_H414. % 119.90/120.16 generalize (zenon_H414 (loopcounter)). zenon_intro zenon_H486. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H486); [ zenon_intro zenon_H413 | zenon_intro zenon_H487 ]. % 119.90/120.16 exact (zenon_H413 zenon_H412). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H487); [ zenon_intro zenon_H92 | zenon_intro zenon_H47a ]. % 119.90/120.16 exact (zenon_H92 zenon_H7d). % 119.90/120.16 exact (zenon_H47c zenon_H47a). % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 exact (zenon_H478 zenon_H47b). % 119.90/120.16 (* end of lemma zenon_L245_ *) % 119.90/120.16 assert (zenon_L246_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n2)) -> ((loopcounter) = (n2)) -> (~(leq zenon_TG_dq (n1))) -> False). % 119.90/120.16 do 1 intro. intros zenon_H66 zenon_H155 zenon_H7d zenon_H67 zenon_H341 zenon_Hcc zenon_H460. % 119.90/120.16 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.16 generalize (zenon_H330 (n1)). zenon_intro zenon_H461. % 119.90/120.16 apply (zenon_equiv_s _ _ zenon_H461); [ zenon_intro zenon_H460; zenon_intro zenon_H464 | zenon_intro zenon_H463; zenon_intro zenon_H462 ]. % 119.90/120.16 elim (classic ((~((succ (n1)) = (succ (loopcounter))))/\(~(gt (succ (n1)) (succ (loopcounter)))))); [ zenon_intro zenon_H114 | zenon_intro zenon_H115 ]. % 119.90/120.16 apply (zenon_and_s _ _ zenon_H114). zenon_intro zenon_H117. zenon_intro zenon_H116. % 119.90/120.16 apply (zenon_L234_); trivial. % 119.90/120.16 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.16 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.16 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.16 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.16 exact (zenon_H6f zenon_H67). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.16 exact (zenon_H466 zenon_H465). % 119.90/120.16 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n1)) zenon_TG_dq)). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H464. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H469. % 119.90/120.16 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.16 cut (((succ (loopcounter)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H11f]. % 119.90/120.16 congruence. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H115); [ zenon_intro zenon_H121 | zenon_intro zenon_H120 ]. % 119.90/120.16 apply zenon_H121. zenon_intro zenon_H122. % 119.90/120.16 apply zenon_H11f. apply sym_equal. exact zenon_H122. % 119.90/120.16 apply zenon_H120. zenon_intro zenon_H11e. % 119.90/120.16 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.90/120.16 generalize (zenon_H11a (succ (loopcounter))). zenon_intro zenon_H123. % 119.90/120.16 generalize (zenon_H123 zenon_TG_dq). zenon_intro zenon_H46a. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H46a); [ zenon_intro zenon_H116 | zenon_intro zenon_H46b ]. % 119.90/120.16 exact (zenon_H116 zenon_H11e). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H46b); [ zenon_intro zenon_H46c | zenon_intro zenon_H462 ]. % 119.90/120.16 exact (zenon_H46c zenon_H469). % 119.90/120.16 exact (zenon_H464 zenon_H462). % 119.90/120.16 apply zenon_H3d3. apply refl_equal. % 119.90/120.16 elim (classic (gt (loopcounter) zenon_TG_dq)); [ zenon_intro zenon_H46d | zenon_intro zenon_H46e ]. % 119.90/120.16 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.90/120.16 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.90/120.16 generalize (zenon_Hf3 zenon_TG_dq). zenon_intro zenon_H46f. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H46f); [ zenon_intro zenon_H92 | zenon_intro zenon_H470 ]. % 119.90/120.16 exact (zenon_H92 zenon_H7d). % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H470); [ zenon_intro zenon_H46e | zenon_intro zenon_H465 ]. % 119.90/120.16 exact (zenon_H46e zenon_H46d). % 119.90/120.16 exact (zenon_H466 zenon_H465). % 119.90/120.16 elim (classic (gt (loopcounter) (loopcounter))); [ zenon_intro zenon_H134 | zenon_intro zenon_H135 ]. % 119.90/120.16 elim (classic (gt (loopcounter) (n2))); [ zenon_intro zenon_H1a1 | zenon_intro zenon_H19d ]. % 119.90/120.16 cut ((gt (loopcounter) (n2)) = (gt (loopcounter) zenon_TG_dq)). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H46e. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H1a1. % 119.90/120.16 cut (((n2) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H336]. % 119.90/120.16 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.16 congruence. % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 apply zenon_H336. apply sym_equal. exact zenon_H341. % 119.90/120.16 cut ((gt (loopcounter) (loopcounter)) = (gt (loopcounter) (n2))). % 119.90/120.16 intro zenon_D_pnotp. % 119.90/120.16 apply zenon_H19d. % 119.90/120.16 rewrite <- zenon_D_pnotp. % 119.90/120.16 exact zenon_H134. % 119.90/120.16 cut (((loopcounter) = (n2))); [idtac | apply NNPP; zenon_intro zenon_Hc3]. % 119.90/120.16 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.16 congruence. % 119.90/120.16 apply zenon_H7c. apply refl_equal. % 119.90/120.16 exact (zenon_Hc3 zenon_Hcc). % 119.90/120.16 apply (zenon_L230_); trivial. % 119.90/120.16 exact (zenon_H460 zenon_H463). % 119.90/120.16 (* end of lemma zenon_L246_ *) % 119.90/120.16 assert (zenon_L247_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ zenon_TG_dq) (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n2)) -> ((loopcounter) = (n2)) -> ((tptp_minus_1) = (n2)) -> False). % 119.90/120.16 do 1 intro. intros zenon_H66 zenon_H5c zenon_H155 zenon_H7d zenon_H67 zenon_H341 zenon_Hcc zenon_H3f9. % 119.90/120.16 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.16 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_L246_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.16 apply (zenon_L213_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_L224_ zenon_TG_dq); trivial. % 119.90/120.16 (* end of lemma zenon_L247_ *) % 119.90/120.16 assert (zenon_L248_ : forall (zenon_TG_dq : zenon_U), (((leq (n0) (loopcounter))/\(leq (loopcounter) (n2)))->(((loopcounter) = (n0))\/(((loopcounter) = (n1))\/((loopcounter) = (n2))))) -> (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ zenon_TG_dq) (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n2)) -> ((tptp_minus_1) = (n2)) -> False). % 119.90/120.16 do 1 intro. intros zenon_H488 zenon_H66 zenon_H5c zenon_H155 zenon_H7d zenon_H67 zenon_H341 zenon_H3f9. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H488); [ zenon_intro zenon_H48a | zenon_intro zenon_H489 ]. % 119.90/120.16 apply (zenon_notand_s _ _ zenon_H48a); [ zenon_intro zenon_H68 | zenon_intro zenon_H478 ]. % 119.90/120.16 apply (zenon_L5_); trivial. % 119.90/120.16 apply (zenon_L245_); trivial. % 119.90/120.16 apply (zenon_or_s _ _ zenon_H489); [ zenon_intro zenon_H95 | zenon_intro zenon_H48b ]. % 119.90/120.16 apply (zenon_L239_ zenon_TG_dq); trivial. % 119.90/120.16 apply (zenon_or_s _ _ zenon_H48b); [ zenon_intro zenon_Hca | zenon_intro zenon_Hcc ]. % 119.90/120.16 apply (zenon_L141_); trivial. % 119.90/120.16 apply (zenon_L247_ zenon_TG_dq); trivial. % 119.90/120.16 (* end of lemma zenon_L248_ *) % 119.90/120.16 assert (zenon_L249_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ zenon_TG_dq) (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n2)) -> ((loopcounter) = (n2)) -> ((tptp_minus_1) = (n0)) -> False). % 119.90/120.16 do 1 intro. intros zenon_H66 zenon_H5c zenon_H155 zenon_H7d zenon_H67 zenon_H341 zenon_Hcc zenon_H3c1. % 119.90/120.16 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.16 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L246_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L203_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L222_ zenon_TG_dq); trivial. % 119.90/120.17 (* end of lemma zenon_L249_ *) % 119.90/120.17 assert (zenon_L250_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ zenon_TG_dq) (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n2)) -> ((loopcounter) = (n2)) -> ((tptp_minus_1) = (n1)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H5c zenon_H155 zenon_H7d zenon_H67 zenon_H341 zenon_Hcc zenon_H3db. % 119.90/120.17 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L246_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L208_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L223_ zenon_TG_dq); trivial. % 119.90/120.17 (* end of lemma zenon_L250_ *) % 119.90/120.17 assert (zenon_L251_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (gt (succ zenon_TG_dq) (n0)) -> (zenon_TG_dq = (n2)) -> ((loopcounter) = (n2)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H155 zenon_H7d zenon_H67 zenon_H5c zenon_H341 zenon_Hcc. % 119.90/120.17 generalize (finite_domain_2 (tptp_minus_1)). zenon_intro zenon_H44f. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H44f); [ zenon_intro zenon_H451 | zenon_intro zenon_H450 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H451); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H43b ]. % 119.90/120.17 apply (zenon_L198_); trivial. % 119.90/120.17 apply (zenon_L217_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H450); [ zenon_intro zenon_H3c1 | zenon_intro zenon_H452 ]. % 119.90/120.17 apply (zenon_L249_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H452); [ zenon_intro zenon_H3db | zenon_intro zenon_H3f9 ]. % 119.90/120.17 apply (zenon_L250_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L247_ zenon_TG_dq); trivial. % 119.90/120.17 (* end of lemma zenon_L251_ *) % 119.90/120.17 assert (zenon_L252_ : forall (zenon_TG_dq : zenon_U), (~(gt (n3) zenon_TG_dq)) -> (zenon_TG_dq = (n2)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H48c zenon_H341. % 119.90/120.17 elim (classic ((n2) = zenon_TG_dq)); [ zenon_intro zenon_H471 | zenon_intro zenon_H336 ]. % 119.90/120.17 cut ((gt (n3) (n2)) = (gt (n3) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H48c. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact gt_3_2. % 119.90/120.17 cut (((n2) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H336]. % 119.90/120.17 cut (((n3) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H201]. % 119.90/120.17 congruence. % 119.90/120.17 apply zenon_H201. apply refl_equal. % 119.90/120.17 exact (zenon_H336 zenon_H471). % 119.90/120.17 apply zenon_H336. apply sym_equal. exact zenon_H341. % 119.90/120.17 (* end of lemma zenon_L252_ *) % 119.90/120.17 assert (zenon_L253_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) zenon_TG_dq)) -> ((loopcounter) = (n3)) -> (zenon_TG_dq = (n2)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H466 zenon_Hcb zenon_H341 zenon_H155 zenon_H7d zenon_H67. % 119.90/120.17 elim (classic (gt (loopcounter) zenon_TG_dq)); [ zenon_intro zenon_H46d | zenon_intro zenon_H46e ]. % 119.90/120.17 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.90/120.17 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.90/120.17 generalize (zenon_Hf3 zenon_TG_dq). zenon_intro zenon_H46f. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46f); [ zenon_intro zenon_H92 | zenon_intro zenon_H470 ]. % 119.90/120.17 exact (zenon_H92 zenon_H7d). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H470); [ zenon_intro zenon_H46e | zenon_intro zenon_H465 ]. % 119.90/120.17 exact (zenon_H46e zenon_H46d). % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 elim (classic (gt (loopcounter) (loopcounter))); [ zenon_intro zenon_H134 | zenon_intro zenon_H135 ]. % 119.90/120.17 elim (classic (gt (loopcounter) (n3))); [ zenon_intro zenon_H1f9 | zenon_intro zenon_H1f5 ]. % 119.90/120.17 elim (classic (gt (n3) zenon_TG_dq)); [ zenon_intro zenon_H48d | zenon_intro zenon_H48c ]. % 119.90/120.17 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.90/120.17 generalize (zenon_H13b (n3)). zenon_intro zenon_H1fa. % 119.90/120.17 generalize (zenon_H1fa zenon_TG_dq). zenon_intro zenon_H48e. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H48e); [ zenon_intro zenon_H1f5 | zenon_intro zenon_H48f ]. % 119.90/120.17 exact (zenon_H1f5 zenon_H1f9). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H48f); [ zenon_intro zenon_H48c | zenon_intro zenon_H46d ]. % 119.90/120.17 exact (zenon_H48c zenon_H48d). % 119.90/120.17 exact (zenon_H46e zenon_H46d). % 119.90/120.17 apply (zenon_L252_ zenon_TG_dq); trivial. % 119.90/120.17 cut ((gt (loopcounter) (loopcounter)) = (gt (loopcounter) (n3))). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H1f5. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H134. % 119.90/120.17 cut (((loopcounter) = (n3))); [idtac | apply NNPP; zenon_intro zenon_Hc2]. % 119.90/120.17 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.17 congruence. % 119.90/120.17 apply zenon_H7c. apply refl_equal. % 119.90/120.17 exact (zenon_Hc2 zenon_Hcb). % 119.90/120.17 apply (zenon_L230_); trivial. % 119.90/120.17 (* end of lemma zenon_L253_ *) % 119.90/120.17 assert (zenon_L254_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> ((loopcounter) = (n0)) -> (zenon_TG_dq = (n2)) -> ((loopcounter) = (n3)) -> (~(leq zenon_TG_dq (n1))) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_H155 zenon_H95 zenon_H341 zenon_Hcb zenon_H460. % 119.90/120.17 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.17 generalize (zenon_H330 (n1)). zenon_intro zenon_H461. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H461); [ zenon_intro zenon_H460; zenon_intro zenon_H464 | zenon_intro zenon_H463; zenon_intro zenon_H462 ]. % 119.90/120.17 elim (classic ((~((succ (n1)) = (succ (loopcounter))))/\(~(gt (succ (n1)) (succ (loopcounter)))))); [ zenon_intro zenon_H114 | zenon_intro zenon_H115 ]. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H114). zenon_intro zenon_H117. zenon_intro zenon_H116. % 119.90/120.17 apply (zenon_L138_); trivial. % 119.90/120.17 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.17 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.17 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.17 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.17 exact (zenon_H6f zenon_H67). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n1)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H464. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H469. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H11f]. % 119.90/120.17 congruence. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H115); [ zenon_intro zenon_H121 | zenon_intro zenon_H120 ]. % 119.90/120.17 apply zenon_H121. zenon_intro zenon_H122. % 119.90/120.17 apply zenon_H11f. apply sym_equal. exact zenon_H122. % 119.90/120.17 apply zenon_H120. zenon_intro zenon_H11e. % 119.90/120.17 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.90/120.17 generalize (zenon_H11a (succ (loopcounter))). zenon_intro zenon_H123. % 119.90/120.17 generalize (zenon_H123 zenon_TG_dq). zenon_intro zenon_H46a. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46a); [ zenon_intro zenon_H116 | zenon_intro zenon_H46b ]. % 119.90/120.17 exact (zenon_H116 zenon_H11e). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46b); [ zenon_intro zenon_H46c | zenon_intro zenon_H462 ]. % 119.90/120.17 exact (zenon_H46c zenon_H469). % 119.90/120.17 exact (zenon_H464 zenon_H462). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 apply (zenon_L253_ zenon_TG_dq); trivial. % 119.90/120.17 exact (zenon_H460 zenon_H463). % 119.90/120.17 (* end of lemma zenon_L254_ *) % 119.90/120.17 assert (zenon_L255_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ zenon_TG_dq) (n0)) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> ((loopcounter) = (n0)) -> (zenon_TG_dq = (n2)) -> ((loopcounter) = (n3)) -> ((tptp_minus_1) = (n0)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H5c zenon_H67 zenon_H7d zenon_H155 zenon_H95 zenon_H341 zenon_Hcb zenon_H3c1. % 119.90/120.17 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L254_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L203_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L222_ zenon_TG_dq); trivial. % 119.90/120.17 (* end of lemma zenon_L255_ *) % 119.90/120.17 assert (zenon_L256_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> ((tptp_minus_1) = (n1)) -> (zenon_TG_dq = (n2)) -> ((loopcounter) = (n3)) -> (~(leq zenon_TG_dq (n1))) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H155 zenon_H7d zenon_H67 zenon_H3db zenon_H341 zenon_Hcb zenon_H460. % 119.90/120.17 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.17 generalize (zenon_H330 (n1)). zenon_intro zenon_H461. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H461); [ zenon_intro zenon_H460; zenon_intro zenon_H464 | zenon_intro zenon_H463; zenon_intro zenon_H462 ]. % 119.90/120.17 elim (classic ((~((succ (n1)) = (succ (loopcounter))))/\(~(gt (succ (n1)) (succ (loopcounter)))))); [ zenon_intro zenon_H114 | zenon_intro zenon_H115 ]. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H114). zenon_intro zenon_H117. zenon_intro zenon_H116. % 119.90/120.17 apply (zenon_L244_); trivial. % 119.90/120.17 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.17 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.17 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.17 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.17 exact (zenon_H6f zenon_H67). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n1)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H464. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H469. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H11f]. % 119.90/120.17 congruence. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H115); [ zenon_intro zenon_H121 | zenon_intro zenon_H120 ]. % 119.90/120.17 apply zenon_H121. zenon_intro zenon_H122. % 119.90/120.17 apply zenon_H11f. apply sym_equal. exact zenon_H122. % 119.90/120.17 apply zenon_H120. zenon_intro zenon_H11e. % 119.90/120.17 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.90/120.17 generalize (zenon_H11a (succ (loopcounter))). zenon_intro zenon_H123. % 119.90/120.17 generalize (zenon_H123 zenon_TG_dq). zenon_intro zenon_H46a. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46a); [ zenon_intro zenon_H116 | zenon_intro zenon_H46b ]. % 119.90/120.17 exact (zenon_H116 zenon_H11e). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46b); [ zenon_intro zenon_H46c | zenon_intro zenon_H462 ]. % 119.90/120.17 exact (zenon_H46c zenon_H469). % 119.90/120.17 exact (zenon_H464 zenon_H462). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 apply (zenon_L253_ zenon_TG_dq); trivial. % 119.90/120.17 exact (zenon_H460 zenon_H463). % 119.90/120.17 (* end of lemma zenon_L256_ *) % 119.90/120.17 assert (zenon_L257_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ zenon_TG_dq) (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> ((tptp_minus_1) = (n1)) -> (zenon_TG_dq = (n2)) -> ((loopcounter) = (n3)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H5c zenon_H155 zenon_H7d zenon_H67 zenon_H3db zenon_H341 zenon_Hcb. % 119.90/120.17 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L256_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L208_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L223_ zenon_TG_dq); trivial. % 119.90/120.17 (* end of lemma zenon_L257_ *) % 119.90/120.17 assert (zenon_L258_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (succ zenon_TG_dq) (n0)) -> (zenon_TG_dq = (n2)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_H155 zenon_H5c zenon_H341. % 119.90/120.17 generalize (finite_domain_3 (loopcounter)). zenon_intro zenon_Hc5. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_Hc5); [ zenon_intro zenon_Hc7 | zenon_intro zenon_Hc6 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_Hc7); [ zenon_intro zenon_H68 | zenon_intro zenon_Ha4 ]. % 119.90/120.17 apply (zenon_L5_); trivial. % 119.90/120.17 apply (zenon_L12_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_Hc6); [ zenon_intro zenon_H95 | zenon_intro zenon_Hc8 ]. % 119.90/120.17 generalize (finite_domain_3 (tptp_minus_1)). zenon_intro zenon_H44a. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H44a); [ zenon_intro zenon_H44c | zenon_intro zenon_H44b ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H44c); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H3b8 ]. % 119.90/120.17 apply (zenon_L198_); trivial. % 119.90/120.17 apply (zenon_L200_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H44b); [ zenon_intro zenon_H3c1 | zenon_intro zenon_H44d ]. % 119.90/120.17 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L233_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L203_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L222_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H44d); [ zenon_intro zenon_H3db | zenon_intro zenon_H44e ]. % 119.90/120.17 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L233_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L208_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L223_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H44e); [ zenon_intro zenon_H3f9 | zenon_intro zenon_H42f ]. % 119.90/120.17 apply (zenon_L239_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (finite_domain_2 (loopcounter)). zenon_intro zenon_H488. % 119.90/120.17 generalize (finite_domain_2 (tptp_minus_1)). zenon_intro zenon_H44f. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H44f); [ zenon_intro zenon_H451 | zenon_intro zenon_H450 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H451); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H43b ]. % 119.90/120.17 apply (zenon_L198_); trivial. % 119.90/120.17 apply (zenon_L217_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H450); [ zenon_intro zenon_H3c1 | zenon_intro zenon_H452 ]. % 119.90/120.17 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.17 generalize (zenon_H330 (n1)). zenon_intro zenon_H461. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H461); [ zenon_intro zenon_H460; zenon_intro zenon_H464 | zenon_intro zenon_H463; zenon_intro zenon_H462 ]. % 119.90/120.17 elim (classic ((~((succ (n1)) = (succ (loopcounter))))/\(~(gt (succ (n1)) (succ (loopcounter)))))); [ zenon_intro zenon_H114 | zenon_intro zenon_H115 ]. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H114). zenon_intro zenon_H117. zenon_intro zenon_H116. % 119.90/120.17 apply (zenon_L234_); trivial. % 119.90/120.17 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.17 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.17 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.17 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.17 exact (zenon_H6f zenon_H67). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n1)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H464. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H469. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H11f]. % 119.90/120.17 congruence. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H115); [ zenon_intro zenon_H121 | zenon_intro zenon_H120 ]. % 119.90/120.17 apply zenon_H121. zenon_intro zenon_H122. % 119.90/120.17 apply zenon_H11f. apply sym_equal. exact zenon_H122. % 119.90/120.17 apply zenon_H120. zenon_intro zenon_H11e. % 119.90/120.17 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.90/120.17 generalize (zenon_H11a (succ (loopcounter))). zenon_intro zenon_H123. % 119.90/120.17 generalize (zenon_H123 zenon_TG_dq). zenon_intro zenon_H46a. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46a); [ zenon_intro zenon_H116 | zenon_intro zenon_H46b ]. % 119.90/120.17 exact (zenon_H116 zenon_H11e). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46b); [ zenon_intro zenon_H46c | zenon_intro zenon_H462 ]. % 119.90/120.17 exact (zenon_H46c zenon_H469). % 119.90/120.17 exact (zenon_H464 zenon_H462). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 apply (zenon_L243_ zenon_TG_dq); trivial. % 119.90/120.17 exact (zenon_H460 zenon_H463). % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L219_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L225_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H452); [ zenon_intro zenon_H3db | zenon_intro zenon_H3f9 ]. % 119.90/120.17 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.17 generalize (zenon_H330 (n1)). zenon_intro zenon_H461. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H461); [ zenon_intro zenon_H460; zenon_intro zenon_H464 | zenon_intro zenon_H463; zenon_intro zenon_H462 ]. % 119.90/120.17 elim (classic ((~((succ (n1)) = (succ (loopcounter))))/\(~(gt (succ (n1)) (succ (loopcounter)))))); [ zenon_intro zenon_H114 | zenon_intro zenon_H115 ]. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H114). zenon_intro zenon_H117. zenon_intro zenon_H116. % 119.90/120.17 apply (zenon_L244_); trivial. % 119.90/120.17 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.17 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.17 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.17 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.17 exact (zenon_H6f zenon_H67). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n1)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H464. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H469. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H11f]. % 119.90/120.17 congruence. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H115); [ zenon_intro zenon_H121 | zenon_intro zenon_H120 ]. % 119.90/120.17 apply zenon_H121. zenon_intro zenon_H122. % 119.90/120.17 apply zenon_H11f. apply sym_equal. exact zenon_H122. % 119.90/120.17 apply zenon_H120. zenon_intro zenon_H11e. % 119.90/120.17 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.90/120.17 generalize (zenon_H11a (succ (loopcounter))). zenon_intro zenon_H123. % 119.90/120.17 generalize (zenon_H123 zenon_TG_dq). zenon_intro zenon_H46a. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46a); [ zenon_intro zenon_H116 | zenon_intro zenon_H46b ]. % 119.90/120.17 exact (zenon_H116 zenon_H11e). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46b); [ zenon_intro zenon_H46c | zenon_intro zenon_H462 ]. % 119.90/120.17 exact (zenon_H46c zenon_H469). % 119.90/120.17 exact (zenon_H464 zenon_H462). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 apply (zenon_L243_ zenon_TG_dq); trivial. % 119.90/120.17 exact (zenon_H460 zenon_H463). % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L208_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L223_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L248_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_Hc8); [ zenon_intro zenon_Hca | zenon_intro zenon_Hc9 ]. % 119.90/120.17 apply (zenon_L141_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_Hc9); [ zenon_intro zenon_Hcc | zenon_intro zenon_Hcb ]. % 119.90/120.17 apply (zenon_L251_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (finite_domain_2 (loopcounter)). zenon_intro zenon_H488. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H488); [ zenon_intro zenon_H48a | zenon_intro zenon_H489 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H48a); [ zenon_intro zenon_H68 | zenon_intro zenon_H478 ]. % 119.90/120.17 apply (zenon_L5_); trivial. % 119.90/120.17 apply (zenon_L245_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H489); [ zenon_intro zenon_H95 | zenon_intro zenon_H48b ]. % 119.90/120.17 generalize (finite_domain_2 (tptp_minus_1)). zenon_intro zenon_H44f. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H44f); [ zenon_intro zenon_H451 | zenon_intro zenon_H450 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H451); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H43b ]. % 119.90/120.17 apply (zenon_L198_); trivial. % 119.90/120.17 apply (zenon_L217_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H450); [ zenon_intro zenon_H3c1 | zenon_intro zenon_H452 ]. % 119.90/120.17 apply (zenon_L255_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H452); [ zenon_intro zenon_H3db | zenon_intro zenon_H3f9 ]. % 119.90/120.17 apply (zenon_L257_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L239_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H48b); [ zenon_intro zenon_Hca | zenon_intro zenon_Hcc ]. % 119.90/120.17 apply (zenon_L141_); trivial. % 119.90/120.17 apply (zenon_L251_ zenon_TG_dq); trivial. % 119.90/120.17 (* end of lemma zenon_L258_ *) % 119.90/120.17 assert (zenon_L259_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) zenon_TG_dq)) -> (zenon_TG_dq = (n3)) -> ((loopcounter) = (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H466 zenon_H343 zenon_H95 zenon_H155 zenon_H7d zenon_H67. % 119.90/120.17 elim (classic (gt (loopcounter) zenon_TG_dq)); [ zenon_intro zenon_H46d | zenon_intro zenon_H46e ]. % 119.90/120.17 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.90/120.17 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.90/120.17 generalize (zenon_Hf3 zenon_TG_dq). zenon_intro zenon_H46f. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46f); [ zenon_intro zenon_H92 | zenon_intro zenon_H470 ]. % 119.90/120.17 exact (zenon_H92 zenon_H7d). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H470); [ zenon_intro zenon_H46e | zenon_intro zenon_H465 ]. % 119.90/120.17 exact (zenon_H46e zenon_H46d). % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 elim (classic ((n3) = zenon_TG_dq)); [ zenon_intro zenon_H345 | zenon_intro zenon_H337 ]. % 119.90/120.17 elim (classic (gt (loopcounter) (n3))); [ zenon_intro zenon_H1f9 | zenon_intro zenon_H1f5 ]. % 119.90/120.17 cut ((gt (loopcounter) (n3)) = (gt (loopcounter) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H46e. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H1f9. % 119.90/120.17 cut (((n3) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H337]. % 119.90/120.17 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.17 congruence. % 119.90/120.17 apply zenon_H7c. apply refl_equal. % 119.90/120.17 exact (zenon_H337 zenon_H345). % 119.90/120.17 apply (zenon_L231_); trivial. % 119.90/120.17 elim (classic (zenon_TG_dq = zenon_TG_dq)); [ zenon_intro zenon_H3d4 | zenon_intro zenon_H3d3 ]. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq) = ((n3) = zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H337. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H3d4. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut ((zenon_TG_dq = (n3))); [idtac | apply NNPP; zenon_intro zenon_H490]. % 119.90/120.17 congruence. % 119.90/120.17 exact (zenon_H490 zenon_H343). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 (* end of lemma zenon_L259_ *) % 119.90/120.17 assert (zenon_L260_ : (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (succ (n2)) (succ (loopcounter)))) -> ((tptp_minus_1) = (n2)) -> ((loopcounter) = (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.90/120.17 do 0 intro. intros zenon_H66 zenon_H405 zenon_H3f9 zenon_H95 zenon_H155 zenon_H7d zenon_H67. % 119.90/120.17 elim (classic (gt (n0) (succ (loopcounter)))); [ zenon_intro zenon_H146 | zenon_intro zenon_H140 ]. % 119.90/120.17 elim (classic (gt (succ (tptp_minus_1)) (succ (loopcounter)))); [ zenon_intro zenon_H175 | zenon_intro zenon_H16c ]. % 119.90/120.17 cut ((gt (succ (tptp_minus_1)) (succ (loopcounter))) = (gt (succ (n2)) (succ (loopcounter)))). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H405. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H175. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.90/120.17 cut (((succ (tptp_minus_1)) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H491]. % 119.90/120.17 congruence. % 119.90/120.17 elim (classic ((succ (n2)) = (succ (n2)))); [ zenon_intro zenon_H421 | zenon_intro zenon_H40f ]. % 119.90/120.17 cut (((succ (n2)) = (succ (n2))) = ((succ (tptp_minus_1)) = (succ (n2)))). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H491. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H421. % 119.90/120.17 cut (((succ (n2)) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H40f]. % 119.90/120.17 cut (((succ (n2)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H492]. % 119.90/120.17 congruence. % 119.90/120.17 cut (((n2) = (tptp_minus_1))); [idtac | apply NNPP; zenon_intro zenon_H3fe]. % 119.90/120.17 congruence. % 119.90/120.17 apply zenon_H3fe. apply sym_equal. exact zenon_H3f9. % 119.90/120.17 apply zenon_H40f. apply refl_equal. % 119.90/120.17 apply zenon_H40f. apply refl_equal. % 119.90/120.17 apply zenon_H76. apply refl_equal. % 119.90/120.17 cut ((gt (n0) (succ (loopcounter))) = (gt (succ (tptp_minus_1)) (succ (loopcounter)))). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H16c. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H146. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H76]. % 119.90/120.17 cut (((n0) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H167]. % 119.90/120.17 congruence. % 119.90/120.17 elim (classic ((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [ zenon_intro zenon_H16a | zenon_intro zenon_H169 ]. % 119.90/120.17 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1))) = ((n0) = (succ (tptp_minus_1)))). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H167. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H16a. % 119.90/120.17 cut (((succ (tptp_minus_1)) = (succ (tptp_minus_1)))); [idtac | apply NNPP; zenon_intro zenon_H169]. % 119.90/120.17 cut (((succ (tptp_minus_1)) = (n0))); [idtac | apply NNPP; zenon_intro zenon_H16b]. % 119.90/120.17 congruence. % 119.90/120.17 exact (zenon_H16b succ_tptp_minus_1). % 119.90/120.17 apply zenon_H169. apply refl_equal. % 119.90/120.17 apply zenon_H169. apply refl_equal. % 119.90/120.17 apply zenon_H76. apply refl_equal. % 119.90/120.17 apply (zenon_L100_); trivial. % 119.90/120.17 (* end of lemma zenon_L260_ *) % 119.90/120.17 assert (zenon_L261_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) zenon_TG_dq)) -> (zenon_TG_dq = (n3)) -> ((tptp_minus_1) = (n3)) -> ((loopcounter) = (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H466 zenon_H343 zenon_H42f zenon_H95 zenon_H155 zenon_H7d zenon_H67. % 119.90/120.17 elim (classic (gt (loopcounter) zenon_TG_dq)); [ zenon_intro zenon_H46d | zenon_intro zenon_H46e ]. % 119.90/120.17 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.90/120.17 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.90/120.17 generalize (zenon_Hf3 zenon_TG_dq). zenon_intro zenon_H46f. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46f); [ zenon_intro zenon_H92 | zenon_intro zenon_H470 ]. % 119.90/120.17 exact (zenon_H92 zenon_H7d). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H470); [ zenon_intro zenon_H46e | zenon_intro zenon_H465 ]. % 119.90/120.17 exact (zenon_H46e zenon_H46d). % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 elim (classic ((n3) = zenon_TG_dq)); [ zenon_intro zenon_H345 | zenon_intro zenon_H337 ]. % 119.90/120.17 elim (classic (gt (loopcounter) (n3))); [ zenon_intro zenon_H1f9 | zenon_intro zenon_H1f5 ]. % 119.90/120.17 cut ((gt (loopcounter) (n3)) = (gt (loopcounter) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H46e. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H1f9. % 119.90/120.17 cut (((n3) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H337]. % 119.90/120.17 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.17 congruence. % 119.90/120.17 apply zenon_H7c. apply refl_equal. % 119.90/120.17 exact (zenon_H337 zenon_H345). % 119.90/120.17 apply (zenon_L241_); trivial. % 119.90/120.17 elim (classic (zenon_TG_dq = zenon_TG_dq)); [ zenon_intro zenon_H3d4 | zenon_intro zenon_H3d3 ]. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq) = ((n3) = zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H337. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H3d4. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut ((zenon_TG_dq = (n3))); [idtac | apply NNPP; zenon_intro zenon_H490]. % 119.90/120.17 congruence. % 119.90/120.17 exact (zenon_H490 zenon_H343). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 (* end of lemma zenon_L261_ *) % 119.90/120.17 assert (zenon_L262_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n3)) -> ((loopcounter) = (n2)) -> (~(leq zenon_TG_dq (n2))) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H155 zenon_H7d zenon_H67 zenon_H343 zenon_Hcc zenon_H493. % 119.90/120.17 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.17 generalize (zenon_H330 (n2)). zenon_intro zenon_H494. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H494); [ zenon_intro zenon_H493; zenon_intro zenon_H497 | zenon_intro zenon_H496; zenon_intro zenon_H495 ]. % 119.90/120.17 elim (classic ((~((succ (n2)) = (succ (loopcounter))))/\(~(gt (succ (n2)) (succ (loopcounter)))))); [ zenon_intro zenon_H424 | zenon_intro zenon_H425 ]. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H424). zenon_intro zenon_H426. zenon_intro zenon_H405. % 119.90/120.17 apply (zenon_L214_); trivial. % 119.90/120.17 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.17 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.17 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.17 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.17 exact (zenon_H6f zenon_H67). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n2)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H497. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H469. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H427]. % 119.90/120.17 congruence. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H425); [ zenon_intro zenon_H429 | zenon_intro zenon_H428 ]. % 119.90/120.17 apply zenon_H429. zenon_intro zenon_H42a. % 119.90/120.17 apply zenon_H427. apply sym_equal. exact zenon_H42a. % 119.90/120.17 apply zenon_H428. zenon_intro zenon_H40e. % 119.90/120.17 generalize (zenon_H66 (succ (n2))). zenon_intro zenon_H40a. % 119.90/120.17 generalize (zenon_H40a (succ (loopcounter))). zenon_intro zenon_H42b. % 119.90/120.17 generalize (zenon_H42b zenon_TG_dq). zenon_intro zenon_H498. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H498); [ zenon_intro zenon_H405 | zenon_intro zenon_H499 ]. % 119.90/120.17 exact (zenon_H405 zenon_H40e). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H499); [ zenon_intro zenon_H46c | zenon_intro zenon_H495 ]. % 119.90/120.17 exact (zenon_H46c zenon_H469). % 119.90/120.17 exact (zenon_H497 zenon_H495). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 elim (classic (gt (loopcounter) zenon_TG_dq)); [ zenon_intro zenon_H46d | zenon_intro zenon_H46e ]. % 119.90/120.17 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.90/120.17 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.90/120.17 generalize (zenon_Hf3 zenon_TG_dq). zenon_intro zenon_H46f. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46f); [ zenon_intro zenon_H92 | zenon_intro zenon_H470 ]. % 119.90/120.17 exact (zenon_H92 zenon_H7d). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H470); [ zenon_intro zenon_H46e | zenon_intro zenon_H465 ]. % 119.90/120.17 exact (zenon_H46e zenon_H46d). % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 elim (classic (gt (loopcounter) (loopcounter))); [ zenon_intro zenon_H134 | zenon_intro zenon_H135 ]. % 119.90/120.17 elim (classic (gt (loopcounter) (n2))); [ zenon_intro zenon_H1a1 | zenon_intro zenon_H19d ]. % 119.90/120.17 elim (classic (gt (n2) zenon_TG_dq)); [ zenon_intro zenon_H3a2 | zenon_intro zenon_H3a3 ]. % 119.90/120.17 generalize (zenon_H66 (loopcounter)). zenon_intro zenon_H13b. % 119.90/120.17 generalize (zenon_H13b (n2)). zenon_intro zenon_H1a2. % 119.90/120.17 generalize (zenon_H1a2 zenon_TG_dq). zenon_intro zenon_H49a. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H49a); [ zenon_intro zenon_H19d | zenon_intro zenon_H49b ]. % 119.90/120.17 exact (zenon_H19d zenon_H1a1). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H49b); [ zenon_intro zenon_H3a3 | zenon_intro zenon_H46d ]. % 119.90/120.17 exact (zenon_H3a3 zenon_H3a2). % 119.90/120.17 exact (zenon_H46e zenon_H46d). % 119.90/120.17 elim (classic ((n2) = (succ (succ (n0))))); [ zenon_intro zenon_H1b9 | zenon_intro zenon_H102 ]. % 119.90/120.17 elim (classic (gt (n2) (n2))); [ zenon_intro zenon_H1aa | zenon_intro zenon_H1a5 ]. % 119.90/120.17 elim (classic (gt (n2) (succ (succ (n0))))); [ zenon_intro zenon_H314 | zenon_intro zenon_H315 ]. % 119.90/120.17 elim (classic (gt (succ (succ (n0))) zenon_TG_dq)); [ zenon_intro zenon_H3a6 | zenon_intro zenon_H3a7 ]. % 119.90/120.17 generalize (zenon_H66 (n2)). zenon_intro zenon_H1a6. % 119.90/120.17 generalize (zenon_H1a6 (succ (succ (n0)))). zenon_intro zenon_H323. % 119.90/120.17 generalize (zenon_H323 zenon_TG_dq). zenon_intro zenon_H3a8. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H3a8); [ zenon_intro zenon_H315 | zenon_intro zenon_H3a9 ]. % 119.90/120.17 exact (zenon_H315 zenon_H314). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H3a9); [ zenon_intro zenon_H3a7 | zenon_intro zenon_H3a2 ]. % 119.90/120.17 exact (zenon_H3a7 zenon_H3a6). % 119.90/120.17 exact (zenon_H3a3 zenon_H3a2). % 119.90/120.17 elim (classic (gt (succ (succ (n0))) (succ (succ (succ (n0)))))); [ zenon_intro zenon_H233 | zenon_intro zenon_H21b ]. % 119.90/120.17 elim (classic (gt (succ (succ (n0))) (n3))); [ zenon_intro zenon_H219 | zenon_intro zenon_H20b ]. % 119.90/120.17 cut ((gt (succ (succ (n0))) (n3)) = (gt (succ (succ (n0))) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H3a7. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H219. % 119.90/120.17 cut (((n3) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H337]. % 119.90/120.17 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.90/120.17 congruence. % 119.90/120.17 apply zenon_H104. apply refl_equal. % 119.90/120.17 apply zenon_H337. apply sym_equal. exact zenon_H343. % 119.90/120.17 cut ((gt (succ (succ (n0))) (succ (succ (succ (n0))))) = (gt (succ (succ (n0))) (n3))). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H20b. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H233. % 119.90/120.17 cut (((succ (succ (succ (n0)))) = (n3))); [idtac | apply NNPP; zenon_intro zenon_H21f]. % 119.90/120.17 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.90/120.17 congruence. % 119.90/120.17 apply zenon_H104. apply refl_equal. % 119.90/120.17 exact (zenon_H21f successor_3). % 119.90/120.17 apply (zenon_L189_); trivial. % 119.90/120.17 cut ((gt (n2) (n2)) = (gt (n2) (succ (succ (n0))))). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H315. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H1aa. % 119.90/120.17 cut (((n2) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H102]. % 119.90/120.17 cut (((n2) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H63]. % 119.90/120.17 congruence. % 119.90/120.17 apply zenon_H63. apply refl_equal. % 119.90/120.17 exact (zenon_H102 zenon_H1b9). % 119.90/120.17 apply (zenon_L191_); trivial. % 119.90/120.17 elim (classic ((succ (succ (n0))) = (succ (succ (n0))))); [ zenon_intro zenon_H103 | zenon_intro zenon_H104 ]. % 119.90/120.17 cut (((succ (succ (n0))) = (succ (succ (n0)))) = ((n2) = (succ (succ (n0))))). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H102. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H103. % 119.90/120.17 cut (((succ (succ (n0))) = (succ (succ (n0))))); [idtac | apply NNPP; zenon_intro zenon_H104]. % 119.90/120.17 cut (((succ (succ (n0))) = (n2))); [idtac | apply NNPP; zenon_intro zenon_H105]. % 119.90/120.17 congruence. % 119.90/120.17 exact (zenon_H105 successor_2). % 119.90/120.17 apply zenon_H104. apply refl_equal. % 119.90/120.17 apply zenon_H104. apply refl_equal. % 119.90/120.17 cut ((gt (loopcounter) (loopcounter)) = (gt (loopcounter) (n2))). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H19d. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H134. % 119.90/120.17 cut (((loopcounter) = (n2))); [idtac | apply NNPP; zenon_intro zenon_Hc3]. % 119.90/120.17 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.17 congruence. % 119.90/120.17 apply zenon_H7c. apply refl_equal. % 119.90/120.17 exact (zenon_Hc3 zenon_Hcc). % 119.90/120.17 apply (zenon_L230_); trivial. % 119.90/120.17 exact (zenon_H493 zenon_H496). % 119.90/120.17 (* end of lemma zenon_L262_ *) % 119.90/120.17 assert (zenon_L263_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ zenon_TG_dq) (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n3)) -> ((loopcounter) = (n2)) -> ((tptp_minus_1) = (n1)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H5c zenon_H155 zenon_H7d zenon_H67 zenon_H343 zenon_Hcc zenon_H3db. % 119.90/120.17 generalize (finite_domain_2 zenon_TG_dq). zenon_intro zenon_H49c. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H49c); [ zenon_intro zenon_H49e | zenon_intro zenon_H49d ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H49e); [ zenon_intro zenon_H5d | zenon_intro zenon_H493 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L262_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49d); [ zenon_intro zenon_H33d | zenon_intro zenon_H49f ]. % 119.90/120.17 apply (zenon_L208_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49f); [ zenon_intro zenon_H33f | zenon_intro zenon_H341 ]. % 119.90/120.17 apply (zenon_L223_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L250_ zenon_TG_dq); trivial. % 119.90/120.17 (* end of lemma zenon_L263_ *) % 119.90/120.17 assert (zenon_L264_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ zenon_TG_dq) (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n3)) -> ((loopcounter) = (n2)) -> ((tptp_minus_1) = (n2)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H5c zenon_H155 zenon_H7d zenon_H67 zenon_H343 zenon_Hcc zenon_H3f9. % 119.90/120.17 generalize (finite_domain_2 zenon_TG_dq). zenon_intro zenon_H49c. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H49c); [ zenon_intro zenon_H49e | zenon_intro zenon_H49d ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H49e); [ zenon_intro zenon_H5d | zenon_intro zenon_H493 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L262_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49d); [ zenon_intro zenon_H33d | zenon_intro zenon_H49f ]. % 119.90/120.17 apply (zenon_L213_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49f); [ zenon_intro zenon_H33f | zenon_intro zenon_H341 ]. % 119.90/120.17 apply (zenon_L224_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L247_ zenon_TG_dq); trivial. % 119.90/120.17 (* end of lemma zenon_L264_ *) % 119.90/120.17 assert (zenon_L265_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ zenon_TG_dq) (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n2)) -> ((loopcounter) = (n2)) -> ((tptp_minus_1) = (n3)) -> ((tptp_minus_1) = (n0)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H5c zenon_H155 zenon_H7d zenon_H67 zenon_H341 zenon_Hcc zenon_H42f zenon_H3c1. % 119.90/120.17 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L246_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L219_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L225_ zenon_TG_dq); trivial. % 119.90/120.17 (* end of lemma zenon_L265_ *) % 119.90/120.17 assert (zenon_L266_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (~(gt (n1) zenon_TG_dq)) -> ((loopcounter) = (n3)) -> (zenon_TG_dq = (n3)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H466 zenon_Hcb zenon_H343 zenon_H155 zenon_H7d zenon_H67. % 119.90/120.17 elim (classic (gt (loopcounter) zenon_TG_dq)); [ zenon_intro zenon_H46d | zenon_intro zenon_H46e ]. % 119.90/120.17 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.90/120.17 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.90/120.17 generalize (zenon_Hf3 zenon_TG_dq). zenon_intro zenon_H46f. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46f); [ zenon_intro zenon_H92 | zenon_intro zenon_H470 ]. % 119.90/120.17 exact (zenon_H92 zenon_H7d). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H470); [ zenon_intro zenon_H46e | zenon_intro zenon_H465 ]. % 119.90/120.17 exact (zenon_H46e zenon_H46d). % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 elim (classic (gt (loopcounter) (loopcounter))); [ zenon_intro zenon_H134 | zenon_intro zenon_H135 ]. % 119.90/120.17 elim (classic (gt (loopcounter) (n3))); [ zenon_intro zenon_H1f9 | zenon_intro zenon_H1f5 ]. % 119.90/120.17 cut ((gt (loopcounter) (n3)) = (gt (loopcounter) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H46e. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H1f9. % 119.90/120.17 cut (((n3) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H337]. % 119.90/120.17 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.17 congruence. % 119.90/120.17 apply zenon_H7c. apply refl_equal. % 119.90/120.17 apply zenon_H337. apply sym_equal. exact zenon_H343. % 119.90/120.17 cut ((gt (loopcounter) (loopcounter)) = (gt (loopcounter) (n3))). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H1f5. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H134. % 119.90/120.17 cut (((loopcounter) = (n3))); [idtac | apply NNPP; zenon_intro zenon_Hc2]. % 119.90/120.17 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.17 congruence. % 119.90/120.17 apply zenon_H7c. apply refl_equal. % 119.90/120.17 exact (zenon_Hc2 zenon_Hcb). % 119.90/120.17 apply (zenon_L230_); trivial. % 119.90/120.17 (* end of lemma zenon_L266_ *) % 119.90/120.17 assert (zenon_L267_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n3)) -> ((loopcounter) = (n3)) -> (~(leq zenon_TG_dq (n2))) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H155 zenon_H7d zenon_H67 zenon_H343 zenon_Hcb zenon_H493. % 119.90/120.17 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.17 generalize (zenon_H330 (n2)). zenon_intro zenon_H494. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H494); [ zenon_intro zenon_H493; zenon_intro zenon_H497 | zenon_intro zenon_H496; zenon_intro zenon_H495 ]. % 119.90/120.17 elim (classic ((~((succ (n2)) = (succ (loopcounter))))/\(~(gt (succ (n2)) (succ (loopcounter)))))); [ zenon_intro zenon_H424 | zenon_intro zenon_H425 ]. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H424). zenon_intro zenon_H426. zenon_intro zenon_H405. % 119.90/120.17 apply (zenon_L214_); trivial. % 119.90/120.17 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.17 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.17 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.17 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.17 exact (zenon_H6f zenon_H67). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n2)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H497. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H469. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H427]. % 119.90/120.17 congruence. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H425); [ zenon_intro zenon_H429 | zenon_intro zenon_H428 ]. % 119.90/120.17 apply zenon_H429. zenon_intro zenon_H42a. % 119.90/120.17 apply zenon_H427. apply sym_equal. exact zenon_H42a. % 119.90/120.17 apply zenon_H428. zenon_intro zenon_H40e. % 119.90/120.17 generalize (zenon_H66 (succ (n2))). zenon_intro zenon_H40a. % 119.90/120.17 generalize (zenon_H40a (succ (loopcounter))). zenon_intro zenon_H42b. % 119.90/120.17 generalize (zenon_H42b zenon_TG_dq). zenon_intro zenon_H498. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H498); [ zenon_intro zenon_H405 | zenon_intro zenon_H499 ]. % 119.90/120.17 exact (zenon_H405 zenon_H40e). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H499); [ zenon_intro zenon_H46c | zenon_intro zenon_H495 ]. % 119.90/120.17 exact (zenon_H46c zenon_H469). % 119.90/120.17 exact (zenon_H497 zenon_H495). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 apply (zenon_L266_ zenon_TG_dq); trivial. % 119.90/120.17 exact (zenon_H493 zenon_H496). % 119.90/120.17 (* end of lemma zenon_L267_ *) % 119.90/120.17 assert (zenon_L268_ : forall (zenon_TG_dq : zenon_U), ((loopcounter) = (n3)) -> (~(gt (loopcounter) zenon_TG_dq)) -> (zenon_TG_dq = (n2)) -> False). % 119.90/120.17 do 1 intro. intros zenon_Hcb zenon_H46e zenon_H341. % 119.90/120.17 elim (classic (gt (n3) zenon_TG_dq)); [ zenon_intro zenon_H48d | zenon_intro zenon_H48c ]. % 119.90/120.17 cut ((gt (n3) zenon_TG_dq) = (gt (loopcounter) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H46e. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H48d. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut (((n3) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H1f6]. % 119.90/120.17 congruence. % 119.90/120.17 elim (classic ((loopcounter) = (loopcounter))); [ zenon_intro zenon_Hed | zenon_intro zenon_H7c ]. % 119.90/120.17 cut (((loopcounter) = (loopcounter)) = ((n3) = (loopcounter))). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H1f6. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_Hed. % 119.90/120.17 cut (((loopcounter) = (loopcounter))); [idtac | apply NNPP; zenon_intro zenon_H7c]. % 119.90/120.17 cut (((loopcounter) = (n3))); [idtac | apply NNPP; zenon_intro zenon_Hc2]. % 119.90/120.17 congruence. % 119.90/120.17 exact (zenon_Hc2 zenon_Hcb). % 119.90/120.17 apply zenon_H7c. apply refl_equal. % 119.90/120.17 apply zenon_H7c. apply refl_equal. % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 apply (zenon_L252_ zenon_TG_dq); trivial. % 119.90/120.17 (* end of lemma zenon_L268_ *) % 119.90/120.17 assert (zenon_L269_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n2)) -> ((loopcounter) = (n3)) -> (~(leq zenon_TG_dq (n1))) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H155 zenon_H7d zenon_H67 zenon_H341 zenon_Hcb zenon_H460. % 119.90/120.17 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.17 generalize (zenon_H330 (n1)). zenon_intro zenon_H461. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H461); [ zenon_intro zenon_H460; zenon_intro zenon_H464 | zenon_intro zenon_H463; zenon_intro zenon_H462 ]. % 119.90/120.17 elim (classic ((~((succ (n1)) = (succ (loopcounter))))/\(~(gt (succ (n1)) (succ (loopcounter)))))); [ zenon_intro zenon_H114 | zenon_intro zenon_H115 ]. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H114). zenon_intro zenon_H117. zenon_intro zenon_H116. % 119.90/120.17 apply (zenon_L234_); trivial. % 119.90/120.17 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.17 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.17 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.17 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.17 exact (zenon_H6f zenon_H67). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n1)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H464. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H469. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H11f]. % 119.90/120.17 congruence. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H115); [ zenon_intro zenon_H121 | zenon_intro zenon_H120 ]. % 119.90/120.17 apply zenon_H121. zenon_intro zenon_H122. % 119.90/120.17 apply zenon_H11f. apply sym_equal. exact zenon_H122. % 119.90/120.17 apply zenon_H120. zenon_intro zenon_H11e. % 119.90/120.17 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.90/120.17 generalize (zenon_H11a (succ (loopcounter))). zenon_intro zenon_H123. % 119.90/120.17 generalize (zenon_H123 zenon_TG_dq). zenon_intro zenon_H46a. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46a); [ zenon_intro zenon_H116 | zenon_intro zenon_H46b ]. % 119.90/120.17 exact (zenon_H116 zenon_H11e). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46b); [ zenon_intro zenon_H46c | zenon_intro zenon_H462 ]. % 119.90/120.17 exact (zenon_H46c zenon_H469). % 119.90/120.17 exact (zenon_H464 zenon_H462). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 elim (classic (gt (loopcounter) zenon_TG_dq)); [ zenon_intro zenon_H46d | zenon_intro zenon_H46e ]. % 119.90/120.17 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.90/120.17 generalize (zenon_He4 (loopcounter)). zenon_intro zenon_Hf3. % 119.90/120.17 generalize (zenon_Hf3 zenon_TG_dq). zenon_intro zenon_H46f. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46f); [ zenon_intro zenon_H92 | zenon_intro zenon_H470 ]. % 119.90/120.17 exact (zenon_H92 zenon_H7d). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H470); [ zenon_intro zenon_H46e | zenon_intro zenon_H465 ]. % 119.90/120.17 exact (zenon_H46e zenon_H46d). % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 apply (zenon_L268_ zenon_TG_dq); trivial. % 119.90/120.17 exact (zenon_H460 zenon_H463). % 119.90/120.17 (* end of lemma zenon_L269_ *) % 119.90/120.17 assert (zenon_L270_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ zenon_TG_dq) (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n3)) -> ((loopcounter) = (n3)) -> ((tptp_minus_1) = (n1)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H5c zenon_H155 zenon_H7d zenon_H67 zenon_H343 zenon_Hcb zenon_H3db. % 119.90/120.17 generalize (finite_domain_2 zenon_TG_dq). zenon_intro zenon_H49c. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H49c); [ zenon_intro zenon_H49e | zenon_intro zenon_H49d ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H49e); [ zenon_intro zenon_H5d | zenon_intro zenon_H493 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L267_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49d); [ zenon_intro zenon_H33d | zenon_intro zenon_H49f ]. % 119.90/120.17 apply (zenon_L208_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49f); [ zenon_intro zenon_H33f | zenon_intro zenon_H341 ]. % 119.90/120.17 apply (zenon_L223_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L269_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L208_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L223_ zenon_TG_dq); trivial. % 119.90/120.17 (* end of lemma zenon_L270_ *) % 119.90/120.17 assert (zenon_L271_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> ((loopcounter) = (n0)) -> ((tptp_minus_1) = (n2)) -> (zenon_TG_dq = (n3)) -> ((loopcounter) = (n3)) -> (~(leq zenon_TG_dq (n2))) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_H155 zenon_H95 zenon_H3f9 zenon_H343 zenon_Hcb zenon_H493. % 119.90/120.17 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.17 generalize (zenon_H330 (n2)). zenon_intro zenon_H494. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H494); [ zenon_intro zenon_H493; zenon_intro zenon_H497 | zenon_intro zenon_H496; zenon_intro zenon_H495 ]. % 119.90/120.17 elim (classic ((~((succ (n2)) = (succ (loopcounter))))/\(~(gt (succ (n2)) (succ (loopcounter)))))); [ zenon_intro zenon_H424 | zenon_intro zenon_H425 ]. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H424). zenon_intro zenon_H426. zenon_intro zenon_H405. % 119.90/120.17 apply (zenon_L260_); trivial. % 119.90/120.17 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.17 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.17 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.17 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.17 exact (zenon_H6f zenon_H67). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n2)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H497. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H469. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H427]. % 119.90/120.17 congruence. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H425); [ zenon_intro zenon_H429 | zenon_intro zenon_H428 ]. % 119.90/120.17 apply zenon_H429. zenon_intro zenon_H42a. % 119.90/120.17 apply zenon_H427. apply sym_equal. exact zenon_H42a. % 119.90/120.17 apply zenon_H428. zenon_intro zenon_H40e. % 119.90/120.17 generalize (zenon_H66 (succ (n2))). zenon_intro zenon_H40a. % 119.90/120.17 generalize (zenon_H40a (succ (loopcounter))). zenon_intro zenon_H42b. % 119.90/120.17 generalize (zenon_H42b zenon_TG_dq). zenon_intro zenon_H498. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H498); [ zenon_intro zenon_H405 | zenon_intro zenon_H499 ]. % 119.90/120.17 exact (zenon_H405 zenon_H40e). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H499); [ zenon_intro zenon_H46c | zenon_intro zenon_H495 ]. % 119.90/120.17 exact (zenon_H46c zenon_H469). % 119.90/120.17 exact (zenon_H497 zenon_H495). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 apply (zenon_L266_ zenon_TG_dq); trivial. % 119.90/120.17 exact (zenon_H493 zenon_H496). % 119.90/120.17 (* end of lemma zenon_L271_ *) % 119.90/120.17 assert (zenon_L272_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ zenon_TG_dq) (n0)) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> ((loopcounter) = (n0)) -> ((tptp_minus_1) = (n2)) -> (zenon_TG_dq = (n3)) -> ((loopcounter) = (n3)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H5c zenon_H67 zenon_H7d zenon_H155 zenon_H95 zenon_H3f9 zenon_H343 zenon_Hcb. % 119.90/120.17 generalize (finite_domain_2 zenon_TG_dq). zenon_intro zenon_H49c. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H49c); [ zenon_intro zenon_H49e | zenon_intro zenon_H49d ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H49e); [ zenon_intro zenon_H5d | zenon_intro zenon_H493 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L271_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49d); [ zenon_intro zenon_H33d | zenon_intro zenon_H49f ]. % 119.90/120.17 apply (zenon_L213_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49f); [ zenon_intro zenon_H33f | zenon_intro zenon_H341 ]. % 119.90/120.17 apply (zenon_L224_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L269_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L213_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L224_ zenon_TG_dq); trivial. % 119.90/120.17 (* end of lemma zenon_L272_ *) % 119.90/120.17 assert (zenon_L273_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ zenon_TG_dq) (n0)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (n1) (loopcounter)) -> (gt (succ (loopcounter)) (n1)) -> (zenon_TG_dq = (n3)) -> ((loopcounter) = (n3)) -> ((tptp_minus_1) = (n2)) -> ((loopcounter) = (n2)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H5c zenon_H155 zenon_H7d zenon_H67 zenon_H343 zenon_Hcb zenon_H3f9 zenon_Hcc. % 119.90/120.17 generalize (finite_domain_2 zenon_TG_dq). zenon_intro zenon_H49c. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H49c); [ zenon_intro zenon_H49e | zenon_intro zenon_H49d ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H49e); [ zenon_intro zenon_H5d | zenon_intro zenon_H493 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L267_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49d); [ zenon_intro zenon_H33d | zenon_intro zenon_H49f ]. % 119.90/120.17 apply (zenon_L213_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49f); [ zenon_intro zenon_H33f | zenon_intro zenon_H341 ]. % 119.90/120.17 apply (zenon_L224_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L247_ zenon_TG_dq); trivial. % 119.90/120.17 (* end of lemma zenon_L273_ *) % 119.90/120.17 assert (zenon_L274_ : forall (zenon_TG_dq : zenon_U), (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z)))))) -> (gt (succ (loopcounter)) (n1)) -> (gt (n1) (loopcounter)) -> ((sum (n0) (tptp_minus_1) zenon_E) = (n0)) -> (gt (succ zenon_TG_dq) (n0)) -> (zenon_TG_dq = (n3)) -> False). % 119.90/120.17 do 1 intro. intros zenon_H66 zenon_H67 zenon_H7d zenon_H155 zenon_H5c zenon_H343. % 119.90/120.17 generalize (finite_domain_3 (loopcounter)). zenon_intro zenon_Hc5. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_Hc5); [ zenon_intro zenon_Hc7 | zenon_intro zenon_Hc6 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_Hc7); [ zenon_intro zenon_H68 | zenon_intro zenon_Ha4 ]. % 119.90/120.17 apply (zenon_L5_); trivial. % 119.90/120.17 apply (zenon_L12_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_Hc6); [ zenon_intro zenon_H95 | zenon_intro zenon_Hc8 ]. % 119.90/120.17 generalize (finite_domain_3 (tptp_minus_1)). zenon_intro zenon_H44a. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H44a); [ zenon_intro zenon_H44c | zenon_intro zenon_H44b ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H44c); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H3b8 ]. % 119.90/120.17 apply (zenon_L198_); trivial. % 119.90/120.17 apply (zenon_L200_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H44b); [ zenon_intro zenon_H3c1 | zenon_intro zenon_H44d ]. % 119.90/120.17 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.17 generalize (zenon_H330 (n1)). zenon_intro zenon_H461. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H461); [ zenon_intro zenon_H460; zenon_intro zenon_H464 | zenon_intro zenon_H463; zenon_intro zenon_H462 ]. % 119.90/120.17 elim (classic ((~((succ (n1)) = (succ (loopcounter))))/\(~(gt (succ (n1)) (succ (loopcounter)))))); [ zenon_intro zenon_H114 | zenon_intro zenon_H115 ]. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H114). zenon_intro zenon_H117. zenon_intro zenon_H116. % 119.90/120.17 apply (zenon_L234_); trivial. % 119.90/120.17 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.17 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.17 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.17 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.17 exact (zenon_H6f zenon_H67). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n1)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H464. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H469. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H11f]. % 119.90/120.17 congruence. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H115); [ zenon_intro zenon_H121 | zenon_intro zenon_H120 ]. % 119.90/120.17 apply zenon_H121. zenon_intro zenon_H122. % 119.90/120.17 apply zenon_H11f. apply sym_equal. exact zenon_H122. % 119.90/120.17 apply zenon_H120. zenon_intro zenon_H11e. % 119.90/120.17 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.90/120.17 generalize (zenon_H11a (succ (loopcounter))). zenon_intro zenon_H123. % 119.90/120.17 generalize (zenon_H123 zenon_TG_dq). zenon_intro zenon_H46a. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46a); [ zenon_intro zenon_H116 | zenon_intro zenon_H46b ]. % 119.90/120.17 exact (zenon_H116 zenon_H11e). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46b); [ zenon_intro zenon_H46c | zenon_intro zenon_H462 ]. % 119.90/120.17 exact (zenon_H46c zenon_H469). % 119.90/120.17 exact (zenon_H464 zenon_H462). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 apply (zenon_L259_ zenon_TG_dq); trivial. % 119.90/120.17 exact (zenon_H460 zenon_H463). % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L203_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L222_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H44d); [ zenon_intro zenon_H3db | zenon_intro zenon_H44e ]. % 119.90/120.17 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.17 generalize (zenon_H330 (n1)). zenon_intro zenon_H461. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H461); [ zenon_intro zenon_H460; zenon_intro zenon_H464 | zenon_intro zenon_H463; zenon_intro zenon_H462 ]. % 119.90/120.17 elim (classic ((~((succ (n1)) = (succ (loopcounter))))/\(~(gt (succ (n1)) (succ (loopcounter)))))); [ zenon_intro zenon_H114 | zenon_intro zenon_H115 ]. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H114). zenon_intro zenon_H117. zenon_intro zenon_H116. % 119.90/120.17 apply (zenon_L244_); trivial. % 119.90/120.17 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.17 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.17 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.17 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.17 exact (zenon_H6f zenon_H67). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n1)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H464. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H469. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H11f]. % 119.90/120.17 congruence. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H115); [ zenon_intro zenon_H121 | zenon_intro zenon_H120 ]. % 119.90/120.17 apply zenon_H121. zenon_intro zenon_H122. % 119.90/120.17 apply zenon_H11f. apply sym_equal. exact zenon_H122. % 119.90/120.17 apply zenon_H120. zenon_intro zenon_H11e. % 119.90/120.17 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.90/120.17 generalize (zenon_H11a (succ (loopcounter))). zenon_intro zenon_H123. % 119.90/120.17 generalize (zenon_H123 zenon_TG_dq). zenon_intro zenon_H46a. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46a); [ zenon_intro zenon_H116 | zenon_intro zenon_H46b ]. % 119.90/120.17 exact (zenon_H116 zenon_H11e). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46b); [ zenon_intro zenon_H46c | zenon_intro zenon_H462 ]. % 119.90/120.17 exact (zenon_H46c zenon_H469). % 119.90/120.17 exact (zenon_H464 zenon_H462). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 apply (zenon_L259_ zenon_TG_dq); trivial. % 119.90/120.17 exact (zenon_H460 zenon_H463). % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L208_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L223_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H44e); [ zenon_intro zenon_H3f9 | zenon_intro zenon_H42f ]. % 119.90/120.17 generalize (finite_domain_2 zenon_TG_dq). zenon_intro zenon_H49c. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H49c); [ zenon_intro zenon_H49e | zenon_intro zenon_H49d ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H49e); [ zenon_intro zenon_H5d | zenon_intro zenon_H493 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.17 generalize (zenon_H330 (n2)). zenon_intro zenon_H494. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H494); [ zenon_intro zenon_H493; zenon_intro zenon_H497 | zenon_intro zenon_H496; zenon_intro zenon_H495 ]. % 119.90/120.17 elim (classic ((~((succ (n2)) = (succ (loopcounter))))/\(~(gt (succ (n2)) (succ (loopcounter)))))); [ zenon_intro zenon_H424 | zenon_intro zenon_H425 ]. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H424). zenon_intro zenon_H426. zenon_intro zenon_H405. % 119.90/120.17 apply (zenon_L260_); trivial. % 119.90/120.17 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.17 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.17 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.17 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.17 exact (zenon_H6f zenon_H67). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n2)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H497. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H469. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H427]. % 119.90/120.17 congruence. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H425); [ zenon_intro zenon_H429 | zenon_intro zenon_H428 ]. % 119.90/120.17 apply zenon_H429. zenon_intro zenon_H42a. % 119.90/120.17 apply zenon_H427. apply sym_equal. exact zenon_H42a. % 119.90/120.17 apply zenon_H428. zenon_intro zenon_H40e. % 119.90/120.17 generalize (zenon_H66 (succ (n2))). zenon_intro zenon_H40a. % 119.90/120.17 generalize (zenon_H40a (succ (loopcounter))). zenon_intro zenon_H42b. % 119.90/120.17 generalize (zenon_H42b zenon_TG_dq). zenon_intro zenon_H498. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H498); [ zenon_intro zenon_H405 | zenon_intro zenon_H499 ]. % 119.90/120.17 exact (zenon_H405 zenon_H40e). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H499); [ zenon_intro zenon_H46c | zenon_intro zenon_H495 ]. % 119.90/120.17 exact (zenon_H46c zenon_H469). % 119.90/120.17 exact (zenon_H497 zenon_H495). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 apply (zenon_L259_ zenon_TG_dq); trivial. % 119.90/120.17 exact (zenon_H493 zenon_H496). % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49d); [ zenon_intro zenon_H33d | zenon_intro zenon_H49f ]. % 119.90/120.17 apply (zenon_L213_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49f); [ zenon_intro zenon_H33f | zenon_intro zenon_H341 ]. % 119.90/120.17 apply (zenon_L224_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L239_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (finite_domain_2 (tptp_minus_1)). zenon_intro zenon_H44f. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H44f); [ zenon_intro zenon_H451 | zenon_intro zenon_H450 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H451); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H43b ]. % 119.90/120.17 apply (zenon_L198_); trivial. % 119.90/120.17 apply (zenon_L217_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H450); [ zenon_intro zenon_H3c1 | zenon_intro zenon_H452 ]. % 119.90/120.17 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.17 generalize (zenon_H330 (n1)). zenon_intro zenon_H461. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H461); [ zenon_intro zenon_H460; zenon_intro zenon_H464 | zenon_intro zenon_H463; zenon_intro zenon_H462 ]. % 119.90/120.17 elim (classic ((~((succ (n1)) = (succ (loopcounter))))/\(~(gt (succ (n1)) (succ (loopcounter)))))); [ zenon_intro zenon_H114 | zenon_intro zenon_H115 ]. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H114). zenon_intro zenon_H117. zenon_intro zenon_H116. % 119.90/120.17 apply (zenon_L234_); trivial. % 119.90/120.17 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.17 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.17 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.17 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.17 exact (zenon_H6f zenon_H67). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n1)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H464. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H469. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H11f]. % 119.90/120.17 congruence. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H115); [ zenon_intro zenon_H121 | zenon_intro zenon_H120 ]. % 119.90/120.17 apply zenon_H121. zenon_intro zenon_H122. % 119.90/120.17 apply zenon_H11f. apply sym_equal. exact zenon_H122. % 119.90/120.17 apply zenon_H120. zenon_intro zenon_H11e. % 119.90/120.17 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.90/120.17 generalize (zenon_H11a (succ (loopcounter))). zenon_intro zenon_H123. % 119.90/120.17 generalize (zenon_H123 zenon_TG_dq). zenon_intro zenon_H46a. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46a); [ zenon_intro zenon_H116 | zenon_intro zenon_H46b ]. % 119.90/120.17 exact (zenon_H116 zenon_H11e). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46b); [ zenon_intro zenon_H46c | zenon_intro zenon_H462 ]. % 119.90/120.17 exact (zenon_H46c zenon_H469). % 119.90/120.17 exact (zenon_H464 zenon_H462). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 apply (zenon_L261_ zenon_TG_dq); trivial. % 119.90/120.17 exact (zenon_H460 zenon_H463). % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L203_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L222_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H452); [ zenon_intro zenon_H3db | zenon_intro zenon_H3f9 ]. % 119.90/120.17 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.17 generalize (zenon_H330 (n1)). zenon_intro zenon_H461. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H461); [ zenon_intro zenon_H460; zenon_intro zenon_H464 | zenon_intro zenon_H463; zenon_intro zenon_H462 ]. % 119.90/120.17 elim (classic ((~((succ (n1)) = (succ (loopcounter))))/\(~(gt (succ (n1)) (succ (loopcounter)))))); [ zenon_intro zenon_H114 | zenon_intro zenon_H115 ]. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H114). zenon_intro zenon_H117. zenon_intro zenon_H116. % 119.90/120.17 apply (zenon_L244_); trivial. % 119.90/120.17 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.17 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.17 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.17 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.17 exact (zenon_H6f zenon_H67). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n1)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H464. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H469. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (n1)))); [idtac | apply NNPP; zenon_intro zenon_H11f]. % 119.90/120.17 congruence. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H115); [ zenon_intro zenon_H121 | zenon_intro zenon_H120 ]. % 119.90/120.17 apply zenon_H121. zenon_intro zenon_H122. % 119.90/120.17 apply zenon_H11f. apply sym_equal. exact zenon_H122. % 119.90/120.17 apply zenon_H120. zenon_intro zenon_H11e. % 119.90/120.17 generalize (zenon_H66 (succ (n1))). zenon_intro zenon_H11a. % 119.90/120.17 generalize (zenon_H11a (succ (loopcounter))). zenon_intro zenon_H123. % 119.90/120.17 generalize (zenon_H123 zenon_TG_dq). zenon_intro zenon_H46a. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46a); [ zenon_intro zenon_H116 | zenon_intro zenon_H46b ]. % 119.90/120.17 exact (zenon_H116 zenon_H11e). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H46b); [ zenon_intro zenon_H46c | zenon_intro zenon_H462 ]. % 119.90/120.17 exact (zenon_H46c zenon_H469). % 119.90/120.17 exact (zenon_H464 zenon_H462). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 apply (zenon_L261_ zenon_TG_dq); trivial. % 119.90/120.17 exact (zenon_H460 zenon_H463). % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L208_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L223_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (finite_domain_2 zenon_TG_dq). zenon_intro zenon_H49c. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H49c); [ zenon_intro zenon_H49e | zenon_intro zenon_H49d ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H49e); [ zenon_intro zenon_H5d | zenon_intro zenon_H493 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.17 generalize (zenon_H330 (n2)). zenon_intro zenon_H494. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H494); [ zenon_intro zenon_H493; zenon_intro zenon_H497 | zenon_intro zenon_H496; zenon_intro zenon_H495 ]. % 119.90/120.17 elim (classic ((~((succ (n2)) = (succ (loopcounter))))/\(~(gt (succ (n2)) (succ (loopcounter)))))); [ zenon_intro zenon_H424 | zenon_intro zenon_H425 ]. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H424). zenon_intro zenon_H426. zenon_intro zenon_H405. % 119.90/120.17 apply (zenon_L260_); trivial. % 119.90/120.17 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.17 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.17 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.17 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.17 exact (zenon_H6f zenon_H67). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n2)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H497. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H469. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (n2)))); [idtac | apply NNPP; zenon_intro zenon_H427]. % 119.90/120.17 congruence. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H425); [ zenon_intro zenon_H429 | zenon_intro zenon_H428 ]. % 119.90/120.17 apply zenon_H429. zenon_intro zenon_H42a. % 119.90/120.17 apply zenon_H427. apply sym_equal. exact zenon_H42a. % 119.90/120.17 apply zenon_H428. zenon_intro zenon_H40e. % 119.90/120.17 generalize (zenon_H66 (succ (n2))). zenon_intro zenon_H40a. % 119.90/120.17 generalize (zenon_H40a (succ (loopcounter))). zenon_intro zenon_H42b. % 119.90/120.17 generalize (zenon_H42b zenon_TG_dq). zenon_intro zenon_H498. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H498); [ zenon_intro zenon_H405 | zenon_intro zenon_H499 ]. % 119.90/120.17 exact (zenon_H405 zenon_H40e). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H499); [ zenon_intro zenon_H46c | zenon_intro zenon_H495 ]. % 119.90/120.17 exact (zenon_H46c zenon_H469). % 119.90/120.17 exact (zenon_H497 zenon_H495). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 apply (zenon_L261_ zenon_TG_dq); trivial. % 119.90/120.17 exact (zenon_H493 zenon_H496). % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49d); [ zenon_intro zenon_H33d | zenon_intro zenon_H49f ]. % 119.90/120.17 apply (zenon_L213_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49f); [ zenon_intro zenon_H33f | zenon_intro zenon_H341 ]. % 119.90/120.17 apply (zenon_L224_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L239_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_Hc8); [ zenon_intro zenon_Hca | zenon_intro zenon_Hc9 ]. % 119.90/120.17 apply (zenon_L141_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_Hc9); [ zenon_intro zenon_Hcc | zenon_intro zenon_Hcb ]. % 119.90/120.17 generalize (finite_domain_3 (tptp_minus_1)). zenon_intro zenon_H44a. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H44a); [ zenon_intro zenon_H44c | zenon_intro zenon_H44b ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H44c); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H3b8 ]. % 119.90/120.17 apply (zenon_L198_); trivial. % 119.90/120.17 apply (zenon_L200_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H44b); [ zenon_intro zenon_H3c1 | zenon_intro zenon_H44d ]. % 119.90/120.17 generalize (finite_domain_2 zenon_TG_dq). zenon_intro zenon_H49c. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H49c); [ zenon_intro zenon_H49e | zenon_intro zenon_H49d ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H49e); [ zenon_intro zenon_H5d | zenon_intro zenon_H493 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L262_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49d); [ zenon_intro zenon_H33d | zenon_intro zenon_H49f ]. % 119.90/120.17 apply (zenon_L203_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49f); [ zenon_intro zenon_H33f | zenon_intro zenon_H341 ]. % 119.90/120.17 apply (zenon_L222_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L249_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H44d); [ zenon_intro zenon_H3db | zenon_intro zenon_H44e ]. % 119.90/120.17 apply (zenon_L263_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H44e); [ zenon_intro zenon_H3f9 | zenon_intro zenon_H42f ]. % 119.90/120.17 apply (zenon_L264_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (finite_domain_2 (tptp_minus_1)). zenon_intro zenon_H44f. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H44f); [ zenon_intro zenon_H451 | zenon_intro zenon_H450 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H451); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H43b ]. % 119.90/120.17 apply (zenon_L198_); trivial. % 119.90/120.17 apply (zenon_L217_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H450); [ zenon_intro zenon_H3c1 | zenon_intro zenon_H452 ]. % 119.90/120.17 generalize (finite_domain_2 zenon_TG_dq). zenon_intro zenon_H49c. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H49c); [ zenon_intro zenon_H49e | zenon_intro zenon_H49d ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H49e); [ zenon_intro zenon_H5d | zenon_intro zenon_H493 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L262_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49d); [ zenon_intro zenon_H33d | zenon_intro zenon_H49f ]. % 119.90/120.17 apply (zenon_L203_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49f); [ zenon_intro zenon_H33f | zenon_intro zenon_H341 ]. % 119.90/120.17 apply (zenon_L225_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L265_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H452); [ zenon_intro zenon_H3db | zenon_intro zenon_H3f9 ]. % 119.90/120.17 apply (zenon_L263_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L264_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (finite_domain_3 (tptp_minus_1)). zenon_intro zenon_H44a. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H44a); [ zenon_intro zenon_H44c | zenon_intro zenon_H44b ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H44c); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H3b8 ]. % 119.90/120.17 apply (zenon_L198_); trivial. % 119.90/120.17 apply (zenon_L200_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H44b); [ zenon_intro zenon_H3c1 | zenon_intro zenon_H44d ]. % 119.90/120.17 generalize (finite_domain_2 zenon_TG_dq). zenon_intro zenon_H49c. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H49c); [ zenon_intro zenon_H49e | zenon_intro zenon_H49d ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H49e); [ zenon_intro zenon_H5d | zenon_intro zenon_H493 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L267_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49d); [ zenon_intro zenon_H33d | zenon_intro zenon_H49f ]. % 119.90/120.17 apply (zenon_L203_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49f); [ zenon_intro zenon_H33f | zenon_intro zenon_H341 ]. % 119.90/120.17 apply (zenon_L222_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L269_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L203_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L222_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H44d); [ zenon_intro zenon_H3db | zenon_intro zenon_H44e ]. % 119.90/120.17 apply (zenon_L270_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H44e); [ zenon_intro zenon_H3f9 | zenon_intro zenon_H42f ]. % 119.90/120.17 generalize (finite_domain_2 (loopcounter)). zenon_intro zenon_H488. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H488); [ zenon_intro zenon_H48a | zenon_intro zenon_H489 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H48a); [ zenon_intro zenon_H68 | zenon_intro zenon_H478 ]. % 119.90/120.17 apply (zenon_L5_); trivial. % 119.90/120.17 apply (zenon_L245_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H489); [ zenon_intro zenon_H95 | zenon_intro zenon_H48b ]. % 119.90/120.17 apply (zenon_L272_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H48b); [ zenon_intro zenon_Hca | zenon_intro zenon_Hcc ]. % 119.90/120.17 apply (zenon_L141_); trivial. % 119.90/120.17 apply (zenon_L273_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (finite_domain_2 (loopcounter)). zenon_intro zenon_H488. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H488); [ zenon_intro zenon_H48a | zenon_intro zenon_H489 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H48a); [ zenon_intro zenon_H68 | zenon_intro zenon_H478 ]. % 119.90/120.17 apply (zenon_L5_); trivial. % 119.90/120.17 apply (zenon_L245_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H489); [ zenon_intro zenon_H95 | zenon_intro zenon_H48b ]. % 119.90/120.17 generalize (finite_domain_2 (tptp_minus_1)). zenon_intro zenon_H44f. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H44f); [ zenon_intro zenon_H451 | zenon_intro zenon_H450 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H451); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H43b ]. % 119.90/120.17 apply (zenon_L198_); trivial. % 119.90/120.17 apply (zenon_L217_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H450); [ zenon_intro zenon_H3c1 | zenon_intro zenon_H452 ]. % 119.90/120.17 generalize (finite_domain_2 zenon_TG_dq). zenon_intro zenon_H49c. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H49c); [ zenon_intro zenon_H49e | zenon_intro zenon_H49d ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H49e); [ zenon_intro zenon_H5d | zenon_intro zenon_H493 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L267_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49d); [ zenon_intro zenon_H33d | zenon_intro zenon_H49f ]. % 119.90/120.17 apply (zenon_L219_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49f); [ zenon_intro zenon_H33f | zenon_intro zenon_H341 ]. % 119.90/120.17 apply (zenon_L225_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (finite_domain_1 zenon_TG_dq). zenon_intro zenon_H473. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H473); [ zenon_intro zenon_H475 | zenon_intro zenon_H474 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H475); [ zenon_intro zenon_H5d | zenon_intro zenon_H460 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L269_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H474); [ zenon_intro zenon_H33d | zenon_intro zenon_H33f ]. % 119.90/120.17 apply (zenon_L219_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L225_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H452); [ zenon_intro zenon_H3db | zenon_intro zenon_H3f9 ]. % 119.90/120.17 apply (zenon_L270_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L272_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H48b); [ zenon_intro zenon_Hca | zenon_intro zenon_Hcc ]. % 119.90/120.17 apply (zenon_L141_); trivial. % 119.90/120.17 generalize (finite_domain_2 (tptp_minus_1)). zenon_intro zenon_H44f. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H44f); [ zenon_intro zenon_H451 | zenon_intro zenon_H450 ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H451); [ zenon_intro zenon_H3b2 | zenon_intro zenon_H43b ]. % 119.90/120.17 apply (zenon_L198_); trivial. % 119.90/120.17 apply (zenon_L217_); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H450); [ zenon_intro zenon_H3c1 | zenon_intro zenon_H452 ]. % 119.90/120.17 generalize (finite_domain_2 zenon_TG_dq). zenon_intro zenon_H49c. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H49c); [ zenon_intro zenon_H49e | zenon_intro zenon_H49d ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H49e); [ zenon_intro zenon_H5d | zenon_intro zenon_H493 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L267_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49d); [ zenon_intro zenon_H33d | zenon_intro zenon_H49f ]. % 119.90/120.17 apply (zenon_L219_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49f); [ zenon_intro zenon_H33f | zenon_intro zenon_H341 ]. % 119.90/120.17 apply (zenon_L225_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L265_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H452); [ zenon_intro zenon_H3db | zenon_intro zenon_H3f9 ]. % 119.90/120.17 generalize (finite_domain_2 zenon_TG_dq). zenon_intro zenon_H49c. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H49c); [ zenon_intro zenon_H49e | zenon_intro zenon_H49d ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H49e); [ zenon_intro zenon_H5d | zenon_intro zenon_H493 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L267_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49d); [ zenon_intro zenon_H33d | zenon_intro zenon_H49f ]. % 119.90/120.17 apply (zenon_L208_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_or_s _ _ zenon_H49f); [ zenon_intro zenon_H33f | zenon_intro zenon_H341 ]. % 119.90/120.17 apply (zenon_L223_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L250_ zenon_TG_dq); trivial. % 119.90/120.17 apply (zenon_L273_ zenon_TG_dq); trivial. % 119.90/120.17 (* end of lemma zenon_L274_ *) % 119.90/120.17 apply NNPP. intro zenon_G. % 119.90/120.17 elim (classic (forall x : zenon_U, (forall y : zenon_U, (forall z : zenon_U, ((gt x y)->((gt y z)->(gt x z))))))); [ zenon_intro zenon_H66 | zenon_intro zenon_H4a0 ]. % 119.90/120.17 apply (zenon_notimply_s _ _ zenon_G). zenon_intro zenon_H4a2. zenon_intro zenon_H4a1. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H4a2). zenon_intro zenon_H4a4. zenon_intro zenon_H4a3. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H4a3). zenon_intro zenon_H4a6. zenon_intro zenon_H4a5. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H4a5). zenon_intro zenon_H7d. zenon_intro zenon_H4a7. % 119.90/120.17 generalize (leq_succ_gt_equiv (n1)). zenon_intro zenon_H12c. % 119.90/120.17 generalize (zenon_H12c (loopcounter)). zenon_intro zenon_H4a8. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H4a8); [ zenon_intro zenon_H4a9; zenon_intro zenon_H6f | zenon_intro zenon_H4a6; zenon_intro zenon_H67 ]. % 119.90/120.17 exact (zenon_H4a9 zenon_H4a6). % 119.90/120.17 apply (zenon_notallex_s (fun G : zenon_U => (((leq (n0) G)/\(leq G (n4)))->((a_select2 (muold_init) G) = (init)))) zenon_H4a1); [ zenon_intro zenon_H4aa; idtac ]. % 119.90/120.17 elim zenon_H4aa. zenon_intro zenon_TG_dq. zenon_intro zenon_H4ab. % 119.90/120.17 apply (zenon_notimply_s _ _ zenon_H4ab). zenon_intro zenon_H4ad. zenon_intro zenon_H4ac. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H4ad). zenon_intro zenon_H61. zenon_intro zenon_H332. % 119.90/120.17 generalize (leq_succ_gt_equiv (n0)). zenon_intro zenon_H5f. % 119.90/120.17 generalize (zenon_H5f zenon_TG_dq). zenon_intro zenon_H60. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H60); [ zenon_intro zenon_H5d; zenon_intro zenon_H62 | zenon_intro zenon_H61; zenon_intro zenon_H5c ]. % 119.90/120.17 exact (zenon_H5d zenon_H61). % 119.90/120.17 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.17 generalize (zenon_H330 (n4)). zenon_intro zenon_H331. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H331); [ zenon_intro zenon_H32f; zenon_intro zenon_H333 | zenon_intro zenon_H332; zenon_intro zenon_H32e ]. % 119.90/120.17 exact (zenon_H32f zenon_H332). % 119.90/120.17 generalize (sum_plus_base zenon_E). zenon_intro zenon_H155. % 119.90/120.17 generalize (finite_domain_3 zenon_TG_dq). zenon_intro zenon_H4ae. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H4ae); [ zenon_intro zenon_H4b0 | zenon_intro zenon_H4af ]. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H4b0); [ zenon_intro zenon_H5d | zenon_intro zenon_H4b1 ]. % 119.90/120.17 apply (zenon_L1_ zenon_TG_dq); trivial. % 119.90/120.17 generalize (leq_succ_gt_equiv zenon_TG_dq). zenon_intro zenon_H330. % 119.90/120.17 generalize (zenon_H330 (n3)). zenon_intro zenon_H4b2. % 119.90/120.17 apply (zenon_equiv_s _ _ zenon_H4b2); [ zenon_intro zenon_H4b1; zenon_intro zenon_H39b | zenon_intro zenon_H4b3; zenon_intro zenon_H3b1 ]. % 119.90/120.17 elim (classic ((~((succ (n3)) = (succ (loopcounter))))/\(~(gt (succ (n3)) (succ (loopcounter)))))); [ zenon_intro zenon_H4b4 | zenon_intro zenon_H4b5 ]. % 119.90/120.17 apply (zenon_and_s _ _ zenon_H4b4). zenon_intro zenon_H4b6. zenon_intro zenon_H2a9. % 119.90/120.17 apply (zenon_L134_); trivial. % 119.90/120.17 elim (classic ((n1) = zenon_TG_dq)); [ zenon_intro zenon_H458 | zenon_intro zenon_H335 ]. % 119.90/120.17 cut ((gt (succ (loopcounter)) (n1)) = (gt (succ (n3)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H39b. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H67. % 119.90/120.17 cut (((n1) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H335]. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H4b7]. % 119.90/120.17 congruence. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H4b5); [ zenon_intro zenon_H4b9 | zenon_intro zenon_H4b8 ]. % 119.90/120.17 apply zenon_H4b9. zenon_intro zenon_H4ba. % 119.90/120.17 elim (classic ((succ (n3)) = (succ (n3)))); [ zenon_intro zenon_H9e | zenon_intro zenon_H9f ]. % 119.90/120.17 cut (((succ (n3)) = (succ (n3))) = ((succ (loopcounter)) = (succ (n3)))). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H4b7. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H9e. % 119.90/120.17 cut (((succ (n3)) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H9f]. % 119.90/120.17 cut (((succ (n3)) = (succ (loopcounter)))); [idtac | apply NNPP; zenon_intro zenon_H4b6]. % 119.90/120.17 congruence. % 119.90/120.17 exact (zenon_H4b6 zenon_H4ba). % 119.90/120.17 apply zenon_H9f. apply refl_equal. % 119.90/120.17 apply zenon_H9f. apply refl_equal. % 119.90/120.17 apply zenon_H4b8. zenon_intro zenon_H2b0. % 119.90/120.17 generalize (zenon_H66 (succ (n3))). zenon_intro zenon_Hb5. % 119.90/120.17 generalize (zenon_Hb5 (succ (loopcounter))). zenon_intro zenon_H4bb. % 119.90/120.17 generalize (zenon_H4bb (n1)). zenon_intro zenon_H4bc. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H4bc); [ zenon_intro zenon_H2a9 | zenon_intro zenon_H4bd ]. % 119.90/120.17 exact (zenon_H2a9 zenon_H2b0). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H4bd); [ zenon_intro zenon_H6f | zenon_intro zenon_Hb9 ]. % 119.90/120.17 exact (zenon_H6f zenon_H67). % 119.90/120.17 cut ((gt (succ (n3)) (n1)) = (gt (succ (n3)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H39b. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_Hb9. % 119.90/120.17 cut (((n1) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H335]. % 119.90/120.17 cut (((succ (n3)) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H9f]. % 119.90/120.17 congruence. % 119.90/120.17 apply zenon_H9f. apply refl_equal. % 119.90/120.17 exact (zenon_H335 zenon_H458). % 119.90/120.17 exact (zenon_H335 zenon_H458). % 119.90/120.17 elim (classic (gt (n1) zenon_TG_dq)); [ zenon_intro zenon_H465 | zenon_intro zenon_H466 ]. % 119.90/120.17 generalize (zenon_H66 (succ (loopcounter))). zenon_intro zenon_H77. % 119.90/120.17 generalize (zenon_H77 (n1)). zenon_intro zenon_H78. % 119.90/120.17 generalize (zenon_H78 zenon_TG_dq). zenon_intro zenon_H467. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H467); [ zenon_intro zenon_H6f | zenon_intro zenon_H468 ]. % 119.90/120.17 exact (zenon_H6f zenon_H67). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H468); [ zenon_intro zenon_H466 | zenon_intro zenon_H469 ]. % 119.90/120.17 exact (zenon_H466 zenon_H465). % 119.90/120.17 cut ((gt (succ (loopcounter)) zenon_TG_dq) = (gt (succ (n3)) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H39b. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact zenon_H469. % 119.90/120.17 cut ((zenon_TG_dq = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H3d3]. % 119.90/120.17 cut (((succ (loopcounter)) = (succ (n3)))); [idtac | apply NNPP; zenon_intro zenon_H4b7]. % 119.90/120.17 congruence. % 119.90/120.17 apply (zenon_notand_s _ _ zenon_H4b5); [ zenon_intro zenon_H4b9 | zenon_intro zenon_H4b8 ]. % 119.90/120.17 apply zenon_H4b9. zenon_intro zenon_H4ba. % 119.90/120.17 apply zenon_H4b7. apply sym_equal. exact zenon_H4ba. % 119.90/120.17 apply zenon_H4b8. zenon_intro zenon_H2b0. % 119.90/120.17 generalize (zenon_H66 (succ (n3))). zenon_intro zenon_Hb5. % 119.90/120.17 generalize (zenon_Hb5 (succ (loopcounter))). zenon_intro zenon_H4bb. % 119.90/120.17 generalize (zenon_H4bb zenon_TG_dq). zenon_intro zenon_H4be. % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H4be); [ zenon_intro zenon_H2a9 | zenon_intro zenon_H4bf ]. % 119.90/120.17 exact (zenon_H2a9 zenon_H2b0). % 119.90/120.17 apply (zenon_imply_s _ _ zenon_H4bf); [ zenon_intro zenon_H46c | zenon_intro zenon_H3b1 ]. % 119.90/120.17 exact (zenon_H46c zenon_H469). % 119.90/120.17 exact (zenon_H39b zenon_H3b1). % 119.90/120.17 apply zenon_H3d3. apply refl_equal. % 119.90/120.17 elim (classic ((n0) = zenon_TG_dq)); [ zenon_intro zenon_H4c0 | zenon_intro zenon_H334 ]. % 119.90/120.17 cut ((gt (n1) (n0)) = (gt (n1) zenon_TG_dq)). % 119.90/120.17 intro zenon_D_pnotp. % 119.90/120.17 apply zenon_H466. % 119.90/120.17 rewrite <- zenon_D_pnotp. % 119.90/120.17 exact gt_1_0. % 119.90/120.17 cut (((n0) = zenon_TG_dq)); [idtac | apply NNPP; zenon_intro zenon_H334]. % 119.90/120.17 cut (((n1) = (n1))); [idtac | apply NNPP; zenon_intro zenon_H64]. % 119.90/120.17 congruence. % 119.90/120.17 apply zenon_H64. apply refl_equal. % 119.90/120.17 exact (zenon_H334 zenon_H4c0). % 119.90/120.18 elim (classic (gt (n0) zenon_TG_dq)); [ zenon_intro zenon_H3a1 | zenon_intro zenon_H39a ]. % 119.90/120.18 generalize (zenon_H66 (n1)). zenon_intro zenon_He4. % 119.90/120.18 generalize (zenon_He4 (n0)). zenon_intro zenon_H385. % 119.90/120.18 generalize (zenon_H385 zenon_TG_dq). zenon_intro zenon_H4c1. % 119.90/120.18 apply (zenon_imply_s _ _ zenon_H4c1); [ zenon_intro zenon_H7b | zenon_intro zenon_H4c2 ]. % 119.90/120.18 exact (zenon_H7b gt_1_0). % 119.90/120.18 apply (zenon_imply_s _ _ zenon_H4c2); [ zenon_intro zenon_H39a | zenon_intro zenon_H465 ]. % 119.90/120.18 exact (zenon_H39a zenon_H3a1). % 119.90/120.18 exact (zenon_H466 zenon_H465). % 119.90/120.18 apply (zenon_L197_ zenon_TG_dq); trivial. % 119.90/120.18 exact (zenon_H4b1 zenon_H4b3). % 119.90/120.18 apply (zenon_or_s _ _ zenon_H4af); [ zenon_intro zenon_H33d | zenon_intro zenon_H4c3 ]. % 119.90/120.18 apply (zenon_L220_ zenon_TG_dq); trivial. % 119.90/120.18 apply (zenon_or_s _ _ zenon_H4c3); [ zenon_intro zenon_H33f | zenon_intro zenon_H4c4 ]. % 119.90/120.18 apply (zenon_L226_ zenon_TG_dq); trivial. % 119.90/120.18 apply (zenon_or_s _ _ zenon_H4c4); [ zenon_intro zenon_H341 | zenon_intro zenon_H343 ]. % 119.90/120.18 apply (zenon_L258_ zenon_TG_dq); trivial. % 119.90/120.18 apply (zenon_L274_ zenon_TG_dq); trivial. % 119.90/120.18 apply zenon_H4a0. zenon_intro zenon_Tx_buz. apply NNPP. zenon_intro zenon_H4c6. % 119.90/120.18 apply zenon_H4c6. zenon_intro zenon_Ty_bvb. apply NNPP. zenon_intro zenon_H4c8. % 119.90/120.18 apply zenon_H4c8. zenon_intro zenon_Tz_bvd. apply NNPP. zenon_intro zenon_H4ca. % 119.90/120.18 apply (zenon_notimply_s _ _ zenon_H4ca). zenon_intro zenon_H4cc. zenon_intro zenon_H4cb. % 119.90/120.18 apply (zenon_notimply_s _ _ zenon_H4cb). zenon_intro zenon_H4ce. zenon_intro zenon_H4cd. % 119.90/120.18 generalize (transitivity_gt zenon_Tx_buz). zenon_intro zenon_H4cf. % 119.90/120.18 generalize (zenon_H4cf zenon_Ty_bvb). zenon_intro zenon_H4d0. % 119.90/120.18 generalize (zenon_H4d0 zenon_Tz_bvd). zenon_intro zenon_H4d1. % 119.90/120.18 apply (zenon_imply_s _ _ zenon_H4d1); [ zenon_intro zenon_H4d3 | zenon_intro zenon_H4d2 ]. % 119.90/120.18 apply (zenon_notand_s _ _ zenon_H4d3); [ zenon_intro zenon_H4d5 | zenon_intro zenon_H4d4 ]. % 119.90/120.18 exact (zenon_H4d5 zenon_H4cc). % 119.90/120.18 exact (zenon_H4d4 zenon_H4ce). % 119.90/120.18 exact (zenon_H4cd zenon_H4d2). % 119.90/120.18 Qed. % 119.90/120.18 % SZS output end Proof % 119.90/120.18 (* END-PROOF *) % 119.90/120.18 nodes searched: 7794005 % 119.90/120.18 max branch formulas: 14852 % 119.90/120.18 proof nodes created: 20373 % 119.90/120.18 formulas created: 2854394 % 119.90/120.18 %------------------------------------------------------------------------------