--- a/src/HOL/Import/Generate-HOLLight/GenHOLLight.thy Mon Sep 26 02:06:44 2005 +0200
+++ b/src/HOL/Import/Generate-HOLLight/GenHOLLight.thy Mon Sep 26 02:27:14 2005 +0200
@@ -5,10 +5,6 @@
theory GenHOLLight imports "../HOLLightCompat" "../HOL4Syntax" begin;
-ML {* reset ProofKernel.debug; *}
-ML {* reset Shuffler.debug; *}
-ML {* set show_types; set show_sorts; *}
-
;import_segment "hollight";
setup_dump "../HOLLight" "HOLLight";
--- a/src/HOL/Import/HOL/HOL4Base.thy Mon Sep 26 02:06:44 2005 +0200
+++ b/src/HOL/Import/HOL/HOL4Base.thy Mon Sep 26 02:27:14 2005 +0200
@@ -5,215 +5,259 @@
;setup_theory bool
constdefs
- ARB :: "'a"
- "ARB == SOME x. True"
-
-lemma ARB_DEF: "ARB = (SOME x. True)"
+ ARB :: "'a::type"
+ "ARB == SOME x::'a::type. True"
+
+lemma ARB_DEF: "ARB = (SOME x::'a::type. True)"
by (import bool ARB_DEF)
constdefs
- IN :: "'a => ('a => bool) => bool"
- "IN == %x f. f x"
-
-lemma IN_DEF: "IN = (%x f. f x)"
+ IN :: "'a::type => ('a::type => bool) => bool"
+ "IN == %(x::'a::type) f::'a::type => bool. f x"
+
+lemma IN_DEF: "IN = (%(x::'a::type) f::'a::type => bool. f x)"
by (import bool IN_DEF)
constdefs
- RES_FORALL :: "('a => bool) => ('a => bool) => bool"
- "RES_FORALL == %p m. ALL x. IN x p --> m x"
-
-lemma RES_FORALL_DEF: "RES_FORALL = (%p m. ALL x. IN x p --> m x)"
+ RES_FORALL :: "('a::type => bool) => ('a::type => bool) => bool"
+ "RES_FORALL ==
+%(p::'a::type => bool) m::'a::type => bool. ALL x::'a::type. IN x p --> m x"
+
+lemma RES_FORALL_DEF: "RES_FORALL =
+(%(p::'a::type => bool) m::'a::type => bool.
+ ALL x::'a::type. IN x p --> m x)"
by (import bool RES_FORALL_DEF)
constdefs
- RES_EXISTS :: "('a => bool) => ('a => bool) => bool"
- "RES_EXISTS == %p m. EX x. IN x p & m x"
-
-lemma RES_EXISTS_DEF: "RES_EXISTS = (%p m. EX x. IN x p & m x)"
+ RES_EXISTS :: "('a::type => bool) => ('a::type => bool) => bool"
+ "RES_EXISTS ==
+%(p::'a::type => bool) m::'a::type => bool. EX x::'a::type. IN x p & m x"
+
+lemma RES_EXISTS_DEF: "RES_EXISTS =
+(%(p::'a::type => bool) m::'a::type => bool. EX x::'a::type. IN x p & m x)"
by (import bool RES_EXISTS_DEF)
constdefs
- RES_EXISTS_UNIQUE :: "('a => bool) => ('a => bool) => bool"
+ RES_EXISTS_UNIQUE :: "('a::type => bool) => ('a::type => bool) => bool"
"RES_EXISTS_UNIQUE ==
-%p m. RES_EXISTS p m &
- RES_FORALL p (%x. RES_FORALL p (%y. m x & m y --> x = y))"
+%(p::'a::type => bool) m::'a::type => bool.
+ RES_EXISTS p m &
+ RES_FORALL p
+ (%x::'a::type. RES_FORALL p (%y::'a::type. m x & m y --> x = y))"
lemma RES_EXISTS_UNIQUE_DEF: "RES_EXISTS_UNIQUE =
-(%p m. RES_EXISTS p m &
- RES_FORALL p (%x. RES_FORALL p (%y. m x & m y --> x = y)))"
+(%(p::'a::type => bool) m::'a::type => bool.
+ RES_EXISTS p m &
+ RES_FORALL p
+ (%x::'a::type. RES_FORALL p (%y::'a::type. m x & m y --> x = y)))"
by (import bool RES_EXISTS_UNIQUE_DEF)
constdefs
- RES_SELECT :: "('a => bool) => ('a => bool) => 'a"
- "RES_SELECT == %p m. SOME x. IN x p & m x"
-
-lemma RES_SELECT_DEF: "RES_SELECT = (%p m. SOME x. IN x p & m x)"
+ RES_SELECT :: "('a::type => bool) => ('a::type => bool) => 'a::type"
+ "RES_SELECT ==
+%(p::'a::type => bool) m::'a::type => bool. SOME x::'a::type. IN x p & m x"
+
+lemma RES_SELECT_DEF: "RES_SELECT =
+(%(p::'a::type => bool) m::'a::type => bool. SOME x::'a::type. IN x p & m x)"
by (import bool RES_SELECT_DEF)
-lemma EXCLUDED_MIDDLE: "ALL t. t | ~ t"
+lemma EXCLUDED_MIDDLE: "ALL t::bool. t | ~ t"
by (import bool EXCLUDED_MIDDLE)
-lemma FORALL_THM: "All f = All f"
+lemma FORALL_THM: "All (f::'a::type => bool) = All f"
by (import bool FORALL_THM)
-lemma EXISTS_THM: "Ex f = Ex f"
+lemma EXISTS_THM: "Ex (f::'a::type => bool) = Ex f"
by (import bool EXISTS_THM)
-lemma F_IMP: "ALL t. ~ t --> t --> False"
+lemma F_IMP: "ALL t::bool. ~ t --> t --> False"
by (import bool F_IMP)
-lemma NOT_AND: "~ (t & ~ t)"
+lemma NOT_AND: "~ ((t::bool) & ~ t)"
by (import bool NOT_AND)
-lemma AND_CLAUSES: "ALL t.
+lemma AND_CLAUSES: "ALL t::bool.
(True & t) = t &
(t & True) = t & (False & t) = False & (t & False) = False & (t & t) = t"
by (import bool AND_CLAUSES)
-lemma OR_CLAUSES: "ALL t.
+lemma OR_CLAUSES: "ALL t::bool.
(True | t) = True &
(t | True) = True & (False | t) = t & (t | False) = t & (t | t) = t"
by (import bool OR_CLAUSES)
-lemma IMP_CLAUSES: "ALL t.
+lemma IMP_CLAUSES: "ALL t::bool.
(True --> t) = t &
(t --> True) = True &
(False --> t) = True & (t --> t) = True & (t --> False) = (~ t)"
by (import bool IMP_CLAUSES)
-lemma NOT_CLAUSES: "(ALL t. (~ ~ t) = t) & (~ True) = False & (~ False) = True"
+lemma NOT_CLAUSES: "(ALL t::bool. (~ ~ t) = t) & (~ True) = False & (~ False) = True"
by (import bool NOT_CLAUSES)
lemma BOOL_EQ_DISTINCT: "True ~= False & False ~= True"
by (import bool BOOL_EQ_DISTINCT)
-lemma EQ_CLAUSES: "ALL t.
+lemma EQ_CLAUSES: "ALL t::bool.
(True = t) = t &
(t = True) = t & (False = t) = (~ t) & (t = False) = (~ t)"
by (import bool EQ_CLAUSES)
-lemma COND_CLAUSES: "ALL t1 t2. (if True then t1 else t2) = t1 & (if False then t1 else t2) = t2"
+lemma COND_CLAUSES: "ALL (t1::'a::type) t2::'a::type.
+ (if True then t1 else t2) = t1 & (if False then t1 else t2) = t2"
by (import bool COND_CLAUSES)
-lemma SELECT_UNIQUE: "ALL P x. (ALL y. P y = (y = x)) --> Eps P = x"
+lemma SELECT_UNIQUE: "ALL (P::'a::type => bool) x::'a::type.
+ (ALL y::'a::type. P y = (y = x)) --> Eps P = x"
by (import bool SELECT_UNIQUE)
-lemma BOTH_EXISTS_AND_THM: "ALL (P::bool) Q::bool. (EX x::'a. P & Q) = ((EX x::'a. P) & (EX x::'a. Q))"
+lemma BOTH_EXISTS_AND_THM: "ALL (P::bool) Q::bool.
+ (EX x::'a::type. P & Q) = ((EX x::'a::type. P) & (EX x::'a::type. Q))"
by (import bool BOTH_EXISTS_AND_THM)
lemma BOTH_FORALL_OR_THM: "ALL (P::bool) Q::bool.
- (ALL x::'a. P | Q) = ((ALL x::'a. P) | (ALL x::'a. Q))"
+ (ALL x::'a::type. P | Q) = ((ALL x::'a::type. P) | (ALL x::'a::type. Q))"
by (import bool BOTH_FORALL_OR_THM)
lemma BOTH_FORALL_IMP_THM: "ALL (P::bool) Q::bool.
- (ALL x::'a. P --> Q) = ((EX x::'a. P) --> (ALL x::'a. Q))"
+ (ALL x::'a::type. P --> Q) =
+ ((EX x::'a::type. P) --> (ALL x::'a::type. Q))"
by (import bool BOTH_FORALL_IMP_THM)
lemma BOTH_EXISTS_IMP_THM: "ALL (P::bool) Q::bool.
- (EX x::'a. P --> Q) = ((ALL x::'a. P) --> (EX x::'a. Q))"
+ (EX x::'a::type. P --> Q) =
+ ((ALL x::'a::type. P) --> (EX x::'a::type. Q))"
by (import bool BOTH_EXISTS_IMP_THM)
-lemma OR_IMP_THM: "ALL A B. (A = (B | A)) = (B --> A)"
+lemma OR_IMP_THM: "ALL (A::bool) B::bool. (A = (B | A)) = (B --> A)"
by (import bool OR_IMP_THM)
-lemma DE_MORGAN_THM: "ALL A B. (~ (A & B)) = (~ A | ~ B) & (~ (A | B)) = (~ A & ~ B)"
+lemma DE_MORGAN_THM: "ALL (A::bool) B::bool. (~ (A & B)) = (~ A | ~ B) & (~ (A | B)) = (~ A & ~ B)"
by (import bool DE_MORGAN_THM)
-lemma IMP_F_EQ_F: "ALL t. (t --> False) = (t = False)"
+lemma IMP_F_EQ_F: "ALL t::bool. (t --> False) = (t = False)"
by (import bool IMP_F_EQ_F)
-lemma EQ_EXPAND: "ALL t1 t2. (t1 = t2) = (t1 & t2 | ~ t1 & ~ t2)"
+lemma EQ_EXPAND: "ALL (t1::bool) t2::bool. (t1 = t2) = (t1 & t2 | ~ t1 & ~ t2)"
by (import bool EQ_EXPAND)
-lemma COND_RATOR: "ALL b f g x. (if b then f else g) x = (if b then f x else g x)"
+lemma COND_RATOR: "ALL (b::bool) (f::'a::type => 'b::type) (g::'a::type => 'b::type)
+ x::'a::type. (if b then f else g) x = (if b then f x else g x)"
by (import bool COND_RATOR)
-lemma COND_ABS: "ALL b f g. (%x. if b then f x else g x) = (if b then f else g)"
+lemma COND_ABS: "ALL (b::bool) (f::'a::type => 'b::type) g::'a::type => 'b::type.
+ (%x::'a::type. if b then f x else g x) = (if b then f else g)"
by (import bool COND_ABS)
-lemma COND_EXPAND: "ALL b t1 t2. (if b then t1 else t2) = ((~ b | t1) & (b | t2))"
+lemma COND_EXPAND: "ALL (b::bool) (t1::bool) t2::bool.
+ (if b then t1 else t2) = ((~ b | t1) & (b | t2))"
by (import bool COND_EXPAND)
-lemma ONE_ONE_THM: "ALL f. inj f = (ALL x1 x2. f x1 = f x2 --> x1 = x2)"
+lemma ONE_ONE_THM: "ALL f::'a::type => 'b::type.
+ inj f = (ALL (x1::'a::type) x2::'a::type. f x1 = f x2 --> x1 = x2)"
by (import bool ONE_ONE_THM)
-lemma ABS_REP_THM: "(All::(('a => bool) => bool) => bool)
- (%P::'a => bool.
+lemma ABS_REP_THM: "(All::(('a::type => bool) => bool) => bool)
+ (%P::'a::type => bool.
(op -->::bool => bool => bool)
- ((Ex::(('b => 'a) => bool) => bool)
- ((TYPE_DEFINITION::('a => bool) => ('b => 'a) => bool) P))
- ((Ex::(('b => 'a) => bool) => bool)
- (%x::'b => 'a.
- (Ex::(('a => 'b) => bool) => bool)
- (%abs::'a => 'b.
+ ((Ex::(('b::type => 'a::type) => bool) => bool)
+ ((TYPE_DEFINITION::('a::type => bool)
+ => ('b::type => 'a::type) => bool)
+ P))
+ ((Ex::(('b::type => 'a::type) => bool) => bool)
+ (%x::'b::type => 'a::type.
+ (Ex::(('a::type => 'b::type) => bool) => bool)
+ (%abs::'a::type => 'b::type.
(op &::bool => bool => bool)
- ((All::('b => bool) => bool)
- (%a::'b. (op =::'b => 'b => bool) (abs (x a)) a))
- ((All::('a => bool) => bool)
- (%r::'a.
+ ((All::('b::type => bool) => bool)
+ (%a::'b::type.
+ (op =::'b::type => 'b::type => bool) (abs (x a)) a))
+ ((All::('a::type => bool) => bool)
+ (%r::'a::type.
(op =::bool => bool => bool) (P r)
- ((op =::'a => 'a => bool) (x (abs r)) r)))))))"
+ ((op =::'a::type => 'a::type => bool) (x (abs r))
+ r)))))))"
by (import bool ABS_REP_THM)
-lemma LET_RAND: "(P::'b => bool) (Let (M::'a) (N::'a => 'b)) = (let x::'a = M in P (N x))"
+lemma LET_RAND: "(P::'b::type => bool) (Let (M::'a::type) (N::'a::type => 'b::type)) =
+(let x::'a::type = M in P (N x))"
by (import bool LET_RAND)
-lemma LET_RATOR: "Let (M::'a) (N::'a => 'b => 'c) (b::'b) = (let x::'a = M in N x b)"
+lemma LET_RATOR: "Let (M::'a::type) (N::'a::type => 'b::type => 'c::type) (b::'b::type) =
+(let x::'a::type = M in N x b)"
by (import bool LET_RATOR)
-lemma SWAP_FORALL_THM: "ALL P. (ALL x. All (P x)) = (ALL y x. P x y)"
+lemma SWAP_FORALL_THM: "ALL P::'a::type => 'b::type => bool.
+ (ALL x::'a::type. All (P x)) = (ALL (y::'b::type) x::'a::type. P x y)"
by (import bool SWAP_FORALL_THM)
-lemma SWAP_EXISTS_THM: "ALL P. (EX x. Ex (P x)) = (EX y x. P x y)"
+lemma SWAP_EXISTS_THM: "ALL P::'a::type => 'b::type => bool.
+ (EX x::'a::type. Ex (P x)) = (EX (y::'b::type) x::'a::type. P x y)"
by (import bool SWAP_EXISTS_THM)
-lemma AND_CONG: "ALL P P' Q Q'. (Q --> P = P') & (P' --> Q = Q') --> (P & Q) = (P' & Q')"
+lemma AND_CONG: "ALL (P::bool) (P'::bool) (Q::bool) Q'::bool.
+ (Q --> P = P') & (P' --> Q = Q') --> (P & Q) = (P' & Q')"
by (import bool AND_CONG)
-lemma OR_CONG: "ALL P P' Q Q'. (~ Q --> P = P') & (~ P' --> Q = Q') --> (P | Q) = (P' | Q')"
+lemma OR_CONG: "ALL (P::bool) (P'::bool) (Q::bool) Q'::bool.
+ (~ Q --> P = P') & (~ P' --> Q = Q') --> (P | Q) = (P' | Q')"
by (import bool OR_CONG)
-lemma COND_CONG: "ALL P Q x x' y y'.
+lemma COND_CONG: "ALL (P::bool) (Q::bool) (x::'a::type) (x'::'a::type) (y::'a::type)
+ y'::'a::type.
P = Q & (Q --> x = x') & (~ Q --> y = y') -->
(if P then x else y) = (if Q then x' else y')"
by (import bool COND_CONG)
-lemma MONO_COND: "(x --> y) --> (z --> w) --> (if b then x else z) --> (if b then y else w)"
+lemma MONO_COND: "((x::bool) --> (y::bool)) -->
+((z::bool) --> (w::bool)) -->
+(if b::bool then x else z) --> (if b then y else w)"
by (import bool MONO_COND)
-lemma SKOLEM_THM: "ALL P. (ALL x. Ex (P x)) = (EX f. ALL x. P x (f x))"
+lemma SKOLEM_THM: "ALL P::'a::type => 'b::type => bool.
+ (ALL x::'a::type. Ex (P x)) =
+ (EX f::'a::type => 'b::type. ALL x::'a::type. P x (f x))"
by (import bool SKOLEM_THM)
-lemma bool_case_thm: "(ALL (e0::'a) e1::'a. (case True of True => e0 | False => e1) = e0) &
-(ALL (e0::'a) e1::'a. (case False of True => e0 | False => e1) = e1)"
+lemma bool_case_thm: "(ALL (e0::'a::type) e1::'a::type.
+ (case True of True => e0 | False => e1) = e0) &
+(ALL (e0::'a::type) e1::'a::type.
+ (case False of True => e0 | False => e1) = e1)"
by (import bool bool_case_thm)
-lemma bool_case_ID: "ALL x b. (case b of True => x | _ => x) = x"
+lemma bool_case_ID: "ALL (x::'a::type) b::bool. (case b of True => x | _ => x) = x"
by (import bool bool_case_ID)
-lemma boolAxiom: "ALL e0 e1. EX x. x True = e0 & x False = e1"
+lemma boolAxiom: "ALL (e0::'a::type) e1::'a::type.
+ EX x::bool => 'a::type. x True = e0 & x False = e1"
by (import bool boolAxiom)
-lemma UEXISTS_OR_THM: "ALL P Q. (EX! x. P x | Q x) --> Ex1 P | Ex1 Q"
+lemma UEXISTS_OR_THM: "ALL (P::'a::type => bool) Q::'a::type => bool.
+ (EX! x::'a::type. P x | Q x) --> Ex1 P | Ex1 Q"
by (import bool UEXISTS_OR_THM)
-lemma UEXISTS_SIMP: "(EX! x::'a. (t::bool)) = (t & (ALL x::'a. All (op = x)))"
+lemma UEXISTS_SIMP: "(EX! x::'a::type. (t::bool)) = (t & (ALL x::'a::type. All (op = x)))"
by (import bool UEXISTS_SIMP)
consts
- RES_ABSTRACT :: "('a => bool) => ('a => 'b) => 'a => 'b"
-
-specification (RES_ABSTRACT) RES_ABSTRACT_DEF: "(ALL (p::'a => bool) (m::'a => 'b) x::'a.
+ RES_ABSTRACT :: "('a::type => bool) => ('a::type => 'b::type) => 'a::type => 'b::type"
+
+specification (RES_ABSTRACT) RES_ABSTRACT_DEF: "(ALL (p::'a::type => bool) (m::'a::type => 'b::type) x::'a::type.
IN x p --> RES_ABSTRACT p m x = m x) &
-(ALL (p::'a => bool) (m1::'a => 'b) m2::'a => 'b.
- (ALL x::'a. IN x p --> m1 x = m2 x) -->
+(ALL (p::'a::type => bool) (m1::'a::type => 'b::type)
+ m2::'a::type => 'b::type.
+ (ALL x::'a::type. IN x p --> m1 x = m2 x) -->
RES_ABSTRACT p m1 = RES_ABSTRACT p m2)"
by (import bool RES_ABSTRACT_DEF)
-lemma BOOL_FUN_CASES_THM: "ALL f. f = (%b. True) | f = (%b. False) | f = (%b. b) | f = Not"
+lemma BOOL_FUN_CASES_THM: "ALL f::bool => bool.
+ f = (%b::bool. True) |
+ f = (%b::bool. False) | f = (%b::bool. b) | f = Not"
by (import bool BOOL_FUN_CASES_THM)
-lemma BOOL_FUN_INDUCT: "ALL P. P (%b. True) & P (%b. False) & P (%b. b) & P Not --> All P"
+lemma BOOL_FUN_INDUCT: "ALL P::(bool => bool) => bool.
+ P (%b::bool. True) & P (%b::bool. False) & P (%b::bool. b) & P Not -->
+ All P"
by (import bool BOOL_FUN_INDUCT)
;end_setup
@@ -221,67 +265,80 @@
;setup_theory combin
constdefs
- K :: "'a => 'b => 'a"
- "K == %x y. x"
-
-lemma K_DEF: "K = (%x y. x)"
+ K :: "'a::type => 'b::type => 'a::type"
+ "K == %(x::'a::type) y::'b::type. x"
+
+lemma K_DEF: "K = (%(x::'a::type) y::'b::type. x)"
by (import combin K_DEF)
constdefs
- S :: "('a => 'b => 'c) => ('a => 'b) => 'a => 'c"
- "S == %f g x. f x (g x)"
-
-lemma S_DEF: "S = (%f g x. f x (g x))"
+ S :: "('a::type => 'b::type => 'c::type)
+=> ('a::type => 'b::type) => 'a::type => 'c::type"
+ "S ==
+%(f::'a::type => 'b::type => 'c::type) (g::'a::type => 'b::type)
+ x::'a::type. f x (g x)"
+
+lemma S_DEF: "S =
+(%(f::'a::type => 'b::type => 'c::type) (g::'a::type => 'b::type)
+ x::'a::type. f x (g x))"
by (import combin S_DEF)
constdefs
- I :: "'a => 'a"
- "(op ==::('a => 'a) => ('a => 'a) => prop) (I::'a => 'a)
- ((S::('a => ('a => 'a) => 'a) => ('a => 'a => 'a) => 'a => 'a)
- (K::'a => ('a => 'a) => 'a) (K::'a => 'a => 'a))"
-
-lemma I_DEF: "(op =::('a => 'a) => ('a => 'a) => bool) (I::'a => 'a)
- ((S::('a => ('a => 'a) => 'a) => ('a => 'a => 'a) => 'a => 'a)
- (K::'a => ('a => 'a) => 'a) (K::'a => 'a => 'a))"
+ I :: "'a::type => 'a::type"
+ "(op ==::('a::type => 'a::type) => ('a::type => 'a::type) => prop)
+ (I::'a::type => 'a::type)
+ ((S::('a::type => ('a::type => 'a::type) => 'a::type)
+ => ('a::type => 'a::type => 'a::type) => 'a::type => 'a::type)
+ (K::'a::type => ('a::type => 'a::type) => 'a::type)
+ (K::'a::type => 'a::type => 'a::type))"
+
+lemma I_DEF: "(op =::('a::type => 'a::type) => ('a::type => 'a::type) => bool)
+ (I::'a::type => 'a::type)
+ ((S::('a::type => ('a::type => 'a::type) => 'a::type)
+ => ('a::type => 'a::type => 'a::type) => 'a::type => 'a::type)
+ (K::'a::type => ('a::type => 'a::type) => 'a::type)
+ (K::'a::type => 'a::type => 'a::type))"
by (import combin I_DEF)
constdefs
- C :: "('a => 'b => 'c) => 'b => 'a => 'c"
- "C == %f x y. f y x"
-
-lemma C_DEF: "C = (%f x y. f y x)"
+ C :: "('a::type => 'b::type => 'c::type) => 'b::type => 'a::type => 'c::type"
+ "C == %(f::'a::type => 'b::type => 'c::type) (x::'b::type) y::'a::type. f y x"
+
+lemma C_DEF: "C =
+(%(f::'a::type => 'b::type => 'c::type) (x::'b::type) y::'a::type. f y x)"
by (import combin C_DEF)
constdefs
- W :: "('a => 'a => 'b) => 'a => 'b"
- "W == %f x. f x x"
-
-lemma W_DEF: "W = (%f x. f x x)"
+ W :: "('a::type => 'a::type => 'b::type) => 'a::type => 'b::type"
+ "W == %(f::'a::type => 'a::type => 'b::type) x::'a::type. f x x"
+
+lemma W_DEF: "W = (%(f::'a::type => 'a::type => 'b::type) x::'a::type. f x x)"
by (import combin W_DEF)
-lemma I_THM: "ALL x. I x = x"
+lemma I_THM: "ALL x::'a::type. I x = x"
by (import combin I_THM)
-lemma I_o_ID: "ALL f. I o f = f & f o I = f"
+lemma I_o_ID: "ALL f::'a::type => 'b::type. I o f = f & f o I = f"
by (import combin I_o_ID)
;end_setup
;setup_theory sum
-lemma ISL_OR_ISR: "ALL x. ISL x | ISR x"
+lemma ISL_OR_ISR: "ALL x::'a::type + 'b::type. ISL x | ISR x"
by (import sum ISL_OR_ISR)
-lemma INL: "ALL x. ISL x --> Inl (OUTL x) = x"
+lemma INL: "ALL x::'a::type + 'b::type. ISL x --> Inl (OUTL x) = x"
by (import sum INL)
-lemma INR: "ALL x. ISR x --> Inr (OUTR x) = x"
+lemma INR: "ALL x::'a::type + 'b::type. ISR x --> Inr (OUTR x) = x"
by (import sum INR)
-lemma sum_case_cong: "ALL (M::'b + 'c) (M'::'b + 'c) (f::'b => 'a) g::'c => 'a.
+lemma sum_case_cong: "ALL (M::'b::type + 'c::type) (M'::'b::type + 'c::type)
+ (f::'b::type => 'a::type) g::'c::type => 'a::type.
M = M' &
- (ALL x::'b. M' = Inl x --> f x = (f'::'b => 'a) x) &
- (ALL y::'c. M' = Inr y --> g y = (g'::'c => 'a) y) -->
+ (ALL x::'b::type. M' = Inl x --> f x = (f'::'b::type => 'a::type) x) &
+ (ALL y::'c::type. M' = Inr y --> g y = (g'::'c::type => 'a::type) y) -->
sum_case f g M = sum_case f' g' M'"
by (import sum sum_case_cong)
@@ -294,167 +351,194 @@
;setup_theory option
lemma option_CLAUSES: "(op &::bool => bool => bool)
- ((All::('a => bool) => bool)
- (%x::'a.
- (All::('a => bool) => bool)
- (%y::'a.
+ ((All::('a::type => bool) => bool)
+ (%x::'a::type.
+ (All::('a::type => bool) => bool)
+ (%y::'a::type.
(op =::bool => bool => bool)
- ((op =::'a option => 'a option => bool) ((Some::'a ~=> 'a) x)
- ((Some::'a ~=> 'a) y))
- ((op =::'a => 'a => bool) x y))))
+ ((op =::'a::type option => 'a::type option => bool)
+ ((Some::'a::type ~=> 'a::type) x)
+ ((Some::'a::type ~=> 'a::type) y))
+ ((op =::'a::type => 'a::type => bool) x y))))
((op &::bool => bool => bool)
- ((All::('a => bool) => bool)
- (%x::'a.
- (op =::'a => 'a => bool)
- ((the::'a option => 'a) ((Some::'a ~=> 'a) x)) x))
+ ((All::('a::type => bool) => bool)
+ (%x::'a::type.
+ (op =::'a::type => 'a::type => bool)
+ ((the::'a::type option => 'a::type)
+ ((Some::'a::type ~=> 'a::type) x))
+ x))
((op &::bool => bool => bool)
- ((All::('a => bool) => bool)
- (%x::'a.
+ ((All::('a::type => bool) => bool)
+ (%x::'a::type.
(Not::bool => bool)
- ((op =::'a option => 'a option => bool) (None::'a option)
- ((Some::'a ~=> 'a) x))))
+ ((op =::'a::type option => 'a::type option => bool)
+ (None::'a::type option) ((Some::'a::type ~=> 'a::type) x))))
((op &::bool => bool => bool)
- ((All::('a => bool) => bool)
- (%x::'a.
+ ((All::('a::type => bool) => bool)
+ (%x::'a::type.
(Not::bool => bool)
- ((op =::'a option => 'a option => bool) ((Some::'a ~=> 'a) x)
- (None::'a option))))
+ ((op =::'a::type option => 'a::type option => bool)
+ ((Some::'a::type ~=> 'a::type) x) (None::'a::type option))))
((op &::bool => bool => bool)
- ((All::('a => bool) => bool)
- (%x::'a.
+ ((All::('a::type => bool) => bool)
+ (%x::'a::type.
(op =::bool => bool => bool)
- ((IS_SOME::'a option => bool) ((Some::'a ~=> 'a) x))
+ ((IS_SOME::'a::type option => bool)
+ ((Some::'a::type ~=> 'a::type) x))
(True::bool)))
((op &::bool => bool => bool)
((op =::bool => bool => bool)
- ((IS_SOME::'a option => bool) (None::'a option)) (False::bool))
+ ((IS_SOME::'a::type option => bool) (None::'a::type option))
+ (False::bool))
((op &::bool => bool => bool)
- ((All::('a option => bool) => bool)
- (%x::'a option.
+ ((All::('a::type option => bool) => bool)
+ (%x::'a::type option.
(op =::bool => bool => bool)
- ((IS_NONE::'a option => bool) x)
- ((op =::'a option => 'a option => bool) x
- (None::'a option))))
+ ((IS_NONE::'a::type option => bool) x)
+ ((op =::'a::type option => 'a::type option => bool) x
+ (None::'a::type option))))
((op &::bool => bool => bool)
- ((All::('a option => bool) => bool)
- (%x::'a option.
+ ((All::('a::type option => bool) => bool)
+ (%x::'a::type option.
(op =::bool => bool => bool)
- ((Not::bool => bool) ((IS_SOME::'a option => bool) x))
- ((op =::'a option => 'a option => bool) x
- (None::'a option))))
+ ((Not::bool => bool)
+ ((IS_SOME::'a::type option => bool) x))
+ ((op =::'a::type option => 'a::type option => bool) x
+ (None::'a::type option))))
((op &::bool => bool => bool)
- ((All::('a option => bool) => bool)
- (%x::'a option.
+ ((All::('a::type option => bool) => bool)
+ (%x::'a::type option.
(op -->::bool => bool => bool)
- ((IS_SOME::'a option => bool) x)
- ((op =::'a option => 'a option => bool)
- ((Some::'a ~=> 'a) ((the::'a option => 'a) x))
+ ((IS_SOME::'a::type option => bool) x)
+ ((op =::'a::type option => 'a::type option => bool)
+ ((Some::'a::type ~=> 'a::type)
+ ((the::'a::type option => 'a::type) x))
x)))
((op &::bool => bool => bool)
- ((All::('a option => bool) => bool)
- (%x::'a option.
- (op =::'a option => 'a option => bool)
- ((option_case::'a option
- => ('a ~=> 'a) => 'a option ~=> 'a)
- (None::'a option) (Some::'a ~=> 'a) x)
+ ((All::('a::type option => bool) => bool)
+ (%x::'a::type option.
+ (op =::'a::type option => 'a::type option => bool)
+ ((option_case::'a::type option
+ => ('a::type ~=> 'a::type) => 'a::type option ~=> 'a::type)
+ (None::'a::type option)
+ (Some::'a::type ~=> 'a::type) x)
x))
((op &::bool => bool => bool)
- ((All::('a option => bool) => bool)
- (%x::'a option.
- (op =::'a option => 'a option => bool)
- ((option_case::'a option
- => ('a ~=> 'a) => 'a option ~=> 'a)
- x (Some::'a ~=> 'a) x)
+ ((All::('a::type option => bool) => bool)
+ (%x::'a::type option.
+ (op =::'a::type option
+ => 'a::type option => bool)
+ ((option_case::'a::type option
+ => ('a::type ~=> 'a::type) => 'a::type option ~=> 'a::type)
+ x (Some::'a::type ~=> 'a::type) x)
x))
((op &::bool => bool => bool)
- ((All::('a option => bool) => bool)
- (%x::'a option.
+ ((All::('a::type option => bool) => bool)
+ (%x::'a::type option.
(op -->::bool => bool => bool)
- ((IS_NONE::'a option => bool) x)
- ((op =::'b => 'b => bool)
- ((option_case::'b
- => ('a => 'b) => 'a option => 'b)
- (e::'b) (f::'a => 'b) x)
+ ((IS_NONE::'a::type option => bool) x)
+ ((op =::'b::type => 'b::type => bool)
+ ((option_case::'b::type
+ => ('a::type => 'b::type) => 'a::type option => 'b::type)
+ (e::'b::type) (f::'a::type => 'b::type) x)
e)))
((op &::bool => bool => bool)
- ((All::('a option => bool) => bool)
- (%x::'a option.
+ ((All::('a::type option => bool) => bool)
+ (%x::'a::type option.
(op -->::bool => bool => bool)
- ((IS_SOME::'a option => bool) x)
- ((op =::'b => 'b => bool)
- ((option_case::'b
- => ('a => 'b) => 'a option => 'b)
+ ((IS_SOME::'a::type option => bool) x)
+ ((op =::'b::type => 'b::type => bool)
+ ((option_case::'b::type
+ => ('a::type => 'b::type) => 'a::type option => 'b::type)
e f x)
- (f ((the::'a option => 'a) x)))))
+ (f ((the::'a::type option => 'a::type)
+ x)))))
((op &::bool => bool => bool)
- ((All::('a option => bool) => bool)
- (%x::'a option.
+ ((All::('a::type option => bool) => bool)
+ (%x::'a::type option.
(op -->::bool => bool => bool)
- ((IS_SOME::'a option => bool) x)
- ((op =::'a option => 'a option => bool)
- ((option_case::'a option
- => ('a ~=> 'a) => 'a option ~=> 'a)
-(ea::'a option) (Some::'a ~=> 'a) x)
+ ((IS_SOME::'a::type option => bool) x)
+ ((op =::'a::type option
+ => 'a::type option => bool)
+ ((option_case::'a::type option
+ => ('a::type ~=> 'a::type) => 'a::type option ~=> 'a::type)
+(ea::'a::type option) (Some::'a::type ~=> 'a::type) x)
x)))
((op &::bool => bool => bool)
- ((All::('b => bool) => bool)
- (%u::'b.
- (All::(('a => 'b) => bool) => bool)
- (%f::'a => 'b.
- (op =::'b => 'b => bool)
- ((option_case::'b => ('a => 'b) => 'a option => 'b) u f
- (None::'a option))
+ ((All::('b::type => bool) => bool)
+ (%u::'b::type.
+ (All::(('a::type => 'b::type) => bool)
+ => bool)
+ (%f::'a::type => 'b::type.
+ (op =::'b::type => 'b::type => bool)
+ ((option_case::'b::type
+ => ('a::type => 'b::type) => 'a::type option => 'b::type)
+ u f (None::'a::type option))
u)))
((op &::bool => bool => bool)
- ((All::('b => bool) => bool)
- (%u::'b.
- (All::(('a => 'b) => bool) => bool)
-(%f::'a => 'b.
- (All::('a => bool) => bool)
- (%x::'a.
- (op =::'b => 'b => bool)
- ((option_case::'b => ('a => 'b) => 'a option => 'b) u f
- ((Some::'a ~=> 'a) x))
+ ((All::('b::type => bool) => bool)
+ (%u::'b::type.
+ (All::(('a::type => 'b::type) => bool)
+ => bool)
+(%f::'a::type => 'b::type.
+ (All::('a::type => bool) => bool)
+ (%x::'a::type.
+ (op =::'b::type => 'b::type => bool)
+ ((option_case::'b::type
+ => ('a::type => 'b::type)
+ => 'a::type option => 'b::type)
+ u f ((Some::'a::type ~=> 'a::type) x))
(f x)))))
((op &::bool => bool => bool)
- ((All::(('a => 'b) => bool) => bool)
- (%f::'a => 'b.
- (All::('a => bool) => bool)
- (%x::'a.
- (op =::'b option => 'b option => bool)
- ((option_map::('a => 'b) => 'a option ~=> 'b) f
- ((Some::'a ~=> 'a) x))
- ((Some::'b ~=> 'b) (f x)))))
+ ((All::(('a::type => 'b::type) => bool)
+ => bool)
+ (%f::'a::type => 'b::type.
+ (All::('a::type => bool) => bool)
+ (%x::'a::type.
+ (op =::'b::type option => 'b::type option => bool)
+ ((option_map::('a::type => 'b::type) => 'a::type option ~=> 'b::type)
+ f ((Some::'a::type ~=> 'a::type) x))
+ ((Some::'b::type ~=> 'b::type) (f x)))))
((op &::bool => bool => bool)
- ((All::(('a => 'b) => bool) => bool)
- (%f::'a => 'b.
- (op =::'b option => 'b option => bool)
- ((option_map::('a => 'b) => 'a option ~=> 'b) f (None::'a option))
- (None::'b option)))
+ ((All::(('a::type => 'b::type) => bool)
+ => bool)
+ (%f::'a::type => 'b::type.
+ (op =::'b::type option => 'b::type option => bool)
+ ((option_map::('a::type => 'b::type) => 'a::type option ~=> 'b::type) f
+ (None::'a::type option))
+ (None::'b::type option)))
((op &::bool => bool => bool)
- ((op =::'a option => 'a option => bool)
- ((OPTION_JOIN::'a option option ~=> 'a) (None::'a option option))
- (None::'a option))
- ((All::('a option => bool) => bool)
- (%x::'a option.
- (op =::'a option => 'a option => bool)
- ((OPTION_JOIN::'a option option ~=> 'a)
- ((Some::'a option ~=> 'a option) x))
+ ((op =::'a::type option
+ => 'a::type option => bool)
+ ((OPTION_JOIN::'a::type option option ~=> 'a::type)
+ (None::'a::type option option))
+ (None::'a::type option))
+ ((All::('a::type option => bool)
+ => bool)
+ (%x::'a::type option.
+ (op =::'a::type option => 'a::type option => bool)
+ ((OPTION_JOIN::'a::type option option ~=> 'a::type)
+ ((Some::'a::type option ~=> 'a::type option) x))
x))))))))))))))))))))"
by (import option option_CLAUSES)
-lemma option_case_compute: "option_case (e::'b) (f::'a => 'b) (x::'a option) =
+lemma option_case_compute: "option_case (e::'b::type) (f::'a::type => 'b::type) (x::'a::type option) =
(if IS_SOME x then f (the x) else e)"
by (import option option_case_compute)
-lemma OPTION_MAP_EQ_SOME: "ALL f x y. (option_map f x = Some y) = (EX z. x = Some z & y = f z)"
+lemma OPTION_MAP_EQ_SOME: "ALL (f::'a::type => 'b::type) (x::'a::type option) y::'b::type.
+ (option_map f x = Some y) = (EX z::'a::type. x = Some z & y = f z)"
by (import option OPTION_MAP_EQ_SOME)
-lemma OPTION_JOIN_EQ_SOME: "ALL x xa. (OPTION_JOIN x = Some xa) = (x = Some (Some xa))"
+lemma OPTION_JOIN_EQ_SOME: "ALL (x::'a::type option option) xa::'a::type.
+ (OPTION_JOIN x = Some xa) = (x = Some (Some xa))"
by (import option OPTION_JOIN_EQ_SOME)
-lemma option_case_cong: "ALL M M' u f.
- M = M' & (M' = None --> u = u') & (ALL x. M' = Some x --> f x = f' x) -->
+lemma option_case_cong: "ALL (M::'a::type option) (M'::'a::type option) (u::'b::type)
+ f::'a::type => 'b::type.
+ M = M' &
+ (M' = None --> u = (u'::'b::type)) &
+ (ALL x::'a::type. M' = Some x --> f x = (f'::'a::type => 'b::type) x) -->
option_case u f M = option_case u' f' M'"
by (import option option_case_cong)
@@ -463,33 +547,33 @@
;setup_theory marker
consts
- stmarker :: "'a => 'a"
+ stmarker :: "'a::type => 'a::type"
defs
- stmarker_primdef: "stmarker == %x. x"
-
-lemma stmarker_def: "ALL x. stmarker x = x"
+ stmarker_primdef: "stmarker == %x::'a::type. x"
+
+lemma stmarker_def: "ALL x::'a::type. stmarker x = x"
by (import marker stmarker_def)
-lemma move_left_conj: "ALL x xa xb.
+lemma move_left_conj: "ALL (x::bool) (xa::bool) xb::bool.
(x & stmarker xb) = (stmarker xb & x) &
((stmarker xb & x) & xa) = (stmarker xb & x & xa) &
(x & stmarker xb & xa) = (stmarker xb & x & xa)"
by (import marker move_left_conj)
-lemma move_right_conj: "ALL x xa xb.
+lemma move_right_conj: "ALL (x::bool) (xa::bool) xb::bool.
(stmarker xb & x) = (x & stmarker xb) &
(x & xa & stmarker xb) = ((x & xa) & stmarker xb) &
((x & stmarker xb) & xa) = ((x & xa) & stmarker xb)"
by (import marker move_right_conj)
-lemma move_left_disj: "ALL x xa xb.
+lemma move_left_disj: "ALL (x::bool) (xa::bool) xb::bool.
(x | stmarker xb) = (stmarker xb | x) &
((stmarker xb | x) | xa) = (stmarker xb | x | xa) &
(x | stmarker xb | xa) = (stmarker xb | x | xa)"
by (import marker move_left_disj)
-lemma move_right_disj: "ALL x xa xb.
+lemma move_right_disj: "ALL (x::bool) (xa::bool) xb::bool.
(stmarker xb | x) = (x | stmarker xb) &
(x | xa | stmarker xb) = ((x | xa) | stmarker xb) &
((x | stmarker xb) | xa) = ((x | xa) | stmarker xb)"
@@ -500,356 +584,516 @@
;setup_theory relation
constdefs
- TC :: "('a => 'a => bool) => 'a => 'a => bool"
+ TC :: "('a::type => 'a::type => bool) => 'a::type => 'a::type => bool"
"TC ==
-%R a b.
- ALL P.
- (ALL x y. R x y --> P x y) & (ALL x y z. P x y & P y z --> P x z) -->
+%(R::'a::type => 'a::type => bool) (a::'a::type) b::'a::type.
+ ALL P::'a::type => 'a::type => bool.
+ (ALL (x::'a::type) y::'a::type. R x y --> P x y) &
+ (ALL (x::'a::type) (y::'a::type) z::'a::type.
+ P x y & P y z --> P x z) -->
P a b"
-lemma TC_DEF: "ALL R a b.
+lemma TC_DEF: "ALL (R::'a::type => 'a::type => bool) (a::'a::type) b::'a::type.
TC R a b =
- (ALL P.
- (ALL x y. R x y --> P x y) & (ALL x y z. P x y & P y z --> P x z) -->
+ (ALL P::'a::type => 'a::type => bool.
+ (ALL (x::'a::type) y::'a::type. R x y --> P x y) &
+ (ALL (x::'a::type) (y::'a::type) z::'a::type.
+ P x y & P y z --> P x z) -->
P a b)"
by (import relation TC_DEF)
constdefs
- RTC :: "('a => 'a => bool) => 'a => 'a => bool"
+ RTC :: "('a::type => 'a::type => bool) => 'a::type => 'a::type => bool"
"RTC ==
-%R a b.
- ALL P. (ALL x. P x x) & (ALL x y z. R x y & P y z --> P x z) --> P a b"
-
-lemma RTC_DEF: "ALL R a b.
+%(R::'a::type => 'a::type => bool) (a::'a::type) b::'a::type.
+ ALL P::'a::type => 'a::type => bool.
+ (ALL x::'a::type. P x x) &
+ (ALL (x::'a::type) (y::'a::type) z::'a::type.
+ R x y & P y z --> P x z) -->
+ P a b"
+
+lemma RTC_DEF: "ALL (R::'a::type => 'a::type => bool) (a::'a::type) b::'a::type.
RTC R a b =
- (ALL P. (ALL x. P x x) & (ALL x y z. R x y & P y z --> P x z) --> P a b)"
+ (ALL P::'a::type => 'a::type => bool.
+ (ALL x::'a::type. P x x) &
+ (ALL (x::'a::type) (y::'a::type) z::'a::type.
+ R x y & P y z --> P x z) -->
+ P a b)"
by (import relation RTC_DEF)
consts
- RC :: "('a => 'a => bool) => 'a => 'a => bool"
+ RC :: "('a::type => 'a::type => bool) => 'a::type => 'a::type => bool"
defs
- RC_primdef: "RC == %R x y. x = y | R x y"
-
-lemma RC_def: "ALL R x y. RC R x y = (x = y | R x y)"
+ RC_primdef: "RC ==
+%(R::'a::type => 'a::type => bool) (x::'a::type) y::'a::type. x = y | R x y"
+
+lemma RC_def: "ALL (R::'a::type => 'a::type => bool) (x::'a::type) y::'a::type.
+ RC R x y = (x = y | R x y)"
by (import relation RC_def)
consts
- transitive :: "('a => 'a => bool) => bool"
+ transitive :: "('a::type => 'a::type => bool) => bool"
defs
- transitive_primdef: "transitive == %R. ALL x y z. R x y & R y z --> R x z"
-
-lemma transitive_def: "ALL R. transitive R = (ALL x y z. R x y & R y z --> R x z)"
+ transitive_primdef: "transitive ==
+%R::'a::type => 'a::type => bool.
+ ALL (x::'a::type) (y::'a::type) z::'a::type. R x y & R y z --> R x z"
+
+lemma transitive_def: "ALL R::'a::type => 'a::type => bool.
+ transitive R =
+ (ALL (x::'a::type) (y::'a::type) z::'a::type. R x y & R y z --> R x z)"
by (import relation transitive_def)
constdefs
- pred_reflexive :: "('a => 'a => bool) => bool"
- "pred_reflexive == %R. ALL x. R x x"
-
-lemma reflexive_def: "ALL R. pred_reflexive R = (ALL x. R x x)"
+ pred_reflexive :: "('a::type => 'a::type => bool) => bool"
+ "pred_reflexive == %R::'a::type => 'a::type => bool. ALL x::'a::type. R x x"
+
+lemma reflexive_def: "ALL R::'a::type => 'a::type => bool.
+ pred_reflexive R = (ALL x::'a::type. R x x)"
by (import relation reflexive_def)
-lemma TC_TRANSITIVE: "ALL x. transitive (TC x)"
+lemma TC_TRANSITIVE: "ALL x::'a::type => 'a::type => bool. transitive (TC x)"
by (import relation TC_TRANSITIVE)
-lemma RTC_INDUCT: "ALL x xa.
- (ALL x. xa x x) & (ALL xb y z. x xb y & xa y z --> xa xb z) -->
- (ALL xb xc. RTC x xb xc --> xa xb xc)"
+lemma RTC_INDUCT: "ALL (x::'a::type => 'a::type => bool) xa::'a::type => 'a::type => bool.
+ (ALL x::'a::type. xa x x) &
+ (ALL (xb::'a::type) (y::'a::type) z::'a::type.
+ x xb y & xa y z --> xa xb z) -->
+ (ALL (xb::'a::type) xc::'a::type. RTC x xb xc --> xa xb xc)"
by (import relation RTC_INDUCT)
-lemma TC_RULES: "ALL x.
- (ALL xa xb. x xa xb --> TC x xa xb) &
- (ALL xa xb xc. TC x xa xb & TC x xb xc --> TC x xa xc)"
+lemma TC_RULES: "ALL x::'a::type => 'a::type => bool.
+ (ALL (xa::'a::type) xb::'a::type. x xa xb --> TC x xa xb) &
+ (ALL (xa::'a::type) (xb::'a::type) xc::'a::type.
+ TC x xa xb & TC x xb xc --> TC x xa xc)"
by (import relation TC_RULES)
-lemma RTC_RULES: "ALL x.
- (ALL xa. RTC x xa xa) &
- (ALL xa xb xc. x xa xb & RTC x xb xc --> RTC x xa xc)"
+lemma RTC_RULES: "ALL x::'a::type => 'a::type => bool.
+ (ALL xa::'a::type. RTC x xa xa) &
+ (ALL (xa::'a::type) (xb::'a::type) xc::'a::type.
+ x xa xb & RTC x xb xc --> RTC x xa xc)"
by (import relation RTC_RULES)
-lemma RTC_STRONG_INDUCT: "ALL R P.
- (ALL x. P x x) & (ALL x y z. R x y & RTC R y z & P y z --> P x z) -->
- (ALL x y. RTC R x y --> P x y)"
+lemma RTC_STRONG_INDUCT: "ALL (R::'a::type => 'a::type => bool) P::'a::type => 'a::type => bool.
+ (ALL x::'a::type. P x x) &
+ (ALL (x::'a::type) (y::'a::type) z::'a::type.
+ R x y & RTC R y z & P y z --> P x z) -->
+ (ALL (x::'a::type) y::'a::type. RTC R x y --> P x y)"
by (import relation RTC_STRONG_INDUCT)
-lemma RTC_RTC: "ALL R x y. RTC R x y --> (ALL z. RTC R y z --> RTC R x z)"
+lemma RTC_RTC: "ALL (R::'a::type => 'a::type => bool) (x::'a::type) y::'a::type.
+ RTC R x y --> (ALL z::'a::type. RTC R y z --> RTC R x z)"
by (import relation RTC_RTC)
-lemma RTC_TRANSITIVE: "ALL x. transitive (RTC x)"
+lemma RTC_TRANSITIVE: "ALL x::'a::type => 'a::type => bool. transitive (RTC x)"
by (import relation RTC_TRANSITIVE)
-lemma RTC_REFLEXIVE: "ALL R. pred_reflexive (RTC R)"
+lemma RTC_REFLEXIVE: "ALL R::'a::type => 'a::type => bool. pred_reflexive (RTC R)"
by (import relation RTC_REFLEXIVE)
-lemma RC_REFLEXIVE: "ALL R. pred_reflexive (RC R)"
+lemma RC_REFLEXIVE: "ALL R::'a::type => 'a::type => bool. pred_reflexive (RC R)"
by (import relation RC_REFLEXIVE)
-lemma TC_SUBSET: "ALL x xa xb. x xa xb --> TC x xa xb"
+lemma TC_SUBSET: "ALL (x::'a::type => 'a::type => bool) (xa::'a::type) xb::'a::type.
+ x xa xb --> TC x xa xb"
by (import relation TC_SUBSET)
-lemma RTC_SUBSET: "ALL R x y. R x y --> RTC R x y"
+lemma RTC_SUBSET: "ALL (R::'a::type => 'a::type => bool) (x::'a::type) y::'a::type.
+ R x y --> RTC R x y"
by (import relation RTC_SUBSET)
-lemma RC_SUBSET: "ALL R x y. R x y --> RC R x y"
+lemma RC_SUBSET: "ALL (R::'a::type => 'a::type => bool) (x::'a::type) y::'a::type.
+ R x y --> RC R x y"
by (import relation RC_SUBSET)
-lemma RC_RTC: "ALL R x y. RC R x y --> RTC R x y"
+lemma RC_RTC: "ALL (R::'a::type => 'a::type => bool) (x::'a::type) y::'a::type.
+ RC R x y --> RTC R x y"
by (import relation RC_RTC)
-lemma TC_INDUCT: "ALL x xa.
- (ALL xb y. x xb y --> xa xb y) &
- (ALL x y z. xa x y & xa y z --> xa x z) -->
- (ALL xb xc. TC x xb xc --> xa xb xc)"
+lemma TC_INDUCT: "ALL (x::'a::type => 'a::type => bool) xa::'a::type => 'a::type => bool.
+ (ALL (xb::'a::type) y::'a::type. x xb y --> xa xb y) &
+ (ALL (x::'a::type) (y::'a::type) z::'a::type.
+ xa x y & xa y z --> xa x z) -->
+ (ALL (xb::'a::type) xc::'a::type. TC x xb xc --> xa xb xc)"
by (import relation TC_INDUCT)
-lemma TC_INDUCT_LEFT1: "ALL x xa.
- (ALL xb y. x xb y --> xa xb y) &
- (ALL xb y z. x xb y & xa y z --> xa xb z) -->
- (ALL xb xc. TC x xb xc --> xa xb xc)"
+lemma TC_INDUCT_LEFT1: "ALL (x::'a::type => 'a::type => bool) xa::'a::type => 'a::type => bool.
+ (ALL (xb::'a::type) y::'a::type. x xb y --> xa xb y) &
+ (ALL (xb::'a::type) (y::'a::type) z::'a::type.
+ x xb y & xa y z --> xa xb z) -->
+ (ALL (xb::'a::type) xc::'a::type. TC x xb xc --> xa xb xc)"
by (import relation TC_INDUCT_LEFT1)
-lemma TC_STRONG_INDUCT: "ALL R P.
- (ALL x y. R x y --> P x y) &
- (ALL x y z. P x y & P y z & TC R x y & TC R y z --> P x z) -->
- (ALL u v. TC R u v --> P u v)"
+lemma TC_STRONG_INDUCT: "ALL (R::'a::type => 'a::type => bool) P::'a::type => 'a::type => bool.
+ (ALL (x::'a::type) y::'a::type. R x y --> P x y) &
+ (ALL (x::'a::type) (y::'a::type) z::'a::type.
+ P x y & P y z & TC R x y & TC R y z --> P x z) -->
+ (ALL (u::'a::type) v::'a::type. TC R u v --> P u v)"
by (import relation TC_STRONG_INDUCT)
-lemma TC_STRONG_INDUCT_LEFT1: "ALL R P.
- (ALL x y. R x y --> P x y) &
- (ALL x y z. R x y & P y z & TC R y z --> P x z) -->
- (ALL u v. TC R u v --> P u v)"
+lemma TC_STRONG_INDUCT_LEFT1: "ALL (R::'a::type => 'a::type => bool) P::'a::type => 'a::type => bool.
+ (ALL (x::'a::type) y::'a::type. R x y --> P x y) &
+ (ALL (x::'a::type) (y::'a::type) z::'a::type.
+ R x y & P y z & TC R y z --> P x z) -->
+ (ALL (u::'a::type) v::'a::type. TC R u v --> P u v)"
by (import relation TC_STRONG_INDUCT_LEFT1)
-lemma TC_RTC: "ALL R x y. TC R x y --> RTC R x y"
+lemma TC_RTC: "ALL (R::'a::type => 'a::type => bool) (x::'a::type) y::'a::type.
+ TC R x y --> RTC R x y"
by (import relation TC_RTC)
-lemma RTC_TC_RC: "ALL R x y. RTC R x y --> RC R x y | TC R x y"
+lemma RTC_TC_RC: "ALL (R::'a::type => 'a::type => bool) (x::'a::type) y::'a::type.
+ RTC R x y --> RC R x y | TC R x y"
by (import relation RTC_TC_RC)
-lemma TC_RC_EQNS: "ALL R. RC (TC R) = RTC R & TC (RC R) = RTC R"
+lemma TC_RC_EQNS: "ALL R::'a::type => 'a::type => bool. RC (TC R) = RTC R & TC (RC R) = RTC R"
by (import relation TC_RC_EQNS)
-lemma RC_IDEM: "ALL R. RC (RC R) = RC R"
+lemma RC_IDEM: "ALL R::'a::type => 'a::type => bool. RC (RC R) = RC R"
by (import relation RC_IDEM)
-lemma TC_IDEM: "ALL R. TC (TC R) = TC R"
+lemma TC_IDEM: "ALL R::'a::type => 'a::type => bool. TC (TC R) = TC R"
by (import relation TC_IDEM)
-lemma RTC_IDEM: "ALL R. RTC (RTC R) = RTC R"
+lemma RTC_IDEM: "ALL R::'a::type => 'a::type => bool. RTC (RTC R) = RTC R"
by (import relation RTC_IDEM)
-lemma RTC_CASES1: "ALL x xa xb. RTC x xa xb = (xa = xb | (EX u. x xa u & RTC x u xb))"
+lemma RTC_CASES1: "ALL (x::'a::type => 'a::type => bool) (xa::'a::type) xb::'a::type.
+ RTC x xa xb = (xa = xb | (EX u::'a::type. x xa u & RTC x u xb))"
by (import relation RTC_CASES1)
-lemma RTC_CASES2: "ALL x xa xb. RTC x xa xb = (xa = xb | (EX u. RTC x xa u & x u xb))"
+lemma RTC_CASES2: "ALL (x::'a::type => 'a::type => bool) (xa::'a::type) xb::'a::type.
+ RTC x xa xb = (xa = xb | (EX u::'a::type. RTC x xa u & x u xb))"
by (import relation RTC_CASES2)
-lemma RTC_CASES_RTC_TWICE: "ALL x xa xb. RTC x xa xb = (EX u. RTC x xa u & RTC x u xb)"
+lemma RTC_CASES_RTC_TWICE: "ALL (x::'a::type => 'a::type => bool) (xa::'a::type) xb::'a::type.
+ RTC x xa xb = (EX u::'a::type. RTC x xa u & RTC x u xb)"
by (import relation RTC_CASES_RTC_TWICE)
-lemma TC_CASES1: "ALL R x z. TC R x z --> R x z | (EX y. R x y & TC R y z)"
+lemma TC_CASES1: "ALL (R::'a::type => 'a::type => bool) (x::'a::type) z::'a::type.
+ TC R x z --> R x z | (EX y::'a::type. R x y & TC R y z)"
by (import relation TC_CASES1)
-lemma TC_CASES2: "ALL R x z. TC R x z --> R x z | (EX y. TC R x y & R y z)"
+lemma TC_CASES2: "ALL (R::'a::type => 'a::type => bool) (x::'a::type) z::'a::type.
+ TC R x z --> R x z | (EX y::'a::type. TC R x y & R y z)"
by (import relation TC_CASES2)
-lemma TC_MONOTONE: "ALL R Q. (ALL x y. R x y --> Q x y) --> (ALL x y. TC R x y --> TC Q x y)"
+lemma TC_MONOTONE: "ALL (R::'a::type => 'a::type => bool) Q::'a::type => 'a::type => bool.
+ (ALL (x::'a::type) y::'a::type. R x y --> Q x y) -->
+ (ALL (x::'a::type) y::'a::type. TC R x y --> TC Q x y)"
by (import relation TC_MONOTONE)
-lemma RTC_MONOTONE: "ALL R Q. (ALL x y. R x y --> Q x y) --> (ALL x y. RTC R x y --> RTC Q x y)"
+lemma RTC_MONOTONE: "ALL (R::'a::type => 'a::type => bool) Q::'a::type => 'a::type => bool.
+ (ALL (x::'a::type) y::'a::type. R x y --> Q x y) -->
+ (ALL (x::'a::type) y::'a::type. RTC R x y --> RTC Q x y)"
by (import relation RTC_MONOTONE)
constdefs
- WF :: "('a => 'a => bool) => bool"
- "WF == %R. ALL B. Ex B --> (EX min. B min & (ALL b. R b min --> ~ B b))"
-
-lemma WF_DEF: "ALL R. WF R = (ALL B. Ex B --> (EX min. B min & (ALL b. R b min --> ~ B b)))"
+ WF :: "('a::type => 'a::type => bool) => bool"
+ "WF ==
+%R::'a::type => 'a::type => bool.
+ ALL B::'a::type => bool.
+ Ex B -->
+ (EX min::'a::type. B min & (ALL b::'a::type. R b min --> ~ B b))"
+
+lemma WF_DEF: "ALL R::'a::type => 'a::type => bool.
+ WF R =
+ (ALL B::'a::type => bool.
+ Ex B -->
+ (EX min::'a::type. B min & (ALL b::'a::type. R b min --> ~ B b)))"
by (import relation WF_DEF)
-lemma WF_INDUCTION_THM: "ALL R. WF R --> (ALL P. (ALL x. (ALL y. R y x --> P y) --> P x) --> All P)"
+lemma WF_INDUCTION_THM: "ALL R::'a::type => 'a::type => bool.
+ WF R -->
+ (ALL P::'a::type => bool.
+ (ALL x::'a::type. (ALL y::'a::type. R y x --> P y) --> P x) -->
+ All P)"
by (import relation WF_INDUCTION_THM)
-lemma WF_NOT_REFL: "ALL x xa xb. WF x --> x xa xb --> xa ~= xb"
+lemma WF_NOT_REFL: "ALL (x::'a::type => 'a::type => bool) (xa::'a::type) xb::'a::type.
+ WF x --> x xa xb --> xa ~= xb"
by (import relation WF_NOT_REFL)
constdefs
- EMPTY_REL :: "'a => 'a => bool"
- "EMPTY_REL == %x y. False"
-
-lemma EMPTY_REL_DEF: "ALL x y. EMPTY_REL x y = False"
+ EMPTY_REL :: "'a::type => 'a::type => bool"
+ "EMPTY_REL == %(x::'a::type) y::'a::type. False"
+
+lemma EMPTY_REL_DEF: "ALL (x::'a::type) y::'a::type. EMPTY_REL x y = False"
by (import relation EMPTY_REL_DEF)
lemma WF_EMPTY_REL: "WF EMPTY_REL"
by (import relation WF_EMPTY_REL)
-lemma WF_SUBSET: "ALL x xa. WF x & (ALL xb y. xa xb y --> x xb y) --> WF xa"
+lemma WF_SUBSET: "ALL (x::'a::type => 'a::type => bool) xa::'a::type => 'a::type => bool.
+ WF x & (ALL (xb::'a::type) y::'a::type. xa xb y --> x xb y) --> WF xa"
by (import relation WF_SUBSET)
-lemma WF_TC: "ALL R. WF R --> WF (TC R)"
+lemma WF_TC: "ALL R::'a::type => 'a::type => bool. WF R --> WF (TC R)"
by (import relation WF_TC)
consts
- inv_image :: "('b => 'b => bool) => ('a => 'b) => 'a => 'a => bool"
+ inv_image :: "('b::type => 'b::type => bool)
+=> ('a::type => 'b::type) => 'a::type => 'a::type => bool"
defs
inv_image_primdef: "relation.inv_image ==
-%(R::'b => 'b => bool) (f::'a => 'b) (x::'a) y::'a. R (f x) (f y)"
-
-lemma inv_image_def: "ALL (R::'b => 'b => bool) f::'a => 'b.
- relation.inv_image R f = (%(x::'a) y::'a. R (f x) (f y))"
+%(R::'b::type => 'b::type => bool) (f::'a::type => 'b::type) (x::'a::type)
+ y::'a::type. R (f x) (f y)"
+
+lemma inv_image_def: "ALL (R::'b::type => 'b::type => bool) f::'a::type => 'b::type.
+ relation.inv_image R f = (%(x::'a::type) y::'a::type. R (f x) (f y))"
by (import relation inv_image_def)
-lemma WF_inv_image: "ALL (R::'b => 'b => bool) f::'a => 'b. WF R --> WF (relation.inv_image R f)"
+lemma WF_inv_image: "ALL (R::'b::type => 'b::type => bool) f::'a::type => 'b::type.
+ WF R --> WF (relation.inv_image R f)"
by (import relation WF_inv_image)
constdefs
- RESTRICT :: "('a => 'b) => ('a => 'a => bool) => 'a => 'a => 'b"
- "RESTRICT == %f R x y. if R y x then f y else ARB"
-
-lemma RESTRICT_DEF: "ALL f R x. RESTRICT f R x = (%y. if R y x then f y else ARB)"
+ RESTRICT :: "('a::type => 'b::type)
+=> ('a::type => 'a::type => bool) => 'a::type => 'a::type => 'b::type"
+ "RESTRICT ==
+%(f::'a::type => 'b::type) (R::'a::type => 'a::type => bool) (x::'a::type)
+ y::'a::type. if R y x then f y else ARB"
+
+lemma RESTRICT_DEF: "ALL (f::'a::type => 'b::type) (R::'a::type => 'a::type => bool) x::'a::type.
+ RESTRICT f R x = (%y::'a::type. if R y x then f y else ARB)"
by (import relation RESTRICT_DEF)
-lemma RESTRICT_LEMMA: "ALL x xa xb xc. xa xb xc --> RESTRICT x xa xc xb = x xb"
+lemma RESTRICT_LEMMA: "ALL (x::'a::type => 'b::type) (xa::'a::type => 'a::type => bool)
+ (xb::'a::type) xc::'a::type. xa xb xc --> RESTRICT x xa xc xb = x xb"
by (import relation RESTRICT_LEMMA)
consts
- approx :: "('a => 'a => bool) => (('a => 'b) => 'a => 'b) => 'a => ('a => 'b) => bool"
+ approx :: "('a::type => 'a::type => bool)
+=> (('a::type => 'b::type) => 'a::type => 'b::type)
+ => 'a::type => ('a::type => 'b::type) => bool"
defs
- approx_primdef: "approx == %R M x f. f = RESTRICT (%y. M (RESTRICT f R y) y) R x"
-
-lemma approx_def: "ALL R M x f. approx R M x f = (f = RESTRICT (%y. M (RESTRICT f R y) y) R x)"
+ approx_primdef: "approx ==
+%(R::'a::type => 'a::type => bool)
+ (M::('a::type => 'b::type) => 'a::type => 'b::type) (x::'a::type)
+ f::'a::type => 'b::type.
+ f = RESTRICT (%y::'a::type. M (RESTRICT f R y) y) R x"
+
+lemma approx_def: "ALL (R::'a::type => 'a::type => bool)
+ (M::('a::type => 'b::type) => 'a::type => 'b::type) (x::'a::type)
+ f::'a::type => 'b::type.
+ approx R M x f = (f = RESTRICT (%y::'a::type. M (RESTRICT f R y) y) R x)"
by (import relation approx_def)
consts
- the_fun :: "('a => 'a => bool) => (('a => 'b) => 'a => 'b) => 'a => 'a => 'b"
+ the_fun :: "('a::type => 'a::type => bool)
+=> (('a::type => 'b::type) => 'a::type => 'b::type)
+ => 'a::type => 'a::type => 'b::type"
defs
- the_fun_primdef: "the_fun == %R M x. Eps (approx R M x)"
-
-lemma the_fun_def: "ALL R M x. the_fun R M x = Eps (approx R M x)"
+ the_fun_primdef: "the_fun ==
+%(R::'a::type => 'a::type => bool)
+ (M::('a::type => 'b::type) => 'a::type => 'b::type) x::'a::type.
+ Eps (approx R M x)"
+
+lemma the_fun_def: "ALL (R::'a::type => 'a::type => bool)
+ (M::('a::type => 'b::type) => 'a::type => 'b::type) x::'a::type.
+ the_fun R M x = Eps (approx R M x)"
by (import relation the_fun_def)
constdefs
- WFREC :: "('a => 'a => bool) => (('a => 'b) => 'a => 'b) => 'a => 'b"
+ WFREC :: "('a::type => 'a::type => bool)
+=> (('a::type => 'b::type) => 'a::type => 'b::type) => 'a::type => 'b::type"
"WFREC ==
-%R M x. M (RESTRICT (the_fun (TC R) (%f v. M (RESTRICT f R v) v) x) R x) x"
-
-lemma WFREC_DEF: "ALL R M.
+%(R::'a::type => 'a::type => bool)
+ (M::('a::type => 'b::type) => 'a::type => 'b::type) x::'a::type.
+ M (RESTRICT
+ (the_fun (TC R)
+ (%(f::'a::type => 'b::type) v::'a::type. M (RESTRICT f R v) v) x)
+ R x)
+ x"
+
+lemma WFREC_DEF: "ALL (R::'a::type => 'a::type => bool)
+ M::('a::type => 'b::type) => 'a::type => 'b::type.
WFREC R M =
- (%x. M (RESTRICT (the_fun (TC R) (%f v. M (RESTRICT f R v) v) x) R x) x)"
+ (%x::'a::type.
+ M (RESTRICT
+ (the_fun (TC R)
+ (%(f::'a::type => 'b::type) v::'a::type. M (RESTRICT f R v) v)
+ x)
+ R x)
+ x)"
by (import relation WFREC_DEF)
-lemma WFREC_THM: "ALL R M. WF R --> (ALL x. WFREC R M x = M (RESTRICT (WFREC R M) R x) x)"
+lemma WFREC_THM: "ALL (R::'a::type => 'a::type => bool)
+ M::('a::type => 'b::type) => 'a::type => 'b::type.
+ WF R --> (ALL x::'a::type. WFREC R M x = M (RESTRICT (WFREC R M) R x) x)"
by (import relation WFREC_THM)
-lemma WFREC_COROLLARY: "ALL M R f. f = WFREC R M --> WF R --> (ALL x. f x = M (RESTRICT f R x) x)"
+lemma WFREC_COROLLARY: "ALL (M::('a::type => 'b::type) => 'a::type => 'b::type)
+ (R::'a::type => 'a::type => bool) f::'a::type => 'b::type.
+ f = WFREC R M --> WF R --> (ALL x::'a::type. f x = M (RESTRICT f R x) x)"
by (import relation WFREC_COROLLARY)
-lemma WF_RECURSION_THM: "ALL R. WF R --> (ALL M. EX! f. ALL x. f x = M (RESTRICT f R x) x)"
+lemma WF_RECURSION_THM: "ALL R::'a::type => 'a::type => bool.
+ WF R -->
+ (ALL M::('a::type => 'b::type) => 'a::type => 'b::type.
+ EX! f::'a::type => 'b::type.
+ ALL x::'a::type. f x = M (RESTRICT f R x) x)"
by (import relation WF_RECURSION_THM)
;end_setup
;setup_theory pair
-lemma CURRY_ONE_ONE_THM: "(curry f = curry g) = (f = g)"
+lemma CURRY_ONE_ONE_THM: "(curry (f::'a::type * 'b::type => 'c::type) =
+ curry (g::'a::type * 'b::type => 'c::type)) =
+(f = g)"
by (import pair CURRY_ONE_ONE_THM)
lemma UNCURRY_ONE_ONE_THM: "(op =::bool => bool => bool)
- ((op =::('a * 'b => 'c) => ('a * 'b => 'c) => bool)
- ((split::('a => 'b => 'c) => 'a * 'b => 'c) (f::'a => 'b => 'c))
- ((split::('a => 'b => 'c) => 'a * 'b => 'c) (g::'a => 'b => 'c)))
- ((op =::('a => 'b => 'c) => ('a => 'b => 'c) => bool) f g)"
+ ((op =::('a::type * 'b::type => 'c::type)
+ => ('a::type * 'b::type => 'c::type) => bool)
+ ((split::('a::type => 'b::type => 'c::type)
+ => 'a::type * 'b::type => 'c::type)
+ (f::'a::type => 'b::type => 'c::type))
+ ((split::('a::type => 'b::type => 'c::type)
+ => 'a::type * 'b::type => 'c::type)
+ (g::'a::type => 'b::type => 'c::type)))
+ ((op =::('a::type => 'b::type => 'c::type)
+ => ('a::type => 'b::type => 'c::type) => bool)
+ f g)"
by (import pair UNCURRY_ONE_ONE_THM)
-lemma pair_Axiom: "ALL f. EX x. ALL xa y. x (xa, y) = f xa y"
+lemma pair_Axiom: "ALL f::'a::type => 'b::type => 'c::type.
+ EX x::'a::type * 'b::type => 'c::type.
+ ALL (xa::'a::type) y::'b::type. x (xa, y) = f xa y"
by (import pair pair_Axiom)
-lemma UNCURRY_CONG: "ALL M M' f.
- M = M' & (ALL x y. M' = (x, y) --> f x y = f' x y) -->
+lemma UNCURRY_CONG: "ALL (M::'a::type * 'b::type) (M'::'a::type * 'b::type)
+ f::'a::type => 'b::type => 'c::type.
+ M = M' &
+ (ALL (x::'a::type) y::'b::type.
+ M' = (x, y) -->
+ f x y = (f'::'a::type => 'b::type => 'c::type) x y) -->
split f M = split f' M'"
by (import pair UNCURRY_CONG)
-lemma ELIM_PEXISTS: "(EX p. P (fst p) (snd p)) = (EX p1. Ex (P p1))"
+lemma ELIM_PEXISTS: "(EX p::'a::type * 'b::type.
+ (P::'a::type => 'b::type => bool) (fst p) (snd p)) =
+(EX p1::'a::type. Ex (P p1))"
by (import pair ELIM_PEXISTS)
-lemma ELIM_PFORALL: "(ALL p. P (fst p) (snd p)) = (ALL p1. All (P p1))"
+lemma ELIM_PFORALL: "(ALL p::'a::type * 'b::type.
+ (P::'a::type => 'b::type => bool) (fst p) (snd p)) =
+(ALL p1::'a::type. All (P p1))"
by (import pair ELIM_PFORALL)
-lemma PFORALL_THM: "(All::(('a => 'b => bool) => bool) => bool)
- (%x::'a => 'b => bool.
+lemma PFORALL_THM: "(All::(('a::type => 'b::type => bool) => bool) => bool)
+ (%x::'a::type => 'b::type => bool.
(op =::bool => bool => bool)
- ((All::('a => bool) => bool)
- (%xa::'a. (All::('b => bool) => bool) (x xa)))
- ((All::('a * 'b => bool) => bool)
- ((split::('a => 'b => bool) => 'a * 'b => bool) x)))"
+ ((All::('a::type => bool) => bool)
+ (%xa::'a::type. (All::('b::type => bool) => bool) (x xa)))
+ ((All::('a::type * 'b::type => bool) => bool)
+ ((split::('a::type => 'b::type => bool)
+ => 'a::type * 'b::type => bool)
+ x)))"
by (import pair PFORALL_THM)
-lemma PEXISTS_THM: "(All::(('a => 'b => bool) => bool) => bool)
- (%x::'a => 'b => bool.
+lemma PEXISTS_THM: "(All::(('a::type => 'b::type => bool) => bool) => bool)
+ (%x::'a::type => 'b::type => bool.
(op =::bool => bool => bool)
- ((Ex::('a => bool) => bool)
- (%xa::'a. (Ex::('b => bool) => bool) (x xa)))
- ((Ex::('a * 'b => bool) => bool)
- ((split::('a => 'b => bool) => 'a * 'b => bool) x)))"
+ ((Ex::('a::type => bool) => bool)
+ (%xa::'a::type. (Ex::('b::type => bool) => bool) (x xa)))
+ ((Ex::('a::type * 'b::type => bool) => bool)
+ ((split::('a::type => 'b::type => bool)
+ => 'a::type * 'b::type => bool)
+ x)))"
by (import pair PEXISTS_THM)
-lemma LET2_RAND: "(All::(('c => 'd) => bool) => bool)
- (%x::'c => 'd.
- (All::('a * 'b => bool) => bool)
- (%xa::'a * 'b.
- (All::(('a => 'b => 'c) => bool) => bool)
- (%xb::'a => 'b => 'c.
- (op =::'d => 'd => bool)
- (x ((Let::'a * 'b => ('a * 'b => 'c) => 'c) xa
- ((split::('a => 'b => 'c) => 'a * 'b => 'c) xb)))
- ((Let::'a * 'b => ('a * 'b => 'd) => 'd) xa
- ((split::('a => 'b => 'd) => 'a * 'b => 'd)
- (%(xa::'a) y::'b. x (xb xa y)))))))"
+lemma LET2_RAND: "(All::(('c::type => 'd::type) => bool) => bool)
+ (%x::'c::type => 'd::type.
+ (All::('a::type * 'b::type => bool) => bool)
+ (%xa::'a::type * 'b::type.
+ (All::(('a::type => 'b::type => 'c::type) => bool) => bool)
+ (%xb::'a::type => 'b::type => 'c::type.
+ (op =::'d::type => 'd::type => bool)
+ (x ((Let::'a::type * 'b::type
+ => ('a::type * 'b::type => 'c::type) => 'c::type)
+ xa ((split::('a::type => 'b::type => 'c::type)
+ => 'a::type * 'b::type => 'c::type)
+ xb)))
+ ((Let::'a::type * 'b::type
+ => ('a::type * 'b::type => 'd::type) => 'd::type)
+ xa ((split::('a::type => 'b::type => 'd::type)
+ => 'a::type * 'b::type => 'd::type)
+ (%(xa::'a::type) y::'b::type. x (xb xa y)))))))"
by (import pair LET2_RAND)
-lemma LET2_RATOR: "(All::('a1 * 'a2 => bool) => bool)
- (%x::'a1 * 'a2.
- (All::(('a1 => 'a2 => 'b => 'c) => bool) => bool)
- (%xa::'a1 => 'a2 => 'b => 'c.
- (All::('b => bool) => bool)
- (%xb::'b.
- (op =::'c => 'c => bool)
- ((Let::'a1 * 'a2 => ('a1 * 'a2 => 'b => 'c) => 'b => 'c) x
- ((split::('a1 => 'a2 => 'b => 'c)
- => 'a1 * 'a2 => 'b => 'c)
- xa)
+lemma LET2_RATOR: "(All::('a1::type * 'a2::type => bool) => bool)
+ (%x::'a1::type * 'a2::type.
+ (All::(('a1::type => 'a2::type => 'b::type => 'c::type) => bool)
+ => bool)
+ (%xa::'a1::type => 'a2::type => 'b::type => 'c::type.
+ (All::('b::type => bool) => bool)
+ (%xb::'b::type.
+ (op =::'c::type => 'c::type => bool)
+ ((Let::'a1::type * 'a2::type
+ => ('a1::type * 'a2::type => 'b::type => 'c::type)
+ => 'b::type => 'c::type)
+ x ((split::('a1::type
+ => 'a2::type => 'b::type => 'c::type)
+ => 'a1::type * 'a2::type
+ => 'b::type => 'c::type)
+ xa)
xb)
- ((Let::'a1 * 'a2 => ('a1 * 'a2 => 'c) => 'c) x
- ((split::('a1 => 'a2 => 'c) => 'a1 * 'a2 => 'c)
- (%(x::'a1) y::'a2. xa x y xb))))))"
+ ((Let::'a1::type * 'a2::type
+ => ('a1::type * 'a2::type => 'c::type) => 'c::type)
+ x ((split::('a1::type => 'a2::type => 'c::type)
+ => 'a1::type * 'a2::type => 'c::type)
+ (%(x::'a1::type) y::'a2::type. xa x y xb))))))"
by (import pair LET2_RATOR)
-lemma pair_case_cong: "ALL x xa xb.
- x = xa & (ALL x y. xa = (x, y) --> xb x y = f' x y) -->
+lemma pair_case_cong: "ALL (x::'a::type * 'b::type) (xa::'a::type * 'b::type)
+ xb::'a::type => 'b::type => 'c::type.
+ x = xa &
+ (ALL (x::'a::type) y::'b::type.
+ xa = (x, y) -->
+ xb x y = (f'::'a::type => 'b::type => 'c::type) x y) -->
split xb x = split f' xa"
by (import pair pair_case_cong)
constdefs
- LEX :: "('a => 'a => bool) => ('b => 'b => bool) => 'a * 'b => 'a * 'b => bool"
- "LEX == %R1 R2 (s, t) (u, v). R1 s u | s = u & R2 t v"
-
-lemma LEX_DEF: "ALL R1 R2. LEX R1 R2 = (%(s, t) (u, v). R1 s u | s = u & R2 t v)"
+ LEX :: "('a::type => 'a::type => bool)
+=> ('b::type => 'b::type => bool)
+ => 'a::type * 'b::type => 'a::type * 'b::type => bool"
+ "LEX ==
+%(R1::'a::type => 'a::type => bool) (R2::'b::type => 'b::type => bool)
+ (s::'a::type, t::'b::type) (u::'a::type, v::'b::type).
+ R1 s u | s = u & R2 t v"
+
+lemma LEX_DEF: "ALL (R1::'a::type => 'a::type => bool) R2::'b::type => 'b::type => bool.
+ LEX R1 R2 =
+ (%(s::'a::type, t::'b::type) (u::'a::type, v::'b::type).
+ R1 s u | s = u & R2 t v)"
by (import pair LEX_DEF)
-lemma WF_LEX: "ALL x xa. WF x & WF xa --> WF (LEX x xa)"
+lemma WF_LEX: "ALL (x::'a::type => 'a::type => bool) xa::'b::type => 'b::type => bool.
+ WF x & WF xa --> WF (LEX x xa)"
by (import pair WF_LEX)
constdefs
- RPROD :: "('a => 'a => bool) => ('b => 'b => bool) => 'a * 'b => 'a * 'b => bool"
- "RPROD == %R1 R2 (s, t) (u, v). R1 s u & R2 t v"
-
-lemma RPROD_DEF: "ALL R1 R2. RPROD R1 R2 = (%(s, t) (u, v). R1 s u & R2 t v)"
+ RPROD :: "('a::type => 'a::type => bool)
+=> ('b::type => 'b::type => bool)
+ => 'a::type * 'b::type => 'a::type * 'b::type => bool"
+ "RPROD ==
+%(R1::'a::type => 'a::type => bool) (R2::'b::type => 'b::type => bool)
+ (s::'a::type, t::'b::type) (u::'a::type, v::'b::type). R1 s u & R2 t v"
+
+lemma RPROD_DEF: "ALL (R1::'a::type => 'a::type => bool) R2::'b::type => 'b::type => bool.
+ RPROD R1 R2 =
+ (%(s::'a::type, t::'b::type) (u::'a::type, v::'b::type). R1 s u & R2 t v)"
by (import pair RPROD_DEF)
-lemma WF_RPROD: "ALL R Q. WF R & WF Q --> WF (RPROD R Q)"
+lemma WF_RPROD: "ALL (R::'a::type => 'a::type => bool) Q::'b::type => 'b::type => bool.
+ WF R & WF Q --> WF (RPROD R Q)"
by (import pair WF_RPROD)
;end_setup
@@ -860,152 +1104,184 @@
;setup_theory prim_rec
-lemma LESS_0_0: "0 < Suc 0"
+lemma LESS_0_0: "(0::nat) < Suc (0::nat)"
by (import prim_rec LESS_0_0)
-lemma LESS_LEMMA1: "ALL x xa. x < Suc xa --> x = xa | x < xa"
+lemma LESS_LEMMA1: "ALL (x::nat) xa::nat. x < Suc xa --> x = xa | x < xa"
by (import prim_rec LESS_LEMMA1)
-lemma LESS_LEMMA2: "ALL m n. m = n | m < n --> m < Suc n"
+lemma LESS_LEMMA2: "ALL (m::nat) n::nat. m = n | m < n --> m < Suc n"
by (import prim_rec LESS_LEMMA2)
-lemma LESS_THM: "ALL m n. (m < Suc n) = (m = n | m < n)"
+lemma LESS_THM: "ALL (m::nat) n::nat. (m < Suc n) = (m = n | m < n)"
by (import prim_rec LESS_THM)
-lemma LESS_SUC_IMP: "ALL x xa. x < Suc xa --> x ~= xa --> x < xa"
+lemma LESS_SUC_IMP: "ALL (x::nat) xa::nat. x < Suc xa --> x ~= xa --> x < xa"
by (import prim_rec LESS_SUC_IMP)
-lemma EQ_LESS: "ALL n. Suc m = n --> m < n"
+lemma EQ_LESS: "ALL n::nat. Suc (m::nat) = n --> m < n"
by (import prim_rec EQ_LESS)
lemma NOT_LESS_EQ: "ALL (m::nat) n::nat. m = n --> ~ m < n"
by (import prim_rec NOT_LESS_EQ)
constdefs
- SIMP_REC_REL :: "(nat => 'a) => 'a => ('a => 'a) => nat => bool"
- "(op ==::((nat => 'a) => 'a => ('a => 'a) => nat => bool)
- => ((nat => 'a) => 'a => ('a => 'a) => nat => bool) => prop)
- (SIMP_REC_REL::(nat => 'a) => 'a => ('a => 'a) => nat => bool)
- (%(fun::nat => 'a) (x::'a) (f::'a => 'a) n::nat.
+ SIMP_REC_REL :: "(nat => 'a::type) => 'a::type => ('a::type => 'a::type) => nat => bool"
+ "(op ==::((nat => 'a::type)
+ => 'a::type => ('a::type => 'a::type) => nat => bool)
+ => ((nat => 'a::type)
+ => 'a::type => ('a::type => 'a::type) => nat => bool)
+ => prop)
+ (SIMP_REC_REL::(nat => 'a::type)
+ => 'a::type => ('a::type => 'a::type) => nat => bool)
+ (%(fun::nat => 'a::type) (x::'a::type) (f::'a::type => 'a::type) n::nat.
(op &::bool => bool => bool)
- ((op =::'a => 'a => bool) (fun (0::nat)) x)
+ ((op =::'a::type => 'a::type => bool) (fun (0::nat)) x)
((All::(nat => bool) => bool)
(%m::nat.
(op -->::bool => bool => bool) ((op <::nat => nat => bool) m n)
- ((op =::'a => 'a => bool) (fun ((Suc::nat => nat) m))
- (f (fun m))))))"
-
-lemma SIMP_REC_REL: "(All::((nat => 'a) => bool) => bool)
- (%fun::nat => 'a.
- (All::('a => bool) => bool)
- (%x::'a.
- (All::(('a => 'a) => bool) => bool)
- (%f::'a => 'a.
+ ((op =::'a::type => 'a::type => bool)
+ (fun ((Suc::nat => nat) m)) (f (fun m))))))"
+
+lemma SIMP_REC_REL: "(All::((nat => 'a::type) => bool) => bool)
+ (%fun::nat => 'a::type.
+ (All::('a::type => bool) => bool)
+ (%x::'a::type.
+ (All::(('a::type => 'a::type) => bool) => bool)
+ (%f::'a::type => 'a::type.
(All::(nat => bool) => bool)
(%n::nat.
(op =::bool => bool => bool)
- ((SIMP_REC_REL::(nat => 'a)
- => 'a => ('a => 'a) => nat => bool)
+ ((SIMP_REC_REL::(nat => 'a::type)
+ => 'a::type
+ => ('a::type => 'a::type) => nat => bool)
fun x f n)
((op &::bool => bool => bool)
- ((op =::'a => 'a => bool) (fun (0::nat)) x)
+ ((op =::'a::type => 'a::type => bool) (fun (0::nat))
+ x)
((All::(nat => bool) => bool)
(%m::nat.
(op -->::bool => bool => bool)
((op <::nat => nat => bool) m n)
- ((op =::'a => 'a => bool)
+ ((op =::'a::type => 'a::type => bool)
(fun ((Suc::nat => nat) m))
(f (fun m))))))))))"
by (import prim_rec SIMP_REC_REL)
-lemma SIMP_REC_EXISTS: "ALL x f n. EX fun. SIMP_REC_REL fun x f n"
+lemma SIMP_REC_EXISTS: "ALL (x::'a::type) (f::'a::type => 'a::type) n::nat.
+ EX fun::nat => 'a::type. SIMP_REC_REL fun x f n"
by (import prim_rec SIMP_REC_EXISTS)
-lemma SIMP_REC_REL_UNIQUE: "ALL x xa xb xc xd xe.
+lemma SIMP_REC_REL_UNIQUE: "ALL (x::'a::type) (xa::'a::type => 'a::type) (xb::nat => 'a::type)
+ (xc::nat => 'a::type) (xd::nat) xe::nat.
SIMP_REC_REL xb x xa xd & SIMP_REC_REL xc x xa xe -->
- (ALL n. n < xd & n < xe --> xb n = xc n)"
+ (ALL n::nat. n < xd & n < xe --> xb n = xc n)"
by (import prim_rec SIMP_REC_REL_UNIQUE)
-lemma SIMP_REC_REL_UNIQUE_RESULT: "ALL x f n. EX! y. EX g. SIMP_REC_REL g x f (Suc n) & y = g n"
+lemma SIMP_REC_REL_UNIQUE_RESULT: "ALL (x::'a::type) (f::'a::type => 'a::type) n::nat.
+ EX! y::'a::type.
+ EX g::nat => 'a::type. SIMP_REC_REL g x f (Suc n) & y = g n"
by (import prim_rec SIMP_REC_REL_UNIQUE_RESULT)
consts
- SIMP_REC :: "'a => ('a => 'a) => nat => 'a"
-
-specification (SIMP_REC) SIMP_REC: "ALL x f' n. EX g. SIMP_REC_REL g x f' (Suc n) & SIMP_REC x f' n = g n"
+ SIMP_REC :: "'a::type => ('a::type => 'a::type) => nat => 'a::type"
+
+specification (SIMP_REC) SIMP_REC: "ALL (x::'a::type) (f'::'a::type => 'a::type) n::nat.
+ EX g::nat => 'a::type.
+ SIMP_REC_REL g x f' (Suc n) & SIMP_REC x f' n = g n"
by (import prim_rec SIMP_REC)
-lemma LESS_SUC_SUC: "ALL m. m < Suc m & m < Suc (Suc m)"
+lemma LESS_SUC_SUC: "ALL m::nat. m < Suc m & m < Suc (Suc m)"
by (import prim_rec LESS_SUC_SUC)
-lemma SIMP_REC_THM: "ALL x f.
- SIMP_REC x f 0 = x & (ALL m. SIMP_REC x f (Suc m) = f (SIMP_REC x f m))"
+lemma SIMP_REC_THM: "ALL (x::'a::type) f::'a::type => 'a::type.
+ SIMP_REC x f (0::nat) = x &
+ (ALL m::nat. SIMP_REC x f (Suc m) = f (SIMP_REC x f m))"
by (import prim_rec SIMP_REC_THM)
constdefs
PRE :: "nat => nat"
- "PRE == %m. if m = 0 then 0 else SOME n. m = Suc n"
-
-lemma PRE_DEF: "ALL m. PRE m = (if m = 0 then 0 else SOME n. m = Suc n)"
+ "PRE == %m::nat. if m = (0::nat) then 0::nat else SOME n::nat. m = Suc n"
+
+lemma PRE_DEF: "ALL m::nat.
+ PRE m = (if m = (0::nat) then 0::nat else SOME n::nat. m = Suc n)"
by (import prim_rec PRE_DEF)
-lemma PRE: "PRE 0 = 0 & (ALL m. PRE (Suc m) = m)"
+lemma PRE: "PRE (0::nat) = (0::nat) & (ALL m::nat. PRE (Suc m) = m)"
by (import prim_rec PRE)
constdefs
- PRIM_REC_FUN :: "'a => ('a => nat => 'a) => nat => nat => 'a"
- "PRIM_REC_FUN == %x f. SIMP_REC (%n. x) (%fun n. f (fun (PRE n)) n)"
-
-lemma PRIM_REC_FUN: "ALL x f. PRIM_REC_FUN x f = SIMP_REC (%n. x) (%fun n. f (fun (PRE n)) n)"
+ PRIM_REC_FUN :: "'a::type => ('a::type => nat => 'a::type) => nat => nat => 'a::type"
+ "PRIM_REC_FUN ==
+%(x::'a::type) f::'a::type => nat => 'a::type.
+ SIMP_REC (%n::nat. x) (%(fun::nat => 'a::type) n::nat. f (fun (PRE n)) n)"
+
+lemma PRIM_REC_FUN: "ALL (x::'a::type) f::'a::type => nat => 'a::type.
+ PRIM_REC_FUN x f =
+ SIMP_REC (%n::nat. x) (%(fun::nat => 'a::type) n::nat. f (fun (PRE n)) n)"
by (import prim_rec PRIM_REC_FUN)
-lemma PRIM_REC_EQN: "ALL x f.
- (ALL n. PRIM_REC_FUN x f 0 n = x) &
- (ALL m n. PRIM_REC_FUN x f (Suc m) n = f (PRIM_REC_FUN x f m (PRE n)) n)"
+lemma PRIM_REC_EQN: "ALL (x::'a::type) f::'a::type => nat => 'a::type.
+ (ALL n::nat. PRIM_REC_FUN x f (0::nat) n = x) &
+ (ALL (m::nat) n::nat.
+ PRIM_REC_FUN x f (Suc m) n = f (PRIM_REC_FUN x f m (PRE n)) n)"
by (import prim_rec PRIM_REC_EQN)
constdefs
- PRIM_REC :: "'a => ('a => nat => 'a) => nat => 'a"
- "PRIM_REC == %x f m. PRIM_REC_FUN x f m (PRE m)"
-
-lemma PRIM_REC: "ALL x f m. PRIM_REC x f m = PRIM_REC_FUN x f m (PRE m)"
+ PRIM_REC :: "'a::type => ('a::type => nat => 'a::type) => nat => 'a::type"
+ "PRIM_REC ==
+%(x::'a::type) (f::'a::type => nat => 'a::type) m::nat.
+ PRIM_REC_FUN x f m (PRE m)"
+
+lemma PRIM_REC: "ALL (x::'a::type) (f::'a::type => nat => 'a::type) m::nat.
+ PRIM_REC x f m = PRIM_REC_FUN x f m (PRE m)"
by (import prim_rec PRIM_REC)
-lemma PRIM_REC_THM: "ALL x f.
- PRIM_REC x f 0 = x & (ALL m. PRIM_REC x f (Suc m) = f (PRIM_REC x f m) m)"
+lemma PRIM_REC_THM: "ALL (x::'a::type) f::'a::type => nat => 'a::type.
+ PRIM_REC x f (0::nat) = x &
+ (ALL m::nat. PRIM_REC x f (Suc m) = f (PRIM_REC x f m) m)"
by (import prim_rec PRIM_REC_THM)
-lemma DC: "ALL P R a.
- P a & (ALL x. P x --> (EX y. P y & R x y)) -->
- (EX x. x 0 = a & (ALL n. P (x n) & R (x n) (x (Suc n))))"
+lemma DC: "ALL (P::'a::type => bool) (R::'a::type => 'a::type => bool) a::'a::type.
+ P a & (ALL x::'a::type. P x --> (EX y::'a::type. P y & R x y)) -->
+ (EX x::nat => 'a::type.
+ x (0::nat) = a & (ALL n::nat. P (x n) & R (x n) (x (Suc n))))"
by (import prim_rec DC)
-lemma num_Axiom_old: "ALL e f. EX! fn1. fn1 0 = e & (ALL n. fn1 (Suc n) = f (fn1 n) n)"
+lemma num_Axiom_old: "ALL (e::'a::type) f::'a::type => nat => 'a::type.
+ EX! fn1::nat => 'a::type.
+ fn1 (0::nat) = e & (ALL n::nat. fn1 (Suc n) = f (fn1 n) n)"
by (import prim_rec num_Axiom_old)
-lemma num_Axiom: "ALL e f. EX x. x 0 = e & (ALL n. x (Suc n) = f n (x n))"
+lemma num_Axiom: "ALL (e::'a::type) f::nat => 'a::type => 'a::type.
+ EX x::nat => 'a::type.
+ x (0::nat) = e & (ALL n::nat. x (Suc n) = f n (x n))"
by (import prim_rec num_Axiom)
consts
- wellfounded :: "('a => 'a => bool) => bool"
+ wellfounded :: "('a::type => 'a::type => bool) => bool"
defs
- wellfounded_primdef: "wellfounded == %R. ~ (EX f. ALL n. R (f (Suc n)) (f n))"
-
-lemma wellfounded_def: "ALL R. wellfounded R = (~ (EX f. ALL n. R (f (Suc n)) (f n)))"
+ wellfounded_primdef: "wellfounded ==
+%R::'a::type => 'a::type => bool.
+ ~ (EX f::nat => 'a::type. ALL n::nat. R (f (Suc n)) (f n))"
+
+lemma wellfounded_def: "ALL R::'a::type => 'a::type => bool.
+ wellfounded R =
+ (~ (EX f::nat => 'a::type. ALL n::nat. R (f (Suc n)) (f n)))"
by (import prim_rec wellfounded_def)
-lemma WF_IFF_WELLFOUNDED: "ALL R. WF R = wellfounded R"
+lemma WF_IFF_WELLFOUNDED: "ALL R::'a::type => 'a::type => bool. WF R = wellfounded R"
by (import prim_rec WF_IFF_WELLFOUNDED)
-lemma WF_PRED: "WF (%x y. y = Suc x)"
+lemma WF_PRED: "WF (%(x::nat) y::nat. y = Suc x)"
by (import prim_rec WF_PRED)
lemma WF_LESS: "(WF::(nat => nat => bool) => bool) (op <::nat => nat => bool)"
by (import prim_rec WF_LESS)
consts
- measure :: "('a => nat) => 'a => 'a => bool"
+ measure :: "('a::type => nat) => 'a::type => 'a::type => bool"
defs
measure_primdef: "prim_rec.measure == relation.inv_image op <"
@@ -1013,10 +1289,11 @@
lemma measure_def: "prim_rec.measure = relation.inv_image op <"
by (import prim_rec measure_def)
-lemma WF_measure: "ALL x. WF (prim_rec.measure x)"
+lemma WF_measure: "ALL x::'a::type => nat. WF (prim_rec.measure x)"
by (import prim_rec WF_measure)
-lemma measure_thm: "ALL x xa xb. prim_rec.measure x xa xb = (x xa < x xb)"
+lemma measure_thm: "ALL (x::'a::type => nat) (xa::'a::type) xb::'a::type.
+ prim_rec.measure x xa xb = (x xa < x xb)"
by (import prim_rec measure_thm)
;end_setup
@@ -1025,33 +1302,36 @@
constdefs
nat_elim__magic :: "nat => nat"
- "nat_elim__magic == %n. n"
-
-lemma nat_elim__magic: "ALL n. nat_elim__magic n = n"
+ "nat_elim__magic == %n::nat. n"
+
+lemma nat_elim__magic: "ALL n::nat. nat_elim__magic n = n"
by (import arithmetic nat_elim__magic)
consts
EVEN :: "nat => bool"
-specification (EVEN) EVEN: "EVEN 0 = True & (ALL n. EVEN (Suc n) = (~ EVEN n))"
+specification (EVEN) EVEN: "EVEN (0::nat) = True & (ALL n::nat. EVEN (Suc n) = (~ EVEN n))"
by (import arithmetic EVEN)
consts
ODD :: "nat => bool"
-specification (ODD) ODD: "ODD 0 = False & (ALL n. ODD (Suc n) = (~ ODD n))"
+specification (ODD) ODD: "ODD (0::nat) = False & (ALL n::nat. ODD (Suc n) = (~ ODD n))"
by (import arithmetic ODD)
-lemma TWO: "2 = Suc 1"
+lemma TWO: "(2::nat) = Suc (1::nat)"
by (import arithmetic TWO)
lemma NORM_0: "(0::nat) = (0::nat)"
by (import arithmetic NORM_0)
-lemma num_case_compute: "ALL n. nat_case f g n = (if n = 0 then f else g (PRE n))"
+lemma num_case_compute: "ALL n::nat.
+ nat_case (f::'a::type) (g::nat => 'a::type) n =
+ (if n = (0::nat) then f else g (PRE n))"
by (import arithmetic num_case_compute)
-lemma ADD_CLAUSES: "0 + m = m & m + 0 = m & Suc m + n = Suc (m + n) & m + Suc n = Suc (m + n)"
+lemma ADD_CLAUSES: "(0::nat) + (m::nat) = m &
+m + (0::nat) = m & Suc m + (n::nat) = Suc (m + n) & m + Suc n = Suc (m + n)"
by (import arithmetic ADD_CLAUSES)
lemma LESS_ADD: "ALL (m::nat) n::nat. n < m --> (EX p::nat. p + n = m)"
@@ -1060,13 +1340,14 @@
lemma LESS_ANTISYM: "ALL (m::nat) n::nat. ~ (m < n & n < m)"
by (import arithmetic LESS_ANTISYM)
-lemma LESS_LESS_SUC: "ALL x xa. ~ (x < xa & xa < Suc x)"
+lemma LESS_LESS_SUC: "ALL (x::nat) xa::nat. ~ (x < xa & xa < Suc x)"
by (import arithmetic LESS_LESS_SUC)
-lemma FUN_EQ_LEMMA: "ALL f x1 x2. f x1 & ~ f x2 --> x1 ~= x2"
+lemma FUN_EQ_LEMMA: "ALL (f::'a::type => bool) (x1::'a::type) x2::'a::type.
+ f x1 & ~ f x2 --> x1 ~= x2"
by (import arithmetic FUN_EQ_LEMMA)
-lemma LESS_NOT_SUC: "ALL m n. m < n & n ~= Suc m --> Suc m < n"
+lemma LESS_NOT_SUC: "ALL (m::nat) n::nat. m < n & n ~= Suc m --> Suc m < n"
by (import arithmetic LESS_NOT_SUC)
lemma LESS_0_CASES: "ALL m::nat. (0::nat) = m | (0::nat) < m"
@@ -1078,7 +1359,7 @@
lemma LESS_CASES: "ALL (m::nat) n::nat. m < n | n <= m"
by (import arithmetic LESS_CASES)
-lemma LESS_EQ_SUC_REFL: "ALL m. m <= Suc m"
+lemma LESS_EQ_SUC_REFL: "ALL m::nat. m <= Suc m"
by (import arithmetic LESS_EQ_SUC_REFL)
lemma LESS_ADD_NONZERO: "ALL (m::nat) n::nat. n ~= (0::nat) --> m < m + n"
@@ -1090,20 +1371,20 @@
lemma SUB_0: "ALL m::nat. (0::nat) - m = (0::nat) & m - (0::nat) = m"
by (import arithmetic SUB_0)
-lemma SUC_SUB1: "ALL m. Suc m - 1 = m"
+lemma SUC_SUB1: "ALL m::nat. Suc m - (1::nat) = m"
by (import arithmetic SUC_SUB1)
-lemma PRE_SUB1: "ALL m. PRE m = m - 1"
+lemma PRE_SUB1: "ALL m::nat. PRE m = m - (1::nat)"
by (import arithmetic PRE_SUB1)
-lemma MULT_CLAUSES: "ALL x xa.
- 0 * x = 0 &
- x * 0 = 0 &
- 1 * x = x &
- x * 1 = x & Suc x * xa = x * xa + xa & x * Suc xa = x + x * xa"
+lemma MULT_CLAUSES: "ALL (x::nat) xa::nat.
+ (0::nat) * x = (0::nat) &
+ x * (0::nat) = (0::nat) &
+ (1::nat) * x = x &
+ x * (1::nat) = x & Suc x * xa = x * xa + xa & x * Suc xa = x + x * xa"
by (import arithmetic MULT_CLAUSES)
-lemma PRE_SUB: "ALL m n. PRE (m - n) = PRE m - n"
+lemma PRE_SUB: "ALL (m::nat) n::nat. PRE (m - n) = PRE m - n"
by (import arithmetic PRE_SUB)
lemma ADD_EQ_1: "ALL (m::nat) n::nat.
@@ -1114,13 +1395,14 @@
lemma ADD_INV_0_EQ: "ALL (m::nat) n::nat. (m + n = m) = (n = (0::nat))"
by (import arithmetic ADD_INV_0_EQ)
-lemma PRE_SUC_EQ: "ALL m n. 0 < n --> (m = PRE n) = (Suc m = n)"
+lemma PRE_SUC_EQ: "ALL (m::nat) n::nat. (0::nat) < n --> (m = PRE n) = (Suc m = n)"
by (import arithmetic PRE_SUC_EQ)
-lemma INV_PRE_EQ: "ALL m n. 0 < m & 0 < n --> (PRE m = PRE n) = (m = n)"
+lemma INV_PRE_EQ: "ALL (m::nat) n::nat.
+ (0::nat) < m & (0::nat) < n --> (PRE m = PRE n) = (m = n)"
by (import arithmetic INV_PRE_EQ)
-lemma LESS_SUC_NOT: "ALL m n. m < n --> ~ n < Suc m"
+lemma LESS_SUC_NOT: "ALL (m::nat) n::nat. m < n --> ~ n < Suc m"
by (import arithmetic LESS_SUC_NOT)
lemma ADD_EQ_SUB: "ALL (m::nat) (n::nat) p::nat. n <= p --> (m + n = p) = (m = p - n)"
@@ -1129,16 +1411,17 @@
lemma LESS_ADD_1: "ALL (x::nat) xa::nat. xa < x --> (EX xb::nat. x = xa + (xb + (1::nat)))"
by (import arithmetic LESS_ADD_1)
-lemma NOT_ODD_EQ_EVEN: "ALL n m. Suc (n + n) ~= m + m"
+lemma NOT_ODD_EQ_EVEN: "ALL (n::nat) m::nat. Suc (n + n) ~= m + m"
by (import arithmetic NOT_ODD_EQ_EVEN)
-lemma MULT_SUC_EQ: "ALL p m n. (n * Suc p = m * Suc p) = (n = m)"
+lemma MULT_SUC_EQ: "ALL (p::nat) (m::nat) n::nat. (n * Suc p = m * Suc p) = (n = m)"
by (import arithmetic MULT_SUC_EQ)
-lemma MULT_EXP_MONO: "ALL p q n m. (n * Suc q ^ p = m * Suc q ^ p) = (n = m)"
+lemma MULT_EXP_MONO: "ALL (p::nat) (q::nat) (n::nat) m::nat.
+ (n * Suc q ^ p = m * Suc q ^ p) = (n = m)"
by (import arithmetic MULT_EXP_MONO)
-lemma LESS_ADD_SUC: "ALL m n. m < m + Suc n"
+lemma LESS_ADD_SUC: "ALL (m::nat) n::nat. m < m + Suc n"
by (import arithmetic LESS_ADD_SUC)
lemma LESS_OR_EQ_ADD: "ALL (n::nat) m::nat. n < m | (EX p::nat. n = p + m)"
@@ -1157,10 +1440,10 @@
((Not::bool => bool) (P m)))))))"
by (import arithmetic WOP)
-lemma INV_PRE_LESS: "ALL m>0. ALL n. (PRE m < PRE n) = (m < n)"
+lemma INV_PRE_LESS: "ALL m>0::nat. ALL n::nat. (PRE m < PRE n) = (m < n)"
by (import arithmetic INV_PRE_LESS)
-lemma INV_PRE_LESS_EQ: "ALL n>0. ALL m. (PRE m <= PRE n) = (m <= n)"
+lemma INV_PRE_LESS_EQ: "ALL n>0::nat. ALL m::nat. (PRE m <= PRE n) = (m <= n)"
by (import arithmetic INV_PRE_LESS_EQ)
lemma SUB_EQ_EQ_0: "ALL (m::nat) n::nat. (m - n = m) = (m = (0::nat) | n = (0::nat))"
@@ -1175,7 +1458,7 @@
lemma LESS_EQ_SUB_LESS: "ALL (x::nat) xa::nat. xa <= x --> (ALL c::nat. (x - xa < c) = (x < xa + c))"
by (import arithmetic LESS_EQ_SUB_LESS)
-lemma NOT_SUC_LESS_EQ: "ALL x xa. (~ Suc x <= xa) = (xa <= x)"
+lemma NOT_SUC_LESS_EQ: "ALL (x::nat) xa::nat. (~ Suc x <= xa) = (xa <= x)"
by (import arithmetic NOT_SUC_LESS_EQ)
lemma SUB_LESS_EQ_ADD: "ALL (m::nat) p::nat. m <= p --> (ALL n::nat. (p - m <= n) = (p <= m + n))"
@@ -1185,16 +1468,18 @@
xa <= x & xb <= x --> (x - xa = x - xb) = (xa = xb)"
by (import arithmetic SUB_CANCEL)
-lemma NOT_EXP_0: "ALL m n. Suc n ^ m ~= 0"
+lemma NOT_EXP_0: "ALL (m::nat) n::nat. Suc n ^ m ~= (0::nat)"
by (import arithmetic NOT_EXP_0)
-lemma ZERO_LESS_EXP: "ALL m n. 0 < Suc n ^ m"
+lemma ZERO_LESS_EXP: "ALL (m::nat) n::nat. (0::nat) < Suc n ^ m"
by (import arithmetic ZERO_LESS_EXP)
-lemma ODD_OR_EVEN: "ALL x. EX xa. x = Suc (Suc 0) * xa | x = Suc (Suc 0) * xa + 1"
+lemma ODD_OR_EVEN: "ALL x::nat.
+ EX xa::nat.
+ x = Suc (Suc (0::nat)) * xa | x = Suc (Suc (0::nat)) * xa + (1::nat)"
by (import arithmetic ODD_OR_EVEN)
-lemma LESS_EXP_SUC_MONO: "ALL n m. Suc (Suc m) ^ n < Suc (Suc m) ^ Suc n"
+lemma LESS_EXP_SUC_MONO: "ALL (n::nat) m::nat. Suc (Suc m) ^ n < Suc (Suc m) ^ Suc n"
by (import arithmetic LESS_EXP_SUC_MONO)
lemma LESS_LESS_CASES: "ALL (m::nat) n::nat. m = n | m < n | n < m"
@@ -1212,67 +1497,69 @@
consts
FACT :: "nat => nat"
-specification (FACT) FACT: "FACT 0 = 1 & (ALL n. FACT (Suc n) = Suc n * FACT n)"
+specification (FACT) FACT: "FACT (0::nat) = (1::nat) & (ALL n::nat. FACT (Suc n) = Suc n * FACT n)"
by (import arithmetic FACT)
-lemma FACT_LESS: "ALL n. 0 < FACT n"
+lemma FACT_LESS: "ALL n::nat. (0::nat) < FACT n"
by (import arithmetic FACT_LESS)
-lemma EVEN_ODD: "ALL n. EVEN n = (~ ODD n)"
+lemma EVEN_ODD: "ALL n::nat. EVEN n = (~ ODD n)"
by (import arithmetic EVEN_ODD)
-lemma ODD_EVEN: "ALL x. ODD x = (~ EVEN x)"
+lemma ODD_EVEN: "ALL x::nat. ODD x = (~ EVEN x)"
by (import arithmetic ODD_EVEN)
-lemma EVEN_OR_ODD: "ALL x. EVEN x | ODD x"
+lemma EVEN_OR_ODD: "ALL x::nat. EVEN x | ODD x"
by (import arithmetic EVEN_OR_ODD)
-lemma EVEN_AND_ODD: "ALL x. ~ (EVEN x & ODD x)"
+lemma EVEN_AND_ODD: "ALL x::nat. ~ (EVEN x & ODD x)"
by (import arithmetic EVEN_AND_ODD)
-lemma EVEN_ADD: "ALL m n. EVEN (m + n) = (EVEN m = EVEN n)"
+lemma EVEN_ADD: "ALL (m::nat) n::nat. EVEN (m + n) = (EVEN m = EVEN n)"
by (import arithmetic EVEN_ADD)
-lemma EVEN_MULT: "ALL m n. EVEN (m * n) = (EVEN m | EVEN n)"
+lemma EVEN_MULT: "ALL (m::nat) n::nat. EVEN (m * n) = (EVEN m | EVEN n)"
by (import arithmetic EVEN_MULT)
-lemma ODD_ADD: "ALL m n. ODD (m + n) = (ODD m ~= ODD n)"
+lemma ODD_ADD: "ALL (m::nat) n::nat. ODD (m + n) = (ODD m ~= ODD n)"
by (import arithmetic ODD_ADD)
-lemma ODD_MULT: "ALL m n. ODD (m * n) = (ODD m & ODD n)"
+lemma ODD_MULT: "ALL (m::nat) n::nat. ODD (m * n) = (ODD m & ODD n)"
by (import arithmetic ODD_MULT)
-lemma EVEN_DOUBLE: "ALL n. EVEN (2 * n)"
+lemma EVEN_DOUBLE: "ALL n::nat. EVEN ((2::nat) * n)"
by (import arithmetic EVEN_DOUBLE)
-lemma ODD_DOUBLE: "ALL x. ODD (Suc (2 * x))"
+lemma ODD_DOUBLE: "ALL x::nat. ODD (Suc ((2::nat) * x))"
by (import arithmetic ODD_DOUBLE)
-lemma EVEN_ODD_EXISTS: "ALL x. (EVEN x --> (EX m. x = 2 * m)) & (ODD x --> (EX m. x = Suc (2 * m)))"
+lemma EVEN_ODD_EXISTS: "ALL x::nat.
+ (EVEN x --> (EX m::nat. x = (2::nat) * m)) &
+ (ODD x --> (EX m::nat. x = Suc ((2::nat) * m)))"
by (import arithmetic EVEN_ODD_EXISTS)
-lemma EVEN_EXISTS: "ALL n. EVEN n = (EX m. n = 2 * m)"
+lemma EVEN_EXISTS: "ALL n::nat. EVEN n = (EX m::nat. n = (2::nat) * m)"
by (import arithmetic EVEN_EXISTS)
-lemma ODD_EXISTS: "ALL n. ODD n = (EX m. n = Suc (2 * m))"
+lemma ODD_EXISTS: "ALL n::nat. ODD n = (EX m::nat. n = Suc ((2::nat) * m))"
by (import arithmetic ODD_EXISTS)
-lemma NOT_SUC_LESS_EQ_0: "ALL x. ~ Suc x <= 0"
+lemma NOT_SUC_LESS_EQ_0: "ALL x::nat. ~ Suc x <= (0::nat)"
by (import arithmetic NOT_SUC_LESS_EQ_0)
-lemma NOT_LEQ: "ALL x xa. (~ x <= xa) = (Suc xa <= x)"
+lemma NOT_LEQ: "ALL (x::nat) xa::nat. (~ x <= xa) = (Suc xa <= x)"
by (import arithmetic NOT_LEQ)
-lemma NOT_NUM_EQ: "ALL x xa. (x ~= xa) = (Suc x <= xa | Suc xa <= x)"
+lemma NOT_NUM_EQ: "ALL (x::nat) xa::nat. (x ~= xa) = (Suc x <= xa | Suc xa <= x)"
by (import arithmetic NOT_NUM_EQ)
-lemma NOT_GREATER_EQ: "ALL x xa. (~ xa <= x) = (Suc x <= xa)"
+lemma NOT_GREATER_EQ: "ALL (x::nat) xa::nat. (~ xa <= x) = (Suc x <= xa)"
by (import arithmetic NOT_GREATER_EQ)
-lemma SUC_ADD_SYM: "ALL m n. Suc (m + n) = Suc n + m"
+lemma SUC_ADD_SYM: "ALL (m::nat) n::nat. Suc (m + n) = Suc n + m"
by (import arithmetic SUC_ADD_SYM)
-lemma NOT_SUC_ADD_LESS_EQ: "ALL m n. ~ Suc (m + n) <= m"
+lemma NOT_SUC_ADD_LESS_EQ: "ALL (m::nat) n::nat. ~ Suc (m + n) <= m"
by (import arithmetic NOT_SUC_ADD_LESS_EQ)
lemma SUB_LEFT_ADD: "ALL (m::nat) (n::nat) p::nat.
@@ -1286,7 +1573,8 @@
m - (n - p) = (if n <= p then m else m + p - n)"
by (import arithmetic SUB_LEFT_SUB)
-lemma SUB_LEFT_SUC: "ALL m n. Suc (m - n) = (if m <= n then Suc 0 else Suc m - n)"
+lemma SUB_LEFT_SUC: "ALL (m::nat) n::nat.
+ Suc (m - n) = (if m <= n then Suc (0::nat) else Suc m - n)"
by (import arithmetic SUB_LEFT_SUC)
lemma SUB_LEFT_LESS_EQ: "ALL (m::nat) (n::nat) p::nat. (m <= n - p) = (m + p <= n | m <= (0::nat))"
@@ -1391,22 +1679,26 @@
(0::nat) < n & (0::nat) < q --> n * (p mod q) = n * p mod (n * q)"
by (import arithmetic MOD_COMMON_FACTOR)
-lemma num_case_cong: "ALL M M' b f.
- M = M' & (M' = 0 --> b = b') & (ALL n. M' = Suc n --> f n = f' n) -->
+lemma num_case_cong: "ALL (M::nat) (M'::nat) (b::'a::type) f::nat => 'a::type.
+ M = M' &
+ (M' = (0::nat) --> b = (b'::'a::type)) &
+ (ALL n::nat. M' = Suc n --> f n = (f'::nat => 'a::type) n) -->
nat_case b f M = nat_case b' f' M'"
by (import arithmetic num_case_cong)
-lemma SUC_ELIM_THM: "ALL P. (ALL n. P (Suc n) n) = (ALL n>0. P n (n - 1))"
+lemma SUC_ELIM_THM: "ALL P::nat => nat => bool.
+ (ALL n::nat. P (Suc n) n) = (ALL n>0::nat. P n (n - (1::nat)))"
by (import arithmetic SUC_ELIM_THM)
lemma SUB_ELIM_THM: "(P::nat => bool) ((a::nat) - (b::nat)) =
(ALL x::nat. (b = a + x --> P (0::nat)) & (a = b + x --> P x))"
by (import arithmetic SUB_ELIM_THM)
-lemma PRE_ELIM_THM: "P (PRE n) = (ALL m. (n = 0 --> P 0) & (n = Suc m --> P m))"
+lemma PRE_ELIM_THM: "(P::nat => bool) (PRE (n::nat)) =
+(ALL m::nat. (n = (0::nat) --> P (0::nat)) & (n = Suc m --> P m))"
by (import arithmetic PRE_ELIM_THM)
-lemma MULT_INCREASES: "ALL m n. 1 < m & 0 < n --> Suc n <= m * n"
+lemma MULT_INCREASES: "ALL (m::nat) n::nat. (1::nat) < m & (0::nat) < n --> Suc n <= m * n"
by (import arithmetic MULT_INCREASES)
lemma EXP_ALWAYS_BIG_ENOUGH: "ALL b>1::nat. ALL n::nat. EX m::nat. n <= b ^ m"
@@ -1466,133 +1758,146 @@
constdefs
trat_1 :: "nat * nat"
- "trat_1 == (0, 0)"
-
-lemma trat_1: "trat_1 = (0, 0)"
+ "trat_1 == (0::nat, 0::nat)"
+
+lemma trat_1: "trat_1 = (0::nat, 0::nat)"
by (import hrat trat_1)
constdefs
trat_inv :: "nat * nat => nat * nat"
- "trat_inv == %(x, y). (y, x)"
-
-lemma trat_inv: "ALL x y. trat_inv (x, y) = (y, x)"
+ "trat_inv == %(x::nat, y::nat). (y, x)"
+
+lemma trat_inv: "ALL (x::nat) y::nat. trat_inv (x, y) = (y, x)"
by (import hrat trat_inv)
constdefs
trat_add :: "nat * nat => nat * nat => nat * nat"
"trat_add ==
-%(x, y) (x', y').
+%(x::nat, y::nat) (x'::nat, y'::nat).
(PRE (Suc x * Suc y' + Suc x' * Suc y), PRE (Suc y * Suc y'))"
-lemma trat_add: "ALL x y x' y'.
+lemma trat_add: "ALL (x::nat) (y::nat) (x'::nat) y'::nat.
trat_add (x, y) (x', y') =
(PRE (Suc x * Suc y' + Suc x' * Suc y), PRE (Suc y * Suc y'))"
by (import hrat trat_add)
constdefs
trat_mul :: "nat * nat => nat * nat => nat * nat"
- "trat_mul == %(x, y) (x', y'). (PRE (Suc x * Suc x'), PRE (Suc y * Suc y'))"
-
-lemma trat_mul: "ALL x y x' y'.
+ "trat_mul ==
+%(x::nat, y::nat) (x'::nat, y'::nat).
+ (PRE (Suc x * Suc x'), PRE (Suc y * Suc y'))"
+
+lemma trat_mul: "ALL (x::nat) (y::nat) (x'::nat) y'::nat.
trat_mul (x, y) (x', y') = (PRE (Suc x * Suc x'), PRE (Suc y * Suc y'))"
by (import hrat trat_mul)
consts
trat_sucint :: "nat => nat * nat"
-specification (trat_sucint) trat_sucint: "trat_sucint 0 = trat_1 &
-(ALL n. trat_sucint (Suc n) = trat_add (trat_sucint n) trat_1)"
+specification (trat_sucint) trat_sucint: "trat_sucint (0::nat) = trat_1 &
+(ALL n::nat. trat_sucint (Suc n) = trat_add (trat_sucint n) trat_1)"
by (import hrat trat_sucint)
constdefs
trat_eq :: "nat * nat => nat * nat => bool"
- "trat_eq == %(x, y) (x', y'). Suc x * Suc y' = Suc x' * Suc y"
-
-lemma trat_eq: "ALL x y x' y'. trat_eq (x, y) (x', y') = (Suc x * Suc y' = Suc x' * Suc y)"
+ "trat_eq ==
+%(x::nat, y::nat) (x'::nat, y'::nat). Suc x * Suc y' = Suc x' * Suc y"
+
+lemma trat_eq: "ALL (x::nat) (y::nat) (x'::nat) y'::nat.
+ trat_eq (x, y) (x', y') = (Suc x * Suc y' = Suc x' * Suc y)"
by (import hrat trat_eq)
-lemma TRAT_EQ_REFL: "ALL p. trat_eq p p"
+lemma TRAT_EQ_REFL: "ALL p::nat * nat. trat_eq p p"
by (import hrat TRAT_EQ_REFL)
-lemma TRAT_EQ_SYM: "ALL p q. trat_eq p q = trat_eq q p"
+lemma TRAT_EQ_SYM: "ALL (p::nat * nat) q::nat * nat. trat_eq p q = trat_eq q p"
by (import hrat TRAT_EQ_SYM)
-lemma TRAT_EQ_TRANS: "ALL p q r. trat_eq p q & trat_eq q r --> trat_eq p r"
+lemma TRAT_EQ_TRANS: "ALL (p::nat * nat) (q::nat * nat) r::nat * nat.
+ trat_eq p q & trat_eq q r --> trat_eq p r"
by (import hrat TRAT_EQ_TRANS)
-lemma TRAT_EQ_AP: "ALL p q. p = q --> trat_eq p q"
+lemma TRAT_EQ_AP: "ALL (p::nat * nat) q::nat * nat. p = q --> trat_eq p q"
by (import hrat TRAT_EQ_AP)
-lemma TRAT_ADD_SYM_EQ: "ALL h i. trat_add h i = trat_add i h"
+lemma TRAT_ADD_SYM_EQ: "ALL (h::nat * nat) i::nat * nat. trat_add h i = trat_add i h"
by (import hrat TRAT_ADD_SYM_EQ)
-lemma TRAT_MUL_SYM_EQ: "ALL h i. trat_mul h i = trat_mul i h"
+lemma TRAT_MUL_SYM_EQ: "ALL (h::nat * nat) i::nat * nat. trat_mul h i = trat_mul i h"
by (import hrat TRAT_MUL_SYM_EQ)
-lemma TRAT_INV_WELLDEFINED: "ALL p q. trat_eq p q --> trat_eq (trat_inv p) (trat_inv q)"
+lemma TRAT_INV_WELLDEFINED: "ALL (p::nat * nat) q::nat * nat.
+ trat_eq p q --> trat_eq (trat_inv p) (trat_inv q)"
by (import hrat TRAT_INV_WELLDEFINED)
-lemma TRAT_ADD_WELLDEFINED: "ALL p q r. trat_eq p q --> trat_eq (trat_add p r) (trat_add q r)"
+lemma TRAT_ADD_WELLDEFINED: "ALL (p::nat * nat) (q::nat * nat) r::nat * nat.
+ trat_eq p q --> trat_eq (trat_add p r) (trat_add q r)"
by (import hrat TRAT_ADD_WELLDEFINED)
-lemma TRAT_ADD_WELLDEFINED2: "ALL p1 p2 q1 q2.
+lemma TRAT_ADD_WELLDEFINED2: "ALL (p1::nat * nat) (p2::nat * nat) (q1::nat * nat) q2::nat * nat.
trat_eq p1 p2 & trat_eq q1 q2 -->
trat_eq (trat_add p1 q1) (trat_add p2 q2)"
by (import hrat TRAT_ADD_WELLDEFINED2)
-lemma TRAT_MUL_WELLDEFINED: "ALL p q r. trat_eq p q --> trat_eq (trat_mul p r) (trat_mul q r)"
+lemma TRAT_MUL_WELLDEFINED: "ALL (p::nat * nat) (q::nat * nat) r::nat * nat.
+ trat_eq p q --> trat_eq (trat_mul p r) (trat_mul q r)"
by (import hrat TRAT_MUL_WELLDEFINED)
-lemma TRAT_MUL_WELLDEFINED2: "ALL p1 p2 q1 q2.
+lemma TRAT_MUL_WELLDEFINED2: "ALL (p1::nat * nat) (p2::nat * nat) (q1::nat * nat) q2::nat * nat.
trat_eq p1 p2 & trat_eq q1 q2 -->
trat_eq (trat_mul p1 q1) (trat_mul p2 q2)"
by (import hrat TRAT_MUL_WELLDEFINED2)
-lemma TRAT_ADD_SYM: "ALL h i. trat_eq (trat_add h i) (trat_add i h)"
+lemma TRAT_ADD_SYM: "ALL (h::nat * nat) i::nat * nat. trat_eq (trat_add h i) (trat_add i h)"
by (import hrat TRAT_ADD_SYM)
-lemma TRAT_ADD_ASSOC: "ALL h i j. trat_eq (trat_add h (trat_add i j)) (trat_add (trat_add h i) j)"
+lemma TRAT_ADD_ASSOC: "ALL (h::nat * nat) (i::nat * nat) j::nat * nat.
+ trat_eq (trat_add h (trat_add i j)) (trat_add (trat_add h i) j)"
by (import hrat TRAT_ADD_ASSOC)
-lemma TRAT_MUL_SYM: "ALL h i. trat_eq (trat_mul h i) (trat_mul i h)"
+lemma TRAT_MUL_SYM: "ALL (h::nat * nat) i::nat * nat. trat_eq (trat_mul h i) (trat_mul i h)"
by (import hrat TRAT_MUL_SYM)
-lemma TRAT_MUL_ASSOC: "ALL h i j. trat_eq (trat_mul h (trat_mul i j)) (trat_mul (trat_mul h i) j)"
+lemma TRAT_MUL_ASSOC: "ALL (h::nat * nat) (i::nat * nat) j::nat * nat.
+ trat_eq (trat_mul h (trat_mul i j)) (trat_mul (trat_mul h i) j)"
by (import hrat TRAT_MUL_ASSOC)
-lemma TRAT_LDISTRIB: "ALL h i j.
+lemma TRAT_LDISTRIB: "ALL (h::nat * nat) (i::nat * nat) j::nat * nat.
trat_eq (trat_mul h (trat_add i j))
(trat_add (trat_mul h i) (trat_mul h j))"
by (import hrat TRAT_LDISTRIB)
-lemma TRAT_MUL_LID: "ALL h. trat_eq (trat_mul trat_1 h) h"
+lemma TRAT_MUL_LID: "ALL h::nat * nat. trat_eq (trat_mul trat_1 h) h"
by (import hrat TRAT_MUL_LID)
-lemma TRAT_MUL_LINV: "ALL h. trat_eq (trat_mul (trat_inv h) h) trat_1"
+lemma TRAT_MUL_LINV: "ALL h::nat * nat. trat_eq (trat_mul (trat_inv h) h) trat_1"
by (import hrat TRAT_MUL_LINV)
-lemma TRAT_NOZERO: "ALL h i. ~ trat_eq (trat_add h i) h"
+lemma TRAT_NOZERO: "ALL (h::nat * nat) i::nat * nat. ~ trat_eq (trat_add h i) h"
by (import hrat TRAT_NOZERO)
-lemma TRAT_ADD_TOTAL: "ALL h i.
+lemma TRAT_ADD_TOTAL: "ALL (h::nat * nat) i::nat * nat.
trat_eq h i |
- (EX d. trat_eq h (trat_add i d)) | (EX d. trat_eq i (trat_add h d))"
+ (EX d::nat * nat. trat_eq h (trat_add i d)) |
+ (EX d::nat * nat. trat_eq i (trat_add h d))"
by (import hrat TRAT_ADD_TOTAL)
-lemma TRAT_SUCINT_0: "ALL n. trat_eq (trat_sucint n) (n, 0)"
+lemma TRAT_SUCINT_0: "ALL n::nat. trat_eq (trat_sucint n) (n, 0::nat)"
by (import hrat TRAT_SUCINT_0)
-lemma TRAT_ARCH: "ALL h. EX n d. trat_eq (trat_sucint n) (trat_add h d)"
+lemma TRAT_ARCH: "ALL h::nat * nat.
+ EX (n::nat) d::nat * nat. trat_eq (trat_sucint n) (trat_add h d)"
by (import hrat TRAT_ARCH)
-lemma TRAT_SUCINT: "trat_eq (trat_sucint 0) trat_1 &
-(ALL n. trat_eq (trat_sucint (Suc n)) (trat_add (trat_sucint n) trat_1))"
+lemma TRAT_SUCINT: "trat_eq (trat_sucint (0::nat)) trat_1 &
+(ALL n::nat.
+ trat_eq (trat_sucint (Suc n)) (trat_add (trat_sucint n) trat_1))"
by (import hrat TRAT_SUCINT)
-lemma TRAT_EQ_EQUIV: "ALL p q. trat_eq p q = (trat_eq p = trat_eq q)"
+lemma TRAT_EQ_EQUIV: "ALL (p::nat * nat) q::nat * nat. trat_eq p q = (trat_eq p = trat_eq q)"
by (import hrat TRAT_EQ_EQUIV)
-typedef (open) hrat = "{x. EX xa. x = trat_eq xa}"
+typedef (open) hrat = "{x::nat * nat => bool. EX xa::nat * nat. x = trat_eq xa}"
by (rule typedef_helper,import hrat hrat_TY_DEF)
lemmas hrat_TY_DEF = typedef_hol2hol4 [OF type_definition_hrat]
@@ -1601,8 +1906,9 @@
mk_hrat :: "(nat * nat => bool) => hrat"
dest_hrat :: "hrat => nat * nat => bool"
-specification (dest_hrat mk_hrat) hrat_tybij: "(ALL a. mk_hrat (dest_hrat a) = a) &
-(ALL r. (EX x. r = trat_eq x) = (dest_hrat (mk_hrat r) = r))"
+specification (dest_hrat mk_hrat) hrat_tybij: "(ALL a::hrat. mk_hrat (dest_hrat a) = a) &
+(ALL r::nat * nat => bool.
+ (EX x::nat * nat. r = trat_eq x) = (dest_hrat (mk_hrat r) = r))"
by (import hrat hrat_tybij)
constdefs
@@ -1614,18 +1920,19 @@
constdefs
hrat_inv :: "hrat => hrat"
- "hrat_inv == %T1. mk_hrat (trat_eq (trat_inv (Eps (dest_hrat T1))))"
-
-lemma hrat_inv: "ALL T1. hrat_inv T1 = mk_hrat (trat_eq (trat_inv (Eps (dest_hrat T1))))"
+ "hrat_inv == %T1::hrat. mk_hrat (trat_eq (trat_inv (Eps (dest_hrat T1))))"
+
+lemma hrat_inv: "ALL T1::hrat.
+ hrat_inv T1 = mk_hrat (trat_eq (trat_inv (Eps (dest_hrat T1))))"
by (import hrat hrat_inv)
constdefs
hrat_add :: "hrat => hrat => hrat"
"hrat_add ==
-%T1 T2.
+%(T1::hrat) T2::hrat.
mk_hrat (trat_eq (trat_add (Eps (dest_hrat T1)) (Eps (dest_hrat T2))))"
-lemma hrat_add: "ALL T1 T2.
+lemma hrat_add: "ALL (T1::hrat) T2::hrat.
hrat_add T1 T2 =
mk_hrat (trat_eq (trat_add (Eps (dest_hrat T1)) (Eps (dest_hrat T2))))"
by (import hrat hrat_add)
@@ -1633,54 +1940,57 @@
constdefs
hrat_mul :: "hrat => hrat => hrat"
"hrat_mul ==
-%T1 T2.
+%(T1::hrat) T2::hrat.
mk_hrat (trat_eq (trat_mul (Eps (dest_hrat T1)) (Eps (dest_hrat T2))))"
-lemma hrat_mul: "ALL T1 T2.
+lemma hrat_mul: "ALL (T1::hrat) T2::hrat.
hrat_mul T1 T2 =
mk_hrat (trat_eq (trat_mul (Eps (dest_hrat T1)) (Eps (dest_hrat T2))))"
by (import hrat hrat_mul)
constdefs
hrat_sucint :: "nat => hrat"
- "hrat_sucint == %T1. mk_hrat (trat_eq (trat_sucint T1))"
-
-lemma hrat_sucint: "ALL T1. hrat_sucint T1 = mk_hrat (trat_eq (trat_sucint T1))"
+ "hrat_sucint == %T1::nat. mk_hrat (trat_eq (trat_sucint T1))"
+
+lemma hrat_sucint: "ALL T1::nat. hrat_sucint T1 = mk_hrat (trat_eq (trat_sucint T1))"
by (import hrat hrat_sucint)
-lemma HRAT_ADD_SYM: "ALL h i. hrat_add h i = hrat_add i h"
+lemma HRAT_ADD_SYM: "ALL (h::hrat) i::hrat. hrat_add h i = hrat_add i h"
by (import hrat HRAT_ADD_SYM)
-lemma HRAT_ADD_ASSOC: "ALL h i j. hrat_add h (hrat_add i j) = hrat_add (hrat_add h i) j"
+lemma HRAT_ADD_ASSOC: "ALL (h::hrat) (i::hrat) j::hrat.
+ hrat_add h (hrat_add i j) = hrat_add (hrat_add h i) j"
by (import hrat HRAT_ADD_ASSOC)
-lemma HRAT_MUL_SYM: "ALL h i. hrat_mul h i = hrat_mul i h"
+lemma HRAT_MUL_SYM: "ALL (h::hrat) i::hrat. hrat_mul h i = hrat_mul i h"
by (import hrat HRAT_MUL_SYM)
-lemma HRAT_MUL_ASSOC: "ALL h i j. hrat_mul h (hrat_mul i j) = hrat_mul (hrat_mul h i) j"
+lemma HRAT_MUL_ASSOC: "ALL (h::hrat) (i::hrat) j::hrat.
+ hrat_mul h (hrat_mul i j) = hrat_mul (hrat_mul h i) j"
by (import hrat HRAT_MUL_ASSOC)
-lemma HRAT_LDISTRIB: "ALL h i j.
+lemma HRAT_LDISTRIB: "ALL (h::hrat) (i::hrat) j::hrat.
hrat_mul h (hrat_add i j) = hrat_add (hrat_mul h i) (hrat_mul h j)"
by (import hrat HRAT_LDISTRIB)
-lemma HRAT_MUL_LID: "ALL h. hrat_mul hrat_1 h = h"
+lemma HRAT_MUL_LID: "ALL h::hrat. hrat_mul hrat_1 h = h"
by (import hrat HRAT_MUL_LID)
-lemma HRAT_MUL_LINV: "ALL h. hrat_mul (hrat_inv h) h = hrat_1"
+lemma HRAT_MUL_LINV: "ALL h::hrat. hrat_mul (hrat_inv h) h = hrat_1"
by (import hrat HRAT_MUL_LINV)
-lemma HRAT_NOZERO: "ALL h i. hrat_add h i ~= h"
+lemma HRAT_NOZERO: "ALL (h::hrat) i::hrat. hrat_add h i ~= h"
by (import hrat HRAT_NOZERO)
-lemma HRAT_ADD_TOTAL: "ALL h i. h = i | (EX x. h = hrat_add i x) | (EX x. i = hrat_add h x)"
+lemma HRAT_ADD_TOTAL: "ALL (h::hrat) i::hrat.
+ h = i | (EX x::hrat. h = hrat_add i x) | (EX x::hrat. i = hrat_add h x)"
by (import hrat HRAT_ADD_TOTAL)
-lemma HRAT_ARCH: "ALL h. EX x xa. hrat_sucint x = hrat_add h xa"
+lemma HRAT_ARCH: "ALL h::hrat. EX (x::nat) xa::hrat. hrat_sucint x = hrat_add h xa"
by (import hrat HRAT_ARCH)
-lemma HRAT_SUCINT: "hrat_sucint 0 = hrat_1 &
-(ALL x. hrat_sucint (Suc x) = hrat_add (hrat_sucint x) hrat_1)"
+lemma HRAT_SUCINT: "hrat_sucint (0::nat) = hrat_1 &
+(ALL x::nat. hrat_sucint (Suc x) = hrat_add (hrat_sucint x) hrat_1)"
by (import hrat HRAT_SUCINT)
;end_setup
@@ -1689,128 +1999,138 @@
constdefs
hrat_lt :: "hrat => hrat => bool"
- "hrat_lt == %x y. EX d. y = hrat_add x d"
-
-lemma hrat_lt: "ALL x y. hrat_lt x y = (EX d. y = hrat_add x d)"
+ "hrat_lt == %(x::hrat) y::hrat. EX d::hrat. y = hrat_add x d"
+
+lemma hrat_lt: "ALL (x::hrat) y::hrat. hrat_lt x y = (EX d::hrat. y = hrat_add x d)"
by (import hreal hrat_lt)
-lemma HRAT_LT_REFL: "ALL x. ~ hrat_lt x x"
+lemma HRAT_LT_REFL: "ALL x::hrat. ~ hrat_lt x x"
by (import hreal HRAT_LT_REFL)
-lemma HRAT_LT_TRANS: "ALL x y z. hrat_lt x y & hrat_lt y z --> hrat_lt x z"
+lemma HRAT_LT_TRANS: "ALL (x::hrat) (y::hrat) z::hrat. hrat_lt x y & hrat_lt y z --> hrat_lt x z"
by (import hreal HRAT_LT_TRANS)
-lemma HRAT_LT_ANTISYM: "ALL x y. ~ (hrat_lt x y & hrat_lt y x)"
+lemma HRAT_LT_ANTISYM: "ALL (x::hrat) y::hrat. ~ (hrat_lt x y & hrat_lt y x)"
by (import hreal HRAT_LT_ANTISYM)
-lemma HRAT_LT_TOTAL: "ALL x y. x = y | hrat_lt x y | hrat_lt y x"
+lemma HRAT_LT_TOTAL: "ALL (x::hrat) y::hrat. x = y | hrat_lt x y | hrat_lt y x"
by (import hreal HRAT_LT_TOTAL)
-lemma HRAT_MUL_RID: "ALL x. hrat_mul x hrat_1 = x"
+lemma HRAT_MUL_RID: "ALL x::hrat. hrat_mul x hrat_1 = x"
by (import hreal HRAT_MUL_RID)
-lemma HRAT_MUL_RINV: "ALL x. hrat_mul x (hrat_inv x) = hrat_1"
+lemma HRAT_MUL_RINV: "ALL x::hrat. hrat_mul x (hrat_inv x) = hrat_1"
by (import hreal HRAT_MUL_RINV)
-lemma HRAT_RDISTRIB: "ALL x y z.
+lemma HRAT_RDISTRIB: "ALL (x::hrat) (y::hrat) z::hrat.
hrat_mul (hrat_add x y) z = hrat_add (hrat_mul x z) (hrat_mul y z)"
by (import hreal HRAT_RDISTRIB)
-lemma HRAT_LT_ADDL: "ALL x y. hrat_lt x (hrat_add x y)"
+lemma HRAT_LT_ADDL: "ALL (x::hrat) y::hrat. hrat_lt x (hrat_add x y)"
by (import hreal HRAT_LT_ADDL)
-lemma HRAT_LT_ADDR: "ALL x xa. hrat_lt xa (hrat_add x xa)"
+lemma HRAT_LT_ADDR: "ALL (x::hrat) xa::hrat. hrat_lt xa (hrat_add x xa)"
by (import hreal HRAT_LT_ADDR)
-lemma HRAT_LT_GT: "ALL x y. hrat_lt x y --> ~ hrat_lt y x"
+lemma HRAT_LT_GT: "ALL (x::hrat) y::hrat. hrat_lt x y --> ~ hrat_lt y x"
by (import hreal HRAT_LT_GT)
-lemma HRAT_LT_NE: "ALL x y. hrat_lt x y --> x ~= y"
+lemma HRAT_LT_NE: "ALL (x::hrat) y::hrat. hrat_lt x y --> x ~= y"
by (import hreal HRAT_LT_NE)
-lemma HRAT_EQ_LADD: "ALL x y z. (hrat_add x y = hrat_add x z) = (y = z)"
+lemma HRAT_EQ_LADD: "ALL (x::hrat) (y::hrat) z::hrat. (hrat_add x y = hrat_add x z) = (y = z)"
by (import hreal HRAT_EQ_LADD)
-lemma HRAT_EQ_LMUL: "ALL x y z. (hrat_mul x y = hrat_mul x z) = (y = z)"
+lemma HRAT_EQ_LMUL: "ALL (x::hrat) (y::hrat) z::hrat. (hrat_mul x y = hrat_mul x z) = (y = z)"
by (import hreal HRAT_EQ_LMUL)
-lemma HRAT_LT_ADD2: "ALL u v x y.
+lemma HRAT_LT_ADD2: "ALL (u::hrat) (v::hrat) (x::hrat) y::hrat.
hrat_lt u x & hrat_lt v y --> hrat_lt (hrat_add u v) (hrat_add x y)"
by (import hreal HRAT_LT_ADD2)
-lemma HRAT_LT_LADD: "ALL x y z. hrat_lt (hrat_add z x) (hrat_add z y) = hrat_lt x y"
+lemma HRAT_LT_LADD: "ALL (x::hrat) (y::hrat) z::hrat.
+ hrat_lt (hrat_add z x) (hrat_add z y) = hrat_lt x y"
by (import hreal HRAT_LT_LADD)
-lemma HRAT_LT_RADD: "ALL x y z. hrat_lt (hrat_add x z) (hrat_add y z) = hrat_lt x y"
+lemma HRAT_LT_RADD: "ALL (x::hrat) (y::hrat) z::hrat.
+ hrat_lt (hrat_add x z) (hrat_add y z) = hrat_lt x y"
by (import hreal HRAT_LT_RADD)
-lemma HRAT_LT_MUL2: "ALL u v x y.
+lemma HRAT_LT_MUL2: "ALL (u::hrat) (v::hrat) (x::hrat) y::hrat.
hrat_lt u x & hrat_lt v y --> hrat_lt (hrat_mul u v) (hrat_mul x y)"
by (import hreal HRAT_LT_MUL2)
-lemma HRAT_LT_LMUL: "ALL x y z. hrat_lt (hrat_mul z x) (hrat_mul z y) = hrat_lt x y"
+lemma HRAT_LT_LMUL: "ALL (x::hrat) (y::hrat) z::hrat.
+ hrat_lt (hrat_mul z x) (hrat_mul z y) = hrat_lt x y"
by (import hreal HRAT_LT_LMUL)
-lemma HRAT_LT_RMUL: "ALL x y z. hrat_lt (hrat_mul x z) (hrat_mul y z) = hrat_lt x y"
+lemma HRAT_LT_RMUL: "ALL (x::hrat) (y::hrat) z::hrat.
+ hrat_lt (hrat_mul x z) (hrat_mul y z) = hrat_lt x y"
by (import hreal HRAT_LT_RMUL)
-lemma HRAT_LT_LMUL1: "ALL x y. hrat_lt (hrat_mul x y) y = hrat_lt x hrat_1"
+lemma HRAT_LT_LMUL1: "ALL (x::hrat) y::hrat. hrat_lt (hrat_mul x y) y = hrat_lt x hrat_1"
by (import hreal HRAT_LT_LMUL1)
-lemma HRAT_LT_RMUL1: "ALL x y. hrat_lt (hrat_mul x y) x = hrat_lt y hrat_1"
+lemma HRAT_LT_RMUL1: "ALL (x::hrat) y::hrat. hrat_lt (hrat_mul x y) x = hrat_lt y hrat_1"
by (import hreal HRAT_LT_RMUL1)
-lemma HRAT_GT_LMUL1: "ALL x y. hrat_lt y (hrat_mul x y) = hrat_lt hrat_1 x"
+lemma HRAT_GT_LMUL1: "ALL (x::hrat) y::hrat. hrat_lt y (hrat_mul x y) = hrat_lt hrat_1 x"
by (import hreal HRAT_GT_LMUL1)
-lemma HRAT_LT_L1: "ALL x y. hrat_lt (hrat_mul (hrat_inv x) y) hrat_1 = hrat_lt y x"
+lemma HRAT_LT_L1: "ALL (x::hrat) y::hrat.
+ hrat_lt (hrat_mul (hrat_inv x) y) hrat_1 = hrat_lt y x"
by (import hreal HRAT_LT_L1)
-lemma HRAT_LT_R1: "ALL x y. hrat_lt (hrat_mul x (hrat_inv y)) hrat_1 = hrat_lt x y"
+lemma HRAT_LT_R1: "ALL (x::hrat) y::hrat.
+ hrat_lt (hrat_mul x (hrat_inv y)) hrat_1 = hrat_lt x y"
by (import hreal HRAT_LT_R1)
-lemma HRAT_GT_L1: "ALL x y. hrat_lt hrat_1 (hrat_mul (hrat_inv x) y) = hrat_lt x y"
+lemma HRAT_GT_L1: "ALL (x::hrat) y::hrat.
+ hrat_lt hrat_1 (hrat_mul (hrat_inv x) y) = hrat_lt x y"
by (import hreal HRAT_GT_L1)
-lemma HRAT_INV_MUL: "ALL x y. hrat_inv (hrat_mul x y) = hrat_mul (hrat_inv x) (hrat_inv y)"
+lemma HRAT_INV_MUL: "ALL (x::hrat) y::hrat.
+ hrat_inv (hrat_mul x y) = hrat_mul (hrat_inv x) (hrat_inv y)"
by (import hreal HRAT_INV_MUL)
-lemma HRAT_UP: "ALL x. Ex (hrat_lt x)"
+lemma HRAT_UP: "ALL x::hrat. Ex (hrat_lt x)"
by (import hreal HRAT_UP)
-lemma HRAT_DOWN: "ALL x. EX xa. hrat_lt xa x"
+lemma HRAT_DOWN: "ALL x::hrat. EX xa::hrat. hrat_lt xa x"
by (import hreal HRAT_DOWN)
-lemma HRAT_DOWN2: "ALL x y. EX xa. hrat_lt xa x & hrat_lt xa y"
+lemma HRAT_DOWN2: "ALL (x::hrat) y::hrat. EX xa::hrat. hrat_lt xa x & hrat_lt xa y"
by (import hreal HRAT_DOWN2)
-lemma HRAT_MEAN: "ALL x y. hrat_lt x y --> (EX xa. hrat_lt x xa & hrat_lt xa y)"
+lemma HRAT_MEAN: "ALL (x::hrat) y::hrat.
+ hrat_lt x y --> (EX xa::hrat. hrat_lt x xa & hrat_lt xa y)"
by (import hreal HRAT_MEAN)
constdefs
isacut :: "(hrat => bool) => bool"
"isacut ==
-%C. Ex C &
- (EX x. ~ C x) &
- (ALL x y. C x & hrat_lt y x --> C y) &
- (ALL x. C x --> (EX y. C y & hrat_lt x y))"
-
-lemma isacut: "ALL C.
+%C::hrat => bool.
+ Ex C &
+ (EX x::hrat. ~ C x) &
+ (ALL (x::hrat) y::hrat. C x & hrat_lt y x --> C y) &
+ (ALL x::hrat. C x --> (EX y::hrat. C y & hrat_lt x y))"
+
+lemma isacut: "ALL C::hrat => bool.
isacut C =
(Ex C &
- (EX x. ~ C x) &
- (ALL x y. C x & hrat_lt y x --> C y) &
- (ALL x. C x --> (EX y. C y & hrat_lt x y)))"
+ (EX x::hrat. ~ C x) &
+ (ALL (x::hrat) y::hrat. C x & hrat_lt y x --> C y) &
+ (ALL x::hrat. C x --> (EX y::hrat. C y & hrat_lt x y)))"
by (import hreal isacut)
constdefs
cut_of_hrat :: "hrat => hrat => bool"
- "cut_of_hrat == %x y. hrat_lt y x"
-
-lemma cut_of_hrat: "ALL x. cut_of_hrat x = (%y. hrat_lt y x)"
+ "cut_of_hrat == %(x::hrat) y::hrat. hrat_lt y x"
+
+lemma cut_of_hrat: "ALL x::hrat. cut_of_hrat x = (%y::hrat. hrat_lt y x)"
by (import hreal cut_of_hrat)
-lemma ISACUT_HRAT: "ALL h. isacut (cut_of_hrat h)"
+lemma ISACUT_HRAT: "ALL h::hrat. isacut (cut_of_hrat h)"
by (import hreal ISACUT_HRAT)
typedef (open) hreal = "Collect isacut"
@@ -1822,39 +2142,45 @@
hreal :: "(hrat => bool) => hreal"
cut :: "hreal => hrat => bool"
-specification (cut hreal) hreal_tybij: "(ALL a. hreal (hreal.cut a) = a) &
-(ALL r. isacut r = (hreal.cut (hreal r) = r))"
+specification (cut hreal) hreal_tybij: "(ALL a::hreal. hreal (hreal.cut a) = a) &
+(ALL r::hrat => bool. isacut r = (hreal.cut (hreal r) = r))"
by (import hreal hreal_tybij)
-lemma EQUAL_CUTS: "ALL X Y. hreal.cut X = hreal.cut Y --> X = Y"
+lemma EQUAL_CUTS: "ALL (X::hreal) Y::hreal. hreal.cut X = hreal.cut Y --> X = Y"
by (import hreal EQUAL_CUTS)
-lemma CUT_ISACUT: "ALL x. isacut (hreal.cut x)"
+lemma CUT_ISACUT: "ALL x::hreal. isacut (hreal.cut x)"
by (import hreal CUT_ISACUT)
-lemma CUT_NONEMPTY: "ALL x. Ex (hreal.cut x)"
+lemma CUT_NONEMPTY: "ALL x::hreal. Ex (hreal.cut x)"
by (import hreal CUT_NONEMPTY)
-lemma CUT_BOUNDED: "ALL x. EX xa. ~ hreal.cut x xa"
+lemma CUT_BOUNDED: "ALL x::hreal. EX xa::hrat. ~ hreal.cut x xa"
by (import hreal CUT_BOUNDED)
-lemma CUT_DOWN: "ALL x xa xb. hreal.cut x xa & hrat_lt xb xa --> hreal.cut x xb"
+lemma CUT_DOWN: "ALL (x::hreal) (xa::hrat) xb::hrat.
+ hreal.cut x xa & hrat_lt xb xa --> hreal.cut x xb"
by (import hreal CUT_DOWN)
-lemma CUT_UP: "ALL x xa. hreal.cut x xa --> (EX y. hreal.cut x y & hrat_lt xa y)"
+lemma CUT_UP: "ALL (x::hreal) xa::hrat.
+ hreal.cut x xa --> (EX y::hrat. hreal.cut x y & hrat_lt xa y)"
by (import hreal CUT_UP)
-lemma CUT_UBOUND: "ALL x xa xb. ~ hreal.cut x xa & hrat_lt xa xb --> ~ hreal.cut x xb"
+lemma CUT_UBOUND: "ALL (x::hreal) (xa::hrat) xb::hrat.
+ ~ hreal.cut x xa & hrat_lt xa xb --> ~ hreal.cut x xb"
by (import hreal CUT_UBOUND)
-lemma CUT_STRADDLE: "ALL X x y. hreal.cut X x & ~ hreal.cut X y --> hrat_lt x y"
+lemma CUT_STRADDLE: "ALL (X::hreal) (x::hrat) y::hrat.
+ hreal.cut X x & ~ hreal.cut X y --> hrat_lt x y"
by (import hreal CUT_STRADDLE)
-lemma CUT_NEARTOP_ADD: "ALL X e. EX x. hreal.cut X x & ~ hreal.cut X (hrat_add x e)"
+lemma CUT_NEARTOP_ADD: "ALL (X::hreal) e::hrat.
+ EX x::hrat. hreal.cut X x & ~ hreal.cut X (hrat_add x e)"
by (import hreal CUT_NEARTOP_ADD)
-lemma CUT_NEARTOP_MUL: "ALL X u.
- hrat_lt hrat_1 u --> (EX x. hreal.cut X x & ~ hreal.cut X (hrat_mul u x))"
+lemma CUT_NEARTOP_MUL: "ALL (X::hreal) u::hrat.
+ hrat_lt hrat_1 u -->
+ (EX x::hrat. hreal.cut X x & ~ hreal.cut X (hrat_mul u x))"
by (import hreal CUT_NEARTOP_MUL)
constdefs
@@ -1867,128 +2193,170 @@
constdefs
hreal_add :: "hreal => hreal => hreal"
"hreal_add ==
-%X Y. hreal (%w. EX x y. w = hrat_add x y & hreal.cut X x & hreal.cut Y y)"
-
-lemma hreal_add: "ALL X Y.
+%(X::hreal) Y::hreal.
+ hreal
+ (%w::hrat.
+ EX (x::hrat) y::hrat.
+ w = hrat_add x y & hreal.cut X x & hreal.cut Y y)"
+
+lemma hreal_add: "ALL (X::hreal) Y::hreal.
hreal_add X Y =
- hreal (%w. EX x y. w = hrat_add x y & hreal.cut X x & hreal.cut Y y)"
+ hreal
+ (%w::hrat.
+ EX (x::hrat) y::hrat.
+ w = hrat_add x y & hreal.cut X x & hreal.cut Y y)"
by (import hreal hreal_add)
constdefs
hreal_mul :: "hreal => hreal => hreal"
"hreal_mul ==
-%X Y. hreal (%w. EX x y. w = hrat_mul x y & hreal.cut X x & hreal.cut Y y)"
-
-lemma hreal_mul: "ALL X Y.
+%(X::hreal) Y::hreal.
+ hreal
+ (%w::hrat.
+ EX (x::hrat) y::hrat.
+ w = hrat_mul x y & hreal.cut X x & hreal.cut Y y)"
+
+lemma hreal_mul: "ALL (X::hreal) Y::hreal.
hreal_mul X Y =
- hreal (%w. EX x y. w = hrat_mul x y & hreal.cut X x & hreal.cut Y y)"
+ hreal
+ (%w::hrat.
+ EX (x::hrat) y::hrat.
+ w = hrat_mul x y & hreal.cut X x & hreal.cut Y y)"
by (import hreal hreal_mul)
constdefs
hreal_inv :: "hreal => hreal"
"hreal_inv ==
-%X. hreal
- (%w. EX d. hrat_lt d hrat_1 &
- (ALL x. hreal.cut X x --> hrat_lt (hrat_mul w x) d))"
-
-lemma hreal_inv: "ALL X.
+%X::hreal.
+ hreal
+ (%w::hrat.
+ EX d::hrat.
+ hrat_lt d hrat_1 &
+ (ALL x::hrat. hreal.cut X x --> hrat_lt (hrat_mul w x) d))"
+
+lemma hreal_inv: "ALL X::hreal.
hreal_inv X =
hreal
- (%w. EX d. hrat_lt d hrat_1 &
- (ALL x. hreal.cut X x --> hrat_lt (hrat_mul w x) d))"
+ (%w::hrat.
+ EX d::hrat.
+ hrat_lt d hrat_1 &
+ (ALL x::hrat. hreal.cut X x --> hrat_lt (hrat_mul w x) d))"
by (import hreal hreal_inv)
constdefs
hreal_sup :: "(hreal => bool) => hreal"
- "hreal_sup == %P. hreal (%w. EX X. P X & hreal.cut X w)"
-
-lemma hreal_sup: "ALL P. hreal_sup P = hreal (%w. EX X. P X & hreal.cut X w)"
+ "hreal_sup ==
+%P::hreal => bool. hreal (%w::hrat. EX X::hreal. P X & hreal.cut X w)"
+
+lemma hreal_sup: "ALL P::hreal => bool.
+ hreal_sup P = hreal (%w::hrat. EX X::hreal. P X & hreal.cut X w)"
by (import hreal hreal_sup)
constdefs
hreal_lt :: "hreal => hreal => bool"
- "hreal_lt == %X Y. X ~= Y & (ALL x. hreal.cut X x --> hreal.cut Y x)"
-
-lemma hreal_lt: "ALL X Y. hreal_lt X Y = (X ~= Y & (ALL x. hreal.cut X x --> hreal.cut Y x))"
+ "hreal_lt ==
+%(X::hreal) Y::hreal.
+ X ~= Y & (ALL x::hrat. hreal.cut X x --> hreal.cut Y x)"
+
+lemma hreal_lt: "ALL (X::hreal) Y::hreal.
+ hreal_lt X Y = (X ~= Y & (ALL x::hrat. hreal.cut X x --> hreal.cut Y x))"
by (import hreal hreal_lt)
-lemma HREAL_INV_ISACUT: "ALL X.
+lemma HREAL_INV_ISACUT: "ALL X::hreal.
isacut
- (%w. EX d. hrat_lt d hrat_1 &
- (ALL x. hreal.cut X x --> hrat_lt (hrat_mul w x) d))"
+ (%w::hrat.
+ EX d::hrat.
+ hrat_lt d hrat_1 &
+ (ALL x::hrat. hreal.cut X x --> hrat_lt (hrat_mul w x) d))"
by (import hreal HREAL_INV_ISACUT)
-lemma HREAL_ADD_ISACUT: "ALL X Y.
- isacut (%w. EX x y. w = hrat_add x y & hreal.cut X x & hreal.cut Y y)"
+lemma HREAL_ADD_ISACUT: "ALL (X::hreal) Y::hreal.
+ isacut
+ (%w::hrat.
+ EX (x::hrat) y::hrat.
+ w = hrat_add x y & hreal.cut X x & hreal.cut Y y)"
by (import hreal HREAL_ADD_ISACUT)
-lemma HREAL_MUL_ISACUT: "ALL X Y.
- isacut (%w. EX x y. w = hrat_mul x y & hreal.cut X x & hreal.cut Y y)"
+lemma HREAL_MUL_ISACUT: "ALL (X::hreal) Y::hreal.
+ isacut
+ (%w::hrat.
+ EX (x::hrat) y::hrat.
+ w = hrat_mul x y & hreal.cut X x & hreal.cut Y y)"
by (import hreal HREAL_MUL_ISACUT)
-lemma HREAL_ADD_SYM: "ALL X Y. hreal_add X Y = hreal_add Y X"
+lemma HREAL_ADD_SYM: "ALL (X::hreal) Y::hreal. hreal_add X Y = hreal_add Y X"
by (import hreal HREAL_ADD_SYM)
-lemma HREAL_MUL_SYM: "ALL X Y. hreal_mul X Y = hreal_mul Y X"
+lemma HREAL_MUL_SYM: "ALL (X::hreal) Y::hreal. hreal_mul X Y = hreal_mul Y X"
by (import hreal HREAL_MUL_SYM)
-lemma HREAL_ADD_ASSOC: "ALL X Y Z. hreal_add X (hreal_add Y Z) = hreal_add (hreal_add X Y) Z"
+lemma HREAL_ADD_ASSOC: "ALL (X::hreal) (Y::hreal) Z::hreal.
+ hreal_add X (hreal_add Y Z) = hreal_add (hreal_add X Y) Z"
by (import hreal HREAL_ADD_ASSOC)
-lemma HREAL_MUL_ASSOC: "ALL X Y Z. hreal_mul X (hreal_mul Y Z) = hreal_mul (hreal_mul X Y) Z"
+lemma HREAL_MUL_ASSOC: "ALL (X::hreal) (Y::hreal) Z::hreal.
+ hreal_mul X (hreal_mul Y Z) = hreal_mul (hreal_mul X Y) Z"
by (import hreal HREAL_MUL_ASSOC)
-lemma HREAL_LDISTRIB: "ALL X Y Z.
+lemma HREAL_LDISTRIB: "ALL (X::hreal) (Y::hreal) Z::hreal.
hreal_mul X (hreal_add Y Z) = hreal_add (hreal_mul X Y) (hreal_mul X Z)"
by (import hreal HREAL_LDISTRIB)
-lemma HREAL_MUL_LID: "ALL X. hreal_mul hreal_1 X = X"
+lemma HREAL_MUL_LID: "ALL X::hreal. hreal_mul hreal_1 X = X"
by (import hreal HREAL_MUL_LID)
-lemma HREAL_MUL_LINV: "ALL X. hreal_mul (hreal_inv X) X = hreal_1"
+lemma HREAL_MUL_LINV: "ALL X::hreal. hreal_mul (hreal_inv X) X = hreal_1"
by (import hreal HREAL_MUL_LINV)
-lemma HREAL_NOZERO: "ALL X Y. hreal_add X Y ~= X"
+lemma HREAL_NOZERO: "ALL (X::hreal) Y::hreal. hreal_add X Y ~= X"
by (import hreal HREAL_NOZERO)
constdefs
hreal_sub :: "hreal => hreal => hreal"
"hreal_sub ==
-%Y X. hreal (%w. EX x. ~ hreal.cut X x & hreal.cut Y (hrat_add x w))"
-
-lemma hreal_sub: "ALL Y X.
+%(Y::hreal) X::hreal.
+ hreal
+ (%w::hrat. EX x::hrat. ~ hreal.cut X x & hreal.cut Y (hrat_add x w))"
+
+lemma hreal_sub: "ALL (Y::hreal) X::hreal.
hreal_sub Y X =
- hreal (%w. EX x. ~ hreal.cut X x & hreal.cut Y (hrat_add x w))"
+ hreal
+ (%w::hrat. EX x::hrat. ~ hreal.cut X x & hreal.cut Y (hrat_add x w))"
by (import hreal hreal_sub)
-lemma HREAL_LT_LEMMA: "ALL X Y. hreal_lt X Y --> (EX x. ~ hreal.cut X x & hreal.cut Y x)"
+lemma HREAL_LT_LEMMA: "ALL (X::hreal) Y::hreal.
+ hreal_lt X Y --> (EX x::hrat. ~ hreal.cut X x & hreal.cut Y x)"
by (import hreal HREAL_LT_LEMMA)
-lemma HREAL_SUB_ISACUT: "ALL X Y.
+lemma HREAL_SUB_ISACUT: "ALL (X::hreal) Y::hreal.
hreal_lt X Y -->
- isacut (%w. EX x. ~ hreal.cut X x & hreal.cut Y (hrat_add x w))"
+ isacut
+ (%w::hrat. EX x::hrat. ~ hreal.cut X x & hreal.cut Y (hrat_add x w))"
by (import hreal HREAL_SUB_ISACUT)
-lemma HREAL_SUB_ADD: "ALL X Y. hreal_lt X Y --> hreal_add (hreal_sub Y X) X = Y"
+lemma HREAL_SUB_ADD: "ALL (X::hreal) Y::hreal. hreal_lt X Y --> hreal_add (hreal_sub Y X) X = Y"
by (import hreal HREAL_SUB_ADD)
-lemma HREAL_LT_TOTAL: "ALL X Y. X = Y | hreal_lt X Y | hreal_lt Y X"
+lemma HREAL_LT_TOTAL: "ALL (X::hreal) Y::hreal. X = Y | hreal_lt X Y | hreal_lt Y X"
by (import hreal HREAL_LT_TOTAL)
-lemma HREAL_LT: "ALL X Y. hreal_lt X Y = (EX D. Y = hreal_add X D)"
+lemma HREAL_LT: "ALL (X::hreal) Y::hreal. hreal_lt X Y = (EX D::hreal. Y = hreal_add X D)"
by (import hreal HREAL_LT)
-lemma HREAL_ADD_TOTAL: "ALL X Y. X = Y | (EX D. Y = hreal_add X D) | (EX D. X = hreal_add Y D)"
+lemma HREAL_ADD_TOTAL: "ALL (X::hreal) Y::hreal.
+ X = Y |
+ (EX D::hreal. Y = hreal_add X D) | (EX D::hreal. X = hreal_add Y D)"
by (import hreal HREAL_ADD_TOTAL)
-lemma HREAL_SUP_ISACUT: "ALL P.
- Ex P & (EX Y. ALL X. P X --> hreal_lt X Y) -->
- isacut (%w. EX X. P X & hreal.cut X w)"
+lemma HREAL_SUP_ISACUT: "ALL P::hreal => bool.
+ Ex P & (EX Y::hreal. ALL X::hreal. P X --> hreal_lt X Y) -->
+ isacut (%w::hrat. EX X::hreal. P X & hreal.cut X w)"
by (import hreal HREAL_SUP_ISACUT)
-lemma HREAL_SUP: "ALL P.
- Ex P & (EX Y. ALL X. P X --> hreal_lt X Y) -->
- (ALL Y. (EX X. P X & hreal_lt Y X) = hreal_lt Y (hreal_sup P))"
+lemma HREAL_SUP: "ALL P::hreal => bool.
+ Ex P & (EX Y::hreal. ALL X::hreal. P X --> hreal_lt X Y) -->
+ (ALL Y::hreal.
+ (EX X::hreal. P X & hreal_lt Y X) = hreal_lt Y (hreal_sup P))"
by (import hreal HREAL_SUP)
;end_setup
@@ -1996,22 +2364,22 @@
;setup_theory numeral
lemma numeral_suc: "Suc ALT_ZERO = NUMERAL_BIT1 ALT_ZERO &
-(ALL x. Suc (NUMERAL_BIT1 x) = NUMERAL_BIT2 x) &
-(ALL x. Suc (NUMERAL_BIT2 x) = NUMERAL_BIT1 (Suc x))"
+(ALL x::nat. Suc (NUMERAL_BIT1 x) = NUMERAL_BIT2 x) &
+(ALL x::nat. Suc (NUMERAL_BIT2 x) = NUMERAL_BIT1 (Suc x))"
by (import numeral numeral_suc)
constdefs
iZ :: "nat => nat"
- "iZ == %x. x"
-
-lemma iZ: "ALL x. iZ x = x"
+ "iZ == %x::nat. x"
+
+lemma iZ: "ALL x::nat. iZ x = x"
by (import numeral iZ)
constdefs
iiSUC :: "nat => nat"
- "iiSUC == %n. Suc (Suc n)"
-
-lemma iiSUC: "ALL n. iiSUC n = Suc (Suc n)"
+ "iiSUC == %n::nat. Suc (Suc n)"
+
+lemma iiSUC: "ALL n::nat. iiSUC n = Suc (Suc n)"
by (import numeral iiSUC)
lemma numeral_distrib: "(ALL x::nat. (0::nat) + x = x) &
@@ -2051,11 +2419,11 @@
by (import numeral numeral_distrib)
lemma numeral_iisuc: "iiSUC ALT_ZERO = NUMERAL_BIT2 ALT_ZERO &
-iiSUC (NUMERAL_BIT1 n) = NUMERAL_BIT1 (Suc n) &
+iiSUC (NUMERAL_BIT1 (n::nat)) = NUMERAL_BIT1 (Suc n) &
iiSUC (NUMERAL_BIT2 n) = NUMERAL_BIT2 (Suc n)"
by (import numeral numeral_iisuc)
-lemma numeral_add: "ALL x xa.
+lemma numeral_add: "ALL (x::nat) xa::nat.
iZ (ALT_ZERO + x) = x &
iZ (x + ALT_ZERO) = x &
iZ (NUMERAL_BIT1 x + NUMERAL_BIT1 xa) = NUMERAL_BIT2 (iZ (x + xa)) &
@@ -2078,7 +2446,7 @@
iiSUC (NUMERAL_BIT2 x + NUMERAL_BIT2 xa) = NUMERAL_BIT2 (iiSUC (x + xa))"
by (import numeral numeral_add)
-lemma numeral_eq: "ALL x xa.
+lemma numeral_eq: "ALL (x::nat) xa::nat.
(ALT_ZERO = NUMERAL_BIT1 x) = False &
(NUMERAL_BIT1 x = ALT_ZERO) = False &
(ALT_ZERO = NUMERAL_BIT2 x) = False &
@@ -2089,7 +2457,7 @@
(NUMERAL_BIT2 x = NUMERAL_BIT2 xa) = (x = xa)"
by (import numeral numeral_eq)
-lemma numeral_lt: "ALL x xa.
+lemma numeral_lt: "ALL (x::nat) xa::nat.
(ALT_ZERO < NUMERAL_BIT1 x) = True &
(ALT_ZERO < NUMERAL_BIT2 x) = True &
(x < ALT_ZERO) = False &
@@ -2099,7 +2467,7 @@
(NUMERAL_BIT2 x < NUMERAL_BIT1 xa) = (x < xa)"
by (import numeral numeral_lt)
-lemma numeral_lte: "ALL x xa.
+lemma numeral_lte: "ALL (x::nat) xa::nat.
(ALT_ZERO <= x) = True &
(NUMERAL_BIT1 x <= ALT_ZERO) = False &
(NUMERAL_BIT2 x <= ALT_ZERO) = False &
@@ -2111,67 +2479,70 @@
lemma numeral_pre: "PRE ALT_ZERO = ALT_ZERO &
PRE (NUMERAL_BIT1 ALT_ZERO) = ALT_ZERO &
-(ALL x.
+(ALL x::nat.
PRE (NUMERAL_BIT1 (NUMERAL_BIT1 x)) =
NUMERAL_BIT2 (PRE (NUMERAL_BIT1 x))) &
-(ALL x.
+(ALL x::nat.
PRE (NUMERAL_BIT1 (NUMERAL_BIT2 x)) = NUMERAL_BIT2 (NUMERAL_BIT1 x)) &
-(ALL x. PRE (NUMERAL_BIT2 x) = NUMERAL_BIT1 x)"
+(ALL x::nat. PRE (NUMERAL_BIT2 x) = NUMERAL_BIT1 x)"
by (import numeral numeral_pre)
-lemma bit_initiality: "ALL zf b1f b2f.
- EX x. x ALT_ZERO = zf &
- (ALL n. x (NUMERAL_BIT1 n) = b1f n (x n)) &
- (ALL n. x (NUMERAL_BIT2 n) = b2f n (x n))"
+lemma bit_initiality: "ALL (zf::'a::type) (b1f::nat => 'a::type => 'a::type)
+ b2f::nat => 'a::type => 'a::type.
+ EX x::nat => 'a::type.
+ x ALT_ZERO = zf &
+ (ALL n::nat. x (NUMERAL_BIT1 n) = b1f n (x n)) &
+ (ALL n::nat. x (NUMERAL_BIT2 n) = b2f n (x n))"
by (import numeral bit_initiality)
consts
- iBIT_cases :: "nat => 'a => (nat => 'a) => (nat => 'a) => 'a"
-
-specification (iBIT_cases) iBIT_cases: "(ALL (zf::'a) (bf1::nat => 'a) bf2::nat => 'a.
+ iBIT_cases :: "nat => 'a::type => (nat => 'a::type) => (nat => 'a::type) => 'a::type"
+
+specification (iBIT_cases) iBIT_cases: "(ALL (zf::'a::type) (bf1::nat => 'a::type) bf2::nat => 'a::type.
iBIT_cases ALT_ZERO zf bf1 bf2 = zf) &
-(ALL (n::nat) (zf::'a) (bf1::nat => 'a) bf2::nat => 'a.
+(ALL (n::nat) (zf::'a::type) (bf1::nat => 'a::type) bf2::nat => 'a::type.
iBIT_cases (NUMERAL_BIT1 n) zf bf1 bf2 = bf1 n) &
-(ALL (n::nat) (zf::'a) (bf1::nat => 'a) bf2::nat => 'a.
+(ALL (n::nat) (zf::'a::type) (bf1::nat => 'a::type) bf2::nat => 'a::type.
iBIT_cases (NUMERAL_BIT2 n) zf bf1 bf2 = bf2 n)"
by (import numeral iBIT_cases)
constdefs
iDUB :: "nat => nat"
- "iDUB == %x. x + x"
-
-lemma iDUB: "ALL x. iDUB x = x + x"
+ "iDUB == %x::nat. x + x"
+
+lemma iDUB: "ALL x::nat. iDUB x = x + x"
by (import numeral iDUB)
consts
iSUB :: "bool => nat => nat => nat"
-specification (iSUB) iSUB_DEF: "(ALL b x. iSUB b ALT_ZERO x = ALT_ZERO) &
-(ALL b n x.
+specification (iSUB) iSUB_DEF: "(ALL (b::bool) x::nat. iSUB b ALT_ZERO x = ALT_ZERO) &
+(ALL (b::bool) (n::nat) x::nat.
iSUB b (NUMERAL_BIT1 n) x =
(if b
- then iBIT_cases x (NUMERAL_BIT1 n) (%m. iDUB (iSUB True n m))
- (%m. NUMERAL_BIT1 (iSUB False n m))
- else iBIT_cases x (iDUB n) (%m. NUMERAL_BIT1 (iSUB False n m))
- (%m. iDUB (iSUB False n m)))) &
-(ALL b n x.
+ then iBIT_cases x (NUMERAL_BIT1 n) (%m::nat. iDUB (iSUB True n m))
+ (%m::nat. NUMERAL_BIT1 (iSUB False n m))
+ else iBIT_cases x (iDUB n) (%m::nat. NUMERAL_BIT1 (iSUB False n m))
+ (%m::nat. iDUB (iSUB False n m)))) &
+(ALL (b::bool) (n::nat) x::nat.
iSUB b (NUMERAL_BIT2 n) x =
(if b
- then iBIT_cases x (NUMERAL_BIT2 n) (%m. NUMERAL_BIT1 (iSUB True n m))
- (%m. iDUB (iSUB True n m))
- else iBIT_cases x (NUMERAL_BIT1 n) (%m. iDUB (iSUB True n m))
- (%m. NUMERAL_BIT1 (iSUB False n m))))"
+ then iBIT_cases x (NUMERAL_BIT2 n)
+ (%m::nat. NUMERAL_BIT1 (iSUB True n m))
+ (%m::nat. iDUB (iSUB True n m))
+ else iBIT_cases x (NUMERAL_BIT1 n) (%m::nat. iDUB (iSUB True n m))
+ (%m::nat. NUMERAL_BIT1 (iSUB False n m))))"
by (import numeral iSUB_DEF)
-lemma bit_induction: "ALL P.
+lemma bit_induction: "ALL P::nat => bool.
P ALT_ZERO &
- (ALL n. P n --> P (NUMERAL_BIT1 n)) &
- (ALL n. P n --> P (NUMERAL_BIT2 n)) -->
+ (ALL n::nat. P n --> P (NUMERAL_BIT1 n)) &
+ (ALL n::nat. P n --> P (NUMERAL_BIT2 n)) -->
All P"
by (import numeral bit_induction)
-lemma iSUB_THM: "ALL xa xb xc.
- iSUB xa ALT_ZERO x = ALT_ZERO &
+lemma iSUB_THM: "ALL (xa::bool) (xb::nat) xc::nat.
+ iSUB xa ALT_ZERO (x::nat) = ALT_ZERO &
iSUB True xb ALT_ZERO = xb &
iSUB False (NUMERAL_BIT1 xb) ALT_ZERO = iDUB xb &
iSUB True (NUMERAL_BIT1 xb) (NUMERAL_BIT1 xc) = iDUB (iSUB True xb xc) &
@@ -2190,17 +2561,26 @@
NUMERAL_BIT1 (iSUB False xb xc)"
by (import numeral iSUB_THM)
-lemma numeral_sub: "ALL x xa.
- NUMERAL (x - xa) = (if xa < x then NUMERAL (iSUB True x xa) else 0)"
+lemma numeral_sub: "(All::(nat => bool) => bool)
+ (%x::nat.
+ (All::(nat => bool) => bool)
+ (%xa::nat.
+ (op =::nat => nat => bool)
+ ((NUMERAL::nat => nat) ((op -::nat => nat => nat) x xa))
+ ((If::bool => nat => nat => nat)
+ ((op <::nat => nat => bool) xa x)
+ ((NUMERAL::nat => nat)
+ ((iSUB::bool => nat => nat => nat) (True::bool) x xa))
+ (0::nat))))"
by (import numeral numeral_sub)
-lemma iDUB_removal: "ALL x.
+lemma iDUB_removal: "ALL x::nat.
iDUB (NUMERAL_BIT1 x) = NUMERAL_BIT2 (iDUB x) &
iDUB (NUMERAL_BIT2 x) = NUMERAL_BIT2 (NUMERAL_BIT1 x) &
iDUB ALT_ZERO = ALT_ZERO"
by (import numeral iDUB_removal)
-lemma numeral_mult: "ALL x xa.
+lemma numeral_mult: "ALL (x::nat) xa::nat.
ALT_ZERO * x = ALT_ZERO &
x * ALT_ZERO = ALT_ZERO &
NUMERAL_BIT1 x * xa = iZ (iDUB (x * xa) + xa) &
@@ -2209,265 +2589,316 @@
constdefs
iSQR :: "nat => nat"
- "iSQR == %x. x * x"
-
-lemma iSQR: "ALL x. iSQR x = x * x"
+ "iSQR == %x::nat. x * x"
+
+lemma iSQR: "ALL x::nat. iSQR x = x * x"
by (import numeral iSQR)
-lemma numeral_exp: "(ALL x. x ^ ALT_ZERO = NUMERAL_BIT1 ALT_ZERO) &
-(ALL x xa. x ^ NUMERAL_BIT1 xa = x * iSQR (x ^ xa)) &
-(ALL x xa. x ^ NUMERAL_BIT2 xa = iSQR x * iSQR (x ^ xa))"
+lemma numeral_exp: "(ALL x::nat. x ^ ALT_ZERO = NUMERAL_BIT1 ALT_ZERO) &
+(ALL (x::nat) xa::nat. x ^ NUMERAL_BIT1 xa = x * iSQR (x ^ xa)) &
+(ALL (x::nat) xa::nat. x ^ NUMERAL_BIT2 xa = iSQR x * iSQR (x ^ xa))"
by (import numeral numeral_exp)
-lemma numeral_evenodd: "ALL x.
+lemma numeral_evenodd: "ALL x::nat.
EVEN ALT_ZERO &
EVEN (NUMERAL_BIT2 x) &
~ EVEN (NUMERAL_BIT1 x) &
~ ODD ALT_ZERO & ~ ODD (NUMERAL_BIT2 x) & ODD (NUMERAL_BIT1 x)"
by (import numeral numeral_evenodd)
-lemma numeral_fact: "ALL n. FACT n = (if n = 0 then 1 else n * FACT (PRE n))"
+lemma numeral_fact: "ALL n::nat. FACT n = (if n = (0::nat) then 1::nat else n * FACT (PRE n))"
by (import numeral numeral_fact)
-lemma numeral_funpow: "ALL n. (f ^ n) x = (if n = 0 then x else (f ^ (n - 1)) (f x))"
+lemma numeral_funpow: "ALL n::nat.
+ ((f::'a::type => 'a::type) ^ n) (x::'a::type) =
+ (if n = (0::nat) then x else (f ^ (n - (1::nat))) (f x))"
by (import numeral numeral_funpow)
;end_setup
;setup_theory ind_type
-lemma INJ_INVERSE2: "ALL P::'A => 'B => 'C.
- (ALL (x1::'A) (y1::'B) (x2::'A) y2::'B.
+lemma INJ_INVERSE2: "ALL P::'A::type => 'B::type => 'C::type.
+ (ALL (x1::'A::type) (y1::'B::type) (x2::'A::type) y2::'B::type.
(P x1 y1 = P x2 y2) = (x1 = x2 & y1 = y2)) -->
- (EX (x::'C => 'A) Y::'C => 'B.
- ALL (xa::'A) y::'B. x (P xa y) = xa & Y (P xa y) = y)"
+ (EX (x::'C::type => 'A::type) Y::'C::type => 'B::type.
+ ALL (xa::'A::type) y::'B::type. x (P xa y) = xa & Y (P xa y) = y)"
by (import ind_type INJ_INVERSE2)
constdefs
NUMPAIR :: "nat => nat => nat"
- "NUMPAIR == %x y. 2 ^ x * (2 * y + 1)"
-
-lemma NUMPAIR: "ALL x y. NUMPAIR x y = 2 ^ x * (2 * y + 1)"
+ "NUMPAIR == %(x::nat) y::nat. (2::nat) ^ x * ((2::nat) * y + (1::nat))"
+
+lemma NUMPAIR: "ALL (x::nat) y::nat. NUMPAIR x y = (2::nat) ^ x * ((2::nat) * y + (1::nat))"
by (import ind_type NUMPAIR)
-lemma NUMPAIR_INJ_LEMMA: "ALL x xa xb xc. NUMPAIR x xa = NUMPAIR xb xc --> x = xb"
+lemma NUMPAIR_INJ_LEMMA: "ALL (x::nat) (xa::nat) (xb::nat) xc::nat.
+ NUMPAIR x xa = NUMPAIR xb xc --> x = xb"
by (import ind_type NUMPAIR_INJ_LEMMA)
-lemma NUMPAIR_INJ: "ALL x1 y1 x2 y2. (NUMPAIR x1 y1 = NUMPAIR x2 y2) = (x1 = x2 & y1 = y2)"
+lemma NUMPAIR_INJ: "ALL (x1::nat) (y1::nat) (x2::nat) y2::nat.
+ (NUMPAIR x1 y1 = NUMPAIR x2 y2) = (x1 = x2 & y1 = y2)"
by (import ind_type NUMPAIR_INJ)
consts
NUMSND :: "nat => nat"
NUMFST :: "nat => nat"
-specification (NUMFST NUMSND) NUMPAIR_DEST: "ALL x y. NUMFST (NUMPAIR x y) = x & NUMSND (NUMPAIR x y) = y"
+specification (NUMFST NUMSND) NUMPAIR_DEST: "ALL (x::nat) y::nat. NUMFST (NUMPAIR x y) = x & NUMSND (NUMPAIR x y) = y"
by (import ind_type NUMPAIR_DEST)
constdefs
NUMSUM :: "bool => nat => nat"
- "NUMSUM == %b x. if b then Suc (2 * x) else 2 * x"
-
-lemma NUMSUM: "ALL b x. NUMSUM b x = (if b then Suc (2 * x) else 2 * x)"
+ "NUMSUM == %(b::bool) x::nat. if b then Suc ((2::nat) * x) else (2::nat) * x"
+
+lemma NUMSUM: "ALL (b::bool) x::nat.
+ NUMSUM b x = (if b then Suc ((2::nat) * x) else (2::nat) * x)"
by (import ind_type NUMSUM)
-lemma NUMSUM_INJ: "ALL b1 x1 b2 x2. (NUMSUM b1 x1 = NUMSUM b2 x2) = (b1 = b2 & x1 = x2)"
+lemma NUMSUM_INJ: "ALL (b1::bool) (x1::nat) (b2::bool) x2::nat.
+ (NUMSUM b1 x1 = NUMSUM b2 x2) = (b1 = b2 & x1 = x2)"
by (import ind_type NUMSUM_INJ)
consts
NUMRIGHT :: "nat => nat"
NUMLEFT :: "nat => bool"
-specification (NUMLEFT NUMRIGHT) NUMSUM_DEST: "ALL x y. NUMLEFT (NUMSUM x y) = x & NUMRIGHT (NUMSUM x y) = y"
+specification (NUMLEFT NUMRIGHT) NUMSUM_DEST: "ALL (x::bool) y::nat. NUMLEFT (NUMSUM x y) = x & NUMRIGHT (NUMSUM x y) = y"
by (import ind_type NUMSUM_DEST)
constdefs
- INJN :: "nat => nat => 'a => bool"
- "INJN == %m n a. n = m"
-
-lemma INJN: "ALL m. INJN m = (%n a. n = m)"
+ INJN :: "nat => nat => 'a::type => bool"
+ "INJN == %(m::nat) (n::nat) a::'a::type. n = m"
+
+lemma INJN: "ALL m::nat. INJN m = (%(n::nat) a::'a::type. n = m)"
by (import ind_type INJN)
-lemma INJN_INJ: "ALL n1 n2. (INJN n1 = INJN n2) = (n1 = n2)"
+lemma INJN_INJ: "ALL (n1::nat) n2::nat. (INJN n1 = INJN n2) = (n1 = n2)"
by (import ind_type INJN_INJ)
constdefs
- INJA :: "'a => nat => 'a => bool"
- "INJA == %a n b. b = a"
-
-lemma INJA: "ALL a. INJA a = (%n b. b = a)"
+ INJA :: "'a::type => nat => 'a::type => bool"
+ "INJA == %(a::'a::type) (n::nat) b::'a::type. b = a"
+
+lemma INJA: "ALL a::'a::type. INJA a = (%(n::nat) b::'a::type. b = a)"
by (import ind_type INJA)
-lemma INJA_INJ: "ALL a1 a2. (INJA a1 = INJA a2) = (a1 = a2)"
+lemma INJA_INJ: "ALL (a1::'a::type) a2::'a::type. (INJA a1 = INJA a2) = (a1 = a2)"
by (import ind_type INJA_INJ)
constdefs
- INJF :: "(nat => nat => 'a => bool) => nat => 'a => bool"
- "INJF == %f n. f (NUMFST n) (NUMSND n)"
-
-lemma INJF: "ALL f. INJF f = (%n. f (NUMFST n) (NUMSND n))"
+ INJF :: "(nat => nat => 'a::type => bool) => nat => 'a::type => bool"
+ "INJF == %(f::nat => nat => 'a::type => bool) n::nat. f (NUMFST n) (NUMSND n)"
+
+lemma INJF: "ALL f::nat => nat => 'a::type => bool.
+ INJF f = (%n::nat. f (NUMFST n) (NUMSND n))"
by (import ind_type INJF)
-lemma INJF_INJ: "ALL f1 f2. (INJF f1 = INJF f2) = (f1 = f2)"
+lemma INJF_INJ: "ALL (f1::nat => nat => 'a::type => bool) f2::nat => nat => 'a::type => bool.
+ (INJF f1 = INJF f2) = (f1 = f2)"
by (import ind_type INJF_INJ)
constdefs
- INJP :: "(nat => 'a => bool) => (nat => 'a => bool) => nat => 'a => bool"
+ INJP :: "(nat => 'a::type => bool)
+=> (nat => 'a::type => bool) => nat => 'a::type => bool"
"INJP ==
-%f1 f2 n a. if NUMLEFT n then f1 (NUMRIGHT n) a else f2 (NUMRIGHT n) a"
-
-lemma INJP: "ALL f1 f2.
+%(f1::nat => 'a::type => bool) (f2::nat => 'a::type => bool) (n::nat)
+ a::'a::type. if NUMLEFT n then f1 (NUMRIGHT n) a else f2 (NUMRIGHT n) a"
+
+lemma INJP: "ALL (f1::nat => 'a::type => bool) f2::nat => 'a::type => bool.
INJP f1 f2 =
- (%n a. if NUMLEFT n then f1 (NUMRIGHT n) a else f2 (NUMRIGHT n) a)"
+ (%(n::nat) a::'a::type.
+ if NUMLEFT n then f1 (NUMRIGHT n) a else f2 (NUMRIGHT n) a)"
by (import ind_type INJP)
-lemma INJP_INJ: "ALL f1 f1' f2 f2'. (INJP f1 f2 = INJP f1' f2') = (f1 = f1' & f2 = f2')"
+lemma INJP_INJ: "ALL (f1::nat => 'a::type => bool) (f1'::nat => 'a::type => bool)
+ (f2::nat => 'a::type => bool) f2'::nat => 'a::type => bool.
+ (INJP f1 f2 = INJP f1' f2') = (f1 = f1' & f2 = f2')"
by (import ind_type INJP_INJ)
constdefs
- ZCONSTR :: "nat => 'a => (nat => nat => 'a => bool) => nat => 'a => bool"
- "ZCONSTR == %c i r. INJP (INJN (Suc c)) (INJP (INJA i) (INJF r))"
-
-lemma ZCONSTR: "ALL c i r. ZCONSTR c i r = INJP (INJN (Suc c)) (INJP (INJA i) (INJF r))"
+ ZCONSTR :: "nat
+=> 'a::type => (nat => nat => 'a::type => bool) => nat => 'a::type => bool"
+ "ZCONSTR ==
+%(c::nat) (i::'a::type) r::nat => nat => 'a::type => bool.
+ INJP (INJN (Suc c)) (INJP (INJA i) (INJF r))"
+
+lemma ZCONSTR: "ALL (c::nat) (i::'a::type) r::nat => nat => 'a::type => bool.
+ ZCONSTR c i r = INJP (INJN (Suc c)) (INJP (INJA i) (INJF r))"
by (import ind_type ZCONSTR)
constdefs
- ZBOT :: "nat => 'a => bool"
- "ZBOT == INJP (INJN 0) (SOME z. True)"
-
-lemma ZBOT: "ZBOT = INJP (INJN 0) (SOME z. True)"
+ ZBOT :: "nat => 'a::type => bool"
+ "ZBOT == INJP (INJN (0::nat)) (SOME z::nat => 'a::type => bool. True)"
+
+lemma ZBOT: "ZBOT = INJP (INJN (0::nat)) (SOME z::nat => 'a::type => bool. True)"
by (import ind_type ZBOT)
-lemma ZCONSTR_ZBOT: "ALL x xa xb. ZCONSTR x xa xb ~= ZBOT"
+lemma ZCONSTR_ZBOT: "ALL (x::nat) (xa::'a::type) xb::nat => nat => 'a::type => bool.
+ ZCONSTR x xa xb ~= ZBOT"
by (import ind_type ZCONSTR_ZBOT)
constdefs
- ZRECSPACE :: "(nat => 'a => bool) => bool"
+ ZRECSPACE :: "(nat => 'a::type => bool) => bool"
"ZRECSPACE ==
-%a0. ALL ZRECSPACE'.
- (ALL a0.
- a0 = ZBOT |
- (EX c i r. a0 = ZCONSTR c i r & (ALL n. ZRECSPACE' (r n))) -->
- ZRECSPACE' a0) -->
- ZRECSPACE' a0"
+%a0::nat => 'a::type => bool.
+ ALL ZRECSPACE'::(nat => 'a::type => bool) => bool.
+ (ALL a0::nat => 'a::type => bool.
+ a0 = ZBOT |
+ (EX (c::nat) (i::'a::type) r::nat => nat => 'a::type => bool.
+ a0 = ZCONSTR c i r & (ALL n::nat. ZRECSPACE' (r n))) -->
+ ZRECSPACE' a0) -->
+ ZRECSPACE' a0"
lemma ZRECSPACE: "ZRECSPACE =
-(%a0. ALL ZRECSPACE'.
- (ALL a0.
- a0 = ZBOT |
- (EX c i r. a0 = ZCONSTR c i r & (ALL n. ZRECSPACE' (r n))) -->
- ZRECSPACE' a0) -->
- ZRECSPACE' a0)"
+(%a0::nat => 'a::type => bool.
+ ALL ZRECSPACE'::(nat => 'a::type => bool) => bool.
+ (ALL a0::nat => 'a::type => bool.
+ a0 = ZBOT |
+ (EX (c::nat) (i::'a::type) r::nat => nat => 'a::type => bool.
+ a0 = ZCONSTR c i r & (ALL n::nat. ZRECSPACE' (r n))) -->
+ ZRECSPACE' a0) -->
+ ZRECSPACE' a0)"
by (import ind_type ZRECSPACE)
lemma ZRECSPACE_rules: "(op &::bool => bool => bool)
- ((ZRECSPACE::(nat => 'a => bool) => bool) (ZBOT::nat => 'a => bool))
+ ((ZRECSPACE::(nat => 'a::type => bool) => bool)
+ (ZBOT::nat => 'a::type => bool))
((All::(nat => bool) => bool)
(%c::nat.
- (All::('a => bool) => bool)
- (%i::'a.
- (All::((nat => nat => 'a => bool) => bool) => bool)
- (%r::nat => nat => 'a => bool.
+ (All::('a::type => bool) => bool)
+ (%i::'a::type.
+ (All::((nat => nat => 'a::type => bool) => bool) => bool)
+ (%r::nat => nat => 'a::type => bool.
(op -->::bool => bool => bool)
((All::(nat => bool) => bool)
(%n::nat.
- (ZRECSPACE::(nat => 'a => bool) => bool) (r n)))
- ((ZRECSPACE::(nat => 'a => bool) => bool)
+ (ZRECSPACE::(nat => 'a::type => bool) => bool)
+ (r n)))
+ ((ZRECSPACE::(nat => 'a::type => bool) => bool)
((ZCONSTR::nat
- => 'a => (nat => nat => 'a => bool)
- => nat => 'a => bool)
+ => 'a::type
+ => (nat => nat => 'a::type => bool)
+ => nat => 'a::type => bool)
c i r))))))"
by (import ind_type ZRECSPACE_rules)
-lemma ZRECSPACE_ind: "ALL x.
- x ZBOT & (ALL c i r. (ALL n. x (r n)) --> x (ZCONSTR c i r)) -->
- (ALL a0. ZRECSPACE a0 --> x a0)"
+lemma ZRECSPACE_ind: "ALL x::(nat => 'a::type => bool) => bool.
+ x ZBOT &
+ (ALL (c::nat) (i::'a::type) r::nat => nat => 'a::type => bool.
+ (ALL n::nat. x (r n)) --> x (ZCONSTR c i r)) -->
+ (ALL a0::nat => 'a::type => bool. ZRECSPACE a0 --> x a0)"
by (import ind_type ZRECSPACE_ind)
-lemma ZRECSPACE_cases: "ALL a0.
+lemma ZRECSPACE_cases: "ALL a0::nat => 'a::type => bool.
ZRECSPACE a0 =
- (a0 = ZBOT | (EX c i r. a0 = ZCONSTR c i r & (ALL n. ZRECSPACE (r n))))"
+ (a0 = ZBOT |
+ (EX (c::nat) (i::'a::type) r::nat => nat => 'a::type => bool.
+ a0 = ZCONSTR c i r & (ALL n::nat. ZRECSPACE (r n))))"
by (import ind_type ZRECSPACE_cases)
-typedef (open) ('a) recspace = "(Collect::((nat => 'a => bool) => bool) => (nat => 'a => bool) set)
- (ZRECSPACE::(nat => 'a => bool) => bool)"
+typedef (open) ('a) recspace = "(Collect::((nat => 'a::type => bool) => bool)
+ => (nat => 'a::type => bool) set)
+ (ZRECSPACE::(nat => 'a::type => bool) => bool)"
by (rule typedef_helper,import ind_type recspace_TY_DEF)
lemmas recspace_TY_DEF = typedef_hol2hol4 [OF type_definition_recspace]
consts
- mk_rec :: "(nat => 'a => bool) => 'a recspace"
- dest_rec :: "'a recspace => nat => 'a => bool"
-
-specification (dest_rec mk_rec) recspace_repfns: "(ALL a::'a recspace. mk_rec (dest_rec a) = a) &
-(ALL r::nat => 'a => bool. ZRECSPACE r = (dest_rec (mk_rec r) = r))"
+ mk_rec :: "(nat => 'a::type => bool) => 'a::type recspace"
+ dest_rec :: "'a::type recspace => nat => 'a::type => bool"
+
+specification (dest_rec mk_rec) recspace_repfns: "(ALL a::'a::type recspace. mk_rec (dest_rec a) = a) &
+(ALL r::nat => 'a::type => bool. ZRECSPACE r = (dest_rec (mk_rec r) = r))"
by (import ind_type recspace_repfns)
constdefs
- BOTTOM :: "'a recspace"
+ BOTTOM :: "'a::type recspace"
"BOTTOM == mk_rec ZBOT"
lemma BOTTOM: "BOTTOM = mk_rec ZBOT"
by (import ind_type BOTTOM)
constdefs
- CONSTR :: "nat => 'a => (nat => 'a recspace) => 'a recspace"
- "CONSTR == %c i r. mk_rec (ZCONSTR c i (%n. dest_rec (r n)))"
-
-lemma CONSTR: "ALL c i r. CONSTR c i r = mk_rec (ZCONSTR c i (%n. dest_rec (r n)))"
+ CONSTR :: "nat => 'a::type => (nat => 'a::type recspace) => 'a::type recspace"
+ "CONSTR ==
+%(c::nat) (i::'a::type) r::nat => 'a::type recspace.
+ mk_rec (ZCONSTR c i (%n::nat. dest_rec (r n)))"
+
+lemma CONSTR: "ALL (c::nat) (i::'a::type) r::nat => 'a::type recspace.
+ CONSTR c i r = mk_rec (ZCONSTR c i (%n::nat. dest_rec (r n)))"
by (import ind_type CONSTR)
-lemma MK_REC_INJ: "ALL x y. mk_rec x = mk_rec y --> ZRECSPACE x & ZRECSPACE y --> x = y"
+lemma MK_REC_INJ: "ALL (x::nat => 'a::type => bool) y::nat => 'a::type => bool.
+ mk_rec x = mk_rec y --> ZRECSPACE x & ZRECSPACE y --> x = y"
by (import ind_type MK_REC_INJ)
-lemma DEST_REC_INJ: "ALL x y. (dest_rec x = dest_rec y) = (x = y)"
+lemma DEST_REC_INJ: "ALL (x::'a::type recspace) y::'a::type recspace.
+ (dest_rec x = dest_rec y) = (x = y)"
by (import ind_type DEST_REC_INJ)
-lemma CONSTR_BOT: "ALL c i r. CONSTR c i r ~= BOTTOM"
+lemma CONSTR_BOT: "ALL (c::nat) (i::'a::type) r::nat => 'a::type recspace.
+ CONSTR c i r ~= BOTTOM"
by (import ind_type CONSTR_BOT)
-lemma CONSTR_INJ: "ALL c1 i1 r1 c2 i2 r2.
+lemma CONSTR_INJ: "ALL (c1::nat) (i1::'a::type) (r1::nat => 'a::type recspace) (c2::nat)
+ (i2::'a::type) r2::nat => 'a::type recspace.
(CONSTR c1 i1 r1 = CONSTR c2 i2 r2) = (c1 = c2 & i1 = i2 & r1 = r2)"
by (import ind_type CONSTR_INJ)
-lemma CONSTR_IND: "ALL P.
- P BOTTOM & (ALL c i r. (ALL n. P (r n)) --> P (CONSTR c i r)) --> All P"
+lemma CONSTR_IND: "ALL P::'a::type recspace => bool.
+ P BOTTOM &
+ (ALL (c::nat) (i::'a::type) r::nat => 'a::type recspace.
+ (ALL n::nat. P (r n)) --> P (CONSTR c i r)) -->
+ All P"
by (import ind_type CONSTR_IND)
-lemma CONSTR_REC: "ALL Fn. EX f. ALL c i r. f (CONSTR c i r) = Fn c i r (%n. f (r n))"
+lemma CONSTR_REC: "ALL Fn::nat
+ => 'a::type
+ => (nat => 'a::type recspace) => (nat => 'b::type) => 'b::type.
+ EX f::'a::type recspace => 'b::type.
+ ALL (c::nat) (i::'a::type) r::nat => 'a::type recspace.
+ f (CONSTR c i r) = Fn c i r (%n::nat. f (r n))"
by (import ind_type CONSTR_REC)
consts
- FCONS :: "'a => (nat => 'a) => nat => 'a"
-
-specification (FCONS) FCONS: "(ALL (a::'a) f::nat => 'a. FCONS a f (0::nat) = a) &
-(ALL (a::'a) (f::nat => 'a) n::nat. FCONS a f (Suc n) = f n)"
+ FCONS :: "'a::type => (nat => 'a::type) => nat => 'a::type"
+
+specification (FCONS) FCONS: "(ALL (a::'a::type) f::nat => 'a::type. FCONS a f (0::nat) = a) &
+(ALL (a::'a::type) (f::nat => 'a::type) n::nat. FCONS a f (Suc n) = f n)"
by (import ind_type FCONS)
constdefs
- FNIL :: "nat => 'a"
- "FNIL == %n. SOME x. True"
-
-lemma FNIL: "ALL n. FNIL n = (SOME x. True)"
+ FNIL :: "nat => 'a::type"
+ "FNIL == %n::nat. SOME x::'a::type. True"
+
+lemma FNIL: "ALL n::nat. FNIL n = (SOME x::'a::type. True)"
by (import ind_type FNIL)
constdefs
- ISO :: "('a => 'b) => ('b => 'a) => bool"
- "ISO == %f g. (ALL x. f (g x) = x) & (ALL y. g (f y) = y)"
-
-lemma ISO: "ALL f g. ISO f g = ((ALL x. f (g x) = x) & (ALL y. g (f y) = y))"
+ ISO :: "('a::type => 'b::type) => ('b::type => 'a::type) => bool"
+ "ISO ==
+%(f::'a::type => 'b::type) g::'b::type => 'a::type.
+ (ALL x::'b::type. f (g x) = x) & (ALL y::'a::type. g (f y) = y)"
+
+lemma ISO: "ALL (f::'a::type => 'b::type) g::'b::type => 'a::type.
+ ISO f g =
+ ((ALL x::'b::type. f (g x) = x) & (ALL y::'a::type. g (f y) = y))"
by (import ind_type ISO)
-lemma ISO_REFL: "ISO (%x. x) (%x. x)"
+lemma ISO_REFL: "ISO (%x::'a::type. x) (%x::'a::type. x)"
by (import ind_type ISO_REFL)
-lemma ISO_FUN: "ISO (f::'a => 'c) (f'::'c => 'a) & ISO (g::'b => 'd) (g'::'d => 'b) -->
-ISO (%(h::'a => 'b) a'::'c. g (h (f' a')))
- (%(h::'c => 'd) a::'a. g' (h (f a)))"
+lemma ISO_FUN: "ISO (f::'a::type => 'c::type) (f'::'c::type => 'a::type) &
+ISO (g::'b::type => 'd::type) (g'::'d::type => 'b::type) -->
+ISO (%(h::'a::type => 'b::type) a'::'c::type. g (h (f' a')))
+ (%(h::'c::type => 'd::type) a::'a::type. g' (h (f a)))"
by (import ind_type ISO_FUN)
-lemma ISO_USAGE: "ISO f g -->
-(ALL P. All P = (ALL x. P (g x))) &
-(ALL P. Ex P = (EX x. P (g x))) & (ALL a b. (a = g b) = (f a = b))"
+lemma ISO_USAGE: "ISO (f::'a::type => 'b::type) (g::'b::type => 'a::type) -->
+(ALL P::'a::type => bool. All P = (ALL x::'b::type. P (g x))) &
+(ALL P::'a::type => bool. Ex P = (EX x::'b::type. P (g x))) &
+(ALL (a::'a::type) b::'b::type. (a = g b) = (f a = b))"
by (import ind_type ISO_USAGE)
;end_setup
@@ -2480,7 +2911,7 @@
lemma DIVIDES_ADD_2: "ALL (a::nat) (b::nat) c::nat. a dvd b & a dvd b + c --> a dvd c"
by (import divides DIVIDES_ADD_2)
-lemma DIVIDES_FACT: "ALL b>0. b dvd FACT b"
+lemma DIVIDES_FACT: "ALL b>0::nat. b dvd FACT b"
by (import divides DIVIDES_FACT)
lemma DIVIDES_MULT_LEFT: "ALL (x::nat) xa::nat. (x * xa dvd xa) = (xa = (0::nat) | x = (1::nat))"
@@ -2494,15 +2925,18 @@
prime :: "nat => bool"
defs
- prime_primdef: "prime.prime == %a. a ~= 1 & (ALL b. b dvd a --> b = a | b = 1)"
-
-lemma prime_def: "ALL a. prime.prime a = (a ~= 1 & (ALL b. b dvd a --> b = a | b = 1))"
+ prime_primdef: "prime.prime ==
+%a::nat. a ~= (1::nat) & (ALL b::nat. b dvd a --> b = a | b = (1::nat))"
+
+lemma prime_def: "ALL a::nat.
+ prime.prime a =
+ (a ~= (1::nat) & (ALL b::nat. b dvd a --> b = a | b = (1::nat)))"
by (import prime prime_def)
-lemma NOT_PRIME_0: "~ prime.prime 0"
+lemma NOT_PRIME_0: "~ prime.prime (0::nat)"
by (import prime NOT_PRIME_0)
-lemma NOT_PRIME_1: "~ prime.prime 1"
+lemma NOT_PRIME_1: "~ prime.prime (1::nat)"
by (import prime NOT_PRIME_1)
;end_setup
@@ -2510,224 +2944,286 @@
;setup_theory list
consts
- EL :: "nat => 'a list => 'a"
-
-specification (EL) EL: "(ALL l::'a list. EL (0::nat) l = hd l) &
-(ALL (l::'a list) n::nat. EL (Suc n) l = EL n (tl l))"
+ EL :: "nat => 'a::type list => 'a::type"
+
+specification (EL) EL: "(ALL l::'a::type list. EL (0::nat) l = hd l) &
+(ALL (l::'a::type list) n::nat. EL (Suc n) l = EL n (tl l))"
by (import list EL)
-lemma NULL: "(op &::bool => bool => bool) ((null::'a list => bool) ([]::'a list))
- ((All::('a => bool) => bool)
- (%x::'a.
- (All::('a list => bool) => bool)
- (%xa::'a list.
+lemma NULL: "(op &::bool => bool => bool)
+ ((null::'a::type list => bool) ([]::'a::type list))
+ ((All::('a::type => bool) => bool)
+ (%x::'a::type.
+ (All::('a::type list => bool) => bool)
+ (%xa::'a::type list.
(Not::bool => bool)
- ((null::'a list => bool)
- ((op #::'a => 'a list => 'a list) x xa)))))"
+ ((null::'a::type list => bool)
+ ((op #::'a::type => 'a::type list => 'a::type list) x xa)))))"
by (import list NULL)
-lemma list_case_compute: "ALL l. list_case b f l = (if null l then b else f (hd l) (tl l))"
+lemma list_case_compute: "ALL l::'a::type list.
+ list_case (b::'b::type) (f::'a::type => 'a::type list => 'b::type) l =
+ (if null l then b else f (hd l) (tl l))"
by (import list list_case_compute)
-lemma LIST_NOT_EQ: "ALL l1 l2. l1 ~= l2 --> (ALL x xa. x # l1 ~= xa # l2)"
+lemma LIST_NOT_EQ: "ALL (l1::'a::type list) l2::'a::type list.
+ l1 ~= l2 --> (ALL (x::'a::type) xa::'a::type. x # l1 ~= xa # l2)"
by (import list LIST_NOT_EQ)
-lemma NOT_EQ_LIST: "ALL h1 h2. h1 ~= h2 --> (ALL x xa. h1 # x ~= h2 # xa)"
+lemma NOT_EQ_LIST: "ALL (h1::'a::type) h2::'a::type.
+ h1 ~= h2 -->
+ (ALL (x::'a::type list) xa::'a::type list. h1 # x ~= h2 # xa)"
by (import list NOT_EQ_LIST)
-lemma EQ_LIST: "ALL h1 h2. h1 = h2 --> (ALL l1 l2. l1 = l2 --> h1 # l1 = h2 # l2)"
+lemma EQ_LIST: "ALL (h1::'a::type) h2::'a::type.
+ h1 = h2 -->
+ (ALL (l1::'a::type list) l2::'a::type list.
+ l1 = l2 --> h1 # l1 = h2 # l2)"
by (import list EQ_LIST)
-lemma CONS: "ALL l. ~ null l --> hd l # tl l = l"
+lemma CONS: "ALL l::'a::type list. ~ null l --> hd l # tl l = l"
by (import list CONS)
-lemma MAP_EQ_NIL: "ALL l f. (map f l = []) = (l = []) & ([] = map f l) = (l = [])"
+lemma MAP_EQ_NIL: "ALL (l::'a::type list) f::'a::type => 'b::type.
+ (map f l = []) = (l = []) & ([] = map f l) = (l = [])"
by (import list MAP_EQ_NIL)
-lemma EVERY_EL: "(All::('a list => bool) => bool)
- (%l::'a list.
- (All::(('a => bool) => bool) => bool)
- (%P::'a => bool.
+lemma EVERY_EL: "(All::('a::type list => bool) => bool)
+ (%l::'a::type list.
+ (All::(('a::type => bool) => bool) => bool)
+ (%P::'a::type => bool.
(op =::bool => bool => bool)
- ((list_all::('a => bool) => 'a list => bool) P l)
+ ((list_all::('a::type => bool) => 'a::type list => bool) P l)
((All::(nat => bool) => bool)
(%n::nat.
(op -->::bool => bool => bool)
- ((op <::nat => nat => bool) n ((size::'a list => nat) l))
- (P ((EL::nat => 'a list => 'a) n l))))))"
+ ((op <::nat => nat => bool) n
+ ((size::'a::type list => nat) l))
+ (P ((EL::nat => 'a::type list => 'a::type) n l))))))"
by (import list EVERY_EL)
-lemma EVERY_CONJ: "ALL l. list_all (%x. P x & Q x) l = (list_all P l & list_all Q l)"
+lemma EVERY_CONJ: "ALL l::'a::type list.
+ list_all
+ (%x::'a::type. (P::'a::type => bool) x & (Q::'a::type => bool) x) l =
+ (list_all P l & list_all Q l)"
by (import list EVERY_CONJ)
-lemma EVERY_MEM: "ALL P l. list_all P l = (ALL e. e mem l --> P e)"
+lemma EVERY_MEM: "ALL (P::'a::type => bool) l::'a::type list.
+ list_all P l = (ALL e::'a::type. e mem l --> P e)"
by (import list EVERY_MEM)
-lemma EXISTS_MEM: "ALL P l. list_exists P l = (EX e. e mem l & P e)"
+lemma EXISTS_MEM: "ALL (P::'a::type => bool) l::'a::type list.
+ list_exists P l = (EX e::'a::type. e mem l & P e)"
by (import list EXISTS_MEM)
-lemma MEM_APPEND: "ALL e l1 l2. e mem l1 @ l2 = (e mem l1 | e mem l2)"
+lemma MEM_APPEND: "ALL (e::'a::type) (l1::'a::type list) l2::'a::type list.
+ e mem l1 @ l2 = (e mem l1 | e mem l2)"
by (import list MEM_APPEND)
-lemma EXISTS_APPEND: "ALL P l1 l2. list_exists P (l1 @ l2) = (list_exists P l1 | list_exists P l2)"
+lemma EXISTS_APPEND: "ALL (P::'a::type => bool) (l1::'a::type list) l2::'a::type list.
+ list_exists P (l1 @ l2) = (list_exists P l1 | list_exists P l2)"
by (import list EXISTS_APPEND)
-lemma NOT_EVERY: "ALL P l. (~ list_all P l) = list_exists (Not o P) l"
+lemma NOT_EVERY: "ALL (P::'a::type => bool) l::'a::type list.
+ (~ list_all P l) = list_exists (Not o P) l"
by (import list NOT_EVERY)
-lemma NOT_EXISTS: "ALL P l. (~ list_exists P l) = list_all (Not o P) l"
+lemma NOT_EXISTS: "ALL (P::'a::type => bool) l::'a::type list.
+ (~ list_exists P l) = list_all (Not o P) l"
by (import list NOT_EXISTS)
-lemma MEM_MAP: "ALL l f x. x mem map f l = (EX y. x = f y & y mem l)"
+lemma MEM_MAP: "ALL (l::'a::type list) (f::'a::type => 'b::type) x::'b::type.
+ x mem map f l = (EX y::'a::type. x = f y & y mem l)"
by (import list MEM_MAP)
-lemma LENGTH_CONS: "ALL l n. (length l = Suc n) = (EX h l'. length l' = n & l = h # l')"
+lemma LENGTH_CONS: "ALL (l::'a::type list) n::nat.
+ (length l = Suc n) =
+ (EX (h::'a::type) l'::'a::type list. length l' = n & l = h # l')"
by (import list LENGTH_CONS)
-lemma LENGTH_EQ_CONS: "ALL P n.
- (ALL l. length l = Suc n --> P l) =
- (ALL l. length l = n --> (ALL x. P (x # l)))"
+lemma LENGTH_EQ_CONS: "ALL (P::'a::type list => bool) n::nat.
+ (ALL l::'a::type list. length l = Suc n --> P l) =
+ (ALL l::'a::type list. length l = n --> (ALL x::'a::type. P (x # l)))"
by (import list LENGTH_EQ_CONS)
-lemma LENGTH_EQ_NIL: "ALL P. (ALL l. length l = 0 --> P l) = P []"
+lemma LENGTH_EQ_NIL: "ALL P::'a::type list => bool.
+ (ALL l::'a::type list. length l = (0::nat) --> P l) = P []"
by (import list LENGTH_EQ_NIL)
-lemma CONS_ACYCLIC: "ALL l x. l ~= x # l & x # l ~= l"
+lemma CONS_ACYCLIC: "ALL (l::'a::type list) x::'a::type. l ~= x # l & x # l ~= l"
by (import list CONS_ACYCLIC)
-lemma APPEND_eq_NIL: "(ALL (l1::'a list) l2::'a list. ([] = l1 @ l2) = (l1 = [] & l2 = [])) &
-(ALL (l1::'a list) l2::'a list. (l1 @ l2 = []) = (l1 = [] & l2 = []))"
+lemma APPEND_eq_NIL: "(ALL (l1::'a::type list) l2::'a::type list.
+ ([] = l1 @ l2) = (l1 = [] & l2 = [])) &
+(ALL (l1::'a::type list) l2::'a::type list.
+ (l1 @ l2 = []) = (l1 = [] & l2 = []))"
by (import list APPEND_eq_NIL)
-lemma APPEND_11: "(ALL (l1::'a list) (l2::'a list) l3::'a list.
+lemma APPEND_11: "(ALL (l1::'a::type list) (l2::'a::type list) l3::'a::type list.
(l1 @ l2 = l1 @ l3) = (l2 = l3)) &
-(ALL (l1::'a list) (l2::'a list) l3::'a list.
+(ALL (l1::'a::type list) (l2::'a::type list) l3::'a::type list.
(l2 @ l1 = l3 @ l1) = (l2 = l3))"
by (import list APPEND_11)
-lemma EL_compute: "ALL n. EL n l = (if n = 0 then hd l else EL (PRE n) (tl l))"
+lemma EL_compute: "ALL n::nat.
+ EL n (l::'a::type list) =
+ (if n = (0::nat) then hd l else EL (PRE n) (tl l))"
by (import list EL_compute)
-lemma WF_LIST_PRED: "WF (%L1 L2. EX h. L2 = h # L1)"
+lemma WF_LIST_PRED: "WF (%(L1::'a::type list) L2::'a::type list. EX h::'a::type. L2 = h # L1)"
by (import list WF_LIST_PRED)
-lemma list_size_cong: "ALL M N f f'.
- M = N & (ALL x. x mem N --> f x = f' x) -->
+lemma list_size_cong: "ALL (M::'a::type list) (N::'a::type list) (f::'a::type => nat)
+ f'::'a::type => nat.
+ M = N & (ALL x::'a::type. x mem N --> f x = f' x) -->
list_size f M = list_size f' N"
by (import list list_size_cong)
-lemma FOLDR_CONG: "ALL l l' b b' f f'.
- l = l' & b = b' & (ALL x a. x mem l' --> f x a = f' x a) -->
+lemma FOLDR_CONG: "ALL (l::'a::type list) (l'::'a::type list) (b::'b::type) (b'::'b::type)
+ (f::'a::type => 'b::type => 'b::type)
+ f'::'a::type => 'b::type => 'b::type.
+ l = l' &
+ b = b' & (ALL (x::'a::type) a::'b::type. x mem l' --> f x a = f' x a) -->
foldr f l b = foldr f' l' b'"
by (import list FOLDR_CONG)
-lemma FOLDL_CONG: "ALL l l' b b' f f'.
- l = l' & b = b' & (ALL x a. x mem l' --> f a x = f' a x) -->
+lemma FOLDL_CONG: "ALL (l::'a::type list) (l'::'a::type list) (b::'b::type) (b'::'b::type)
+ (f::'b::type => 'a::type => 'b::type)
+ f'::'b::type => 'a::type => 'b::type.
+ l = l' &
+ b = b' & (ALL (x::'a::type) a::'b::type. x mem l' --> f a x = f' a x) -->
foldl f b l = foldl f' b' l'"
by (import list FOLDL_CONG)
-lemma MAP_CONG: "ALL l1 l2 f f'.
- l1 = l2 & (ALL x. x mem l2 --> f x = f' x) --> map f l1 = map f' l2"
+lemma MAP_CONG: "ALL (l1::'a::type list) (l2::'a::type list) (f::'a::type => 'b::type)
+ f'::'a::type => 'b::type.
+ l1 = l2 & (ALL x::'a::type. x mem l2 --> f x = f' x) -->
+ map f l1 = map f' l2"
by (import list MAP_CONG)
-lemma EXISTS_CONG: "ALL l1 l2 P P'.
- l1 = l2 & (ALL x. x mem l2 --> P x = P' x) -->
+lemma EXISTS_CONG: "ALL (l1::'a::type list) (l2::'a::type list) (P::'a::type => bool)
+ P'::'a::type => bool.
+ l1 = l2 & (ALL x::'a::type. x mem l2 --> P x = P' x) -->
list_exists P l1 = list_exists P' l2"
by (import list EXISTS_CONG)
-lemma EVERY_CONG: "ALL l1 l2 P P'.
- l1 = l2 & (ALL x. x mem l2 --> P x = P' x) -->
+lemma EVERY_CONG: "ALL (l1::'a::type list) (l2::'a::type list) (P::'a::type => bool)
+ P'::'a::type => bool.
+ l1 = l2 & (ALL x::'a::type. x mem l2 --> P x = P' x) -->
list_all P l1 = list_all P' l2"
by (import list EVERY_CONG)
-lemma EVERY_MONOTONIC: "ALL P Q. (ALL x. P x --> Q x) --> (ALL l. list_all P l --> list_all Q l)"
+lemma EVERY_MONOTONIC: "ALL (P::'a::type => bool) Q::'a::type => bool.
+ (ALL x::'a::type. P x --> Q x) -->
+ (ALL l::'a::type list. list_all P l --> list_all Q l)"
by (import list EVERY_MONOTONIC)
-lemma LENGTH_ZIP: "ALL l1 l2.
+lemma LENGTH_ZIP: "ALL (l1::'a::type list) l2::'b::type list.
length l1 = length l2 -->
length (zip l1 l2) = length l1 & length (zip l1 l2) = length l2"
by (import list LENGTH_ZIP)
-lemma LENGTH_UNZIP: "ALL pl.
+lemma LENGTH_UNZIP: "ALL pl::('a::type * 'b::type) list.
length (fst (unzip pl)) = length pl & length (snd (unzip pl)) = length pl"
by (import list LENGTH_UNZIP)
-lemma ZIP_UNZIP: "ALL l. ZIP (unzip l) = l"
+lemma ZIP_UNZIP: "ALL l::('a::type * 'b::type) list. ZIP (unzip l) = l"
by (import list ZIP_UNZIP)
-lemma UNZIP_ZIP: "ALL l1 l2. length l1 = length l2 --> unzip (zip l1 l2) = (l1, l2)"
+lemma UNZIP_ZIP: "ALL (l1::'a::type list) l2::'b::type list.
+ length l1 = length l2 --> unzip (zip l1 l2) = (l1, l2)"
by (import list UNZIP_ZIP)
-lemma ZIP_MAP: "ALL l1 l2 f1 f2.
+lemma ZIP_MAP: "ALL (l1::'a::type list) (l2::'b::type list) (f1::'a::type => 'c::type)
+ f2::'b::type => 'd::type.
length l1 = length l2 -->
- zip (map f1 l1) l2 = map (%p. (f1 (fst p), snd p)) (zip l1 l2) &
- zip l1 (map f2 l2) = map (%p. (fst p, f2 (snd p))) (zip l1 l2)"
+ zip (map f1 l1) l2 =
+ map (%p::'a::type * 'b::type. (f1 (fst p), snd p)) (zip l1 l2) &
+ zip l1 (map f2 l2) =
+ map (%p::'a::type * 'b::type. (fst p, f2 (snd p))) (zip l1 l2)"
by (import list ZIP_MAP)
-lemma MEM_ZIP: "(All::('a list => bool) => bool)
- (%l1::'a list.
- (All::('b list => bool) => bool)
- (%l2::'b list.
- (All::('a * 'b => bool) => bool)
- (%p::'a * 'b.
+lemma MEM_ZIP: "(All::('a::type list => bool) => bool)
+ (%l1::'a::type list.
+ (All::('b::type list => bool) => bool)
+ (%l2::'b::type list.
+ (All::('a::type * 'b::type => bool) => bool)
+ (%p::'a::type * 'b::type.
(op -->::bool => bool => bool)
- ((op =::nat => nat => bool) ((size::'a list => nat) l1)
- ((size::'b list => nat) l2))
+ ((op =::nat => nat => bool)
+ ((size::'a::type list => nat) l1)
+ ((size::'b::type list => nat) l2))
((op =::bool => bool => bool)
- ((op mem::'a * 'b => ('a * 'b) list => bool) p
- ((zip::'a list => 'b list => ('a * 'b) list) l1 l2))
+ ((op mem::'a::type * 'b::type
+ => ('a::type * 'b::type) list => bool)
+ p ((zip::'a::type list
+ => 'b::type list => ('a::type * 'b::type) list)
+ l1 l2))
((Ex::(nat => bool) => bool)
(%n::nat.
(op &::bool => bool => bool)
((op <::nat => nat => bool) n
- ((size::'a list => nat) l1))
- ((op =::'a * 'b => 'a * 'b => bool) p
- ((Pair::'a => 'b => 'a * 'b)
- ((EL::nat => 'a list => 'a) n l1)
- ((EL::nat => 'b list => 'b) n l2)))))))))"
+ ((size::'a::type list => nat) l1))
+ ((op =::'a::type * 'b::type
+ => 'a::type * 'b::type => bool)
+ p ((Pair::'a::type
+ => 'b::type => 'a::type * 'b::type)
+ ((EL::nat => 'a::type list => 'a::type) n l1)
+ ((EL::nat => 'b::type list => 'b::type) n
+ l2)))))))))"
by (import list MEM_ZIP)
-lemma EL_ZIP: "ALL l1 l2 n.
+lemma EL_ZIP: "ALL (l1::'a::type list) (l2::'b::type list) n::nat.
length l1 = length l2 & n < length l1 -->
EL n (zip l1 l2) = (EL n l1, EL n l2)"
by (import list EL_ZIP)
-lemma MAP2_ZIP: "(All::('a list => bool) => bool)
- (%l1::'a list.
- (All::('b list => bool) => bool)
- (%l2::'b list.
+lemma MAP2_ZIP: "(All::('a::type list => bool) => bool)
+ (%l1::'a::type list.
+ (All::('b::type list => bool) => bool)
+ (%l2::'b::type list.
(op -->::bool => bool => bool)
- ((op =::nat => nat => bool) ((size::'a list => nat) l1)
- ((size::'b list => nat) l2))
- ((All::(('a => 'b => 'c) => bool) => bool)
- (%f::'a => 'b => 'c.
- (op =::'c list => 'c list => bool)
- ((map2::('a => 'b => 'c) => 'a list => 'b list => 'c list)
+ ((op =::nat => nat => bool) ((size::'a::type list => nat) l1)
+ ((size::'b::type list => nat) l2))
+ ((All::(('a::type => 'b::type => 'c::type) => bool) => bool)
+ (%f::'a::type => 'b::type => 'c::type.
+ (op =::'c::type list => 'c::type list => bool)
+ ((map2::('a::type => 'b::type => 'c::type)
+ => 'a::type list
+ => 'b::type list => 'c::type list)
f l1 l2)
- ((map::('a * 'b => 'c) => ('a * 'b) list => 'c list)
- ((split::('a => 'b => 'c) => 'a * 'b => 'c) f)
- ((zip::'a list => 'b list => ('a * 'b) list) l1 l2))))))"
+ ((map::('a::type * 'b::type => 'c::type)
+ => ('a::type * 'b::type) list => 'c::type list)
+ ((split::('a::type => 'b::type => 'c::type)
+ => 'a::type * 'b::type => 'c::type)
+ f)
+ ((zip::'a::type list
+ => 'b::type list => ('a::type * 'b::type) list)
+ l1 l2))))))"
by (import list MAP2_ZIP)
-lemma MEM_EL: "(All::('a list => bool) => bool)
- (%l::'a list.
- (All::('a => bool) => bool)
- (%x::'a.
- (op =::bool => bool => bool) ((op mem::'a => 'a list => bool) x l)
+lemma MEM_EL: "(All::('a::type list => bool) => bool)
+ (%l::'a::type list.
+ (All::('a::type => bool) => bool)
+ (%x::'a::type.
+ (op =::bool => bool => bool)
+ ((op mem::'a::type => 'a::type list => bool) x l)
((Ex::(nat => bool) => bool)
(%n::nat.
(op &::bool => bool => bool)
- ((op <::nat => nat => bool) n ((size::'a list => nat) l))
- ((op =::'a => 'a => bool) x
- ((EL::nat => 'a list => 'a) n l))))))"
+ ((op <::nat => nat => bool) n
+ ((size::'a::type list => nat) l))
+ ((op =::'a::type => 'a::type => bool) x
+ ((EL::nat => 'a::type list => 'a::type) n l))))))"
by (import list MEM_EL)
-lemma LAST_CONS: "(ALL x::'a. last [x] = x) &
-(ALL (x::'a) (xa::'a) xb::'a list. last (x # xa # xb) = last (xa # xb))"
+lemma LAST_CONS: "(ALL x::'a::type. last [x] = x) &
+(ALL (x::'a::type) (xa::'a::type) xb::'a::type list.
+ last (x # xa # xb) = last (xa # xb))"
by (import list LAST_CONS)
-lemma FRONT_CONS: "(ALL x::'a. butlast [x] = []) &
-(ALL (x::'a) (xa::'a) xb::'a list.
+lemma FRONT_CONS: "(ALL x::'a::type. butlast [x] = []) &
+(ALL (x::'a::type) (xa::'a::type) xb::'a::type list.
butlast (x # xa # xb) = x # butlast (xa # xb))"
by (import list FRONT_CONS)
@@ -2735,10 +3231,12 @@
;setup_theory pred_set
-lemma EXTENSION: "ALL s t. (s = t) = (ALL x. IN x s = IN x t)"
+lemma EXTENSION: "ALL (s::'a::type => bool) t::'a::type => bool.
+ (s = t) = (ALL x::'a::type. IN x s = IN x t)"
by (import pred_set EXTENSION)
-lemma NOT_EQUAL_SETS: "ALL x xa. (x ~= xa) = (EX xb. IN xb xa = (~ IN xb x))"
+lemma NOT_EQUAL_SETS: "ALL (x::'a::type => bool) xa::'a::type => bool.
+ (x ~= xa) = (EX xb::'a::type. IN xb xa = (~ IN xb x))"
by (import pred_set NOT_EQUAL_SETS)
lemma NUM_SET_WOP: "ALL s::nat => bool.
@@ -2747,39 +3245,40 @@
by (import pred_set NUM_SET_WOP)
consts
- GSPEC :: "('b => 'a * bool) => 'a => bool"
-
-specification (GSPEC) GSPECIFICATION: "ALL (f::'b => 'a * bool) v::'a. IN v (GSPEC f) = (EX x::'b. (v, True) = f x)"
+ GSPEC :: "('b::type => 'a::type * bool) => 'a::type => bool"
+
+specification (GSPEC) GSPECIFICATION: "ALL (f::'b::type => 'a::type * bool) v::'a::type.
+ IN v (GSPEC f) = (EX x::'b::type. (v, True) = f x)"
by (import pred_set GSPECIFICATION)
-lemma SET_MINIMUM: "ALL (s::'a => bool) M::'a => nat.
- (EX x::'a. IN x s) =
- (EX x::'a. IN x s & (ALL y::'a. IN y s --> M x <= M y))"
+lemma SET_MINIMUM: "ALL (s::'a::type => bool) M::'a::type => nat.
+ (EX x::'a::type. IN x s) =
+ (EX x::'a::type. IN x s & (ALL y::'a::type. IN y s --> M x <= M y))"
by (import pred_set SET_MINIMUM)
constdefs
- EMPTY :: "'a => bool"
- "EMPTY == %x. False"
-
-lemma EMPTY_DEF: "EMPTY = (%x. False)"
+ EMPTY :: "'a::type => bool"
+ "EMPTY == %x::'a::type. False"
+
+lemma EMPTY_DEF: "EMPTY = (%x::'a::type. False)"
by (import pred_set EMPTY_DEF)
-lemma NOT_IN_EMPTY: "ALL x. ~ IN x EMPTY"
+lemma NOT_IN_EMPTY: "ALL x::'a::type. ~ IN x EMPTY"
by (import pred_set NOT_IN_EMPTY)
-lemma MEMBER_NOT_EMPTY: "ALL x. (EX xa. IN xa x) = (x ~= EMPTY)"
+lemma MEMBER_NOT_EMPTY: "ALL x::'a::type => bool. (EX xa::'a::type. IN xa x) = (x ~= EMPTY)"
by (import pred_set MEMBER_NOT_EMPTY)
consts
- UNIV :: "'a => bool"
+ UNIV :: "'a::type => bool"
defs
- UNIV_def: "pred_set.UNIV == %x. True"
-
-lemma UNIV_DEF: "pred_set.UNIV = (%x. True)"
+ UNIV_def: "pred_set.UNIV == %x::'a::type. True"
+
+lemma UNIV_DEF: "pred_set.UNIV = (%x::'a::type. True)"
by (import pred_set UNIV_DEF)
-lemma IN_UNIV: "ALL x. IN x pred_set.UNIV"
+lemma IN_UNIV: "ALL x::'a::type. IN x pred_set.UNIV"
by (import pred_set IN_UNIV)
lemma UNIV_NOT_EMPTY: "pred_set.UNIV ~= EMPTY"
@@ -2788,868 +3287,1025 @@
lemma EMPTY_NOT_UNIV: "EMPTY ~= pred_set.UNIV"
by (import pred_set EMPTY_NOT_UNIV)
-lemma EQ_UNIV: "(ALL x. IN x s) = (s = pred_set.UNIV)"
+lemma EQ_UNIV: "(ALL x::'a::type. IN x (s::'a::type => bool)) = (s = pred_set.UNIV)"
by (import pred_set EQ_UNIV)
constdefs
- SUBSET :: "('a => bool) => ('a => bool) => bool"
- "SUBSET == %s t. ALL x. IN x s --> IN x t"
-
-lemma SUBSET_DEF: "ALL s t. SUBSET s t = (ALL x. IN x s --> IN x t)"
+ SUBSET :: "('a::type => bool) => ('a::type => bool) => bool"
+ "SUBSET ==
+%(s::'a::type => bool) t::'a::type => bool.
+ ALL x::'a::type. IN x s --> IN x t"
+
+lemma SUBSET_DEF: "ALL (s::'a::type => bool) t::'a::type => bool.
+ SUBSET s t = (ALL x::'a::type. IN x s --> IN x t)"
by (import pred_set SUBSET_DEF)
-lemma SUBSET_TRANS: "ALL x xa xb. SUBSET x xa & SUBSET xa xb --> SUBSET x xb"
+lemma SUBSET_TRANS: "ALL (x::'a::type => bool) (xa::'a::type => bool) xb::'a::type => bool.
+ SUBSET x xa & SUBSET xa xb --> SUBSET x xb"
by (import pred_set SUBSET_TRANS)
-lemma SUBSET_REFL: "ALL x. SUBSET x x"
+lemma SUBSET_REFL: "ALL x::'a::type => bool. SUBSET x x"
by (import pred_set SUBSET_REFL)
-lemma SUBSET_ANTISYM: "ALL x xa. SUBSET x xa & SUBSET xa x --> x = xa"
+lemma SUBSET_ANTISYM: "ALL (x::'a::type => bool) xa::'a::type => bool.
+ SUBSET x xa & SUBSET xa x --> x = xa"
by (import pred_set SUBSET_ANTISYM)
lemma EMPTY_SUBSET: "All (SUBSET EMPTY)"
by (import pred_set EMPTY_SUBSET)
-lemma SUBSET_EMPTY: "ALL x. SUBSET x EMPTY = (x = EMPTY)"
+lemma SUBSET_EMPTY: "ALL x::'a::type => bool. SUBSET x EMPTY = (x = EMPTY)"
by (import pred_set SUBSET_EMPTY)
-lemma SUBSET_UNIV: "ALL x. SUBSET x pred_set.UNIV"
+lemma SUBSET_UNIV: "ALL x::'a::type => bool. SUBSET x pred_set.UNIV"
by (import pred_set SUBSET_UNIV)
-lemma UNIV_SUBSET: "ALL x. SUBSET pred_set.UNIV x = (x = pred_set.UNIV)"
+lemma UNIV_SUBSET: "ALL x::'a::type => bool. SUBSET pred_set.UNIV x = (x = pred_set.UNIV)"
by (import pred_set UNIV_SUBSET)
constdefs
- PSUBSET :: "('a => bool) => ('a => bool) => bool"
- "PSUBSET == %s t. SUBSET s t & s ~= t"
-
-lemma PSUBSET_DEF: "ALL s t. PSUBSET s t = (SUBSET s t & s ~= t)"
+ PSUBSET :: "('a::type => bool) => ('a::type => bool) => bool"
+ "PSUBSET == %(s::'a::type => bool) t::'a::type => bool. SUBSET s t & s ~= t"
+
+lemma PSUBSET_DEF: "ALL (s::'a::type => bool) t::'a::type => bool.
+ PSUBSET s t = (SUBSET s t & s ~= t)"
by (import pred_set PSUBSET_DEF)
-lemma PSUBSET_TRANS: "ALL x xa xb. PSUBSET x xa & PSUBSET xa xb --> PSUBSET x xb"
+lemma PSUBSET_TRANS: "ALL (x::'a::type => bool) (xa::'a::type => bool) xb::'a::type => bool.
+ PSUBSET x xa & PSUBSET xa xb --> PSUBSET x xb"
by (import pred_set PSUBSET_TRANS)
-lemma PSUBSET_IRREFL: "ALL x. ~ PSUBSET x x"
+lemma PSUBSET_IRREFL: "ALL x::'a::type => bool. ~ PSUBSET x x"
by (import pred_set PSUBSET_IRREFL)
-lemma NOT_PSUBSET_EMPTY: "ALL x. ~ PSUBSET x EMPTY"
+lemma NOT_PSUBSET_EMPTY: "ALL x::'a::type => bool. ~ PSUBSET x EMPTY"
by (import pred_set NOT_PSUBSET_EMPTY)
-lemma NOT_UNIV_PSUBSET: "ALL x. ~ PSUBSET pred_set.UNIV x"
+lemma NOT_UNIV_PSUBSET: "ALL x::'a::type => bool. ~ PSUBSET pred_set.UNIV x"
by (import pred_set NOT_UNIV_PSUBSET)
-lemma PSUBSET_UNIV: "ALL x. PSUBSET x pred_set.UNIV = (EX xa. ~ IN xa x)"
+lemma PSUBSET_UNIV: "ALL x::'a::type => bool.
+ PSUBSET x pred_set.UNIV = (EX xa::'a::type. ~ IN xa x)"
by (import pred_set PSUBSET_UNIV)
consts
- UNION :: "('a => bool) => ('a => bool) => 'a => bool"
+ UNION :: "('a::type => bool) => ('a::type => bool) => 'a::type => bool"
defs
- UNION_def: "pred_set.UNION == %s t. GSPEC (%x. (x, IN x s | IN x t))"
-
-lemma UNION_DEF: "ALL s t. pred_set.UNION s t = GSPEC (%x. (x, IN x s | IN x t))"
+ UNION_def: "pred_set.UNION ==
+%(s::'a::type => bool) t::'a::type => bool.
+ GSPEC (%x::'a::type. (x, IN x s | IN x t))"
+
+lemma UNION_DEF: "ALL (s::'a::type => bool) t::'a::type => bool.
+ pred_set.UNION s t = GSPEC (%x::'a::type. (x, IN x s | IN x t))"
by (import pred_set UNION_DEF)
-lemma IN_UNION: "ALL x xa xb. IN xb (pred_set.UNION x xa) = (IN xb x | IN xb xa)"
+lemma IN_UNION: "ALL (x::'a::type => bool) (xa::'a::type => bool) xb::'a::type.
+ IN xb (pred_set.UNION x xa) = (IN xb x | IN xb xa)"
by (import pred_set IN_UNION)
-lemma UNION_ASSOC: "ALL x xa xb.
+lemma UNION_ASSOC: "ALL (x::'a::type => bool) (xa::'a::type => bool) xb::'a::type => bool.
pred_set.UNION x (pred_set.UNION xa xb) =
pred_set.UNION (pred_set.UNION x xa) xb"
by (import pred_set UNION_ASSOC)
-lemma UNION_IDEMPOT: "ALL x. pred_set.UNION x x = x"
+lemma UNION_IDEMPOT: "ALL x::'a::type => bool. pred_set.UNION x x = x"
by (import pred_set UNION_IDEMPOT)
-lemma UNION_COMM: "ALL x xa. pred_set.UNION x xa = pred_set.UNION xa x"
+lemma UNION_COMM: "ALL (x::'a::type => bool) xa::'a::type => bool.
+ pred_set.UNION x xa = pred_set.UNION xa x"
by (import pred_set UNION_COMM)
-lemma SUBSET_UNION: "(ALL (x::'a => bool) xa::'a => bool. SUBSET x (pred_set.UNION x xa)) &
-(ALL (x::'a => bool) xa::'a => bool. SUBSET x (pred_set.UNION xa x))"
+lemma SUBSET_UNION: "(ALL (x::'a::type => bool) xa::'a::type => bool.
+ SUBSET x (pred_set.UNION x xa)) &
+(ALL (x::'a::type => bool) xa::'a::type => bool.
+ SUBSET x (pred_set.UNION xa x))"
by (import pred_set SUBSET_UNION)
-lemma UNION_SUBSET: "ALL s t u. SUBSET (pred_set.UNION s t) u = (SUBSET s u & SUBSET t u)"
+lemma UNION_SUBSET: "ALL (s::'a::type => bool) (t::'a::type => bool) u::'a::type => bool.
+ SUBSET (pred_set.UNION s t) u = (SUBSET s u & SUBSET t u)"
by (import pred_set UNION_SUBSET)
-lemma SUBSET_UNION_ABSORPTION: "ALL x xa. SUBSET x xa = (pred_set.UNION x xa = xa)"
+lemma SUBSET_UNION_ABSORPTION: "ALL (x::'a::type => bool) xa::'a::type => bool.
+ SUBSET x xa = (pred_set.UNION x xa = xa)"
by (import pred_set SUBSET_UNION_ABSORPTION)
-lemma UNION_EMPTY: "(ALL x::'a => bool. pred_set.UNION EMPTY x = x) &
-(ALL x::'a => bool. pred_set.UNION x EMPTY = x)"
+lemma UNION_EMPTY: "(ALL x::'a::type => bool. pred_set.UNION EMPTY x = x) &
+(ALL x::'a::type => bool. pred_set.UNION x EMPTY = x)"
by (import pred_set UNION_EMPTY)
-lemma UNION_UNIV: "(ALL x::'a => bool. pred_set.UNION pred_set.UNIV x = pred_set.UNIV) &
-(ALL x::'a => bool. pred_set.UNION x pred_set.UNIV = pred_set.UNIV)"
+lemma UNION_UNIV: "(ALL x::'a::type => bool. pred_set.UNION pred_set.UNIV x = pred_set.UNIV) &
+(ALL x::'a::type => bool. pred_set.UNION x pred_set.UNIV = pred_set.UNIV)"
by (import pred_set UNION_UNIV)
-lemma EMPTY_UNION: "ALL x xa. (pred_set.UNION x xa = EMPTY) = (x = EMPTY & xa = EMPTY)"
+lemma EMPTY_UNION: "ALL (x::'a::type => bool) xa::'a::type => bool.
+ (pred_set.UNION x xa = EMPTY) = (x = EMPTY & xa = EMPTY)"
by (import pred_set EMPTY_UNION)
consts
- INTER :: "('a => bool) => ('a => bool) => 'a => bool"
+ INTER :: "('a::type => bool) => ('a::type => bool) => 'a::type => bool"
defs
- INTER_def: "pred_set.INTER == %s t. GSPEC (%x. (x, IN x s & IN x t))"
-
-lemma INTER_DEF: "ALL s t. pred_set.INTER s t = GSPEC (%x. (x, IN x s & IN x t))"
+ INTER_def: "pred_set.INTER ==
+%(s::'a::type => bool) t::'a::type => bool.
+ GSPEC (%x::'a::type. (x, IN x s & IN x t))"
+
+lemma INTER_DEF: "ALL (s::'a::type => bool) t::'a::type => bool.
+ pred_set.INTER s t = GSPEC (%x::'a::type. (x, IN x s & IN x t))"
by (import pred_set INTER_DEF)
-lemma IN_INTER: "ALL x xa xb. IN xb (pred_set.INTER x xa) = (IN xb x & IN xb xa)"
+lemma IN_INTER: "ALL (x::'a::type => bool) (xa::'a::type => bool) xb::'a::type.
+ IN xb (pred_set.INTER x xa) = (IN xb x & IN xb xa)"
by (import pred_set IN_INTER)
-lemma INTER_ASSOC: "ALL x xa xb.
+lemma INTER_ASSOC: "ALL (x::'a::type => bool) (xa::'a::type => bool) xb::'a::type => bool.
pred_set.INTER x (pred_set.INTER xa xb) =
pred_set.INTER (pred_set.INTER x xa) xb"
by (import pred_set INTER_ASSOC)
-lemma INTER_IDEMPOT: "ALL x. pred_set.INTER x x = x"
+lemma INTER_IDEMPOT: "ALL x::'a::type => bool. pred_set.INTER x x = x"
by (import pred_set INTER_IDEMPOT)
-lemma INTER_COMM: "ALL x xa. pred_set.INTER x xa = pred_set.INTER xa x"
+lemma INTER_COMM: "ALL (x::'a::type => bool) xa::'a::type => bool.
+ pred_set.INTER x xa = pred_set.INTER xa x"
by (import pred_set INTER_COMM)
-lemma INTER_SUBSET: "(ALL (x::'a => bool) xa::'a => bool. SUBSET (pred_set.INTER x xa) x) &
-(ALL (x::'a => bool) xa::'a => bool. SUBSET (pred_set.INTER xa x) x)"
+lemma INTER_SUBSET: "(ALL (x::'a::type => bool) xa::'a::type => bool.
+ SUBSET (pred_set.INTER x xa) x) &
+(ALL (x::'a::type => bool) xa::'a::type => bool.
+ SUBSET (pred_set.INTER xa x) x)"
by (import pred_set INTER_SUBSET)
-lemma SUBSET_INTER: "ALL s t u. SUBSET s (pred_set.INTER t u) = (SUBSET s t & SUBSET s u)"
+lemma SUBSET_INTER: "ALL (s::'a::type => bool) (t::'a::type => bool) u::'a::type => bool.
+ SUBSET s (pred_set.INTER t u) = (SUBSET s t & SUBSET s u)"
by (import pred_set SUBSET_INTER)
-lemma SUBSET_INTER_ABSORPTION: "ALL x xa. SUBSET x xa = (pred_set.INTER x xa = x)"
+lemma SUBSET_INTER_ABSORPTION: "ALL (x::'a::type => bool) xa::'a::type => bool.
+ SUBSET x xa = (pred_set.INTER x xa = x)"
by (import pred_set SUBSET_INTER_ABSORPTION)
-lemma INTER_EMPTY: "(ALL x::'a => bool. pred_set.INTER EMPTY x = EMPTY) &
-(ALL x::'a => bool. pred_set.INTER x EMPTY = EMPTY)"
+lemma INTER_EMPTY: "(ALL x::'a::type => bool. pred_set.INTER EMPTY x = EMPTY) &
+(ALL x::'a::type => bool. pred_set.INTER x EMPTY = EMPTY)"
by (import pred_set INTER_EMPTY)
-lemma INTER_UNIV: "(ALL x::'a => bool. pred_set.INTER pred_set.UNIV x = x) &
-(ALL x::'a => bool. pred_set.INTER x pred_set.UNIV = x)"
+lemma INTER_UNIV: "(ALL x::'a::type => bool. pred_set.INTER pred_set.UNIV x = x) &
+(ALL x::'a::type => bool. pred_set.INTER x pred_set.UNIV = x)"
by (import pred_set INTER_UNIV)
-lemma UNION_OVER_INTER: "ALL x xa xb.
+lemma UNION_OVER_INTER: "ALL (x::'a::type => bool) (xa::'a::type => bool) xb::'a::type => bool.
pred_set.INTER x (pred_set.UNION xa xb) =
pred_set.UNION (pred_set.INTER x xa) (pred_set.INTER x xb)"
by (import pred_set UNION_OVER_INTER)
-lemma INTER_OVER_UNION: "ALL x xa xb.
+lemma INTER_OVER_UNION: "ALL (x::'a::type => bool) (xa::'a::type => bool) xb::'a::type => bool.
pred_set.UNION x (pred_set.INTER xa xb) =
pred_set.INTER (pred_set.UNION x xa) (pred_set.UNION x xb)"
by (import pred_set INTER_OVER_UNION)
constdefs
- DISJOINT :: "('a => bool) => ('a => bool) => bool"
- "DISJOINT == %s t. pred_set.INTER s t = EMPTY"
-
-lemma DISJOINT_DEF: "ALL s t. DISJOINT s t = (pred_set.INTER s t = EMPTY)"
+ DISJOINT :: "('a::type => bool) => ('a::type => bool) => bool"
+ "DISJOINT ==
+%(s::'a::type => bool) t::'a::type => bool. pred_set.INTER s t = EMPTY"
+
+lemma DISJOINT_DEF: "ALL (s::'a::type => bool) t::'a::type => bool.
+ DISJOINT s t = (pred_set.INTER s t = EMPTY)"
by (import pred_set DISJOINT_DEF)
-lemma IN_DISJOINT: "ALL x xa. DISJOINT x xa = (~ (EX xb. IN xb x & IN xb xa))"
+lemma IN_DISJOINT: "ALL (x::'a::type => bool) xa::'a::type => bool.
+ DISJOINT x xa = (~ (EX xb::'a::type. IN xb x & IN xb xa))"
by (import pred_set IN_DISJOINT)
-lemma DISJOINT_SYM: "ALL x xa. DISJOINT x xa = DISJOINT xa x"
+lemma DISJOINT_SYM: "ALL (x::'a::type => bool) xa::'a::type => bool.
+ DISJOINT x xa = DISJOINT xa x"
by (import pred_set DISJOINT_SYM)
-lemma DISJOINT_EMPTY: "ALL x. DISJOINT EMPTY x & DISJOINT x EMPTY"
+lemma DISJOINT_EMPTY: "ALL x::'a::type => bool. DISJOINT EMPTY x & DISJOINT x EMPTY"
by (import pred_set DISJOINT_EMPTY)
-lemma DISJOINT_EMPTY_REFL: "ALL x. (x = EMPTY) = DISJOINT x x"
+lemma DISJOINT_EMPTY_REFL: "ALL x::'a::type => bool. (x = EMPTY) = DISJOINT x x"
by (import pred_set DISJOINT_EMPTY_REFL)
-lemma DISJOINT_UNION: "ALL x xa xb.
+lemma DISJOINT_UNION: "ALL (x::'a::type => bool) (xa::'a::type => bool) xb::'a::type => bool.
DISJOINT (pred_set.UNION x xa) xb = (DISJOINT x xb & DISJOINT xa xb)"
by (import pred_set DISJOINT_UNION)
-lemma DISJOINT_UNION_BOTH: "ALL s t u.
+lemma DISJOINT_UNION_BOTH: "ALL (s::'a::type => bool) (t::'a::type => bool) u::'a::type => bool.
DISJOINT (pred_set.UNION s t) u = (DISJOINT s u & DISJOINT t u) &
DISJOINT u (pred_set.UNION s t) = (DISJOINT s u & DISJOINT t u)"
by (import pred_set DISJOINT_UNION_BOTH)
constdefs
- DIFF :: "('a => bool) => ('a => bool) => 'a => bool"
- "DIFF == %s t. GSPEC (%x. (x, IN x s & ~ IN x t))"
-
-lemma DIFF_DEF: "ALL s t. DIFF s t = GSPEC (%x. (x, IN x s & ~ IN x t))"
+ DIFF :: "('a::type => bool) => ('a::type => bool) => 'a::type => bool"
+ "DIFF ==
+%(s::'a::type => bool) t::'a::type => bool.
+ GSPEC (%x::'a::type. (x, IN x s & ~ IN x t))"
+
+lemma DIFF_DEF: "ALL (s::'a::type => bool) t::'a::type => bool.
+ DIFF s t = GSPEC (%x::'a::type. (x, IN x s & ~ IN x t))"
by (import pred_set DIFF_DEF)
-lemma IN_DIFF: "ALL s t x. IN x (DIFF s t) = (IN x s & ~ IN x t)"
+lemma IN_DIFF: "ALL (s::'a::type => bool) (t::'a::type => bool) x::'a::type.
+ IN x (DIFF s t) = (IN x s & ~ IN x t)"
by (import pred_set IN_DIFF)
-lemma DIFF_EMPTY: "ALL s. DIFF s EMPTY = s"
+lemma DIFF_EMPTY: "ALL s::'a::type => bool. DIFF s EMPTY = s"
by (import pred_set DIFF_EMPTY)
-lemma EMPTY_DIFF: "ALL s. DIFF EMPTY s = EMPTY"
+lemma EMPTY_DIFF: "ALL s::'a::type => bool. DIFF EMPTY s = EMPTY"
by (import pred_set EMPTY_DIFF)
-lemma DIFF_UNIV: "ALL s. DIFF s pred_set.UNIV = EMPTY"
+lemma DIFF_UNIV: "ALL s::'a::type => bool. DIFF s pred_set.UNIV = EMPTY"
by (import pred_set DIFF_UNIV)
-lemma DIFF_DIFF: "ALL x xa. DIFF (DIFF x xa) xa = DIFF x xa"
+lemma DIFF_DIFF: "ALL (x::'a::type => bool) xa::'a::type => bool.
+ DIFF (DIFF x xa) xa = DIFF x xa"
by (import pred_set DIFF_DIFF)
-lemma DIFF_EQ_EMPTY: "ALL x. DIFF x x = EMPTY"
+lemma DIFF_EQ_EMPTY: "ALL x::'a::type => bool. DIFF x x = EMPTY"
by (import pred_set DIFF_EQ_EMPTY)
constdefs
- INSERT :: "'a => ('a => bool) => 'a => bool"
- "INSERT == %x s. GSPEC (%y. (y, y = x | IN y s))"
-
-lemma INSERT_DEF: "ALL x s. INSERT x s = GSPEC (%y. (y, y = x | IN y s))"
+ INSERT :: "'a::type => ('a::type => bool) => 'a::type => bool"
+ "INSERT ==
+%(x::'a::type) s::'a::type => bool.
+ GSPEC (%y::'a::type. (y, y = x | IN y s))"
+
+lemma INSERT_DEF: "ALL (x::'a::type) s::'a::type => bool.
+ INSERT x s = GSPEC (%y::'a::type. (y, y = x | IN y s))"
by (import pred_set INSERT_DEF)
-lemma IN_INSERT: "ALL x xa xb. IN x (INSERT xa xb) = (x = xa | IN x xb)"
+lemma IN_INSERT: "ALL (x::'a::type) (xa::'a::type) xb::'a::type => bool.
+ IN x (INSERT xa xb) = (x = xa | IN x xb)"
by (import pred_set IN_INSERT)
-lemma COMPONENT: "ALL x xa. IN x (INSERT x xa)"
+lemma COMPONENT: "ALL (x::'a::type) xa::'a::type => bool. IN x (INSERT x xa)"
by (import pred_set COMPONENT)
-lemma SET_CASES: "ALL x. x = EMPTY | (EX xa xb. x = INSERT xa xb & ~ IN xa xb)"
+lemma SET_CASES: "ALL x::'a::type => bool.
+ x = EMPTY |
+ (EX (xa::'a::type) xb::'a::type => bool. x = INSERT xa xb & ~ IN xa xb)"
by (import pred_set SET_CASES)
-lemma DECOMPOSITION: "ALL s x. IN x s = (EX t. s = INSERT x t & ~ IN x t)"
+lemma DECOMPOSITION: "ALL (s::'a::type => bool) x::'a::type.
+ IN x s = (EX t::'a::type => bool. s = INSERT x t & ~ IN x t)"
by (import pred_set DECOMPOSITION)
-lemma ABSORPTION: "ALL x xa. IN x xa = (INSERT x xa = xa)"
+lemma ABSORPTION: "ALL (x::'a::type) xa::'a::type => bool. IN x xa = (INSERT x xa = xa)"
by (import pred_set ABSORPTION)
-lemma INSERT_INSERT: "ALL x xa. INSERT x (INSERT x xa) = INSERT x xa"
+lemma INSERT_INSERT: "ALL (x::'a::type) xa::'a::type => bool. INSERT x (INSERT x xa) = INSERT x xa"
by (import pred_set INSERT_INSERT)
-lemma INSERT_COMM: "ALL x xa xb. INSERT x (INSERT xa xb) = INSERT xa (INSERT x xb)"
+lemma INSERT_COMM: "ALL (x::'a::type) (xa::'a::type) xb::'a::type => bool.
+ INSERT x (INSERT xa xb) = INSERT xa (INSERT x xb)"
by (import pred_set INSERT_COMM)
-lemma INSERT_UNIV: "ALL x. INSERT x pred_set.UNIV = pred_set.UNIV"
+lemma INSERT_UNIV: "ALL x::'a::type. INSERT x pred_set.UNIV = pred_set.UNIV"
by (import pred_set INSERT_UNIV)
-lemma NOT_INSERT_EMPTY: "ALL x xa. INSERT x xa ~= EMPTY"
+lemma NOT_INSERT_EMPTY: "ALL (x::'a::type) xa::'a::type => bool. INSERT x xa ~= EMPTY"
by (import pred_set NOT_INSERT_EMPTY)
-lemma NOT_EMPTY_INSERT: "ALL x xa. EMPTY ~= INSERT x xa"
+lemma NOT_EMPTY_INSERT: "ALL (x::'a::type) xa::'a::type => bool. EMPTY ~= INSERT x xa"
by (import pred_set NOT_EMPTY_INSERT)
-lemma INSERT_UNION: "ALL x s t.
+lemma INSERT_UNION: "ALL (x::'a::type) (s::'a::type => bool) t::'a::type => bool.
pred_set.UNION (INSERT x s) t =
(if IN x t then pred_set.UNION s t else INSERT x (pred_set.UNION s t))"
by (import pred_set INSERT_UNION)
-lemma INSERT_UNION_EQ: "ALL x s t. pred_set.UNION (INSERT x s) t = INSERT x (pred_set.UNION s t)"
+lemma INSERT_UNION_EQ: "ALL (x::'a::type) (s::'a::type => bool) t::'a::type => bool.
+ pred_set.UNION (INSERT x s) t = INSERT x (pred_set.UNION s t)"
by (import pred_set INSERT_UNION_EQ)
-lemma INSERT_INTER: "ALL x s t.
+lemma INSERT_INTER: "ALL (x::'a::type) (s::'a::type => bool) t::'a::type => bool.
pred_set.INTER (INSERT x s) t =
(if IN x t then INSERT x (pred_set.INTER s t) else pred_set.INTER s t)"
by (import pred_set INSERT_INTER)
-lemma DISJOINT_INSERT: "ALL x xa xb. DISJOINT (INSERT x xa) xb = (DISJOINT xa xb & ~ IN x xb)"
+lemma DISJOINT_INSERT: "ALL (x::'a::type) (xa::'a::type => bool) xb::'a::type => bool.
+ DISJOINT (INSERT x xa) xb = (DISJOINT xa xb & ~ IN x xb)"
by (import pred_set DISJOINT_INSERT)
-lemma INSERT_SUBSET: "ALL x xa xb. SUBSET (INSERT x xa) xb = (IN x xb & SUBSET xa xb)"
+lemma INSERT_SUBSET: "ALL (x::'a::type) (xa::'a::type => bool) xb::'a::type => bool.
+ SUBSET (INSERT x xa) xb = (IN x xb & SUBSET xa xb)"
by (import pred_set INSERT_SUBSET)
-lemma SUBSET_INSERT: "ALL x xa. ~ IN x xa --> (ALL xb. SUBSET xa (INSERT x xb) = SUBSET xa xb)"
+lemma SUBSET_INSERT: "ALL (x::'a::type) xa::'a::type => bool.
+ ~ IN x xa -->
+ (ALL xb::'a::type => bool. SUBSET xa (INSERT x xb) = SUBSET xa xb)"
by (import pred_set SUBSET_INSERT)
-lemma INSERT_DIFF: "ALL s t x.
+lemma INSERT_DIFF: "ALL (s::'a::type => bool) (t::'a::type => bool) x::'a::type.
DIFF (INSERT x s) t = (if IN x t then DIFF s t else INSERT x (DIFF s t))"
by (import pred_set INSERT_DIFF)
constdefs
- DELETE :: "('a => bool) => 'a => 'a => bool"
- "DELETE == %s x. DIFF s (INSERT x EMPTY)"
-
-lemma DELETE_DEF: "ALL s x. DELETE s x = DIFF s (INSERT x EMPTY)"
+ DELETE :: "('a::type => bool) => 'a::type => 'a::type => bool"
+ "DELETE == %(s::'a::type => bool) x::'a::type. DIFF s (INSERT x EMPTY)"
+
+lemma DELETE_DEF: "ALL (s::'a::type => bool) x::'a::type. DELETE s x = DIFF s (INSERT x EMPTY)"
by (import pred_set DELETE_DEF)
-lemma IN_DELETE: "ALL x xa xb. IN xa (DELETE x xb) = (IN xa x & xa ~= xb)"
+lemma IN_DELETE: "ALL (x::'a::type => bool) (xa::'a::type) xb::'a::type.
+ IN xa (DELETE x xb) = (IN xa x & xa ~= xb)"
by (import pred_set IN_DELETE)
-lemma DELETE_NON_ELEMENT: "ALL x xa. (~ IN x xa) = (DELETE xa x = xa)"
+lemma DELETE_NON_ELEMENT: "ALL (x::'a::type) xa::'a::type => bool. (~ IN x xa) = (DELETE xa x = xa)"
by (import pred_set DELETE_NON_ELEMENT)
-lemma IN_DELETE_EQ: "ALL s x x'. (IN x s = IN x' s) = (IN x (DELETE s x') = IN x' (DELETE s x))"
+lemma IN_DELETE_EQ: "ALL (s::'a::type => bool) (x::'a::type) x'::'a::type.
+ (IN x s = IN x' s) = (IN x (DELETE s x') = IN x' (DELETE s x))"
by (import pred_set IN_DELETE_EQ)
-lemma EMPTY_DELETE: "ALL x. DELETE EMPTY x = EMPTY"
+lemma EMPTY_DELETE: "ALL x::'a::type. DELETE EMPTY x = EMPTY"
by (import pred_set EMPTY_DELETE)
-lemma DELETE_DELETE: "ALL x xa. DELETE (DELETE xa x) x = DELETE xa x"
+lemma DELETE_DELETE: "ALL (x::'a::type) xa::'a::type => bool. DELETE (DELETE xa x) x = DELETE xa x"
by (import pred_set DELETE_DELETE)
-lemma DELETE_COMM: "ALL x xa xb. DELETE (DELETE xb x) xa = DELETE (DELETE xb xa) x"
+lemma DELETE_COMM: "ALL (x::'a::type) (xa::'a::type) xb::'a::type => bool.
+ DELETE (DELETE xb x) xa = DELETE (DELETE xb xa) x"
by (import pred_set DELETE_COMM)
-lemma DELETE_SUBSET: "ALL x xa. SUBSET (DELETE xa x) xa"
+lemma DELETE_SUBSET: "ALL (x::'a::type) xa::'a::type => bool. SUBSET (DELETE xa x) xa"
by (import pred_set DELETE_SUBSET)
-lemma SUBSET_DELETE: "ALL x xa xb. SUBSET xa (DELETE xb x) = (~ IN x xa & SUBSET xa xb)"
+lemma SUBSET_DELETE: "ALL (x::'a::type) (xa::'a::type => bool) xb::'a::type => bool.
+ SUBSET xa (DELETE xb x) = (~ IN x xa & SUBSET xa xb)"
by (import pred_set SUBSET_DELETE)
-lemma SUBSET_INSERT_DELETE: "ALL x s t. SUBSET s (INSERT x t) = SUBSET (DELETE s x) t"
+lemma SUBSET_INSERT_DELETE: "ALL (x::'a::type) (s::'a::type => bool) t::'a::type => bool.
+ SUBSET s (INSERT x t) = SUBSET (DELETE s x) t"
by (import pred_set SUBSET_INSERT_DELETE)
-lemma DIFF_INSERT: "ALL x xa xb. DIFF x (INSERT xb xa) = DIFF (DELETE x xb) xa"
+lemma DIFF_INSERT: "ALL (x::'a::type => bool) (xa::'a::type => bool) xb::'a::type.
+ DIFF x (INSERT xb xa) = DIFF (DELETE x xb) xa"
by (import pred_set DIFF_INSERT)
-lemma PSUBSET_INSERT_SUBSET: "ALL x xa. PSUBSET x xa = (EX xb. ~ IN xb x & SUBSET (INSERT xb x) xa)"
+lemma PSUBSET_INSERT_SUBSET: "ALL (x::'a::type => bool) xa::'a::type => bool.
+ PSUBSET x xa = (EX xb::'a::type. ~ IN xb x & SUBSET (INSERT xb x) xa)"
by (import pred_set PSUBSET_INSERT_SUBSET)
-lemma PSUBSET_MEMBER: "ALL s t. PSUBSET s t = (SUBSET s t & (EX y. IN y t & ~ IN y s))"
+lemma PSUBSET_MEMBER: "ALL (s::'a::type => bool) t::'a::type => bool.
+ PSUBSET s t = (SUBSET s t & (EX y::'a::type. IN y t & ~ IN y s))"
by (import pred_set PSUBSET_MEMBER)
-lemma DELETE_INSERT: "ALL x xa xb.
+lemma DELETE_INSERT: "ALL (x::'a::type) (xa::'a::type) xb::'a::type => bool.
DELETE (INSERT x xb) xa =
(if x = xa then DELETE xb xa else INSERT x (DELETE xb xa))"
by (import pred_set DELETE_INSERT)
-lemma INSERT_DELETE: "ALL x xa. IN x xa --> INSERT x (DELETE xa x) = xa"
+lemma INSERT_DELETE: "ALL (x::'a::type) xa::'a::type => bool.
+ IN x xa --> INSERT x (DELETE xa x) = xa"
by (import pred_set INSERT_DELETE)
-lemma DELETE_INTER: "ALL x xa xb.
+lemma DELETE_INTER: "ALL (x::'a::type => bool) (xa::'a::type => bool) xb::'a::type.
pred_set.INTER (DELETE x xb) xa = DELETE (pred_set.INTER x xa) xb"
by (import pred_set DELETE_INTER)
-lemma DISJOINT_DELETE_SYM: "ALL x xa xb. DISJOINT (DELETE x xb) xa = DISJOINT (DELETE xa xb) x"
+lemma DISJOINT_DELETE_SYM: "ALL (x::'a::type => bool) (xa::'a::type => bool) xb::'a::type.
+ DISJOINT (DELETE x xb) xa = DISJOINT (DELETE xa xb) x"
by (import pred_set DISJOINT_DELETE_SYM)
consts
- CHOICE :: "('a => bool) => 'a"
-
-specification (CHOICE) CHOICE_DEF: "ALL x. x ~= EMPTY --> IN (CHOICE x) x"
+ CHOICE :: "('a::type => bool) => 'a::type"
+
+specification (CHOICE) CHOICE_DEF: "ALL x::'a::type => bool. x ~= EMPTY --> IN (CHOICE x) x"
by (import pred_set CHOICE_DEF)
constdefs
- REST :: "('a => bool) => 'a => bool"
- "REST == %s. DELETE s (CHOICE s)"
-
-lemma REST_DEF: "ALL s. REST s = DELETE s (CHOICE s)"
+ REST :: "('a::type => bool) => 'a::type => bool"
+ "REST == %s::'a::type => bool. DELETE s (CHOICE s)"
+
+lemma REST_DEF: "ALL s::'a::type => bool. REST s = DELETE s (CHOICE s)"
by (import pred_set REST_DEF)
-lemma CHOICE_NOT_IN_REST: "ALL x. ~ IN (CHOICE x) (REST x)"
+lemma CHOICE_NOT_IN_REST: "ALL x::'a::type => bool. ~ IN (CHOICE x) (REST x)"
by (import pred_set CHOICE_NOT_IN_REST)
-lemma CHOICE_INSERT_REST: "ALL s. s ~= EMPTY --> INSERT (CHOICE s) (REST s) = s"
+lemma CHOICE_INSERT_REST: "ALL s::'a::type => bool. s ~= EMPTY --> INSERT (CHOICE s) (REST s) = s"
by (import pred_set CHOICE_INSERT_REST)
-lemma REST_SUBSET: "ALL x. SUBSET (REST x) x"
+lemma REST_SUBSET: "ALL x::'a::type => bool. SUBSET (REST x) x"
by (import pred_set REST_SUBSET)
-lemma REST_PSUBSET: "ALL x. x ~= EMPTY --> PSUBSET (REST x) x"
+lemma REST_PSUBSET: "ALL x::'a::type => bool. x ~= EMPTY --> PSUBSET (REST x) x"
by (import pred_set REST_PSUBSET)
constdefs
- SING :: "('a => bool) => bool"
- "SING == %s. EX x. s = INSERT x EMPTY"
-
-lemma SING_DEF: "ALL s. SING s = (EX x. s = INSERT x EMPTY)"
+ SING :: "('a::type => bool) => bool"
+ "SING == %s::'a::type => bool. EX x::'a::type. s = INSERT x EMPTY"
+
+lemma SING_DEF: "ALL s::'a::type => bool. SING s = (EX x::'a::type. s = INSERT x EMPTY)"
by (import pred_set SING_DEF)
-lemma SING: "ALL x. SING (INSERT x EMPTY)"
+lemma SING: "ALL x::'a::type. SING (INSERT x EMPTY)"
by (import pred_set SING)
-lemma IN_SING: "ALL x xa. IN x (INSERT xa EMPTY) = (x = xa)"
+lemma IN_SING: "ALL (x::'a::type) xa::'a::type. IN x (INSERT xa EMPTY) = (x = xa)"
by (import pred_set IN_SING)
-lemma NOT_SING_EMPTY: "ALL x. INSERT x EMPTY ~= EMPTY"
+lemma NOT_SING_EMPTY: "ALL x::'a::type. INSERT x EMPTY ~= EMPTY"
by (import pred_set NOT_SING_EMPTY)
-lemma NOT_EMPTY_SING: "ALL x. EMPTY ~= INSERT x EMPTY"
+lemma NOT_EMPTY_SING: "ALL x::'a::type. EMPTY ~= INSERT x EMPTY"
by (import pred_set NOT_EMPTY_SING)
-lemma EQUAL_SING: "ALL x xa. (INSERT x EMPTY = INSERT xa EMPTY) = (x = xa)"
+lemma EQUAL_SING: "ALL (x::'a::type) xa::'a::type.
+ (INSERT x EMPTY = INSERT xa EMPTY) = (x = xa)"
by (import pred_set EQUAL_SING)
-lemma DISJOINT_SING_EMPTY: "ALL x. DISJOINT (INSERT x EMPTY) EMPTY"
+lemma DISJOINT_SING_EMPTY: "ALL x::'a::type. DISJOINT (INSERT x EMPTY) EMPTY"
by (import pred_set DISJOINT_SING_EMPTY)
-lemma INSERT_SING_UNION: "ALL x xa. INSERT xa x = pred_set.UNION (INSERT xa EMPTY) x"
+lemma INSERT_SING_UNION: "ALL (x::'a::type => bool) xa::'a::type.
+ INSERT xa x = pred_set.UNION (INSERT xa EMPTY) x"
by (import pred_set INSERT_SING_UNION)
-lemma SING_DELETE: "ALL x. DELETE (INSERT x EMPTY) x = EMPTY"
+lemma SING_DELETE: "ALL x::'a::type. DELETE (INSERT x EMPTY) x = EMPTY"
by (import pred_set SING_DELETE)
-lemma DELETE_EQ_SING: "ALL x xa. IN xa x --> (DELETE x xa = EMPTY) = (x = INSERT xa EMPTY)"
+lemma DELETE_EQ_SING: "ALL (x::'a::type => bool) xa::'a::type.
+ IN xa x --> (DELETE x xa = EMPTY) = (x = INSERT xa EMPTY)"
by (import pred_set DELETE_EQ_SING)
-lemma CHOICE_SING: "ALL x. CHOICE (INSERT x EMPTY) = x"
+lemma CHOICE_SING: "ALL x::'a::type. CHOICE (INSERT x EMPTY) = x"
by (import pred_set CHOICE_SING)
-lemma REST_SING: "ALL x. REST (INSERT x EMPTY) = EMPTY"
+lemma REST_SING: "ALL x::'a::type. REST (INSERT x EMPTY) = EMPTY"
by (import pred_set REST_SING)
-lemma SING_IFF_EMPTY_REST: "ALL x. SING x = (x ~= EMPTY & REST x = EMPTY)"
+lemma SING_IFF_EMPTY_REST: "ALL x::'a::type => bool. SING x = (x ~= EMPTY & REST x = EMPTY)"
by (import pred_set SING_IFF_EMPTY_REST)
constdefs
- IMAGE :: "('a => 'b) => ('a => bool) => 'b => bool"
- "IMAGE == %f s. GSPEC (%x. (f x, IN x s))"
-
-lemma IMAGE_DEF: "ALL f s. IMAGE f s = GSPEC (%x. (f x, IN x s))"
+ IMAGE :: "('a::type => 'b::type) => ('a::type => bool) => 'b::type => bool"
+ "IMAGE ==
+%(f::'a::type => 'b::type) s::'a::type => bool.
+ GSPEC (%x::'a::type. (f x, IN x s))"
+
+lemma IMAGE_DEF: "ALL (f::'a::type => 'b::type) s::'a::type => bool.
+ IMAGE f s = GSPEC (%x::'a::type. (f x, IN x s))"
by (import pred_set IMAGE_DEF)
-lemma IN_IMAGE: "ALL (x::'b) (xa::'a => bool) xb::'a => 'b.
- IN x (IMAGE xb xa) = (EX xc::'a. x = xb xc & IN xc xa)"
+lemma IN_IMAGE: "ALL (x::'b::type) (xa::'a::type => bool) xb::'a::type => 'b::type.
+ IN x (IMAGE xb xa) = (EX xc::'a::type. x = xb xc & IN xc xa)"
by (import pred_set IN_IMAGE)
-lemma IMAGE_IN: "ALL x xa. IN x xa --> (ALL xb. IN (xb x) (IMAGE xb xa))"
+lemma IMAGE_IN: "ALL (x::'a::type) xa::'a::type => bool.
+ IN x xa --> (ALL xb::'a::type => 'b::type. IN (xb x) (IMAGE xb xa))"
by (import pred_set IMAGE_IN)
-lemma IMAGE_EMPTY: "ALL x. IMAGE x EMPTY = EMPTY"
+lemma IMAGE_EMPTY: "ALL x::'a::type => 'b::type. IMAGE x EMPTY = EMPTY"
by (import pred_set IMAGE_EMPTY)
-lemma IMAGE_ID: "ALL x. IMAGE (%x. x) x = x"
+lemma IMAGE_ID: "ALL x::'a::type => bool. IMAGE (%x::'a::type. x) x = x"
by (import pred_set IMAGE_ID)
-lemma IMAGE_COMPOSE: "ALL (x::'b => 'c) (xa::'a => 'b) xb::'a => bool.
- IMAGE (x o xa) xb = IMAGE x (IMAGE xa xb)"
+lemma IMAGE_COMPOSE: "ALL (x::'b::type => 'c::type) (xa::'a::type => 'b::type)
+ xb::'a::type => bool. IMAGE (x o xa) xb = IMAGE x (IMAGE xa xb)"
by (import pred_set IMAGE_COMPOSE)
-lemma IMAGE_INSERT: "ALL x xa xb. IMAGE x (INSERT xa xb) = INSERT (x xa) (IMAGE x xb)"
+lemma IMAGE_INSERT: "ALL (x::'a::type => 'b::type) (xa::'a::type) xb::'a::type => bool.
+ IMAGE x (INSERT xa xb) = INSERT (x xa) (IMAGE x xb)"
by (import pred_set IMAGE_INSERT)
-lemma IMAGE_EQ_EMPTY: "ALL s x. (IMAGE x s = EMPTY) = (s = EMPTY)"
+lemma IMAGE_EQ_EMPTY: "ALL (s::'a::type => bool) x::'a::type => 'b::type.
+ (IMAGE x s = EMPTY) = (s = EMPTY)"
by (import pred_set IMAGE_EQ_EMPTY)
-lemma IMAGE_DELETE: "ALL f x s. ~ IN x s --> IMAGE f (DELETE s x) = IMAGE f s"
+lemma IMAGE_DELETE: "ALL (f::'a::type => 'b::type) (x::'a::type) s::'a::type => bool.
+ ~ IN x s --> IMAGE f (DELETE s x) = IMAGE f s"
by (import pred_set IMAGE_DELETE)
-lemma IMAGE_UNION: "ALL x xa xb.
+lemma IMAGE_UNION: "ALL (x::'a::type => 'b::type) (xa::'a::type => bool) xb::'a::type => bool.
IMAGE x (pred_set.UNION xa xb) = pred_set.UNION (IMAGE x xa) (IMAGE x xb)"
by (import pred_set IMAGE_UNION)
-lemma IMAGE_SUBSET: "ALL x xa. SUBSET x xa --> (ALL xb. SUBSET (IMAGE xb x) (IMAGE xb xa))"
+lemma IMAGE_SUBSET: "ALL (x::'a::type => bool) xa::'a::type => bool.
+ SUBSET x xa -->
+ (ALL xb::'a::type => 'b::type. SUBSET (IMAGE xb x) (IMAGE xb xa))"
by (import pred_set IMAGE_SUBSET)
-lemma IMAGE_INTER: "ALL f s t.
+lemma IMAGE_INTER: "ALL (f::'a::type => 'b::type) (s::'a::type => bool) t::'a::type => bool.
SUBSET (IMAGE f (pred_set.INTER s t))
(pred_set.INTER (IMAGE f s) (IMAGE f t))"
by (import pred_set IMAGE_INTER)
constdefs
- INJ :: "('a => 'b) => ('a => bool) => ('b => bool) => bool"
+ INJ :: "('a::type => 'b::type) => ('a::type => bool) => ('b::type => bool) => bool"
"INJ ==
-%f s t.
- (ALL x. IN x s --> IN (f x) t) &
- (ALL x y. IN x s & IN y s --> f x = f y --> x = y)"
-
-lemma INJ_DEF: "ALL f s t.
+%(f::'a::type => 'b::type) (s::'a::type => bool) t::'b::type => bool.
+ (ALL x::'a::type. IN x s --> IN (f x) t) &
+ (ALL (x::'a::type) y::'a::type. IN x s & IN y s --> f x = f y --> x = y)"
+
+lemma INJ_DEF: "ALL (f::'a::type => 'b::type) (s::'a::type => bool) t::'b::type => bool.
INJ f s t =
- ((ALL x. IN x s --> IN (f x) t) &
- (ALL x y. IN x s & IN y s --> f x = f y --> x = y))"
+ ((ALL x::'a::type. IN x s --> IN (f x) t) &
+ (ALL (x::'a::type) y::'a::type.
+ IN x s & IN y s --> f x = f y --> x = y))"
by (import pred_set INJ_DEF)
-lemma INJ_ID: "ALL x. INJ (%x. x) x x"
+lemma INJ_ID: "ALL x::'a::type => bool. INJ (%x::'a::type. x) x x"
by (import pred_set INJ_ID)
-lemma INJ_COMPOSE: "ALL x xa xb xc xd. INJ x xb xc & INJ xa xc xd --> INJ (xa o x) xb xd"
+lemma INJ_COMPOSE: "ALL (x::'a::type => 'b::type) (xa::'b::type => 'c::type)
+ (xb::'a::type => bool) (xc::'b::type => bool) xd::'c::type => bool.
+ INJ x xb xc & INJ xa xc xd --> INJ (xa o x) xb xd"
by (import pred_set INJ_COMPOSE)
-lemma INJ_EMPTY: "ALL x. All (INJ x EMPTY) & (ALL xa. INJ x xa EMPTY = (xa = EMPTY))"
+lemma INJ_EMPTY: "ALL x::'a::type => 'b::type.
+ All (INJ x EMPTY) &
+ (ALL xa::'a::type => bool. INJ x xa EMPTY = (xa = EMPTY))"
by (import pred_set INJ_EMPTY)
constdefs
- SURJ :: "('a => 'b) => ('a => bool) => ('b => bool) => bool"
+ SURJ :: "('a::type => 'b::type) => ('a::type => bool) => ('b::type => bool) => bool"
"SURJ ==
-%f s t.
- (ALL x. IN x s --> IN (f x) t) &
- (ALL x. IN x t --> (EX y. IN y s & f y = x))"
-
-lemma SURJ_DEF: "ALL f s t.
+%(f::'a::type => 'b::type) (s::'a::type => bool) t::'b::type => bool.
+ (ALL x::'a::type. IN x s --> IN (f x) t) &
+ (ALL x::'b::type. IN x t --> (EX y::'a::type. IN y s & f y = x))"
+
+lemma SURJ_DEF: "ALL (f::'a::type => 'b::type) (s::'a::type => bool) t::'b::type => bool.
SURJ f s t =
- ((ALL x. IN x s --> IN (f x) t) &
- (ALL x. IN x t --> (EX y. IN y s & f y = x)))"
+ ((ALL x::'a::type. IN x s --> IN (f x) t) &
+ (ALL x::'b::type. IN x t --> (EX y::'a::type. IN y s & f y = x)))"
by (import pred_set SURJ_DEF)
-lemma SURJ_ID: "ALL x. SURJ (%x. x) x x"
+lemma SURJ_ID: "ALL x::'a::type => bool. SURJ (%x::'a::type. x) x x"
by (import pred_set SURJ_ID)
-lemma SURJ_COMPOSE: "ALL x xa xb xc xd. SURJ x xb xc & SURJ xa xc xd --> SURJ (xa o x) xb xd"
+lemma SURJ_COMPOSE: "ALL (x::'a::type => 'b::type) (xa::'b::type => 'c::type)
+ (xb::'a::type => bool) (xc::'b::type => bool) xd::'c::type => bool.
+ SURJ x xb xc & SURJ xa xc xd --> SURJ (xa o x) xb xd"
by (import pred_set SURJ_COMPOSE)
-lemma SURJ_EMPTY: "ALL x.
- (ALL xa. SURJ x EMPTY xa = (xa = EMPTY)) &
- (ALL xa. SURJ x xa EMPTY = (xa = EMPTY))"
+lemma SURJ_EMPTY: "ALL x::'a::type => 'b::type.
+ (ALL xa::'b::type => bool. SURJ x EMPTY xa = (xa = EMPTY)) &
+ (ALL xa::'a::type => bool. SURJ x xa EMPTY = (xa = EMPTY))"
by (import pred_set SURJ_EMPTY)
-lemma IMAGE_SURJ: "ALL x xa xb. SURJ x xa xb = (IMAGE x xa = xb)"
+lemma IMAGE_SURJ: "ALL (x::'a::type => 'b::type) (xa::'a::type => bool) xb::'b::type => bool.
+ SURJ x xa xb = (IMAGE x xa = xb)"
by (import pred_set IMAGE_SURJ)
constdefs
- BIJ :: "('a => 'b) => ('a => bool) => ('b => bool) => bool"
- "BIJ == %f s t. INJ f s t & SURJ f s t"
-
-lemma BIJ_DEF: "ALL f s t. BIJ f s t = (INJ f s t & SURJ f s t)"
+ BIJ :: "('a::type => 'b::type) => ('a::type => bool) => ('b::type => bool) => bool"
+ "BIJ ==
+%(f::'a::type => 'b::type) (s::'a::type => bool) t::'b::type => bool.
+ INJ f s t & SURJ f s t"
+
+lemma BIJ_DEF: "ALL (f::'a::type => 'b::type) (s::'a::type => bool) t::'b::type => bool.
+ BIJ f s t = (INJ f s t & SURJ f s t)"
by (import pred_set BIJ_DEF)
-lemma BIJ_ID: "ALL x. BIJ (%x. x) x x"
+lemma BIJ_ID: "ALL x::'a::type => bool. BIJ (%x::'a::type. x) x x"
by (import pred_set BIJ_ID)
-lemma BIJ_EMPTY: "ALL x.
- (ALL xa. BIJ x EMPTY xa = (xa = EMPTY)) &
- (ALL xa. BIJ x xa EMPTY = (xa = EMPTY))"
+lemma BIJ_EMPTY: "ALL x::'a::type => 'b::type.
+ (ALL xa::'b::type => bool. BIJ x EMPTY xa = (xa = EMPTY)) &
+ (ALL xa::'a::type => bool. BIJ x xa EMPTY = (xa = EMPTY))"
by (import pred_set BIJ_EMPTY)
-lemma BIJ_COMPOSE: "ALL x xa xb xc xd. BIJ x xb xc & BIJ xa xc xd --> BIJ (xa o x) xb xd"
+lemma BIJ_COMPOSE: "ALL (x::'a::type => 'b::type) (xa::'b::type => 'c::type)
+ (xb::'a::type => bool) (xc::'b::type => bool) xd::'c::type => bool.
+ BIJ x xb xc & BIJ xa xc xd --> BIJ (xa o x) xb xd"
by (import pred_set BIJ_COMPOSE)
consts
- LINV :: "('a => 'b) => ('a => bool) => 'b => 'a"
-
-specification (LINV) LINV_DEF: "ALL f s t. INJ f s t --> (ALL x. IN x s --> LINV f s (f x) = x)"
+ LINV :: "('a::type => 'b::type) => ('a::type => bool) => 'b::type => 'a::type"
+
+specification (LINV) LINV_DEF: "ALL (f::'a::type => 'b::type) (s::'a::type => bool) t::'b::type => bool.
+ INJ f s t --> (ALL x::'a::type. IN x s --> LINV f s (f x) = x)"
by (import pred_set LINV_DEF)
consts
- RINV :: "('a => 'b) => ('a => bool) => 'b => 'a"
-
-specification (RINV) RINV_DEF: "ALL f s t. SURJ f s t --> (ALL x. IN x t --> f (RINV f s x) = x)"
+ RINV :: "('a::type => 'b::type) => ('a::type => bool) => 'b::type => 'a::type"
+
+specification (RINV) RINV_DEF: "ALL (f::'a::type => 'b::type) (s::'a::type => bool) t::'b::type => bool.
+ SURJ f s t --> (ALL x::'b::type. IN x t --> f (RINV f s x) = x)"
by (import pred_set RINV_DEF)
constdefs
- FINITE :: "('a => bool) => bool"
+ FINITE :: "('a::type => bool) => bool"
"FINITE ==
-%s. ALL P. P EMPTY & (ALL s. P s --> (ALL e. P (INSERT e s))) --> P s"
-
-lemma FINITE_DEF: "ALL s.
+%s::'a::type => bool.
+ ALL P::('a::type => bool) => bool.
+ P EMPTY &
+ (ALL s::'a::type => bool.
+ P s --> (ALL e::'a::type. P (INSERT e s))) -->
+ P s"
+
+lemma FINITE_DEF: "ALL s::'a::type => bool.
FINITE s =
- (ALL P. P EMPTY & (ALL s. P s --> (ALL e. P (INSERT e s))) --> P s)"
+ (ALL P::('a::type => bool) => bool.
+ P EMPTY &
+ (ALL s::'a::type => bool.
+ P s --> (ALL e::'a::type. P (INSERT e s))) -->
+ P s)"
by (import pred_set FINITE_DEF)
lemma FINITE_EMPTY: "FINITE EMPTY"
by (import pred_set FINITE_EMPTY)
-lemma FINITE_INDUCT: "ALL P.
+lemma FINITE_INDUCT: "ALL P::('a::type => bool) => bool.
P EMPTY &
- (ALL s. FINITE s & P s --> (ALL e. ~ IN e s --> P (INSERT e s))) -->
- (ALL s. FINITE s --> P s)"
+ (ALL s::'a::type => bool.
+ FINITE s & P s -->
+ (ALL e::'a::type. ~ IN e s --> P (INSERT e s))) -->
+ (ALL s::'a::type => bool. FINITE s --> P s)"
by (import pred_set FINITE_INDUCT)
-lemma FINITE_INSERT: "ALL x s. FINITE (INSERT x s) = FINITE s"
+lemma FINITE_INSERT: "ALL (x::'a::type) s::'a::type => bool. FINITE (INSERT x s) = FINITE s"
by (import pred_set FINITE_INSERT)
-lemma FINITE_DELETE: "ALL x s. FINITE (DELETE s x) = FINITE s"
+lemma FINITE_DELETE: "ALL (x::'a::type) s::'a::type => bool. FINITE (DELETE s x) = FINITE s"
by (import pred_set FINITE_DELETE)
-lemma FINITE_UNION: "ALL s t. FINITE (pred_set.UNION s t) = (FINITE s & FINITE t)"
+lemma FINITE_UNION: "ALL (s::'a::type => bool) t::'a::type => bool.
+ FINITE (pred_set.UNION s t) = (FINITE s & FINITE t)"
by (import pred_set FINITE_UNION)
-lemma INTER_FINITE: "ALL s. FINITE s --> (ALL t. FINITE (pred_set.INTER s t))"
+lemma INTER_FINITE: "ALL s::'a::type => bool.
+ FINITE s --> (ALL t::'a::type => bool. FINITE (pred_set.INTER s t))"
by (import pred_set INTER_FINITE)
-lemma SUBSET_FINITE: "ALL s. FINITE s --> (ALL t. SUBSET t s --> FINITE t)"
+lemma SUBSET_FINITE: "ALL s::'a::type => bool.
+ FINITE s --> (ALL t::'a::type => bool. SUBSET t s --> FINITE t)"
by (import pred_set SUBSET_FINITE)
-lemma PSUBSET_FINITE: "ALL x. FINITE x --> (ALL xa. PSUBSET xa x --> FINITE xa)"
+lemma PSUBSET_FINITE: "ALL x::'a::type => bool.
+ FINITE x --> (ALL xa::'a::type => bool. PSUBSET xa x --> FINITE xa)"
by (import pred_set PSUBSET_FINITE)
-lemma FINITE_DIFF: "ALL s. FINITE s --> (ALL t. FINITE (DIFF s t))"
+lemma FINITE_DIFF: "ALL s::'a::type => bool.
+ FINITE s --> (ALL t::'a::type => bool. FINITE (DIFF s t))"
by (import pred_set FINITE_DIFF)
-lemma FINITE_SING: "ALL x. FINITE (INSERT x EMPTY)"
+lemma FINITE_SING: "ALL x::'a::type. FINITE (INSERT x EMPTY)"
by (import pred_set FINITE_SING)
-lemma SING_FINITE: "ALL x. SING x --> FINITE x"
+lemma SING_FINITE: "ALL x::'a::type => bool. SING x --> FINITE x"
by (import pred_set SING_FINITE)
-lemma IMAGE_FINITE: "ALL s. FINITE s --> (ALL f. FINITE (IMAGE f s))"
+lemma IMAGE_FINITE: "ALL s::'a::type => bool.
+ FINITE s --> (ALL f::'a::type => 'b::type. FINITE (IMAGE f s))"
by (import pred_set IMAGE_FINITE)
consts
- CARD :: "('a => bool) => nat"
+ CARD :: "('a::type => bool) => nat"
specification (CARD) CARD_DEF: "(op &::bool => bool => bool)
((op =::nat => nat => bool)
- ((CARD::('a => bool) => nat) (EMPTY::'a => bool)) (0::nat))
- ((All::(('a => bool) => bool) => bool)
- (%s::'a => bool.
- (op -->::bool => bool => bool) ((FINITE::('a => bool) => bool) s)
- ((All::('a => bool) => bool)
- (%x::'a.
+ ((CARD::('a::type => bool) => nat) (EMPTY::'a::type => bool)) (0::nat))
+ ((All::(('a::type => bool) => bool) => bool)
+ (%s::'a::type => bool.
+ (op -->::bool => bool => bool)
+ ((FINITE::('a::type => bool) => bool) s)
+ ((All::('a::type => bool) => bool)
+ (%x::'a::type.
(op =::nat => nat => bool)
- ((CARD::('a => bool) => nat)
- ((INSERT::'a => ('a => bool) => 'a => bool) x s))
+ ((CARD::('a::type => bool) => nat)
+ ((INSERT::'a::type
+ => ('a::type => bool) => 'a::type => bool)
+ x s))
((If::bool => nat => nat => nat)
- ((IN::'a => ('a => bool) => bool) x s)
- ((CARD::('a => bool) => nat) s)
- ((Suc::nat => nat) ((CARD::('a => bool) => nat) s)))))))"
+ ((IN::'a::type => ('a::type => bool) => bool) x s)
+ ((CARD::('a::type => bool) => nat) s)
+ ((Suc::nat => nat)
+ ((CARD::('a::type => bool) => nat) s)))))))"
by (import pred_set CARD_DEF)
-lemma CARD_EMPTY: "CARD EMPTY = 0"
+lemma CARD_EMPTY: "CARD EMPTY = (0::nat)"
by (import pred_set CARD_EMPTY)
-lemma CARD_INSERT: "ALL s.
+lemma CARD_INSERT: "ALL s::'a::type => bool.
FINITE s -->
- (ALL x. CARD (INSERT x s) = (if IN x s then CARD s else Suc (CARD s)))"
+ (ALL x::'a::type.
+ CARD (INSERT x s) = (if IN x s then CARD s else Suc (CARD s)))"
by (import pred_set CARD_INSERT)
-lemma CARD_EQ_0: "ALL s. FINITE s --> (CARD s = 0) = (s = EMPTY)"
+lemma CARD_EQ_0: "ALL s::'a::type => bool. FINITE s --> (CARD s = (0::nat)) = (s = EMPTY)"
by (import pred_set CARD_EQ_0)
-lemma CARD_DELETE: "ALL s.
+lemma CARD_DELETE: "ALL s::'a::type => bool.
FINITE s -->
- (ALL x. CARD (DELETE s x) = (if IN x s then CARD s - 1 else CARD s))"
+ (ALL x::'a::type.
+ CARD (DELETE s x) = (if IN x s then CARD s - (1::nat) else CARD s))"
by (import pred_set CARD_DELETE)
-lemma CARD_INTER_LESS_EQ: "ALL s. FINITE s --> (ALL t. CARD (pred_set.INTER s t) <= CARD s)"
+lemma CARD_INTER_LESS_EQ: "ALL s::'a::type => bool.
+ FINITE s -->
+ (ALL t::'a::type => bool. CARD (pred_set.INTER s t) <= CARD s)"
by (import pred_set CARD_INTER_LESS_EQ)
-lemma CARD_UNION: "ALL s.
+lemma CARD_UNION: "ALL s::'a::type => bool.
FINITE s -->
- (ALL t.
+ (ALL t::'a::type => bool.
FINITE t -->
CARD (pred_set.UNION s t) + CARD (pred_set.INTER s t) =
CARD s + CARD t)"
by (import pred_set CARD_UNION)
-lemma CARD_SUBSET: "ALL s. FINITE s --> (ALL t. SUBSET t s --> CARD t <= CARD s)"
+lemma CARD_SUBSET: "ALL s::'a::type => bool.
+ FINITE s --> (ALL t::'a::type => bool. SUBSET t s --> CARD t <= CARD s)"
by (import pred_set CARD_SUBSET)
-lemma CARD_PSUBSET: "ALL s. FINITE s --> (ALL t. PSUBSET t s --> CARD t < CARD s)"
+lemma CARD_PSUBSET: "ALL s::'a::type => bool.
+ FINITE s --> (ALL t::'a::type => bool. PSUBSET t s --> CARD t < CARD s)"
by (import pred_set CARD_PSUBSET)
-lemma CARD_SING: "ALL x. CARD (INSERT x EMPTY) = 1"
+lemma CARD_SING: "ALL x::'a::type. CARD (INSERT x EMPTY) = (1::nat)"
by (import pred_set CARD_SING)
-lemma SING_IFF_CARD1: "ALL x. SING x = (CARD x = 1 & FINITE x)"
+lemma SING_IFF_CARD1: "ALL x::'a::type => bool. SING x = (CARD x = (1::nat) & FINITE x)"
by (import pred_set SING_IFF_CARD1)
-lemma CARD_DIFF: "ALL t.
+lemma CARD_DIFF: "ALL t::'a::type => bool.
FINITE t -->
- (ALL s.
+ (ALL s::'a::type => bool.
FINITE s --> CARD (DIFF s t) = CARD s - CARD (pred_set.INTER s t))"
by (import pred_set CARD_DIFF)
-lemma LESS_CARD_DIFF: "ALL t.
+lemma LESS_CARD_DIFF: "ALL t::'a::type => bool.
FINITE t -->
- (ALL s. FINITE s --> CARD t < CARD s --> 0 < CARD (DIFF s t))"
+ (ALL s::'a::type => bool.
+ FINITE s --> CARD t < CARD s --> (0::nat) < CARD (DIFF s t))"
by (import pred_set LESS_CARD_DIFF)
-lemma FINITE_COMPLETE_INDUCTION: "ALL P.
- (ALL x. (ALL y. PSUBSET y x --> P y) --> FINITE x --> P x) -->
- (ALL x. FINITE x --> P x)"
+lemma FINITE_COMPLETE_INDUCTION: "ALL P::('a::type => bool) => bool.
+ (ALL x::'a::type => bool.
+ (ALL y::'a::type => bool. PSUBSET y x --> P y) -->
+ FINITE x --> P x) -->
+ (ALL x::'a::type => bool. FINITE x --> P x)"
by (import pred_set FINITE_COMPLETE_INDUCTION)
constdefs
- INFINITE :: "('a => bool) => bool"
- "INFINITE == %s. ~ FINITE s"
-
-lemma INFINITE_DEF: "ALL s. INFINITE s = (~ FINITE s)"
+ INFINITE :: "('a::type => bool) => bool"
+ "INFINITE == %s::'a::type => bool. ~ FINITE s"
+
+lemma INFINITE_DEF: "ALL s::'a::type => bool. INFINITE s = (~ FINITE s)"
by (import pred_set INFINITE_DEF)
lemma NOT_IN_FINITE: "(op =::bool => bool => bool)
- ((INFINITE::('a => bool) => bool) (pred_set.UNIV::'a => bool))
- ((All::(('a => bool) => bool) => bool)
- (%s::'a => bool.
- (op -->::bool => bool => bool) ((FINITE::('a => bool) => bool) s)
- ((Ex::('a => bool) => bool)
- (%x::'a.
- (Not::bool => bool) ((IN::'a => ('a => bool) => bool) x s)))))"
+ ((INFINITE::('a::type => bool) => bool) (pred_set.UNIV::'a::type => bool))
+ ((All::(('a::type => bool) => bool) => bool)
+ (%s::'a::type => bool.
+ (op -->::bool => bool => bool)
+ ((FINITE::('a::type => bool) => bool) s)
+ ((Ex::('a::type => bool) => bool)
+ (%x::'a::type.
+ (Not::bool => bool)
+ ((IN::'a::type => ('a::type => bool) => bool) x s)))))"
by (import pred_set NOT_IN_FINITE)
-lemma INFINITE_INHAB: "ALL x. INFINITE x --> (EX xa. IN xa x)"
+lemma INFINITE_INHAB: "ALL x::'a::type => bool. INFINITE x --> (EX xa::'a::type. IN xa x)"
by (import pred_set INFINITE_INHAB)
-lemma IMAGE_11_INFINITE: "ALL f.
- (ALL x y. f x = f y --> x = y) -->
- (ALL s. INFINITE s --> INFINITE (IMAGE f s))"
+lemma IMAGE_11_INFINITE: "ALL f::'a::type => 'b::type.
+ (ALL (x::'a::type) y::'a::type. f x = f y --> x = y) -->
+ (ALL s::'a::type => bool. INFINITE s --> INFINITE (IMAGE f s))"
by (import pred_set IMAGE_11_INFINITE)
-lemma INFINITE_SUBSET: "ALL x. INFINITE x --> (ALL xa. SUBSET x xa --> INFINITE xa)"
+lemma INFINITE_SUBSET: "ALL x::'a::type => bool.
+ INFINITE x --> (ALL xa::'a::type => bool. SUBSET x xa --> INFINITE xa)"
by (import pred_set INFINITE_SUBSET)
-lemma IN_INFINITE_NOT_FINITE: "ALL x xa. INFINITE x & FINITE xa --> (EX xb. IN xb x & ~ IN xb xa)"
+lemma IN_INFINITE_NOT_FINITE: "ALL (x::'a::type => bool) xa::'a::type => bool.
+ INFINITE x & FINITE xa --> (EX xb::'a::type. IN xb x & ~ IN xb xa)"
by (import pred_set IN_INFINITE_NOT_FINITE)
lemma INFINITE_UNIV: "(op =::bool => bool => bool)
- ((INFINITE::('a => bool) => bool) (pred_set.UNIV::'a => bool))
- ((Ex::(('a => 'a) => bool) => bool)
- (%f::'a => 'a.
+ ((INFINITE::('a::type => bool) => bool) (pred_set.UNIV::'a::type => bool))
+ ((Ex::(('a::type => 'a::type) => bool) => bool)
+ (%f::'a::type => 'a::type.
(op &::bool => bool => bool)
- ((All::('a => bool) => bool)
- (%x::'a.
- (All::('a => bool) => bool)
- (%y::'a.
+ ((All::('a::type => bool) => bool)
+ (%x::'a::type.
+ (All::('a::type => bool) => bool)
+ (%y::'a::type.
(op -->::bool => bool => bool)
- ((op =::'a => 'a => bool) (f x) (f y))
- ((op =::'a => 'a => bool) x y))))
- ((Ex::('a => bool) => bool)
- (%y::'a.
- (All::('a => bool) => bool)
- (%x::'a.
+ ((op =::'a::type => 'a::type => bool) (f x) (f y))
+ ((op =::'a::type => 'a::type => bool) x y))))
+ ((Ex::('a::type => bool) => bool)
+ (%y::'a::type.
+ (All::('a::type => bool) => bool)
+ (%x::'a::type.
(Not::bool => bool)
- ((op =::'a => 'a => bool) (f x) y))))))"
+ ((op =::'a::type => 'a::type => bool) (f x) y))))))"
by (import pred_set INFINITE_UNIV)
-lemma FINITE_PSUBSET_INFINITE: "ALL x. INFINITE x = (ALL xa. FINITE xa --> SUBSET xa x --> PSUBSET xa x)"
+lemma FINITE_PSUBSET_INFINITE: "ALL x::'a::type => bool.
+ INFINITE x =
+ (ALL xa::'a::type => bool. FINITE xa --> SUBSET xa x --> PSUBSET xa x)"
by (import pred_set FINITE_PSUBSET_INFINITE)
lemma FINITE_PSUBSET_UNIV: "(op =::bool => bool => bool)
- ((INFINITE::('a => bool) => bool) (pred_set.UNIV::'a => bool))
- ((All::(('a => bool) => bool) => bool)
- (%s::'a => bool.
- (op -->::bool => bool => bool) ((FINITE::('a => bool) => bool) s)
- ((PSUBSET::('a => bool) => ('a => bool) => bool) s
- (pred_set.UNIV::'a => bool))))"
+ ((INFINITE::('a::type => bool) => bool) (pred_set.UNIV::'a::type => bool))
+ ((All::(('a::type => bool) => bool) => bool)
+ (%s::'a::type => bool.
+ (op -->::bool => bool => bool)
+ ((FINITE::('a::type => bool) => bool) s)
+ ((PSUBSET::('a::type => bool) => ('a::type => bool) => bool) s
+ (pred_set.UNIV::'a::type => bool))))"
by (import pred_set FINITE_PSUBSET_UNIV)
-lemma INFINITE_DIFF_FINITE: "ALL s t. INFINITE s & FINITE t --> DIFF s t ~= EMPTY"
+lemma INFINITE_DIFF_FINITE: "ALL (s::'a::type => bool) t::'a::type => bool.
+ INFINITE s & FINITE t --> DIFF s t ~= EMPTY"
by (import pred_set INFINITE_DIFF_FINITE)
-lemma FINITE_ISO_NUM: "ALL s.
+lemma FINITE_ISO_NUM: "ALL s::'a::type => bool.
FINITE s -->
- (EX f. (ALL n m. n < CARD s & m < CARD s --> f n = f m --> n = m) &
- s = GSPEC (%n. (f n, n < CARD s)))"
+ (EX f::nat => 'a::type.
+ (ALL (n::nat) m::nat.
+ n < CARD s & m < CARD s --> f n = f m --> n = m) &
+ s = GSPEC (%n::nat. (f n, n < CARD s)))"
by (import pred_set FINITE_ISO_NUM)
-lemma FINITE_WEAK_ENUMERATE: "(All::(('a => bool) => bool) => bool)
- (%x::'a => bool.
- (op =::bool => bool => bool) ((FINITE::('a => bool) => bool) x)
- ((Ex::((nat => 'a) => bool) => bool)
- (%f::nat => 'a.
+lemma FINITE_WEAK_ENUMERATE: "(All::(('a::type => bool) => bool) => bool)
+ (%x::'a::type => bool.
+ (op =::bool => bool => bool) ((FINITE::('a::type => bool) => bool) x)
+ ((Ex::((nat => 'a::type) => bool) => bool)
+ (%f::nat => 'a::type.
(Ex::(nat => bool) => bool)
(%b::nat.
- (All::('a => bool) => bool)
- (%e::'a.
+ (All::('a::type => bool) => bool)
+ (%e::'a::type.
(op =::bool => bool => bool)
- ((IN::'a => ('a => bool) => bool) e x)
+ ((IN::'a::type => ('a::type => bool) => bool) e x)
((Ex::(nat => bool) => bool)
(%n::nat.
(op &::bool => bool => bool)
((op <::nat => nat => bool) n b)
- ((op =::'a => 'a => bool) e (f n)))))))))"
+ ((op =::'a::type => 'a::type => bool) e
+ (f n)))))))))"
by (import pred_set FINITE_WEAK_ENUMERATE)
constdefs
- BIGUNION :: "(('a => bool) => bool) => 'a => bool"
- "BIGUNION == %P. GSPEC (%x. (x, EX p. IN p P & IN x p))"
-
-lemma BIGUNION: "ALL P. BIGUNION P = GSPEC (%x. (x, EX p. IN p P & IN x p))"
+ BIGUNION :: "(('a::type => bool) => bool) => 'a::type => bool"
+ "BIGUNION ==
+%P::('a::type => bool) => bool.
+ GSPEC (%x::'a::type. (x, EX p::'a::type => bool. IN p P & IN x p))"
+
+lemma BIGUNION: "ALL P::('a::type => bool) => bool.
+ BIGUNION P =
+ GSPEC (%x::'a::type. (x, EX p::'a::type => bool. IN p P & IN x p))"
by (import pred_set BIGUNION)
-lemma IN_BIGUNION: "ALL x xa. IN x (BIGUNION xa) = (EX s. IN x s & IN s xa)"
+lemma IN_BIGUNION: "ALL (x::'a::type) xa::('a::type => bool) => bool.
+ IN x (BIGUNION xa) = (EX s::'a::type => bool. IN x s & IN s xa)"
by (import pred_set IN_BIGUNION)
lemma BIGUNION_EMPTY: "BIGUNION EMPTY = EMPTY"
by (import pred_set BIGUNION_EMPTY)
-lemma BIGUNION_SING: "ALL x. BIGUNION (INSERT x EMPTY) = x"
+lemma BIGUNION_SING: "ALL x::'a::type => bool. BIGUNION (INSERT x EMPTY) = x"
by (import pred_set BIGUNION_SING)
-lemma BIGUNION_UNION: "ALL x xa.
+lemma BIGUNION_UNION: "ALL (x::('a::type => bool) => bool) xa::('a::type => bool) => bool.
BIGUNION (pred_set.UNION x xa) =
pred_set.UNION (BIGUNION x) (BIGUNION xa)"
by (import pred_set BIGUNION_UNION)
-lemma DISJOINT_BIGUNION: "(ALL (s::('a => bool) => bool) t::'a => bool.
+lemma DISJOINT_BIGUNION: "(ALL (s::('a::type => bool) => bool) t::'a::type => bool.
DISJOINT (BIGUNION s) t =
- (ALL s'::'a => bool. IN s' s --> DISJOINT s' t)) &
-(ALL (x::('a => bool) => bool) xa::'a => bool.
+ (ALL s'::'a::type => bool. IN s' s --> DISJOINT s' t)) &
+(ALL (x::('a::type => bool) => bool) xa::'a::type => bool.
DISJOINT xa (BIGUNION x) =
- (ALL xb::'a => bool. IN xb x --> DISJOINT xa xb))"
+ (ALL xb::'a::type => bool. IN xb x --> DISJOINT xa xb))"
by (import pred_set DISJOINT_BIGUNION)
-lemma BIGUNION_INSERT: "ALL x xa. BIGUNION (INSERT x xa) = pred_set.UNION x (BIGUNION xa)"
+lemma BIGUNION_INSERT: "ALL (x::'a::type => bool) xa::('a::type => bool) => bool.
+ BIGUNION (INSERT x xa) = pred_set.UNION x (BIGUNION xa)"
by (import pred_set BIGUNION_INSERT)
-lemma BIGUNION_SUBSET: "ALL X P. SUBSET (BIGUNION P) X = (ALL Y. IN Y P --> SUBSET Y X)"
+lemma BIGUNION_SUBSET: "ALL (X::'a::type => bool) P::('a::type => bool) => bool.
+ SUBSET (BIGUNION P) X = (ALL Y::'a::type => bool. IN Y P --> SUBSET Y X)"
by (import pred_set BIGUNION_SUBSET)
-lemma FINITE_BIGUNION: "ALL x. FINITE x & (ALL s. IN s x --> FINITE s) --> FINITE (BIGUNION x)"
+lemma FINITE_BIGUNION: "ALL x::('a::type => bool) => bool.
+ FINITE x & (ALL s::'a::type => bool. IN s x --> FINITE s) -->
+ FINITE (BIGUNION x)"
by (import pred_set FINITE_BIGUNION)
constdefs
- BIGINTER :: "(('a => bool) => bool) => 'a => bool"
- "BIGINTER == %B. GSPEC (%x. (x, ALL P. IN P B --> IN x P))"
-
-lemma BIGINTER: "ALL B. BIGINTER B = GSPEC (%x. (x, ALL P. IN P B --> IN x P))"
+ BIGINTER :: "(('a::type => bool) => bool) => 'a::type => bool"
+ "BIGINTER ==
+%B::('a::type => bool) => bool.
+ GSPEC (%x::'a::type. (x, ALL P::'a::type => bool. IN P B --> IN x P))"
+
+lemma BIGINTER: "ALL B::('a::type => bool) => bool.
+ BIGINTER B =
+ GSPEC (%x::'a::type. (x, ALL P::'a::type => bool. IN P B --> IN x P))"
by (import pred_set BIGINTER)
-lemma IN_BIGINTER: "IN x (BIGINTER B) = (ALL P. IN P B --> IN x P)"
+lemma IN_BIGINTER: "IN (x::'a::type) (BIGINTER (B::('a::type => bool) => bool)) =
+(ALL P::'a::type => bool. IN P B --> IN x P)"
by (import pred_set IN_BIGINTER)
-lemma BIGINTER_INSERT: "ALL P B. BIGINTER (INSERT P B) = pred_set.INTER P (BIGINTER B)"
+lemma BIGINTER_INSERT: "ALL (P::'a::type => bool) B::('a::type => bool) => bool.
+ BIGINTER (INSERT P B) = pred_set.INTER P (BIGINTER B)"
by (import pred_set BIGINTER_INSERT)
lemma BIGINTER_EMPTY: "BIGINTER EMPTY = pred_set.UNIV"
by (import pred_set BIGINTER_EMPTY)
-lemma BIGINTER_INTER: "ALL x xa. BIGINTER (INSERT x (INSERT xa EMPTY)) = pred_set.INTER x xa"
+lemma BIGINTER_INTER: "ALL (x::'a::type => bool) xa::'a::type => bool.
+ BIGINTER (INSERT x (INSERT xa EMPTY)) = pred_set.INTER x xa"
by (import pred_set BIGINTER_INTER)
-lemma BIGINTER_SING: "ALL x. BIGINTER (INSERT x EMPTY) = x"
+lemma BIGINTER_SING: "ALL x::'a::type => bool. BIGINTER (INSERT x EMPTY) = x"
by (import pred_set BIGINTER_SING)
-lemma SUBSET_BIGINTER: "ALL X P. SUBSET X (BIGINTER P) = (ALL x. IN x P --> SUBSET X x)"
+lemma SUBSET_BIGINTER: "ALL (X::'a::type => bool) P::('a::type => bool) => bool.
+ SUBSET X (BIGINTER P) = (ALL x::'a::type => bool. IN x P --> SUBSET X x)"
by (import pred_set SUBSET_BIGINTER)
-lemma DISJOINT_BIGINTER: "ALL x xa xb.
+lemma DISJOINT_BIGINTER: "ALL (x::'a::type => bool) (xa::'a::type => bool)
+ xb::('a::type => bool) => bool.
IN xa xb & DISJOINT xa x -->
DISJOINT x (BIGINTER xb) & DISJOINT (BIGINTER xb) x"
by (import pred_set DISJOINT_BIGINTER)
constdefs
- CROSS :: "('a => bool) => ('b => bool) => 'a * 'b => bool"
- "CROSS == %P Q. GSPEC (%p. (p, IN (fst p) P & IN (snd p) Q))"
-
-lemma CROSS_DEF: "ALL P Q. CROSS P Q = GSPEC (%p. (p, IN (fst p) P & IN (snd p) Q))"
+ CROSS :: "('a::type => bool) => ('b::type => bool) => 'a::type * 'b::type => bool"
+ "CROSS ==
+%(P::'a::type => bool) Q::'b::type => bool.
+ GSPEC (%p::'a::type * 'b::type. (p, IN (fst p) P & IN (snd p) Q))"
+
+lemma CROSS_DEF: "ALL (P::'a::type => bool) Q::'b::type => bool.
+ CROSS P Q =
+ GSPEC (%p::'a::type * 'b::type. (p, IN (fst p) P & IN (snd p) Q))"
by (import pred_set CROSS_DEF)
-lemma IN_CROSS: "ALL x xa xb. IN xb (CROSS x xa) = (IN (fst xb) x & IN (snd xb) xa)"
+lemma IN_CROSS: "ALL (x::'a::type => bool) (xa::'b::type => bool) xb::'a::type * 'b::type.
+ IN xb (CROSS x xa) = (IN (fst xb) x & IN (snd xb) xa)"
by (import pred_set IN_CROSS)
-lemma CROSS_EMPTY: "ALL x. CROSS x EMPTY = EMPTY & CROSS EMPTY x = EMPTY"
+lemma CROSS_EMPTY: "ALL x::'a::type => bool. CROSS x EMPTY = EMPTY & CROSS EMPTY x = EMPTY"
by (import pred_set CROSS_EMPTY)
-lemma CROSS_INSERT_LEFT: "ALL x xa xb.
+lemma CROSS_INSERT_LEFT: "ALL (x::'a::type => bool) (xa::'b::type => bool) xb::'a::type.
CROSS (INSERT xb x) xa =
pred_set.UNION (CROSS (INSERT xb EMPTY) xa) (CROSS x xa)"
by (import pred_set CROSS_INSERT_LEFT)
-lemma CROSS_INSERT_RIGHT: "ALL x xa xb.
+lemma CROSS_INSERT_RIGHT: "ALL (x::'a::type => bool) (xa::'b::type => bool) xb::'b::type.
CROSS x (INSERT xb xa) =
pred_set.UNION (CROSS x (INSERT xb EMPTY)) (CROSS x xa)"
by (import pred_set CROSS_INSERT_RIGHT)
-lemma FINITE_CROSS: "ALL x xa. FINITE x & FINITE xa --> FINITE (CROSS x xa)"
+lemma FINITE_CROSS: "ALL (x::'a::type => bool) xa::'b::type => bool.
+ FINITE x & FINITE xa --> FINITE (CROSS x xa)"
by (import pred_set FINITE_CROSS)
-lemma CROSS_SINGS: "ALL x xa. CROSS (INSERT x EMPTY) (INSERT xa EMPTY) = INSERT (x, xa) EMPTY"
+lemma CROSS_SINGS: "ALL (x::'a::type) xa::'b::type.
+ CROSS (INSERT x EMPTY) (INSERT xa EMPTY) = INSERT (x, xa) EMPTY"
by (import pred_set CROSS_SINGS)
-lemma CARD_SING_CROSS: "ALL x s. FINITE s --> CARD (CROSS (INSERT x EMPTY) s) = CARD s"
+lemma CARD_SING_CROSS: "ALL (x::'a::type) s::'b::type => bool.
+ FINITE s --> CARD (CROSS (INSERT x EMPTY) s) = CARD s"
by (import pred_set CARD_SING_CROSS)
-lemma CARD_CROSS: "ALL x xa. FINITE x & FINITE xa --> CARD (CROSS x xa) = CARD x * CARD xa"
+lemma CARD_CROSS: "ALL (x::'a::type => bool) xa::'b::type => bool.
+ FINITE x & FINITE xa --> CARD (CROSS x xa) = CARD x * CARD xa"
by (import pred_set CARD_CROSS)
-lemma CROSS_SUBSET: "ALL x xa xb xc.
+lemma CROSS_SUBSET: "ALL (x::'a::type => bool) (xa::'b::type => bool) (xb::'a::type => bool)
+ xc::'b::type => bool.
SUBSET (CROSS xb xc) (CROSS x xa) =
(xb = EMPTY | xc = EMPTY | SUBSET xb x & SUBSET xc xa)"
by (import pred_set CROSS_SUBSET)
-lemma FINITE_CROSS_EQ: "ALL P Q. FINITE (CROSS P Q) = (P = EMPTY | Q = EMPTY | FINITE P & FINITE Q)"
+lemma FINITE_CROSS_EQ: "ALL (P::'a::type => bool) Q::'b::type => bool.
+ FINITE (CROSS P Q) = (P = EMPTY | Q = EMPTY | FINITE P & FINITE Q)"
by (import pred_set FINITE_CROSS_EQ)
constdefs
- COMPL :: "('a => bool) => 'a => bool"
+ COMPL :: "('a::type => bool) => 'a::type => bool"
"COMPL == DIFF pred_set.UNIV"
-lemma COMPL_DEF: "ALL P. COMPL P = DIFF pred_set.UNIV P"
+lemma COMPL_DEF: "ALL P::'a::type => bool. COMPL P = DIFF pred_set.UNIV P"
by (import pred_set COMPL_DEF)
-lemma IN_COMPL: "ALL x xa. IN x (COMPL xa) = (~ IN x xa)"
+lemma IN_COMPL: "ALL (x::'a::type) xa::'a::type => bool. IN x (COMPL xa) = (~ IN x xa)"
by (import pred_set IN_COMPL)
-lemma COMPL_COMPL: "ALL x. COMPL (COMPL x) = x"
+lemma COMPL_COMPL: "ALL x::'a::type => bool. COMPL (COMPL x) = x"
by (import pred_set COMPL_COMPL)
-lemma COMPL_CLAUSES: "ALL x.
+lemma COMPL_CLAUSES: "ALL x::'a::type => bool.
pred_set.INTER (COMPL x) x = EMPTY &
pred_set.UNION (COMPL x) x = pred_set.UNIV"
by (import pred_set COMPL_CLAUSES)
-lemma COMPL_SPLITS: "ALL x xa.
+lemma COMPL_SPLITS: "ALL (x::'a::type => bool) xa::'a::type => bool.
pred_set.UNION (pred_set.INTER x xa) (pred_set.INTER (COMPL x) xa) = xa"
by (import pred_set COMPL_SPLITS)
-lemma INTER_UNION_COMPL: "ALL x xa. pred_set.INTER x xa = COMPL (pred_set.UNION (COMPL x) (COMPL xa))"
+lemma INTER_UNION_COMPL: "ALL (x::'a::type => bool) xa::'a::type => bool.
+ pred_set.INTER x xa = COMPL (pred_set.UNION (COMPL x) (COMPL xa))"
by (import pred_set INTER_UNION_COMPL)
lemma COMPL_EMPTY: "COMPL EMPTY = pred_set.UNIV"
@@ -3659,48 +4315,54 @@
count :: "nat => nat => bool"
defs
- count_primdef: "count == %n. GSPEC (%m. (m, m < n))"
-
-lemma count_def: "ALL n. count n = GSPEC (%m. (m, m < n))"
+ count_primdef: "count == %n::nat. GSPEC (%m::nat. (m, m < n))"
+
+lemma count_def: "ALL n::nat. count n = GSPEC (%m::nat. (m, m < n))"
by (import pred_set count_def)
-lemma IN_COUNT: "ALL m n. IN m (count n) = (m < n)"
+lemma IN_COUNT: "ALL (m::nat) n::nat. IN m (count n) = (m < n)"
by (import pred_set IN_COUNT)
-lemma COUNT_ZERO: "count 0 = EMPTY"
+lemma COUNT_ZERO: "count (0::nat) = EMPTY"
by (import pred_set COUNT_ZERO)
-lemma COUNT_SUC: "ALL n. count (Suc n) = INSERT n (count n)"
+lemma COUNT_SUC: "ALL n::nat. count (Suc n) = INSERT n (count n)"
by (import pred_set COUNT_SUC)
-lemma FINITE_COUNT: "ALL n. FINITE (count n)"
+lemma FINITE_COUNT: "ALL n::nat. FINITE (count n)"
by (import pred_set FINITE_COUNT)
-lemma CARD_COUNT: "ALL n. CARD (count n) = n"
+lemma CARD_COUNT: "ALL n::nat. CARD (count n) = n"
by (import pred_set CARD_COUNT)
constdefs
- ITSET_tupled :: "('a => 'b => 'b) => ('a => bool) * 'b => 'b"
+ ITSET_tupled :: "('a::type => 'b::type => 'b::type)
+=> ('a::type => bool) * 'b::type => 'b::type"
"ITSET_tupled ==
-%f. WFREC
- (SOME R.
- WF R &
- (ALL b s.
- FINITE s & s ~= EMPTY --> R (REST s, f (CHOICE s) b) (s, b)))
- (%ITSET_tupled (v, v1).
- if FINITE v
- then if v = EMPTY then v1
- else ITSET_tupled (REST v, f (CHOICE v) v1)
- else ARB)"
-
-lemma ITSET_tupled_primitive_def: "ALL f.
+%f::'a::type => 'b::type => 'b::type.
+ WFREC
+ (SOME R::('a::type => bool) * 'b::type
+ => ('a::type => bool) * 'b::type => bool.
+ WF R &
+ (ALL (b::'b::type) s::'a::type => bool.
+ FINITE s & s ~= EMPTY --> R (REST s, f (CHOICE s) b) (s, b)))
+ (%(ITSET_tupled::('a::type => bool) * 'b::type => 'b::type)
+ (v::'a::type => bool, v1::'b::type).
+ if FINITE v
+ then if v = EMPTY then v1
+ else ITSET_tupled (REST v, f (CHOICE v) v1)
+ else ARB)"
+
+lemma ITSET_tupled_primitive_def: "ALL f::'a::type => 'b::type => 'b::type.
ITSET_tupled f =
WFREC
- (SOME R.
+ (SOME R::('a::type => bool) * 'b::type
+ => ('a::type => bool) * 'b::type => bool.
WF R &
- (ALL b s.
+ (ALL (b::'b::type) s::'a::type => bool.
FINITE s & s ~= EMPTY --> R (REST s, f (CHOICE s) b) (s, b)))
- (%ITSET_tupled (v, v1).
+ (%(ITSET_tupled::('a::type => bool) * 'b::type => 'b::type)
+ (v::'a::type => bool, v1::'b::type).
if FINITE v
then if v = EMPTY then v1
else ITSET_tupled (REST v, f (CHOICE v) v1)
@@ -3708,26 +4370,32 @@
by (import pred_set ITSET_tupled_primitive_def)
constdefs
- ITSET :: "('a => 'b => 'b) => ('a => bool) => 'b => 'b"
- "ITSET == %f x x1. ITSET_tupled f (x, x1)"
-
-lemma ITSET_curried_def: "ALL f x x1. ITSET f x x1 = ITSET_tupled f (x, x1)"
+ ITSET :: "('a::type => 'b::type => 'b::type)
+=> ('a::type => bool) => 'b::type => 'b::type"
+ "ITSET ==
+%(f::'a::type => 'b::type => 'b::type) (x::'a::type => bool) x1::'b::type.
+ ITSET_tupled f (x, x1)"
+
+lemma ITSET_curried_def: "ALL (f::'a::type => 'b::type => 'b::type) (x::'a::type => bool)
+ x1::'b::type. ITSET f x x1 = ITSET_tupled f (x, x1)"
by (import pred_set ITSET_curried_def)
-lemma ITSET_IND: "ALL P.
- (ALL s b.
- (FINITE s & s ~= EMPTY --> P (REST s) (f (CHOICE s) b)) -->
+lemma ITSET_IND: "ALL P::('a::type => bool) => 'b::type => bool.
+ (ALL (s::'a::type => bool) b::'b::type.
+ (FINITE s & s ~= EMPTY -->
+ P (REST s) ((f::'a::type => 'b::type => 'b::type) (CHOICE s) b)) -->
P s b) -->
- (ALL v. All (P v))"
+ (ALL v::'a::type => bool. All (P v))"
by (import pred_set ITSET_IND)
-lemma ITSET_THM: "ALL s f b.
+lemma ITSET_THM: "ALL (s::'a::type => bool) (f::'a::type => 'b::type => 'b::type) b::'b::type.
FINITE s -->
ITSET f s b =
(if s = EMPTY then b else ITSET f (REST s) (f (CHOICE s) b))"
by (import pred_set ITSET_THM)
-lemma ITSET_EMPTY: "ALL x xa. ITSET x EMPTY xa = xa"
+lemma ITSET_EMPTY: "ALL (x::'a::type => 'b::type => 'b::type) xa::'b::type.
+ ITSET x EMPTY xa = xa"
by (import pred_set ITSET_EMPTY)
;end_setup
@@ -3735,45 +4403,67 @@
;setup_theory operator
constdefs
- ASSOC :: "('a => 'a => 'a) => bool"
- "ASSOC == %f. ALL x y z. f x (f y z) = f (f x y) z"
-
-lemma ASSOC_DEF: "ALL f. ASSOC f = (ALL x y z. f x (f y z) = f (f x y) z)"
+ ASSOC :: "('a::type => 'a::type => 'a::type) => bool"
+ "ASSOC ==
+%f::'a::type => 'a::type => 'a::type.
+ ALL (x::'a::type) (y::'a::type) z::'a::type. f x (f y z) = f (f x y) z"
+
+lemma ASSOC_DEF: "ALL f::'a::type => 'a::type => 'a::type.
+ ASSOC f =
+ (ALL (x::'a::type) (y::'a::type) z::'a::type. f x (f y z) = f (f x y) z)"
by (import operator ASSOC_DEF)
constdefs
- COMM :: "('a => 'a => 'b) => bool"
- "COMM == %f. ALL x y. f x y = f y x"
-
-lemma COMM_DEF: "ALL f. COMM f = (ALL x y. f x y = f y x)"
+ COMM :: "('a::type => 'a::type => 'b::type) => bool"
+ "COMM ==
+%f::'a::type => 'a::type => 'b::type.
+ ALL (x::'a::type) y::'a::type. f x y = f y x"
+
+lemma COMM_DEF: "ALL f::'a::type => 'a::type => 'b::type.
+ COMM f = (ALL (x::'a::type) y::'a::type. f x y = f y x)"
by (import operator COMM_DEF)
constdefs
- FCOMM :: "('a => 'b => 'a) => ('c => 'a => 'a) => bool"
- "FCOMM == %f g. ALL x y z. g x (f y z) = f (g x y) z"
-
-lemma FCOMM_DEF: "ALL f g. FCOMM f g = (ALL x y z. g x (f y z) = f (g x y) z)"
+ FCOMM :: "('a::type => 'b::type => 'a::type)
+=> ('c::type => 'a::type => 'a::type) => bool"
+ "FCOMM ==
+%(f::'a::type => 'b::type => 'a::type) g::'c::type => 'a::type => 'a::type.
+ ALL (x::'c::type) (y::'a::type) z::'b::type. g x (f y z) = f (g x y) z"
+
+lemma FCOMM_DEF: "ALL (f::'a::type => 'b::type => 'a::type)
+ g::'c::type => 'a::type => 'a::type.
+ FCOMM f g =
+ (ALL (x::'c::type) (y::'a::type) z::'b::type. g x (f y z) = f (g x y) z)"
by (import operator FCOMM_DEF)
constdefs
- RIGHT_ID :: "('a => 'b => 'a) => 'b => bool"
- "RIGHT_ID == %f e. ALL x. f x e = x"
-
-lemma RIGHT_ID_DEF: "ALL f e. RIGHT_ID f e = (ALL x. f x e = x)"
+ RIGHT_ID :: "('a::type => 'b::type => 'a::type) => 'b::type => bool"
+ "RIGHT_ID ==
+%(f::'a::type => 'b::type => 'a::type) e::'b::type.
+ ALL x::'a::type. f x e = x"
+
+lemma RIGHT_ID_DEF: "ALL (f::'a::type => 'b::type => 'a::type) e::'b::type.
+ RIGHT_ID f e = (ALL x::'a::type. f x e = x)"
by (import operator RIGHT_ID_DEF)
constdefs
- LEFT_ID :: "('a => 'b => 'b) => 'a => bool"
- "LEFT_ID == %f e. ALL x. f e x = x"
-
-lemma LEFT_ID_DEF: "ALL f e. LEFT_ID f e = (ALL x. f e x = x)"
+ LEFT_ID :: "('a::type => 'b::type => 'b::type) => 'a::type => bool"
+ "LEFT_ID ==
+%(f::'a::type => 'b::type => 'b::type) e::'a::type.
+ ALL x::'b::type. f e x = x"
+
+lemma LEFT_ID_DEF: "ALL (f::'a::type => 'b::type => 'b::type) e::'a::type.
+ LEFT_ID f e = (ALL x::'b::type. f e x = x)"
by (import operator LEFT_ID_DEF)
constdefs
- MONOID :: "('a => 'a => 'a) => 'a => bool"
- "MONOID == %f e. ASSOC f & RIGHT_ID f e & LEFT_ID f e"
-
-lemma MONOID_DEF: "ALL f e. MONOID f e = (ASSOC f & RIGHT_ID f e & LEFT_ID f e)"
+ MONOID :: "('a::type => 'a::type => 'a::type) => 'a::type => bool"
+ "MONOID ==
+%(f::'a::type => 'a::type => 'a::type) e::'a::type.
+ ASSOC f & RIGHT_ID f e & LEFT_ID f e"
+
+lemma MONOID_DEF: "ALL (f::'a::type => 'a::type => 'a::type) e::'a::type.
+ MONOID f e = (ASSOC f & RIGHT_ID f e & LEFT_ID f e)"
by (import operator MONOID_DEF)
lemma ASSOC_CONJ: "ASSOC op &"
@@ -3782,7 +4472,7 @@
lemma ASSOC_DISJ: "ASSOC op |"
by (import operator ASSOC_DISJ)
-lemma FCOMM_ASSOC: "ALL x. FCOMM x x = ASSOC x"
+lemma FCOMM_ASSOC: "ALL x::'a::type => 'a::type => 'a::type. FCOMM x x = ASSOC x"
by (import operator FCOMM_ASSOC)
lemma MONOID_CONJ_T: "MONOID op & True"
@@ -3796,29 +4486,35 @@
;setup_theory rich_list
consts
- SNOC :: "'a => 'a list => 'a list"
-
-specification (SNOC) SNOC: "(ALL x::'a. SNOC x [] = [x]) &
-(ALL (x::'a) (x'::'a) l::'a list. SNOC x (x' # l) = x' # SNOC x l)"
+ SNOC :: "'a::type => 'a::type list => 'a::type list"
+
+specification (SNOC) SNOC: "(ALL x::'a::type. SNOC x [] = [x]) &
+(ALL (x::'a::type) (x'::'a::type) l::'a::type list.
+ SNOC x (x' # l) = x' # SNOC x l)"
by (import rich_list SNOC)
consts
- SCANL :: "('b => 'a => 'b) => 'b => 'a list => 'b list"
-
-specification (SCANL) SCANL: "(ALL (f::'b => 'a => 'b) e::'b. SCANL f e [] = [e]) &
-(ALL (f::'b => 'a => 'b) (e::'b) (x::'a) l::'a list.
- SCANL f e (x # l) = e # SCANL f (f e x) l)"
+ SCANL :: "('b::type => 'a::type => 'b::type)
+=> 'b::type => 'a::type list => 'b::type list"
+
+specification (SCANL) SCANL: "(ALL (f::'b::type => 'a::type => 'b::type) e::'b::type.
+ SCANL f e [] = [e]) &
+(ALL (f::'b::type => 'a::type => 'b::type) (e::'b::type) (x::'a::type)
+ l::'a::type list. SCANL f e (x # l) = e # SCANL f (f e x) l)"
by (import rich_list SCANL)
consts
- SCANR :: "('a => 'b => 'b) => 'b => 'a list => 'b list"
-
-specification (SCANR) SCANR: "(ALL (f::'a => 'b => 'b) e::'b. SCANR f e [] = [e]) &
-(ALL (f::'a => 'b => 'b) (e::'b) (x::'a) l::'a list.
+ SCANR :: "('a::type => 'b::type => 'b::type)
+=> 'b::type => 'a::type list => 'b::type list"
+
+specification (SCANR) SCANR: "(ALL (f::'a::type => 'b::type => 'b::type) e::'b::type.
+ SCANR f e [] = [e]) &
+(ALL (f::'a::type => 'b::type => 'b::type) (e::'b::type) (x::'a::type)
+ l::'a::type list.
SCANR f e (x # l) = f x (hd (SCANR f e l)) # SCANR f e l)"
by (import rich_list SCANR)
-lemma IS_EL_DEF: "ALL x l. x mem l = list_exists (op = x) l"
+lemma IS_EL_DEF: "ALL (x::'a::type) l::'a::type list. x mem l = list_exists (op = x) l"
by (import rich_list IS_EL_DEF)
constdefs
@@ -3836,255 +4532,290 @@
by (import rich_list OR_EL_DEF)
consts
- FIRSTN :: "nat => 'a list => 'a list"
-
-specification (FIRSTN) FIRSTN: "(ALL l::'a list. FIRSTN (0::nat) l = []) &
-(ALL (n::nat) (x::'a) l::'a list. FIRSTN (Suc n) (x # l) = x # FIRSTN n l)"
+ FIRSTN :: "nat => 'a::type list => 'a::type list"
+
+specification (FIRSTN) FIRSTN: "(ALL l::'a::type list. FIRSTN (0::nat) l = []) &
+(ALL (n::nat) (x::'a::type) l::'a::type list.
+ FIRSTN (Suc n) (x # l) = x # FIRSTN n l)"
by (import rich_list FIRSTN)
consts
- BUTFIRSTN :: "nat => 'a list => 'a list"
-
-specification (BUTFIRSTN) BUTFIRSTN: "(ALL l::'a list. BUTFIRSTN (0::nat) l = l) &
-(ALL (n::nat) (x::'a) l::'a list. BUTFIRSTN (Suc n) (x # l) = BUTFIRSTN n l)"
+ BUTFIRSTN :: "nat => 'a::type list => 'a::type list"
+
+specification (BUTFIRSTN) BUTFIRSTN: "(ALL l::'a::type list. BUTFIRSTN (0::nat) l = l) &
+(ALL (n::nat) (x::'a::type) l::'a::type list.
+ BUTFIRSTN (Suc n) (x # l) = BUTFIRSTN n l)"
by (import rich_list BUTFIRSTN)
consts
- SEG :: "nat => nat => 'a list => 'a list"
-
-specification (SEG) SEG: "(ALL (k::nat) l::'a list. SEG (0::nat) k l = []) &
-(ALL (m::nat) (x::'a) l::'a list.
+ SEG :: "nat => nat => 'a::type list => 'a::type list"
+
+specification (SEG) SEG: "(ALL (k::nat) l::'a::type list. SEG (0::nat) k l = []) &
+(ALL (m::nat) (x::'a::type) l::'a::type list.
SEG (Suc m) (0::nat) (x # l) = x # SEG m (0::nat) l) &
-(ALL (m::nat) (k::nat) (x::'a) l::'a list.
+(ALL (m::nat) (k::nat) (x::'a::type) l::'a::type list.
SEG (Suc m) (Suc k) (x # l) = SEG (Suc m) k l)"
by (import rich_list SEG)
-lemma LAST: "ALL x l. last (SNOC x l) = x"
+lemma LAST: "ALL (x::'a::type) l::'a::type list. last (SNOC x l) = x"
by (import rich_list LAST)
-lemma BUTLAST: "ALL x l. butlast (SNOC x l) = l"
+lemma BUTLAST: "ALL (x::'a::type) l::'a::type list. butlast (SNOC x l) = l"
by (import rich_list BUTLAST)
consts
- LASTN :: "nat => 'a list => 'a list"
-
-specification (LASTN) LASTN: "(ALL l::'a list. LASTN (0::nat) l = []) &
-(ALL (n::nat) (x::'a) l::'a list.
+ LASTN :: "nat => 'a::type list => 'a::type list"
+
+specification (LASTN) LASTN: "(ALL l::'a::type list. LASTN (0::nat) l = []) &
+(ALL (n::nat) (x::'a::type) l::'a::type list.
LASTN (Suc n) (SNOC x l) = SNOC x (LASTN n l))"
by (import rich_list LASTN)
consts
- BUTLASTN :: "nat => 'a list => 'a list"
-
-specification (BUTLASTN) BUTLASTN: "(ALL l::'a list. BUTLASTN (0::nat) l = l) &
-(ALL (n::nat) (x::'a) l::'a list.
+ BUTLASTN :: "nat => 'a::type list => 'a::type list"
+
+specification (BUTLASTN) BUTLASTN: "(ALL l::'a::type list. BUTLASTN (0::nat) l = l) &
+(ALL (n::nat) (x::'a::type) l::'a::type list.
BUTLASTN (Suc n) (SNOC x l) = BUTLASTN n l)"
by (import rich_list BUTLASTN)
-lemma EL: "(ALL x::'a list. EL (0::nat) x = hd x) &
-(ALL (x::nat) xa::'a list. EL (Suc x) xa = EL x (tl xa))"
+lemma EL: "(ALL x::'a::type list. EL (0::nat) x = hd x) &
+(ALL (x::nat) xa::'a::type list. EL (Suc x) xa = EL x (tl xa))"
by (import rich_list EL)
consts
- ELL :: "nat => 'a list => 'a"
-
-specification (ELL) ELL: "(ALL l::'a list. ELL (0::nat) l = last l) &
-(ALL (n::nat) l::'a list. ELL (Suc n) l = ELL n (butlast l))"
+ ELL :: "nat => 'a::type list => 'a::type"
+
+specification (ELL) ELL: "(ALL l::'a::type list. ELL (0::nat) l = last l) &
+(ALL (n::nat) l::'a::type list. ELL (Suc n) l = ELL n (butlast l))"
by (import rich_list ELL)
consts
- IS_PREFIX :: "'a list => 'a list => bool"
-
-specification (IS_PREFIX) IS_PREFIX: "(ALL l::'a list. IS_PREFIX l [] = True) &
-(ALL (x::'a) l::'a list. IS_PREFIX [] (x # l) = False) &
-(ALL (x1::'a) (l1::'a list) (x2::'a) l2::'a list.
+ IS_PREFIX :: "'a::type list => 'a::type list => bool"
+
+specification (IS_PREFIX) IS_PREFIX: "(ALL l::'a::type list. IS_PREFIX l [] = True) &
+(ALL (x::'a::type) l::'a::type list. IS_PREFIX [] (x # l) = False) &
+(ALL (x1::'a::type) (l1::'a::type list) (x2::'a::type) l2::'a::type list.
IS_PREFIX (x1 # l1) (x2 # l2) = (x1 = x2 & IS_PREFIX l1 l2))"
by (import rich_list IS_PREFIX)
-lemma SNOC_APPEND: "ALL x l. SNOC x l = l @ [x]"
+lemma SNOC_APPEND: "ALL (x::'a::type) l::'a::type list. SNOC x l = l @ [x]"
by (import rich_list SNOC_APPEND)
-lemma REVERSE: "rev [] = [] & (ALL (x::'a) xa::'a list. rev (x # xa) = SNOC x (rev xa))"
+lemma REVERSE: "rev [] = [] &
+(ALL (x::'a::type) xa::'a::type list. rev (x # xa) = SNOC x (rev xa))"
by (import rich_list REVERSE)
-lemma REVERSE_SNOC: "ALL x l. rev (SNOC x l) = x # rev l"
+lemma REVERSE_SNOC: "ALL (x::'a::type) l::'a::type list. rev (SNOC x l) = x # rev l"
by (import rich_list REVERSE_SNOC)
-lemma SNOC_Axiom: "ALL (e::'b) f::'a => 'a list => 'b => 'b.
- EX x::'a list => 'b.
- x [] = e & (ALL (xa::'a) l::'a list. x (SNOC xa l) = f xa l (x l))"
+lemma SNOC_Axiom: "ALL (e::'b::type) f::'a::type => 'a::type list => 'b::type => 'b::type.
+ EX x::'a::type list => 'b::type.
+ x [] = e &
+ (ALL (xa::'a::type) l::'a::type list. x (SNOC xa l) = f xa l (x l))"
by (import rich_list SNOC_Axiom)
consts
- IS_SUFFIX :: "'a list => 'a list => bool"
-
-specification (IS_SUFFIX) IS_SUFFIX: "(ALL l::'a list. IS_SUFFIX l [] = True) &
-(ALL (x::'a) l::'a list. IS_SUFFIX [] (SNOC x l) = False) &
-(ALL (x1::'a) (l1::'a list) (x2::'a) l2::'a list.
+ IS_SUFFIX :: "'a::type list => 'a::type list => bool"
+
+specification (IS_SUFFIX) IS_SUFFIX: "(ALL l::'a::type list. IS_SUFFIX l [] = True) &
+(ALL (x::'a::type) l::'a::type list. IS_SUFFIX [] (SNOC x l) = False) &
+(ALL (x1::'a::type) (l1::'a::type list) (x2::'a::type) l2::'a::type list.
IS_SUFFIX (SNOC x1 l1) (SNOC x2 l2) = (x1 = x2 & IS_SUFFIX l1 l2))"
by (import rich_list IS_SUFFIX)
consts
- IS_SUBLIST :: "'a list => 'a list => bool"
-
-specification (IS_SUBLIST) IS_SUBLIST: "(ALL l::'a list. IS_SUBLIST l [] = True) &
-(ALL (x::'a) l::'a list. IS_SUBLIST [] (x # l) = False) &
-(ALL (x1::'a) (l1::'a list) (x2::'a) l2::'a list.
+ IS_SUBLIST :: "'a::type list => 'a::type list => bool"
+
+specification (IS_SUBLIST) IS_SUBLIST: "(ALL l::'a::type list. IS_SUBLIST l [] = True) &
+(ALL (x::'a::type) l::'a::type list. IS_SUBLIST [] (x # l) = False) &
+(ALL (x1::'a::type) (l1::'a::type list) (x2::'a::type) l2::'a::type list.
IS_SUBLIST (x1 # l1) (x2 # l2) =
(x1 = x2 & IS_PREFIX l1 l2 | IS_SUBLIST l1 (x2 # l2)))"
by (import rich_list IS_SUBLIST)
consts
- SPLITP :: "('a => bool) => 'a list => 'a list * 'a list"
-
-specification (SPLITP) SPLITP: "(ALL P::'a => bool. SPLITP P [] = ([], [])) &
-(ALL (P::'a => bool) (x::'a) l::'a list.
+ SPLITP :: "('a::type => bool) => 'a::type list => 'a::type list * 'a::type list"
+
+specification (SPLITP) SPLITP: "(ALL P::'a::type => bool. SPLITP P [] = ([], [])) &
+(ALL (P::'a::type => bool) (x::'a::type) l::'a::type list.
SPLITP P (x # l) =
(if P x then ([], x # l) else (x # fst (SPLITP P l), snd (SPLITP P l))))"
by (import rich_list SPLITP)
constdefs
- PREFIX :: "('a => bool) => 'a list => 'a list"
- "PREFIX == %P l. fst (SPLITP (Not o P) l)"
-
-lemma PREFIX_DEF: "ALL P l. PREFIX P l = fst (SPLITP (Not o P) l)"
+ PREFIX :: "('a::type => bool) => 'a::type list => 'a::type list"
+ "PREFIX == %(P::'a::type => bool) l::'a::type list. fst (SPLITP (Not o P) l)"
+
+lemma PREFIX_DEF: "ALL (P::'a::type => bool) l::'a::type list.
+ PREFIX P l = fst (SPLITP (Not o P) l)"
by (import rich_list PREFIX_DEF)
constdefs
- SUFFIX :: "('a => bool) => 'a list => 'a list"
- "SUFFIX == %P. foldl (%l' x. if P x then SNOC x l' else []) []"
-
-lemma SUFFIX_DEF: "ALL P l. SUFFIX P l = foldl (%l' x. if P x then SNOC x l' else []) [] l"
+ SUFFIX :: "('a::type => bool) => 'a::type list => 'a::type list"
+ "SUFFIX ==
+%P::'a::type => bool.
+ foldl (%(l'::'a::type list) x::'a::type. if P x then SNOC x l' else [])
+ []"
+
+lemma SUFFIX_DEF: "ALL (P::'a::type => bool) l::'a::type list.
+ SUFFIX P l =
+ foldl (%(l'::'a::type list) x::'a::type. if P x then SNOC x l' else [])
+ [] l"
by (import rich_list SUFFIX_DEF)
constdefs
- UNZIP_FST :: "('a * 'b) list => 'a list"
- "UNZIP_FST == %l. fst (unzip l)"
-
-lemma UNZIP_FST_DEF: "ALL l. UNZIP_FST l = fst (unzip l)"
+ UNZIP_FST :: "('a::type * 'b::type) list => 'a::type list"
+ "UNZIP_FST == %l::('a::type * 'b::type) list. fst (unzip l)"
+
+lemma UNZIP_FST_DEF: "ALL l::('a::type * 'b::type) list. UNZIP_FST l = fst (unzip l)"
by (import rich_list UNZIP_FST_DEF)
constdefs
- UNZIP_SND :: "('a * 'b) list => 'b list"
- "UNZIP_SND == %l. snd (unzip l)"
-
-lemma UNZIP_SND_DEF: "ALL l. UNZIP_SND l = snd (unzip l)"
+ UNZIP_SND :: "('a::type * 'b::type) list => 'b::type list"
+ "UNZIP_SND == %l::('a::type * 'b::type) list. snd (unzip l)"
+
+lemma UNZIP_SND_DEF: "ALL l::('a::type * 'b::type) list. UNZIP_SND l = snd (unzip l)"
by (import rich_list UNZIP_SND_DEF)
consts
- GENLIST :: "(nat => 'a) => nat => 'a list"
-
-specification (GENLIST) GENLIST: "(ALL f::nat => 'a. GENLIST f (0::nat) = []) &
-(ALL (f::nat => 'a) n::nat. GENLIST f (Suc n) = SNOC (f n) (GENLIST f n))"
+ GENLIST :: "(nat => 'a::type) => nat => 'a::type list"
+
+specification (GENLIST) GENLIST: "(ALL f::nat => 'a::type. GENLIST f (0::nat) = []) &
+(ALL (f::nat => 'a::type) n::nat.
+ GENLIST f (Suc n) = SNOC (f n) (GENLIST f n))"
by (import rich_list GENLIST)
consts
- REPLICATE :: "nat => 'a => 'a list"
-
-specification (REPLICATE) REPLICATE: "(ALL x::'a. REPLICATE (0::nat) x = []) &
-(ALL (n::nat) x::'a. REPLICATE (Suc n) x = x # REPLICATE n x)"
+ REPLICATE :: "nat => 'a::type => 'a::type list"
+
+specification (REPLICATE) REPLICATE: "(ALL x::'a::type. REPLICATE (0::nat) x = []) &
+(ALL (n::nat) x::'a::type. REPLICATE (Suc n) x = x # REPLICATE n x)"
by (import rich_list REPLICATE)
-lemma LENGTH_MAP2: "ALL l1 l2.
+lemma LENGTH_MAP2: "ALL (l1::'a::type list) l2::'b::type list.
length l1 = length l2 -->
- (ALL f.
+ (ALL f::'a::type => 'b::type => 'c::type.
length (map2 f l1 l2) = length l1 &
length (map2 f l1 l2) = length l2)"
by (import rich_list LENGTH_MAP2)
-lemma NULL_EQ_NIL: "ALL l. null l = (l = [])"
+lemma NULL_EQ_NIL: "ALL l::'a::type list. null l = (l = [])"
by (import rich_list NULL_EQ_NIL)
-lemma LENGTH_EQ: "ALL x y. x = y --> length x = length y"
+lemma LENGTH_EQ: "ALL (x::'a::type list) y::'a::type list. x = y --> length x = length y"
by (import rich_list LENGTH_EQ)
-lemma LENGTH_NOT_NULL: "ALL l. (0 < length l) = (~ null l)"
+lemma LENGTH_NOT_NULL: "ALL l::'a::type list. ((0::nat) < length l) = (~ null l)"
by (import rich_list LENGTH_NOT_NULL)
-lemma SNOC_INDUCT: "ALL P. P [] & (ALL l. P l --> (ALL x. P (SNOC x l))) --> All P"
+lemma SNOC_INDUCT: "ALL P::'a::type list => bool.
+ P [] &
+ (ALL l::'a::type list. P l --> (ALL x::'a::type. P (SNOC x l))) -->
+ All P"
by (import rich_list SNOC_INDUCT)
-lemma SNOC_CASES: "ALL x'. x' = [] | (EX x l. x' = SNOC x l)"
+lemma SNOC_CASES: "ALL x'::'a::type list.
+ x' = [] | (EX (x::'a::type) l::'a::type list. x' = SNOC x l)"
by (import rich_list SNOC_CASES)
-lemma LENGTH_SNOC: "ALL x l. length (SNOC x l) = Suc (length l)"
+lemma LENGTH_SNOC: "ALL (x::'a::type) l::'a::type list. length (SNOC x l) = Suc (length l)"
by (import rich_list LENGTH_SNOC)
-lemma NOT_NIL_SNOC: "ALL x xa. [] ~= SNOC x xa"
+lemma NOT_NIL_SNOC: "ALL (x::'a::type) xa::'a::type list. [] ~= SNOC x xa"
by (import rich_list NOT_NIL_SNOC)
-lemma NOT_SNOC_NIL: "ALL x xa. SNOC x xa ~= []"
+lemma NOT_SNOC_NIL: "ALL (x::'a::type) xa::'a::type list. SNOC x xa ~= []"
by (import rich_list NOT_SNOC_NIL)
-lemma SNOC_11: "ALL x l x' l'. (SNOC x l = SNOC x' l') = (x = x' & l = l')"
+lemma SNOC_11: "ALL (x::'a::type) (l::'a::type list) (x'::'a::type) l'::'a::type list.
+ (SNOC x l = SNOC x' l') = (x = x' & l = l')"
by (import rich_list SNOC_11)
-lemma SNOC_EQ_LENGTH_EQ: "ALL x1 l1 x2 l2. SNOC x1 l1 = SNOC x2 l2 --> length l1 = length l2"
+lemma SNOC_EQ_LENGTH_EQ: "ALL (x1::'a::type) (l1::'a::type list) (x2::'a::type) l2::'a::type list.
+ SNOC x1 l1 = SNOC x2 l2 --> length l1 = length l2"
by (import rich_list SNOC_EQ_LENGTH_EQ)
-lemma SNOC_REVERSE_CONS: "ALL x xa. SNOC x xa = rev (x # rev xa)"
+lemma SNOC_REVERSE_CONS: "ALL (x::'a::type) xa::'a::type list. SNOC x xa = rev (x # rev xa)"
by (import rich_list SNOC_REVERSE_CONS)
-lemma MAP_SNOC: "ALL x xa xb. map x (SNOC xa xb) = SNOC (x xa) (map x xb)"
+lemma MAP_SNOC: "ALL (x::'a::type => 'b::type) (xa::'a::type) xb::'a::type list.
+ map x (SNOC xa xb) = SNOC (x xa) (map x xb)"
by (import rich_list MAP_SNOC)
-lemma FOLDR_SNOC: "ALL f e x l. foldr f (SNOC x l) e = foldr f l (f x e)"
+lemma FOLDR_SNOC: "ALL (f::'a::type => 'b::type => 'b::type) (e::'b::type) (x::'a::type)
+ l::'a::type list. foldr f (SNOC x l) e = foldr f l (f x e)"
by (import rich_list FOLDR_SNOC)
-lemma FOLDL_SNOC: "ALL (f::'b => 'a => 'b) (e::'b) (x::'a) l::'a list.
- foldl f e (SNOC x l) = f (foldl f e l) x"
+lemma FOLDL_SNOC: "ALL (f::'b::type => 'a::type => 'b::type) (e::'b::type) (x::'a::type)
+ l::'a::type list. foldl f e (SNOC x l) = f (foldl f e l) x"
by (import rich_list FOLDL_SNOC)
-lemma FOLDR_FOLDL: "ALL f e. MONOID f e --> (ALL l. foldr f l e = foldl f e l)"
+lemma FOLDR_FOLDL: "ALL (f::'a::type => 'a::type => 'a::type) e::'a::type.
+ MONOID f e --> (ALL l::'a::type list. foldr f l e = foldl f e l)"
by (import rich_list FOLDR_FOLDL)
-lemma LENGTH_FOLDR: "ALL l. length l = foldr (%x. Suc) l 0"
+lemma LENGTH_FOLDR: "ALL l::'a::type list. length l = foldr (%x::'a::type. Suc) l (0::nat)"
by (import rich_list LENGTH_FOLDR)
-lemma LENGTH_FOLDL: "ALL l. length l = foldl (%l' x. Suc l') 0 l"
+lemma LENGTH_FOLDL: "ALL l::'a::type list.
+ length l = foldl (%(l'::nat) x::'a::type. Suc l') (0::nat) l"
by (import rich_list LENGTH_FOLDL)
-lemma MAP_FOLDR: "ALL f l. map f l = foldr (%x. op # (f x)) l []"
+lemma MAP_FOLDR: "ALL (f::'a::type => 'b::type) l::'a::type list.
+ map f l = foldr (%x::'a::type. op # (f x)) l []"
by (import rich_list MAP_FOLDR)
-lemma MAP_FOLDL: "ALL f l. map f l = foldl (%l' x. SNOC (f x) l') [] l"
+lemma MAP_FOLDL: "ALL (f::'a::type => 'b::type) l::'a::type list.
+ map f l = foldl (%(l'::'b::type list) x::'a::type. SNOC (f x) l') [] l"
by (import rich_list MAP_FOLDL)
-lemma MAP_o: "ALL (f::'b => 'c) g::'a => 'b. map (f o g) = map f o map g"
+lemma MAP_o: "ALL (f::'b::type => 'c::type) g::'a::type => 'b::type.
+ map (f o g) = map f o map g"
by (import rich_list MAP_o)
-lemma FILTER_FOLDR: "ALL P l. filter P l = foldr (%x l'. if P x then x # l' else l') l []"
+lemma FILTER_FOLDR: "ALL (P::'a::type => bool) l::'a::type list.
+ filter P l =
+ foldr (%(x::'a::type) l'::'a::type list. if P x then x # l' else l') l []"
by (import rich_list FILTER_FOLDR)
-lemma FILTER_SNOC: "ALL P x l.
+lemma FILTER_SNOC: "ALL (P::'a::type => bool) (x::'a::type) l::'a::type list.
filter P (SNOC x l) = (if P x then SNOC x (filter P l) else filter P l)"
by (import rich_list FILTER_SNOC)
-lemma FILTER_FOLDL: "ALL P l. filter P l = foldl (%l' x. if P x then SNOC x l' else l') [] l"
+lemma FILTER_FOLDL: "ALL (P::'a::type => bool) l::'a::type list.
+ filter P l =
+ foldl (%(l'::'a::type list) x::'a::type. if P x then SNOC x l' else l')
+ [] l"
by (import rich_list FILTER_FOLDL)
-lemma FILTER_COMM: "ALL f1 f2 l. filter f1 (filter f2 l) = filter f2 (filter f1 l)"
+lemma FILTER_COMM: "ALL (f1::'a::type => bool) (f2::'a::type => bool) l::'a::type list.
+ filter f1 (filter f2 l) = filter f2 (filter f1 l)"
by (import rich_list FILTER_COMM)
-lemma FILTER_IDEM: "ALL f l. filter f (filter f l) = filter f l"
+lemma FILTER_IDEM: "ALL (f::'a::type => bool) l::'a::type list.
+ filter f (filter f l) = filter f l"
by (import rich_list FILTER_IDEM)
-lemma LENGTH_SEG: "ALL n k l. n + k <= length l --> length (SEG n k l) = n"
+lemma LENGTH_SEG: "ALL (n::nat) (k::nat) l::'a::type list.
+ n + k <= length l --> length (SEG n k l) = n"
by (import rich_list LENGTH_SEG)
-lemma APPEND_NIL: "(ALL l::'a list. l @ [] = l) & (ALL x::'a list. [] @ x = x)"
+lemma APPEND_NIL: "(ALL l::'a::type list. l @ [] = l) & (ALL x::'a::type list. [] @ x = x)"
by (import rich_list APPEND_NIL)
-lemma APPEND_SNOC: "ALL l1 x l2. l1 @ SNOC x l2 = SNOC x (l1 @ l2)"
+lemma APPEND_SNOC: "ALL (l1::'a::type list) (x::'a::type) l2::'a::type list.
+ l1 @ SNOC x l2 = SNOC x (l1 @ l2)"
by (import rich_list APPEND_SNOC)
-lemma APPEND_FOLDR: "ALL l1 l2. l1 @ l2 = foldr op # l1 l2"
+lemma APPEND_FOLDR: "ALL (l1::'a::type list) l2::'a::type list. l1 @ l2 = foldr op # l1 l2"
by (import rich_list APPEND_FOLDR)
-lemma APPEND_FOLDL: "ALL l1 l2. l1 @ l2 = foldl (%l' x. SNOC x l') l1 l2"
+lemma APPEND_FOLDL: "ALL (l1::'a::type list) l2::'a::type list.
+ l1 @ l2 = foldl (%(l'::'a::type list) x::'a::type. SNOC x l') l1 l2"
by (import rich_list APPEND_FOLDL)
-lemma CONS_APPEND: "ALL x l. x # l = [x] @ l"
+lemma CONS_APPEND: "ALL (x::'a::type) l::'a::type list. x # l = [x] @ l"
by (import rich_list CONS_APPEND)
lemma ASSOC_APPEND: "ASSOC op @"
@@ -4093,767 +4824,924 @@
lemma MONOID_APPEND_NIL: "MONOID op @ []"
by (import rich_list MONOID_APPEND_NIL)
-lemma APPEND_LENGTH_EQ: "ALL l1 l1'.
+lemma APPEND_LENGTH_EQ: "ALL (l1::'a::type list) l1'::'a::type list.
length l1 = length l1' -->
- (ALL l2 l2'.
+ (ALL (l2::'a::type list) l2'::'a::type list.
length l2 = length l2' -->
(l1 @ l2 = l1' @ l2') = (l1 = l1' & l2 = l2'))"
by (import rich_list APPEND_LENGTH_EQ)
-lemma FLAT_SNOC: "ALL x l. concat (SNOC x l) = concat l @ x"
+lemma FLAT_SNOC: "ALL (x::'a::type list) l::'a::type list list.
+ concat (SNOC x l) = concat l @ x"
by (import rich_list FLAT_SNOC)
-lemma FLAT_FOLDR: "ALL l. concat l = foldr op @ l []"
+lemma FLAT_FOLDR: "ALL l::'a::type list list. concat l = foldr op @ l []"
by (import rich_list FLAT_FOLDR)
-lemma FLAT_FOLDL: "ALL l. concat l = foldl op @ [] l"
+lemma FLAT_FOLDL: "ALL l::'a::type list list. concat l = foldl op @ [] l"
by (import rich_list FLAT_FOLDL)
-lemma LENGTH_FLAT: "ALL l. length (concat l) = sum (map size l)"
+lemma LENGTH_FLAT: "ALL l::'a::type list list. length (concat l) = sum (map size l)"
by (import rich_list LENGTH_FLAT)
-lemma REVERSE_FOLDR: "ALL l. rev l = foldr SNOC l []"
+lemma REVERSE_FOLDR: "ALL l::'a::type list. rev l = foldr SNOC l []"
by (import rich_list REVERSE_FOLDR)
-lemma REVERSE_FOLDL: "ALL l. rev l = foldl (%l' x. x # l') [] l"
+lemma REVERSE_FOLDL: "ALL l::'a::type list.
+ rev l = foldl (%(l'::'a::type list) x::'a::type. x # l') [] l"
by (import rich_list REVERSE_FOLDL)
-lemma ALL_EL_SNOC: "ALL P x l. list_all P (SNOC x l) = (list_all P l & P x)"
+lemma ALL_EL_SNOC: "ALL (P::'a::type => bool) (x::'a::type) l::'a::type list.
+ list_all P (SNOC x l) = (list_all P l & P x)"
by (import rich_list ALL_EL_SNOC)
-lemma ALL_EL_MAP: "ALL (P::'b => bool) (f::'a => 'b) l::'a list.
+lemma ALL_EL_MAP: "ALL (P::'b::type => bool) (f::'a::type => 'b::type) l::'a::type list.
list_all P (map f l) = list_all (P o f) l"
by (import rich_list ALL_EL_MAP)
-lemma SOME_EL_SNOC: "ALL P x l. list_exists P (SNOC x l) = (P x | list_exists P l)"
+lemma SOME_EL_SNOC: "ALL (P::'a::type => bool) (x::'a::type) l::'a::type list.
+ list_exists P (SNOC x l) = (P x | list_exists P l)"
by (import rich_list SOME_EL_SNOC)
-lemma IS_EL_SNOC: "ALL y x l. y mem SNOC x l = (y = x | y mem l)"
+lemma IS_EL_SNOC: "ALL (y::'a::type) (x::'a::type) l::'a::type list.
+ y mem SNOC x l = (y = x | y mem l)"
by (import rich_list IS_EL_SNOC)
-lemma SUM_SNOC: "ALL x l. sum (SNOC x l) = sum l + x"
+lemma SUM_SNOC: "ALL (x::nat) l::nat list. sum (SNOC x l) = sum l + x"
by (import rich_list SUM_SNOC)
-lemma SUM_FOLDL: "ALL l. sum l = foldl op + 0 l"
+lemma SUM_FOLDL: "ALL l::nat list. sum l = foldl op + (0::nat) l"
by (import rich_list SUM_FOLDL)
-lemma IS_PREFIX_APPEND: "ALL l1 l2. IS_PREFIX l1 l2 = (EX l. l1 = l2 @ l)"
+lemma IS_PREFIX_APPEND: "ALL (l1::'a::type list) l2::'a::type list.
+ IS_PREFIX l1 l2 = (EX l::'a::type list. l1 = l2 @ l)"
by (import rich_list IS_PREFIX_APPEND)
-lemma IS_SUFFIX_APPEND: "ALL l1 l2. IS_SUFFIX l1 l2 = (EX l. l1 = l @ l2)"
+lemma IS_SUFFIX_APPEND: "ALL (l1::'a::type list) l2::'a::type list.
+ IS_SUFFIX l1 l2 = (EX l::'a::type list. l1 = l @ l2)"
by (import rich_list IS_SUFFIX_APPEND)
-lemma IS_SUBLIST_APPEND: "ALL l1 l2. IS_SUBLIST l1 l2 = (EX l l'. l1 = l @ l2 @ l')"
+lemma IS_SUBLIST_APPEND: "ALL (l1::'a::type list) l2::'a::type list.
+ IS_SUBLIST l1 l2 =
+ (EX (l::'a::type list) l'::'a::type list. l1 = l @ l2 @ l')"
by (import rich_list IS_SUBLIST_APPEND)
-lemma IS_PREFIX_IS_SUBLIST: "ALL l1 l2. IS_PREFIX l1 l2 --> IS_SUBLIST l1 l2"
+lemma IS_PREFIX_IS_SUBLIST: "ALL (l1::'a::type list) l2::'a::type list.
+ IS_PREFIX l1 l2 --> IS_SUBLIST l1 l2"
by (import rich_list IS_PREFIX_IS_SUBLIST)
-lemma IS_SUFFIX_IS_SUBLIST: "ALL l1 l2. IS_SUFFIX l1 l2 --> IS_SUBLIST l1 l2"
+lemma IS_SUFFIX_IS_SUBLIST: "ALL (l1::'a::type list) l2::'a::type list.
+ IS_SUFFIX l1 l2 --> IS_SUBLIST l1 l2"
by (import rich_list IS_SUFFIX_IS_SUBLIST)
-lemma IS_PREFIX_REVERSE: "ALL l1 l2. IS_PREFIX (rev l1) (rev l2) = IS_SUFFIX l1 l2"
+lemma IS_PREFIX_REVERSE: "ALL (l1::'a::type list) l2::'a::type list.
+ IS_PREFIX (rev l1) (rev l2) = IS_SUFFIX l1 l2"
by (import rich_list IS_PREFIX_REVERSE)
-lemma IS_SUFFIX_REVERSE: "ALL l2 l1. IS_SUFFIX (rev l1) (rev l2) = IS_PREFIX l1 l2"
+lemma IS_SUFFIX_REVERSE: "ALL (l2::'a::type list) l1::'a::type list.
+ IS_SUFFIX (rev l1) (rev l2) = IS_PREFIX l1 l2"
by (import rich_list IS_SUFFIX_REVERSE)
-lemma IS_SUBLIST_REVERSE: "ALL l1 l2. IS_SUBLIST (rev l1) (rev l2) = IS_SUBLIST l1 l2"
+lemma IS_SUBLIST_REVERSE: "ALL (l1::'a::type list) l2::'a::type list.
+ IS_SUBLIST (rev l1) (rev l2) = IS_SUBLIST l1 l2"
by (import rich_list IS_SUBLIST_REVERSE)
-lemma PREFIX_FOLDR: "ALL P x. PREFIX P x = foldr (%x l'. if P x then x # l' else []) x []"
+lemma PREFIX_FOLDR: "ALL (P::'a::type => bool) x::'a::type list.
+ PREFIX P x =
+ foldr (%(x::'a::type) l'::'a::type list. if P x then x # l' else []) x []"
by (import rich_list PREFIX_FOLDR)
-lemma PREFIX: "(ALL x::'a => bool. PREFIX x [] = []) &
-(ALL (x::'a => bool) (xa::'a) xb::'a list.
+lemma PREFIX: "(ALL x::'a::type => bool. PREFIX x [] = []) &
+(ALL (x::'a::type => bool) (xa::'a::type) xb::'a::type list.
PREFIX x (xa # xb) = (if x xa then xa # PREFIX x xb else []))"
by (import rich_list PREFIX)
-lemma IS_PREFIX_PREFIX: "ALL P l. IS_PREFIX l (PREFIX P l)"
+lemma IS_PREFIX_PREFIX: "ALL (P::'a::type => bool) l::'a::type list. IS_PREFIX l (PREFIX P l)"
by (import rich_list IS_PREFIX_PREFIX)
-lemma LENGTH_SCANL: "ALL (f::'b => 'a => 'b) (e::'b) l::'a list.
+lemma LENGTH_SCANL: "ALL (f::'b::type => 'a::type => 'b::type) (e::'b::type) l::'a::type list.
length (SCANL f e l) = Suc (length l)"
by (import rich_list LENGTH_SCANL)
-lemma LENGTH_SCANR: "ALL f e l. length (SCANR f e l) = Suc (length l)"
+lemma LENGTH_SCANR: "ALL (f::'a::type => 'b::type => 'b::type) (e::'b::type) l::'a::type list.
+ length (SCANR f e l) = Suc (length l)"
by (import rich_list LENGTH_SCANR)
-lemma COMM_MONOID_FOLDL: "ALL x.
+lemma COMM_MONOID_FOLDL: "ALL x::'a::type => 'a::type => 'a::type.
COMM x -->
- (ALL xa. MONOID x xa --> (ALL e l. foldl x e l = x e (foldl x xa l)))"
+ (ALL xa::'a::type.
+ MONOID x xa -->
+ (ALL (e::'a::type) l::'a::type list.
+ foldl x e l = x e (foldl x xa l)))"
by (import rich_list COMM_MONOID_FOLDL)
-lemma COMM_MONOID_FOLDR: "ALL x.
+lemma COMM_MONOID_FOLDR: "ALL x::'a::type => 'a::type => 'a::type.
COMM x -->
- (ALL xa. MONOID x xa --> (ALL e l. foldr x l e = x e (foldr x l xa)))"
+ (ALL xa::'a::type.
+ MONOID x xa -->
+ (ALL (e::'a::type) l::'a::type list.
+ foldr x l e = x e (foldr x l xa)))"
by (import rich_list COMM_MONOID_FOLDR)
-lemma FCOMM_FOLDR_APPEND: "ALL x xa.
+lemma FCOMM_FOLDR_APPEND: "ALL (x::'a::type => 'a::type => 'a::type)
+ xa::'b::type => 'a::type => 'a::type.
FCOMM x xa -->
- (ALL xb.
+ (ALL xb::'a::type.
LEFT_ID x xb -->
- (ALL l1 l2.
+ (ALL (l1::'b::type list) l2::'b::type list.
foldr xa (l1 @ l2) xb = x (foldr xa l1 xb) (foldr xa l2 xb)))"
by (import rich_list FCOMM_FOLDR_APPEND)
-lemma FCOMM_FOLDL_APPEND: "ALL x xa.
+lemma FCOMM_FOLDL_APPEND: "ALL (x::'a::type => 'b::type => 'a::type)
+ xa::'a::type => 'a::type => 'a::type.
FCOMM x xa -->
- (ALL xb.
+ (ALL xb::'a::type.
RIGHT_ID xa xb -->
- (ALL l1 l2.
+ (ALL (l1::'b::type list) l2::'b::type list.
foldl x xb (l1 @ l2) = xa (foldl x xb l1) (foldl x xb l2)))"
by (import rich_list FCOMM_FOLDL_APPEND)
-lemma FOLDL_SINGLE: "ALL x xa xb. foldl x xa [xb] = x xa xb"
+lemma FOLDL_SINGLE: "ALL (x::'a::type => 'b::type => 'a::type) (xa::'a::type) xb::'b::type.
+ foldl x xa [xb] = x xa xb"
by (import rich_list FOLDL_SINGLE)
-lemma FOLDR_SINGLE: "ALL x xa xb. foldr x [xb] xa = x xb xa"
+lemma FOLDR_SINGLE: "ALL (x::'a::type => 'b::type => 'b::type) (xa::'b::type) xb::'a::type.
+ foldr x [xb] xa = x xb xa"
by (import rich_list FOLDR_SINGLE)
-lemma FOLDR_CONS_NIL: "ALL l. foldr op # l [] = l"
+lemma FOLDR_CONS_NIL: "ALL l::'a::type list. foldr op # l [] = l"
by (import rich_list FOLDR_CONS_NIL)
-lemma FOLDL_SNOC_NIL: "ALL l. foldl (%xs x. SNOC x xs) [] l = l"
+lemma FOLDL_SNOC_NIL: "ALL l::'a::type list.
+ foldl (%(xs::'a::type list) x::'a::type. SNOC x xs) [] l = l"
by (import rich_list FOLDL_SNOC_NIL)
-lemma FOLDR_REVERSE: "ALL x xa xb. foldr x (rev xb) xa = foldl (%xa y. x y xa) xa xb"
+lemma FOLDR_REVERSE: "ALL (x::'a::type => 'b::type => 'b::type) (xa::'b::type) xb::'a::type list.
+ foldr x (rev xb) xa = foldl (%(xa::'b::type) y::'a::type. x y xa) xa xb"
by (import rich_list FOLDR_REVERSE)
-lemma FOLDL_REVERSE: "ALL x xa xb. foldl x xa (rev xb) = foldr (%xa y. x y xa) xb xa"
+lemma FOLDL_REVERSE: "ALL (x::'a::type => 'b::type => 'a::type) (xa::'a::type) xb::'b::type list.
+ foldl x xa (rev xb) = foldr (%(xa::'b::type) y::'a::type. x y xa) xb xa"
by (import rich_list FOLDL_REVERSE)
-lemma FOLDR_MAP: "ALL (f::'a => 'a => 'a) (e::'a) (g::'b => 'a) l::'b list.
- foldr f (map g l) e = foldr (%x::'b. f (g x)) l e"
+lemma FOLDR_MAP: "ALL (f::'a::type => 'a::type => 'a::type) (e::'a::type)
+ (g::'b::type => 'a::type) l::'b::type list.
+ foldr f (map g l) e = foldr (%x::'b::type. f (g x)) l e"
by (import rich_list FOLDR_MAP)
-lemma FOLDL_MAP: "ALL (f::'a => 'a => 'a) (e::'a) (g::'b => 'a) l::'b list.
- foldl f e (map g l) = foldl (%(x::'a) y::'b. f x (g y)) e l"
+lemma FOLDL_MAP: "ALL (f::'a::type => 'a::type => 'a::type) (e::'a::type)
+ (g::'b::type => 'a::type) l::'b::type list.
+ foldl f e (map g l) = foldl (%(x::'a::type) y::'b::type. f x (g y)) e l"
by (import rich_list FOLDL_MAP)
-lemma ALL_EL_FOLDR: "ALL P l. list_all P l = foldr (%x. op & (P x)) l True"
+lemma ALL_EL_FOLDR: "ALL (P::'a::type => bool) l::'a::type list.
+ list_all P l = foldr (%x::'a::type. op & (P x)) l True"
by (import rich_list ALL_EL_FOLDR)
-lemma ALL_EL_FOLDL: "ALL P l. list_all P l = foldl (%l' x. l' & P x) True l"
+lemma ALL_EL_FOLDL: "ALL (P::'a::type => bool) l::'a::type list.
+ list_all P l = foldl (%(l'::bool) x::'a::type. l' & P x) True l"
by (import rich_list ALL_EL_FOLDL)
-lemma SOME_EL_FOLDR: "ALL P l. list_exists P l = foldr (%x. op | (P x)) l False"
+lemma SOME_EL_FOLDR: "ALL (P::'a::type => bool) l::'a::type list.
+ list_exists P l = foldr (%x::'a::type. op | (P x)) l False"
by (import rich_list SOME_EL_FOLDR)
-lemma SOME_EL_FOLDL: "ALL P l. list_exists P l = foldl (%l' x. l' | P x) False l"
+lemma SOME_EL_FOLDL: "ALL (P::'a::type => bool) l::'a::type list.
+ list_exists P l = foldl (%(l'::bool) x::'a::type. l' | P x) False l"
by (import rich_list SOME_EL_FOLDL)
-lemma ALL_EL_FOLDR_MAP: "ALL x xa. list_all x xa = foldr op & (map x xa) True"
+lemma ALL_EL_FOLDR_MAP: "ALL (x::'a::type => bool) xa::'a::type list.
+ list_all x xa = foldr op & (map x xa) True"
by (import rich_list ALL_EL_FOLDR_MAP)
-lemma ALL_EL_FOLDL_MAP: "ALL x xa. list_all x xa = foldl op & True (map x xa)"
+lemma ALL_EL_FOLDL_MAP: "ALL (x::'a::type => bool) xa::'a::type list.
+ list_all x xa = foldl op & True (map x xa)"
by (import rich_list ALL_EL_FOLDL_MAP)
-lemma SOME_EL_FOLDR_MAP: "ALL x xa. list_exists x xa = foldr op | (map x xa) False"
+lemma SOME_EL_FOLDR_MAP: "ALL (x::'a::type => bool) xa::'a::type list.
+ list_exists x xa = foldr op | (map x xa) False"
by (import rich_list SOME_EL_FOLDR_MAP)
-lemma SOME_EL_FOLDL_MAP: "ALL x xa. list_exists x xa = foldl op | False (map x xa)"
+lemma SOME_EL_FOLDL_MAP: "ALL (x::'a::type => bool) xa::'a::type list.
+ list_exists x xa = foldl op | False (map x xa)"
by (import rich_list SOME_EL_FOLDL_MAP)
-lemma FOLDR_FILTER: "ALL (f::'a => 'a => 'a) (e::'a) (P::'a => bool) l::'a list.
+lemma FOLDR_FILTER: "ALL (f::'a::type => 'a::type => 'a::type) (e::'a::type)
+ (P::'a::type => bool) l::'a::type list.
foldr f (filter P l) e =
- foldr (%(x::'a) y::'a. if P x then f x y else y) l e"
+ foldr (%(x::'a::type) y::'a::type. if P x then f x y else y) l e"
by (import rich_list FOLDR_FILTER)
-lemma FOLDL_FILTER: "ALL (f::'a => 'a => 'a) (e::'a) (P::'a => bool) l::'a list.
+lemma FOLDL_FILTER: "ALL (f::'a::type => 'a::type => 'a::type) (e::'a::type)
+ (P::'a::type => bool) l::'a::type list.
foldl f e (filter P l) =
- foldl (%(x::'a) y::'a. if P y then f x y else x) e l"
+ foldl (%(x::'a::type) y::'a::type. if P y then f x y else x) e l"
by (import rich_list FOLDL_FILTER)
-lemma ASSOC_FOLDR_FLAT: "ALL f.
+lemma ASSOC_FOLDR_FLAT: "ALL f::'a::type => 'a::type => 'a::type.
ASSOC f -->
- (ALL e.
+ (ALL e::'a::type.
LEFT_ID f e -->
- (ALL l. foldr f (concat l) e = foldr f (map (FOLDR f e) l) e))"
+ (ALL l::'a::type list list.
+ foldr f (concat l) e = foldr f (map (FOLDR f e) l) e))"
by (import rich_list ASSOC_FOLDR_FLAT)
-lemma ASSOC_FOLDL_FLAT: "ALL f.
+lemma ASSOC_FOLDL_FLAT: "ALL f::'a::type => 'a::type => 'a::type.
ASSOC f -->
- (ALL e.
+ (ALL e::'a::type.
RIGHT_ID f e -->
- (ALL l. foldl f e (concat l) = foldl f e (map (foldl f e) l)))"
+ (ALL l::'a::type list list.
+ foldl f e (concat l) = foldl f e (map (foldl f e) l)))"
by (import rich_list ASSOC_FOLDL_FLAT)
-lemma SOME_EL_MAP: "ALL (P::'b => bool) (f::'a => 'b) l::'a list.
+lemma SOME_EL_MAP: "ALL (P::'b::type => bool) (f::'a::type => 'b::type) l::'a::type list.
list_exists P (map f l) = list_exists (P o f) l"
by (import rich_list SOME_EL_MAP)
-lemma SOME_EL_DISJ: "ALL P Q l.
- list_exists (%x. P x | Q x) l = (list_exists P l | list_exists Q l)"
+lemma SOME_EL_DISJ: "ALL (P::'a::type => bool) (Q::'a::type => bool) l::'a::type list.
+ list_exists (%x::'a::type. P x | Q x) l =
+ (list_exists P l | list_exists Q l)"
by (import rich_list SOME_EL_DISJ)
-lemma IS_EL_FOLDR: "ALL x xa. x mem xa = foldr (%xa. op | (x = xa)) xa False"
+lemma IS_EL_FOLDR: "ALL (x::'a::type) xa::'a::type list.
+ x mem xa = foldr (%xa::'a::type. op | (x = xa)) xa False"
by (import rich_list IS_EL_FOLDR)
-lemma IS_EL_FOLDL: "ALL x xa. x mem xa = foldl (%l' xa. l' | x = xa) False xa"
+lemma IS_EL_FOLDL: "ALL (x::'a::type) xa::'a::type list.
+ x mem xa = foldl (%(l'::bool) xa::'a::type. l' | x = xa) False xa"
by (import rich_list IS_EL_FOLDL)
-lemma NULL_FOLDR: "ALL l. null l = foldr (%x l'. False) l True"
+lemma NULL_FOLDR: "ALL l::'a::type list. null l = foldr (%(x::'a::type) l'::bool. False) l True"
by (import rich_list NULL_FOLDR)
-lemma NULL_FOLDL: "ALL l. null l = foldl (%x l'. False) True l"
+lemma NULL_FOLDL: "ALL l::'a::type list. null l = foldl (%(x::bool) l'::'a::type. False) True l"
by (import rich_list NULL_FOLDL)
-lemma SEG_LENGTH_ID: "ALL l. SEG (length l) 0 l = l"
+lemma SEG_LENGTH_ID: "ALL l::'a::type list. SEG (length l) (0::nat) l = l"
by (import rich_list SEG_LENGTH_ID)
-lemma SEG_SUC_CONS: "ALL m n l x. SEG m (Suc n) (x # l) = SEG m n l"
+lemma SEG_SUC_CONS: "ALL (m::nat) (n::nat) (l::'a::type list) x::'a::type.
+ SEG m (Suc n) (x # l) = SEG m n l"
by (import rich_list SEG_SUC_CONS)
-lemma SEG_0_SNOC: "ALL m l x. m <= length l --> SEG m 0 (SNOC x l) = SEG m 0 l"
+lemma SEG_0_SNOC: "ALL (m::nat) (l::'a::type list) x::'a::type.
+ m <= length l --> SEG m (0::nat) (SNOC x l) = SEG m (0::nat) l"
by (import rich_list SEG_0_SNOC)
-lemma BUTLASTN_SEG: "ALL n l. n <= length l --> BUTLASTN n l = SEG (length l - n) 0 l"
+lemma BUTLASTN_SEG: "ALL (n::nat) l::'a::type list.
+ n <= length l --> BUTLASTN n l = SEG (length l - n) (0::nat) l"
by (import rich_list BUTLASTN_SEG)
-lemma LASTN_CONS: "ALL n l. n <= length l --> (ALL x. LASTN n (x # l) = LASTN n l)"
+lemma LASTN_CONS: "ALL (n::nat) l::'a::type list.
+ n <= length l --> (ALL x::'a::type. LASTN n (x # l) = LASTN n l)"
by (import rich_list LASTN_CONS)
-lemma LENGTH_LASTN: "ALL n l. n <= length l --> length (LASTN n l) = n"
+lemma LENGTH_LASTN: "ALL (n::nat) l::'a::type list. n <= length l --> length (LASTN n l) = n"
by (import rich_list LENGTH_LASTN)
-lemma LASTN_LENGTH_ID: "ALL l. LASTN (length l) l = l"
+lemma LASTN_LENGTH_ID: "ALL l::'a::type list. LASTN (length l) l = l"
by (import rich_list LASTN_LENGTH_ID)
-lemma LASTN_LASTN: "ALL l n m. m <= length l --> n <= m --> LASTN n (LASTN m l) = LASTN n l"
+lemma LASTN_LASTN: "ALL (l::'a::type list) (n::nat) m::nat.
+ m <= length l --> n <= m --> LASTN n (LASTN m l) = LASTN n l"
by (import rich_list LASTN_LASTN)
-lemma FIRSTN_LENGTH_ID: "ALL l. FIRSTN (length l) l = l"
+lemma FIRSTN_LENGTH_ID: "ALL l::'a::type list. FIRSTN (length l) l = l"
by (import rich_list FIRSTN_LENGTH_ID)
-lemma FIRSTN_SNOC: "ALL n l. n <= length l --> (ALL x. FIRSTN n (SNOC x l) = FIRSTN n l)"
+lemma FIRSTN_SNOC: "ALL (n::nat) l::'a::type list.
+ n <= length l --> (ALL x::'a::type. FIRSTN n (SNOC x l) = FIRSTN n l)"
by (import rich_list FIRSTN_SNOC)
-lemma BUTLASTN_LENGTH_NIL: "ALL l. BUTLASTN (length l) l = []"
+lemma BUTLASTN_LENGTH_NIL: "ALL l::'a::type list. BUTLASTN (length l) l = []"
by (import rich_list BUTLASTN_LENGTH_NIL)
-lemma BUTLASTN_SUC_BUTLAST: "ALL n l. n < length l --> BUTLASTN (Suc n) l = BUTLASTN n (butlast l)"
+lemma BUTLASTN_SUC_BUTLAST: "ALL (n::nat) l::'a::type list.
+ n < length l --> BUTLASTN (Suc n) l = BUTLASTN n (butlast l)"
by (import rich_list BUTLASTN_SUC_BUTLAST)
-lemma BUTLASTN_BUTLAST: "ALL n l. n < length l --> BUTLASTN n (butlast l) = butlast (BUTLASTN n l)"
+lemma BUTLASTN_BUTLAST: "ALL (n::nat) l::'a::type list.
+ n < length l --> BUTLASTN n (butlast l) = butlast (BUTLASTN n l)"
by (import rich_list BUTLASTN_BUTLAST)
-lemma LENGTH_BUTLASTN: "ALL n l. n <= length l --> length (BUTLASTN n l) = length l - n"
+lemma LENGTH_BUTLASTN: "ALL (n::nat) l::'a::type list.
+ n <= length l --> length (BUTLASTN n l) = length l - n"
by (import rich_list LENGTH_BUTLASTN)
-lemma BUTLASTN_BUTLASTN: "ALL m n l.
+lemma BUTLASTN_BUTLASTN: "ALL (m::nat) (n::nat) l::'a::type list.
n + m <= length l --> BUTLASTN n (BUTLASTN m l) = BUTLASTN (n + m) l"
by (import rich_list BUTLASTN_BUTLASTN)
-lemma APPEND_BUTLASTN_LASTN: "ALL n l. n <= length l --> BUTLASTN n l @ LASTN n l = l"
+lemma APPEND_BUTLASTN_LASTN: "ALL (n::nat) l::'a::type list.
+ n <= length l --> BUTLASTN n l @ LASTN n l = l"
by (import rich_list APPEND_BUTLASTN_LASTN)
-lemma APPEND_FIRSTN_LASTN: "ALL m n l. m + n = length l --> FIRSTN n l @ LASTN m l = l"
+lemma APPEND_FIRSTN_LASTN: "ALL (m::nat) (n::nat) l::'a::type list.
+ m + n = length l --> FIRSTN n l @ LASTN m l = l"
by (import rich_list APPEND_FIRSTN_LASTN)
-lemma BUTLASTN_APPEND2: "ALL n l1 l2. n <= length l2 --> BUTLASTN n (l1 @ l2) = l1 @ BUTLASTN n l2"
+lemma BUTLASTN_APPEND2: "ALL (n::nat) (l1::'a::type list) l2::'a::type list.
+ n <= length l2 --> BUTLASTN n (l1 @ l2) = l1 @ BUTLASTN n l2"
by (import rich_list BUTLASTN_APPEND2)
-lemma BUTLASTN_LENGTH_APPEND: "ALL l2 l1. BUTLASTN (length l2) (l1 @ l2) = l1"
+lemma BUTLASTN_LENGTH_APPEND: "ALL (l2::'a::type list) l1::'a::type list.
+ BUTLASTN (length l2) (l1 @ l2) = l1"
by (import rich_list BUTLASTN_LENGTH_APPEND)
-lemma LASTN_LENGTH_APPEND: "ALL l2 l1. LASTN (length l2) (l1 @ l2) = l2"
+lemma LASTN_LENGTH_APPEND: "ALL (l2::'a::type list) l1::'a::type list. LASTN (length l2) (l1 @ l2) = l2"
by (import rich_list LASTN_LENGTH_APPEND)
-lemma BUTLASTN_CONS: "ALL n l. n <= length l --> (ALL x. BUTLASTN n (x # l) = x # BUTLASTN n l)"
+lemma BUTLASTN_CONS: "ALL (n::nat) l::'a::type list.
+ n <= length l -->
+ (ALL x::'a::type. BUTLASTN n (x # l) = x # BUTLASTN n l)"
by (import rich_list BUTLASTN_CONS)
-lemma BUTLASTN_LENGTH_CONS: "ALL l x. BUTLASTN (length l) (x # l) = [x]"
+lemma BUTLASTN_LENGTH_CONS: "ALL (l::'a::type list) x::'a::type. BUTLASTN (length l) (x # l) = [x]"
by (import rich_list BUTLASTN_LENGTH_CONS)
-lemma LAST_LASTN_LAST: "ALL n l. n <= length l --> 0 < n --> last (LASTN n l) = last l"
+lemma LAST_LASTN_LAST: "ALL (n::nat) l::'a::type list.
+ n <= length l --> (0::nat) < n --> last (LASTN n l) = last l"
by (import rich_list LAST_LASTN_LAST)
-lemma BUTLASTN_LASTN_NIL: "ALL n l. n <= length l --> BUTLASTN n (LASTN n l) = []"
+lemma BUTLASTN_LASTN_NIL: "ALL (n::nat) l::'a::type list. n <= length l --> BUTLASTN n (LASTN n l) = []"
by (import rich_list BUTLASTN_LASTN_NIL)
-lemma LASTN_BUTLASTN: "ALL n m l.
+lemma LASTN_BUTLASTN: "ALL (n::nat) (m::nat) l::'a::type list.
n + m <= length l -->
LASTN n (BUTLASTN m l) = BUTLASTN m (LASTN (n + m) l)"
by (import rich_list LASTN_BUTLASTN)
-lemma BUTLASTN_LASTN: "ALL m n l.
+lemma BUTLASTN_LASTN: "ALL (m::nat) (n::nat) l::'a::type list.
m <= n & n <= length l -->
BUTLASTN m (LASTN n l) = LASTN (n - m) (BUTLASTN m l)"
by (import rich_list BUTLASTN_LASTN)
-lemma LASTN_1: "ALL l. l ~= [] --> LASTN 1 l = [last l]"
+lemma LASTN_1: "ALL l::'a::type list. l ~= [] --> LASTN (1::nat) l = [last l]"
by (import rich_list LASTN_1)
-lemma BUTLASTN_1: "ALL l. l ~= [] --> BUTLASTN 1 l = butlast l"
+lemma BUTLASTN_1: "ALL l::'a::type list. l ~= [] --> BUTLASTN (1::nat) l = butlast l"
by (import rich_list BUTLASTN_1)
-lemma BUTLASTN_APPEND1: "ALL l2 n.
+lemma BUTLASTN_APPEND1: "ALL (l2::'a::type list) n::nat.
length l2 <= n -->
- (ALL l1. BUTLASTN n (l1 @ l2) = BUTLASTN (n - length l2) l1)"
+ (ALL l1::'a::type list.
+ BUTLASTN n (l1 @ l2) = BUTLASTN (n - length l2) l1)"
by (import rich_list BUTLASTN_APPEND1)
-lemma LASTN_APPEND2: "ALL n l2. n <= length l2 --> (ALL l1. LASTN n (l1 @ l2) = LASTN n l2)"
+lemma LASTN_APPEND2: "ALL (n::nat) l2::'a::type list.
+ n <= length l2 -->
+ (ALL l1::'a::type list. LASTN n (l1 @ l2) = LASTN n l2)"
by (import rich_list LASTN_APPEND2)
-lemma LASTN_APPEND1: "ALL l2 n.
+lemma LASTN_APPEND1: "ALL (l2::'a::type list) n::nat.
length l2 <= n -->
- (ALL l1. LASTN n (l1 @ l2) = LASTN (n - length l2) l1 @ l2)"
+ (ALL l1::'a::type list.
+ LASTN n (l1 @ l2) = LASTN (n - length l2) l1 @ l2)"
by (import rich_list LASTN_APPEND1)
-lemma LASTN_MAP: "ALL n l. n <= length l --> (ALL f. LASTN n (map f l) = map f (LASTN n l))"
+lemma LASTN_MAP: "ALL (n::nat) l::'a::type list.
+ n <= length l -->
+ (ALL f::'a::type => 'b::type. LASTN n (map f l) = map f (LASTN n l))"
by (import rich_list LASTN_MAP)
-lemma BUTLASTN_MAP: "ALL n l.
- n <= length l --> (ALL f. BUTLASTN n (map f l) = map f (BUTLASTN n l))"
+lemma BUTLASTN_MAP: "ALL (n::nat) l::'a::type list.
+ n <= length l -->
+ (ALL f::'a::type => 'b::type.
+ BUTLASTN n (map f l) = map f (BUTLASTN n l))"
by (import rich_list BUTLASTN_MAP)
-lemma ALL_EL_LASTN: "(All::(('a => bool) => bool) => bool)
- (%P::'a => bool.
- (All::('a list => bool) => bool)
- (%l::'a list.
+lemma ALL_EL_LASTN: "(All::(('a::type => bool) => bool) => bool)
+ (%P::'a::type => bool.
+ (All::('a::type list => bool) => bool)
+ (%l::'a::type list.
(op -->::bool => bool => bool)
- ((list_all::('a => bool) => 'a list => bool) P l)
+ ((list_all::('a::type => bool) => 'a::type list => bool) P l)
((All::(nat => bool) => bool)
(%m::nat.
(op -->::bool => bool => bool)
- ((op <=::nat => nat => bool) m ((size::'a list => nat) l))
- ((list_all::('a => bool) => 'a list => bool) P
- ((LASTN::nat => 'a list => 'a list) m l))))))"
+ ((op <=::nat => nat => bool) m
+ ((size::'a::type list => nat) l))
+ ((list_all::('a::type => bool) => 'a::type list => bool) P
+ ((LASTN::nat => 'a::type list => 'a::type list) m
+ l))))))"
by (import rich_list ALL_EL_LASTN)
-lemma ALL_EL_BUTLASTN: "(All::(('a => bool) => bool) => bool)
- (%P::'a => bool.
- (All::('a list => bool) => bool)
- (%l::'a list.
+lemma ALL_EL_BUTLASTN: "(All::(('a::type => bool) => bool) => bool)
+ (%P::'a::type => bool.
+ (All::('a::type list => bool) => bool)
+ (%l::'a::type list.
(op -->::bool => bool => bool)
- ((list_all::('a => bool) => 'a list => bool) P l)
+ ((list_all::('a::type => bool) => 'a::type list => bool) P l)
((All::(nat => bool) => bool)
(%m::nat.
(op -->::bool => bool => bool)
- ((op <=::nat => nat => bool) m ((size::'a list => nat) l))
- ((list_all::('a => bool) => 'a list => bool) P
- ((BUTLASTN::nat => 'a list => 'a list) m l))))))"
+ ((op <=::nat => nat => bool) m
+ ((size::'a::type list => nat) l))
+ ((list_all::('a::type => bool) => 'a::type list => bool) P
+ ((BUTLASTN::nat => 'a::type list => 'a::type list) m
+ l))))))"
by (import rich_list ALL_EL_BUTLASTN)
-lemma LENGTH_FIRSTN: "ALL n l. n <= length l --> length (FIRSTN n l) = n"
+lemma LENGTH_FIRSTN: "ALL (n::nat) l::'a::type list. n <= length l --> length (FIRSTN n l) = n"
by (import rich_list LENGTH_FIRSTN)
lemma FIRSTN_FIRSTN: "(All::(nat => bool) => bool)
(%m::nat.
- (All::('a list => bool) => bool)
- (%l::'a list.
+ (All::('a::type list => bool) => bool)
+ (%l::'a::type list.
(op -->::bool => bool => bool)
- ((op <=::nat => nat => bool) m ((size::'a list => nat) l))
+ ((op <=::nat => nat => bool) m ((size::'a::type list => nat) l))
((All::(nat => bool) => bool)
(%n::nat.
(op -->::bool => bool => bool)
((op <=::nat => nat => bool) n m)
- ((op =::'a list => 'a list => bool)
- ((FIRSTN::nat => 'a list => 'a list) n
- ((FIRSTN::nat => 'a list => 'a list) m l))
- ((FIRSTN::nat => 'a list => 'a list) n l))))))"
+ ((op =::'a::type list => 'a::type list => bool)
+ ((FIRSTN::nat => 'a::type list => 'a::type list) n
+ ((FIRSTN::nat => 'a::type list => 'a::type list) m l))
+ ((FIRSTN::nat => 'a::type list => 'a::type list) n
+ l))))))"
by (import rich_list FIRSTN_FIRSTN)
-lemma LENGTH_BUTFIRSTN: "ALL n l. n <= length l --> length (BUTFIRSTN n l) = length l - n"
+lemma LENGTH_BUTFIRSTN: "ALL (n::nat) l::'a::type list.
+ n <= length l --> length (BUTFIRSTN n l) = length l - n"
by (import rich_list LENGTH_BUTFIRSTN)
-lemma BUTFIRSTN_LENGTH_NIL: "ALL l. BUTFIRSTN (length l) l = []"
+lemma BUTFIRSTN_LENGTH_NIL: "ALL l::'a::type list. BUTFIRSTN (length l) l = []"
by (import rich_list BUTFIRSTN_LENGTH_NIL)
-lemma BUTFIRSTN_APPEND1: "ALL n l1.
- n <= length l1 --> (ALL l2. BUTFIRSTN n (l1 @ l2) = BUTFIRSTN n l1 @ l2)"
+lemma BUTFIRSTN_APPEND1: "ALL (n::nat) l1::'a::type list.
+ n <= length l1 -->
+ (ALL l2::'a::type list. BUTFIRSTN n (l1 @ l2) = BUTFIRSTN n l1 @ l2)"
by (import rich_list BUTFIRSTN_APPEND1)
-lemma BUTFIRSTN_APPEND2: "ALL l1 n.
+lemma BUTFIRSTN_APPEND2: "ALL (l1::'a::type list) n::nat.
length l1 <= n -->
- (ALL l2. BUTFIRSTN n (l1 @ l2) = BUTFIRSTN (n - length l1) l2)"
+ (ALL l2::'a::type list.
+ BUTFIRSTN n (l1 @ l2) = BUTFIRSTN (n - length l1) l2)"
by (import rich_list BUTFIRSTN_APPEND2)
-lemma BUTFIRSTN_BUTFIRSTN: "ALL n m l.
+lemma BUTFIRSTN_BUTFIRSTN: "ALL (n::nat) (m::nat) l::'a::type list.
n + m <= length l --> BUTFIRSTN n (BUTFIRSTN m l) = BUTFIRSTN (n + m) l"
by (import rich_list BUTFIRSTN_BUTFIRSTN)
-lemma APPEND_FIRSTN_BUTFIRSTN: "ALL n l. n <= length l --> FIRSTN n l @ BUTFIRSTN n l = l"
+lemma APPEND_FIRSTN_BUTFIRSTN: "ALL (n::nat) l::'a::type list.
+ n <= length l --> FIRSTN n l @ BUTFIRSTN n l = l"
by (import rich_list APPEND_FIRSTN_BUTFIRSTN)
-lemma LASTN_SEG: "ALL n l. n <= length l --> LASTN n l = SEG n (length l - n) l"
+lemma LASTN_SEG: "ALL (n::nat) l::'a::type list.
+ n <= length l --> LASTN n l = SEG n (length l - n) l"
by (import rich_list LASTN_SEG)
-lemma FIRSTN_SEG: "ALL n l. n <= length l --> FIRSTN n l = SEG n 0 l"
+lemma FIRSTN_SEG: "ALL (n::nat) l::'a::type list.
+ n <= length l --> FIRSTN n l = SEG n (0::nat) l"
by (import rich_list FIRSTN_SEG)
-lemma BUTFIRSTN_SEG: "ALL n l. n <= length l --> BUTFIRSTN n l = SEG (length l - n) n l"
+lemma BUTFIRSTN_SEG: "ALL (n::nat) l::'a::type list.
+ n <= length l --> BUTFIRSTN n l = SEG (length l - n) n l"
by (import rich_list BUTFIRSTN_SEG)
-lemma BUTFIRSTN_SNOC: "ALL n l.
+lemma BUTFIRSTN_SNOC: "ALL (n::nat) l::'a::type list.
n <= length l -->
- (ALL x. BUTFIRSTN n (SNOC x l) = SNOC x (BUTFIRSTN n l))"
+ (ALL x::'a::type. BUTFIRSTN n (SNOC x l) = SNOC x (BUTFIRSTN n l))"
by (import rich_list BUTFIRSTN_SNOC)
-lemma APPEND_BUTLASTN_BUTFIRSTN: "ALL m n l. m + n = length l --> BUTLASTN m l @ BUTFIRSTN n l = l"
+lemma APPEND_BUTLASTN_BUTFIRSTN: "ALL (m::nat) (n::nat) l::'a::type list.
+ m + n = length l --> BUTLASTN m l @ BUTFIRSTN n l = l"
by (import rich_list APPEND_BUTLASTN_BUTFIRSTN)
-lemma SEG_SEG: "ALL n1 m1 n2 m2 l.
+lemma SEG_SEG: "ALL (n1::nat) (m1::nat) (n2::nat) (m2::nat) l::'a::type list.
n1 + m1 <= length l & n2 + m2 <= n1 -->
SEG n2 m2 (SEG n1 m1 l) = SEG n2 (m1 + m2) l"
by (import rich_list SEG_SEG)
-lemma SEG_APPEND1: "ALL n m l1. n + m <= length l1 --> (ALL l2. SEG n m (l1 @ l2) = SEG n m l1)"
+lemma SEG_APPEND1: "ALL (n::nat) (m::nat) l1::'a::type list.
+ n + m <= length l1 -->
+ (ALL l2::'a::type list. SEG n m (l1 @ l2) = SEG n m l1)"
by (import rich_list SEG_APPEND1)
-lemma SEG_APPEND2: "ALL l1 m n l2.
+lemma SEG_APPEND2: "ALL (l1::'a::type list) (m::nat) (n::nat) l2::'a::type list.
length l1 <= m & n <= length l2 -->
SEG n m (l1 @ l2) = SEG n (m - length l1) l2"
by (import rich_list SEG_APPEND2)
-lemma SEG_FIRSTN_BUTFISTN: "ALL n m l. n + m <= length l --> SEG n m l = FIRSTN n (BUTFIRSTN m l)"
+lemma SEG_FIRSTN_BUTFISTN: "ALL (n::nat) (m::nat) l::'a::type list.
+ n + m <= length l --> SEG n m l = FIRSTN n (BUTFIRSTN m l)"
by (import rich_list SEG_FIRSTN_BUTFISTN)
-lemma SEG_APPEND: "ALL m l1 n l2.
+lemma SEG_APPEND: "ALL (m::nat) (l1::'a::type list) (n::nat) l2::'a::type list.
m < length l1 & length l1 <= n + m & n + m <= length l1 + length l2 -->
SEG n m (l1 @ l2) =
- SEG (length l1 - m) m l1 @ SEG (n + m - length l1) 0 l2"
+ SEG (length l1 - m) m l1 @ SEG (n + m - length l1) (0::nat) l2"
by (import rich_list SEG_APPEND)
-lemma SEG_LENGTH_SNOC: "ALL x xa. SEG 1 (length x) (SNOC xa x) = [xa]"
+lemma SEG_LENGTH_SNOC: "ALL (x::'a::type list) xa::'a::type.
+ SEG (1::nat) (length x) (SNOC xa x) = [xa]"
by (import rich_list SEG_LENGTH_SNOC)
-lemma SEG_SNOC: "ALL n m l. n + m <= length l --> (ALL x. SEG n m (SNOC x l) = SEG n m l)"
+lemma SEG_SNOC: "ALL (n::nat) (m::nat) l::'a::type list.
+ n + m <= length l --> (ALL x::'a::type. SEG n m (SNOC x l) = SEG n m l)"
by (import rich_list SEG_SNOC)
-lemma ELL_SEG: "ALL n l. n < length l --> ELL n l = hd (SEG 1 (PRE (length l - n)) l)"
+lemma ELL_SEG: "ALL (n::nat) l::'a::type list.
+ n < length l --> ELL n l = hd (SEG (1::nat) (PRE (length l - n)) l)"
by (import rich_list ELL_SEG)
-lemma SNOC_FOLDR: "ALL x l. SNOC x l = foldr op # l [x]"
+lemma SNOC_FOLDR: "ALL (x::'a::type) l::'a::type list. SNOC x l = foldr op # l [x]"
by (import rich_list SNOC_FOLDR)
-lemma IS_EL_FOLDR_MAP: "ALL x xa. x mem xa = foldr op | (map (op = x) xa) False"
+lemma IS_EL_FOLDR_MAP: "ALL (x::'a::type) xa::'a::type list.
+ x mem xa = foldr op | (map (op = x) xa) False"
by (import rich_list IS_EL_FOLDR_MAP)
-lemma IS_EL_FOLDL_MAP: "ALL x xa. x mem xa = foldl op | False (map (op = x) xa)"
+lemma IS_EL_FOLDL_MAP: "ALL (x::'a::type) xa::'a::type list.
+ x mem xa = foldl op | False (map (op = x) xa)"
by (import rich_list IS_EL_FOLDL_MAP)
-lemma FILTER_FILTER: "ALL P Q l. filter P (filter Q l) = [x:l. P x & Q x]"
+lemma FILTER_FILTER: "ALL (P::'a::type => bool) (Q::'a::type => bool) l::'a::type list.
+ filter P (filter Q l) = [x::'a::type:l. P x & Q x]"
by (import rich_list FILTER_FILTER)
-lemma FCOMM_FOLDR_FLAT: "ALL g f.
+lemma FCOMM_FOLDR_FLAT: "ALL (g::'a::type => 'a::type => 'a::type)
+ f::'b::type => 'a::type => 'a::type.
FCOMM g f -->
- (ALL e.
+ (ALL e::'a::type.
LEFT_ID g e -->
- (ALL l. foldr f (concat l) e = foldr g (map (FOLDR f e) l) e))"
+ (ALL l::'b::type list list.
+ foldr f (concat l) e = foldr g (map (FOLDR f e) l) e))"
by (import rich_list FCOMM_FOLDR_FLAT)
-lemma FCOMM_FOLDL_FLAT: "ALL f g.
+lemma FCOMM_FOLDL_FLAT: "ALL (f::'a::type => 'b::type => 'a::type)
+ g::'a::type => 'a::type => 'a::type.
FCOMM f g -->
- (ALL e.
+ (ALL e::'a::type.
RIGHT_ID g e -->
- (ALL l. foldl f e (concat l) = foldl g e (map (foldl f e) l)))"
+ (ALL l::'b::type list list.
+ foldl f e (concat l) = foldl g e (map (foldl f e) l)))"
by (import rich_list FCOMM_FOLDL_FLAT)
-lemma FOLDR_MAP_REVERSE: "ALL f::'a => 'a => 'a.
- (ALL (a::'a) (b::'a) c::'a. f a (f b c) = f b (f a c)) -->
- (ALL (e::'a) (g::'b => 'a) l::'b list.
+lemma FOLDR_MAP_REVERSE: "ALL f::'a::type => 'a::type => 'a::type.
+ (ALL (a::'a::type) (b::'a::type) c::'a::type.
+ f a (f b c) = f b (f a c)) -->
+ (ALL (e::'a::type) (g::'b::type => 'a::type) l::'b::type list.
foldr f (map g (rev l)) e = foldr f (map g l) e)"
by (import rich_list FOLDR_MAP_REVERSE)
-lemma FOLDR_FILTER_REVERSE: "ALL f::'a => 'a => 'a.
- (ALL (a::'a) (b::'a) c::'a. f a (f b c) = f b (f a c)) -->
- (ALL (e::'a) (P::'a => bool) l::'a list.
+lemma FOLDR_FILTER_REVERSE: "ALL f::'a::type => 'a::type => 'a::type.
+ (ALL (a::'a::type) (b::'a::type) c::'a::type.
+ f a (f b c) = f b (f a c)) -->
+ (ALL (e::'a::type) (P::'a::type => bool) l::'a::type list.
foldr f (filter P (rev l)) e = foldr f (filter P l) e)"
by (import rich_list FOLDR_FILTER_REVERSE)
-lemma COMM_ASSOC_FOLDR_REVERSE: "ALL f. COMM f --> ASSOC f --> (ALL e l. foldr f (rev l) e = foldr f l e)"
+lemma COMM_ASSOC_FOLDR_REVERSE: "ALL f::'a::type => 'a::type => 'a::type.
+ COMM f -->
+ ASSOC f -->
+ (ALL (e::'a::type) l::'a::type list. foldr f (rev l) e = foldr f l e)"
by (import rich_list COMM_ASSOC_FOLDR_REVERSE)
-lemma COMM_ASSOC_FOLDL_REVERSE: "ALL f. COMM f --> ASSOC f --> (ALL e l. foldl f e (rev l) = foldl f e l)"
+lemma COMM_ASSOC_FOLDL_REVERSE: "ALL f::'a::type => 'a::type => 'a::type.
+ COMM f -->
+ ASSOC f -->
+ (ALL (e::'a::type) l::'a::type list. foldl f e (rev l) = foldl f e l)"
by (import rich_list COMM_ASSOC_FOLDL_REVERSE)
-lemma ELL_LAST: "ALL l. ~ null l --> ELL 0 l = last l"
+lemma ELL_LAST: "ALL l::'a::type list. ~ null l --> ELL (0::nat) l = last l"
by (import rich_list ELL_LAST)
-lemma ELL_0_SNOC: "ALL l x. ELL 0 (SNOC x l) = x"
+lemma ELL_0_SNOC: "ALL (l::'a::type list) x::'a::type. ELL (0::nat) (SNOC x l) = x"
by (import rich_list ELL_0_SNOC)
-lemma ELL_SNOC: "ALL n>0. ALL x l. ELL n (SNOC x l) = ELL (PRE n) l"
+lemma ELL_SNOC: "ALL n>0::nat.
+ ALL (x::'a::type) l::'a::type list. ELL n (SNOC x l) = ELL (PRE n) l"
by (import rich_list ELL_SNOC)
-lemma ELL_SUC_SNOC: "ALL n x xa. ELL (Suc n) (SNOC x xa) = ELL n xa"
+lemma ELL_SUC_SNOC: "ALL (n::nat) (x::'a::type) xa::'a::type list.
+ ELL (Suc n) (SNOC x xa) = ELL n xa"
by (import rich_list ELL_SUC_SNOC)
-lemma ELL_CONS: "ALL n l. n < length l --> (ALL x. ELL n (x # l) = ELL n l)"
+lemma ELL_CONS: "ALL (n::nat) l::'a::type list.
+ n < length l --> (ALL x::'a::type. ELL n (x # l) = ELL n l)"
by (import rich_list ELL_CONS)
-lemma ELL_LENGTH_CONS: "ALL l x. ELL (length l) (x # l) = x"
+lemma ELL_LENGTH_CONS: "ALL (l::'a::type list) x::'a::type. ELL (length l) (x # l) = x"
by (import rich_list ELL_LENGTH_CONS)
-lemma ELL_LENGTH_SNOC: "ALL l x. ELL (length l) (SNOC x l) = (if null l then x else hd l)"
+lemma ELL_LENGTH_SNOC: "ALL (l::'a::type list) x::'a::type.
+ ELL (length l) (SNOC x l) = (if null l then x else hd l)"
by (import rich_list ELL_LENGTH_SNOC)
-lemma ELL_APPEND2: "ALL n l2. n < length l2 --> (ALL l1. ELL n (l1 @ l2) = ELL n l2)"
+lemma ELL_APPEND2: "ALL (n::nat) l2::'a::type list.
+ n < length l2 --> (ALL l1::'a::type list. ELL n (l1 @ l2) = ELL n l2)"
by (import rich_list ELL_APPEND2)
-lemma ELL_APPEND1: "ALL l2 n.
- length l2 <= n --> (ALL l1. ELL n (l1 @ l2) = ELL (n - length l2) l1)"
+lemma ELL_APPEND1: "ALL (l2::'a::type list) n::nat.
+ length l2 <= n -->
+ (ALL l1::'a::type list. ELL n (l1 @ l2) = ELL (n - length l2) l1)"
by (import rich_list ELL_APPEND1)
-lemma ELL_PRE_LENGTH: "ALL l. l ~= [] --> ELL (PRE (length l)) l = hd l"
+lemma ELL_PRE_LENGTH: "ALL l::'a::type list. l ~= [] --> ELL (PRE (length l)) l = hd l"
by (import rich_list ELL_PRE_LENGTH)
-lemma EL_LENGTH_SNOC: "ALL l x. EL (length l) (SNOC x l) = x"
+lemma EL_LENGTH_SNOC: "ALL (l::'a::type list) x::'a::type. EL (length l) (SNOC x l) = x"
by (import rich_list EL_LENGTH_SNOC)
-lemma EL_PRE_LENGTH: "ALL l. l ~= [] --> EL (PRE (length l)) l = last l"
+lemma EL_PRE_LENGTH: "ALL l::'a::type list. l ~= [] --> EL (PRE (length l)) l = last l"
by (import rich_list EL_PRE_LENGTH)
-lemma EL_SNOC: "ALL n l. n < length l --> (ALL x. EL n (SNOC x l) = EL n l)"
+lemma EL_SNOC: "ALL (n::nat) l::'a::type list.
+ n < length l --> (ALL x::'a::type. EL n (SNOC x l) = EL n l)"
by (import rich_list EL_SNOC)
-lemma EL_ELL: "ALL n l. n < length l --> EL n l = ELL (PRE (length l - n)) l"
+lemma EL_ELL: "ALL (n::nat) l::'a::type list.
+ n < length l --> EL n l = ELL (PRE (length l - n)) l"
by (import rich_list EL_ELL)
-lemma EL_LENGTH_APPEND: "ALL l2 l1. ~ null l2 --> EL (length l1) (l1 @ l2) = hd l2"
+lemma EL_LENGTH_APPEND: "ALL (l2::'a::type list) l1::'a::type list.
+ ~ null l2 --> EL (length l1) (l1 @ l2) = hd l2"
by (import rich_list EL_LENGTH_APPEND)
-lemma ELL_EL: "ALL n l. n < length l --> ELL n l = EL (PRE (length l - n)) l"
+lemma ELL_EL: "ALL (n::nat) l::'a::type list.
+ n < length l --> ELL n l = EL (PRE (length l - n)) l"
by (import rich_list ELL_EL)
-lemma ELL_MAP: "ALL n l f. n < length l --> ELL n (map f l) = f (ELL n l)"
+lemma ELL_MAP: "ALL (n::nat) (l::'a::type list) f::'a::type => 'b::type.
+ n < length l --> ELL n (map f l) = f (ELL n l)"
by (import rich_list ELL_MAP)
-lemma LENGTH_BUTLAST: "ALL l. l ~= [] --> length (butlast l) = PRE (length l)"
+lemma LENGTH_BUTLAST: "ALL l::'a::type list. l ~= [] --> length (butlast l) = PRE (length l)"
by (import rich_list LENGTH_BUTLAST)
-lemma BUTFIRSTN_LENGTH_APPEND: "ALL l1 l2. BUTFIRSTN (length l1) (l1 @ l2) = l2"
+lemma BUTFIRSTN_LENGTH_APPEND: "ALL (l1::'a::type list) l2::'a::type list.
+ BUTFIRSTN (length l1) (l1 @ l2) = l2"
by (import rich_list BUTFIRSTN_LENGTH_APPEND)
-lemma FIRSTN_APPEND1: "ALL n l1. n <= length l1 --> (ALL l2. FIRSTN n (l1 @ l2) = FIRSTN n l1)"
+lemma FIRSTN_APPEND1: "ALL (n::nat) l1::'a::type list.
+ n <= length l1 -->
+ (ALL l2::'a::type list. FIRSTN n (l1 @ l2) = FIRSTN n l1)"
by (import rich_list FIRSTN_APPEND1)
-lemma FIRSTN_APPEND2: "ALL l1 n.
+lemma FIRSTN_APPEND2: "ALL (l1::'a::type list) n::nat.
length l1 <= n -->
- (ALL l2. FIRSTN n (l1 @ l2) = l1 @ FIRSTN (n - length l1) l2)"
+ (ALL l2::'a::type list.
+ FIRSTN n (l1 @ l2) = l1 @ FIRSTN (n - length l1) l2)"
by (import rich_list FIRSTN_APPEND2)
-lemma FIRSTN_LENGTH_APPEND: "ALL l1 l2. FIRSTN (length l1) (l1 @ l2) = l1"
+lemma FIRSTN_LENGTH_APPEND: "ALL (l1::'a::type list) l2::'a::type list. FIRSTN (length l1) (l1 @ l2) = l1"
by (import rich_list FIRSTN_LENGTH_APPEND)
-lemma REVERSE_FLAT: "ALL l. rev (concat l) = concat (rev (map rev l))"
+lemma REVERSE_FLAT: "ALL l::'a::type list list. rev (concat l) = concat (rev (map rev l))"
by (import rich_list REVERSE_FLAT)
-lemma MAP_FILTER: "ALL f P l.
- (ALL x. P (f x) = P x) --> map f (filter P l) = filter P (map f l)"
+lemma MAP_FILTER: "ALL (f::'a::type => 'a::type) (P::'a::type => bool) l::'a::type list.
+ (ALL x::'a::type. P (f x) = P x) -->
+ map f (filter P l) = filter P (map f l)"
by (import rich_list MAP_FILTER)
-lemma FLAT_REVERSE: "ALL l. concat (rev l) = rev (concat (map rev l))"
+lemma FLAT_REVERSE: "ALL l::'a::type list list. concat (rev l) = rev (concat (map rev l))"
by (import rich_list FLAT_REVERSE)
-lemma FLAT_FLAT: "ALL l. concat (concat l) = concat (map concat l)"
+lemma FLAT_FLAT: "ALL l::'a::type list list list. concat (concat l) = concat (map concat l)"
by (import rich_list FLAT_FLAT)
-lemma SOME_EL_REVERSE: "ALL P l. list_exists P (rev l) = list_exists P l"
+lemma SOME_EL_REVERSE: "ALL (P::'a::type => bool) l::'a::type list.
+ list_exists P (rev l) = list_exists P l"
by (import rich_list SOME_EL_REVERSE)
-lemma ALL_EL_SEG: "ALL P l.
- list_all P l --> (ALL m k. m + k <= length l --> list_all P (SEG m k l))"
+lemma ALL_EL_SEG: "ALL (P::'a::type => bool) l::'a::type list.
+ list_all P l -->
+ (ALL (m::nat) k::nat. m + k <= length l --> list_all P (SEG m k l))"
by (import rich_list ALL_EL_SEG)
-lemma ALL_EL_FIRSTN: "(All::(('a => bool) => bool) => bool)
- (%P::'a => bool.
- (All::('a list => bool) => bool)
- (%l::'a list.
+lemma ALL_EL_FIRSTN: "(All::(('a::type => bool) => bool) => bool)
+ (%P::'a::type => bool.
+ (All::('a::type list => bool) => bool)
+ (%l::'a::type list.
(op -->::bool => bool => bool)
- ((list_all::('a => bool) => 'a list => bool) P l)
- ((All::(nat => bool) => bool)
- (%m::nat.
- (op -->::bool => bool => bool)
- ((op <=::nat => nat => bool) m ((size::'a list => nat) l))
- ((list_all::('a => bool) => 'a list => bool) P
- ((FIRSTN::nat => 'a list => 'a list) m l))))))"
- by (import rich_list ALL_EL_FIRSTN)
-
-lemma ALL_EL_BUTFIRSTN: "(All::(('a => bool) => bool) => bool)
- (%P::'a => bool.
- (All::('a list => bool) => bool)
- (%l::'a list.
- (op -->::bool => bool => bool)
- ((list_all::('a => bool) => 'a list => bool) P l)
+ ((list_all::('a::type => bool) => 'a::type list => bool) P l)
((All::(nat => bool) => bool)
(%m::nat.
(op -->::bool => bool => bool)
- ((op <=::nat => nat => bool) m ((size::'a list => nat) l))
- ((list_all::('a => bool) => 'a list => bool) P
- ((BUTFIRSTN::nat => 'a list => 'a list) m l))))))"
+ ((op <=::nat => nat => bool) m
+ ((size::'a::type list => nat) l))
+ ((list_all::('a::type => bool) => 'a::type list => bool) P
+ ((FIRSTN::nat => 'a::type list => 'a::type list) m
+ l))))))"
+ by (import rich_list ALL_EL_FIRSTN)
+
+lemma ALL_EL_BUTFIRSTN: "(All::(('a::type => bool) => bool) => bool)
+ (%P::'a::type => bool.
+ (All::('a::type list => bool) => bool)
+ (%l::'a::type list.
+ (op -->::bool => bool => bool)
+ ((list_all::('a::type => bool) => 'a::type list => bool) P l)
+ ((All::(nat => bool) => bool)
+ (%m::nat.
+ (op -->::bool => bool => bool)
+ ((op <=::nat => nat => bool) m
+ ((size::'a::type list => nat) l))
+ ((list_all::('a::type => bool) => 'a::type list => bool) P
+ ((BUTFIRSTN::nat => 'a::type list => 'a::type list) m
+ l))))))"
by (import rich_list ALL_EL_BUTFIRSTN)
-lemma SOME_EL_SEG: "ALL m k l.
+lemma SOME_EL_SEG: "ALL (m::nat) (k::nat) l::'a::type list.
m + k <= length l -->
- (ALL P. list_exists P (SEG m k l) --> list_exists P l)"
+ (ALL P::'a::type => bool. list_exists P (SEG m k l) --> list_exists P l)"
by (import rich_list SOME_EL_SEG)
-lemma SOME_EL_FIRSTN: "ALL m l.
- m <= length l --> (ALL P. list_exists P (FIRSTN m l) --> list_exists P l)"
+lemma SOME_EL_FIRSTN: "ALL (m::nat) l::'a::type list.
+ m <= length l -->
+ (ALL P::'a::type => bool. list_exists P (FIRSTN m l) --> list_exists P l)"
by (import rich_list SOME_EL_FIRSTN)
-lemma SOME_EL_BUTFIRSTN: "ALL m l.
+lemma SOME_EL_BUTFIRSTN: "ALL (m::nat) l::'a::type list.
m <= length l -->
- (ALL P. list_exists P (BUTFIRSTN m l) --> list_exists P l)"
+ (ALL P::'a::type => bool.
+ list_exists P (BUTFIRSTN m l) --> list_exists P l)"
by (import rich_list SOME_EL_BUTFIRSTN)
-lemma SOME_EL_LASTN: "ALL m l.
- m <= length l --> (ALL P. list_exists P (LASTN m l) --> list_exists P l)"
+lemma SOME_EL_LASTN: "ALL (m::nat) l::'a::type list.
+ m <= length l -->
+ (ALL P::'a::type => bool. list_exists P (LASTN m l) --> list_exists P l)"
by (import rich_list SOME_EL_LASTN)
-lemma SOME_EL_BUTLASTN: "ALL m l.
+lemma SOME_EL_BUTLASTN: "ALL (m::nat) l::'a::type list.
m <= length l -->
- (ALL P. list_exists P (BUTLASTN m l) --> list_exists P l)"
+ (ALL P::'a::type => bool.
+ list_exists P (BUTLASTN m l) --> list_exists P l)"
by (import rich_list SOME_EL_BUTLASTN)
-lemma IS_EL_REVERSE: "ALL x l. x mem rev l = x mem l"
+lemma IS_EL_REVERSE: "ALL (x::'a::type) l::'a::type list. x mem rev l = x mem l"
by (import rich_list IS_EL_REVERSE)
-lemma IS_EL_FILTER: "ALL P x. P x --> (ALL l. x mem filter P l = x mem l)"
+lemma IS_EL_FILTER: "ALL (P::'a::type => bool) x::'a::type.
+ P x --> (ALL l::'a::type list. x mem filter P l = x mem l)"
by (import rich_list IS_EL_FILTER)
-lemma IS_EL_SEG: "ALL n m l. n + m <= length l --> (ALL x. x mem SEG n m l --> x mem l)"
+lemma IS_EL_SEG: "ALL (n::nat) (m::nat) l::'a::type list.
+ n + m <= length l --> (ALL x::'a::type. x mem SEG n m l --> x mem l)"
by (import rich_list IS_EL_SEG)
-lemma IS_EL_SOME_EL: "ALL x l. x mem l = list_exists (op = x) l"
+lemma IS_EL_SOME_EL: "ALL (x::'a::type) l::'a::type list. x mem l = list_exists (op = x) l"
by (import rich_list IS_EL_SOME_EL)
-lemma IS_EL_FIRSTN: "ALL x xa. x <= length xa --> (ALL xb. xb mem FIRSTN x xa --> xb mem xa)"
+lemma IS_EL_FIRSTN: "ALL (x::nat) xa::'a::type list.
+ x <= length xa --> (ALL xb::'a::type. xb mem FIRSTN x xa --> xb mem xa)"
by (import rich_list IS_EL_FIRSTN)
-lemma IS_EL_BUTFIRSTN: "ALL x xa. x <= length xa --> (ALL xb. xb mem BUTFIRSTN x xa --> xb mem xa)"
+lemma IS_EL_BUTFIRSTN: "ALL (x::nat) xa::'a::type list.
+ x <= length xa -->
+ (ALL xb::'a::type. xb mem BUTFIRSTN x xa --> xb mem xa)"
by (import rich_list IS_EL_BUTFIRSTN)
-lemma IS_EL_BUTLASTN: "ALL x xa. x <= length xa --> (ALL xb. xb mem BUTLASTN x xa --> xb mem xa)"
+lemma IS_EL_BUTLASTN: "ALL (x::nat) xa::'a::type list.
+ x <= length xa --> (ALL xb::'a::type. xb mem BUTLASTN x xa --> xb mem xa)"
by (import rich_list IS_EL_BUTLASTN)
-lemma IS_EL_LASTN: "ALL x xa. x <= length xa --> (ALL xb. xb mem LASTN x xa --> xb mem xa)"
+lemma IS_EL_LASTN: "ALL (x::nat) xa::'a::type list.
+ x <= length xa --> (ALL xb::'a::type. xb mem LASTN x xa --> xb mem xa)"
by (import rich_list IS_EL_LASTN)
-lemma ZIP_SNOC: "ALL l1 l2.
+lemma ZIP_SNOC: "ALL (l1::'a::type list) l2::'b::type list.
length l1 = length l2 -->
- (ALL x1 x2. zip (SNOC x1 l1) (SNOC x2 l2) = SNOC (x1, x2) (zip l1 l2))"
+ (ALL (x1::'a::type) x2::'b::type.
+ zip (SNOC x1 l1) (SNOC x2 l2) = SNOC (x1, x2) (zip l1 l2))"
by (import rich_list ZIP_SNOC)
-lemma UNZIP_SNOC: "ALL x l.
+lemma UNZIP_SNOC: "ALL (x::'a::type * 'b::type) l::('a::type * 'b::type) list.
unzip (SNOC x l) =
(SNOC (fst x) (fst (unzip l)), SNOC (snd x) (snd (unzip l)))"
by (import rich_list UNZIP_SNOC)
-lemma LENGTH_UNZIP_FST: "ALL x. length (UNZIP_FST x) = length x"
+lemma LENGTH_UNZIP_FST: "ALL x::('a::type * 'b::type) list. length (UNZIP_FST x) = length x"
by (import rich_list LENGTH_UNZIP_FST)
-lemma LENGTH_UNZIP_SND: "ALL x. length (UNZIP_SND x) = length x"
+lemma LENGTH_UNZIP_SND: "ALL x::('a::type * 'b::type) list. length (UNZIP_SND x) = length x"
by (import rich_list LENGTH_UNZIP_SND)
-lemma SUM_APPEND: "ALL l1 l2. sum (l1 @ l2) = sum l1 + sum l2"
+lemma SUM_APPEND: "ALL (l1::nat list) l2::nat list. sum (l1 @ l2) = sum l1 + sum l2"
by (import rich_list SUM_APPEND)
-lemma SUM_REVERSE: "ALL l. sum (rev l) = sum l"
+lemma SUM_REVERSE: "ALL l::nat list. sum (rev l) = sum l"
by (import rich_list SUM_REVERSE)
-lemma SUM_FLAT: "ALL l. sum (concat l) = sum (map sum l)"
+lemma SUM_FLAT: "ALL l::nat list list. sum (concat l) = sum (map sum l)"
by (import rich_list SUM_FLAT)
-lemma EL_APPEND1: "ALL n l1 l2. n < length l1 --> EL n (l1 @ l2) = EL n l1"
+lemma EL_APPEND1: "ALL (n::nat) (l1::'a::type list) l2::'a::type list.
+ n < length l1 --> EL n (l1 @ l2) = EL n l1"
by (import rich_list EL_APPEND1)
-lemma EL_APPEND2: "ALL l1 n.
- length l1 <= n --> (ALL l2. EL n (l1 @ l2) = EL (n - length l1) l2)"
+lemma EL_APPEND2: "ALL (l1::'a::type list) n::nat.
+ length l1 <= n -->
+ (ALL l2::'a::type list. EL n (l1 @ l2) = EL (n - length l1) l2)"
by (import rich_list EL_APPEND2)
-lemma EL_MAP: "ALL n l. n < length l --> (ALL f. EL n (map f l) = f (EL n l))"
+lemma EL_MAP: "ALL (n::nat) l::'a::type list.
+ n < length l -->
+ (ALL f::'a::type => 'b::type. EL n (map f l) = f (EL n l))"
by (import rich_list EL_MAP)
-lemma EL_CONS: "ALL n>0. ALL x l. EL n (x # l) = EL (PRE n) l"
+lemma EL_CONS: "ALL n>0::nat.
+ ALL (x::'a::type) l::'a::type list. EL n (x # l) = EL (PRE n) l"
by (import rich_list EL_CONS)
-lemma EL_SEG: "ALL n l. n < length l --> EL n l = hd (SEG 1 n l)"
+lemma EL_SEG: "ALL (n::nat) l::'a::type list.
+ n < length l --> EL n l = hd (SEG (1::nat) n l)"
by (import rich_list EL_SEG)
-lemma EL_IS_EL: "ALL n l. n < length l --> EL n l mem l"
+lemma EL_IS_EL: "ALL (n::nat) l::'a::type list. n < length l --> EL n l mem l"
by (import rich_list EL_IS_EL)
-lemma TL_SNOC: "ALL x l. tl (SNOC x l) = (if null l then [] else SNOC x (tl l))"
+lemma TL_SNOC: "ALL (x::'a::type) l::'a::type list.
+ tl (SNOC x l) = (if null l then [] else SNOC x (tl l))"
by (import rich_list TL_SNOC)
-lemma EL_REVERSE: "ALL n l. n < length l --> EL n (rev l) = EL (PRE (length l - n)) l"
+lemma EL_REVERSE: "ALL (n::nat) l::'a::type list.
+ n < length l --> EL n (rev l) = EL (PRE (length l - n)) l"
by (import rich_list EL_REVERSE)
-lemma EL_REVERSE_ELL: "ALL n l. n < length l --> EL n (rev l) = ELL n l"
+lemma EL_REVERSE_ELL: "ALL (n::nat) l::'a::type list. n < length l --> EL n (rev l) = ELL n l"
by (import rich_list EL_REVERSE_ELL)
-lemma ELL_LENGTH_APPEND: "ALL l1 l2. ~ null l1 --> ELL (length l2) (l1 @ l2) = last l1"
+lemma ELL_LENGTH_APPEND: "ALL (l1::'a::type list) l2::'a::type list.
+ ~ null l1 --> ELL (length l2) (l1 @ l2) = last l1"
by (import rich_list ELL_LENGTH_APPEND)
-lemma ELL_IS_EL: "ALL n l. n < length l --> ELL n l mem l"
+lemma ELL_IS_EL: "ALL (n::nat) l::'a::type list. n < length l --> ELL n l mem l"
by (import rich_list ELL_IS_EL)
-lemma ELL_REVERSE: "ALL n l. n < length l --> ELL n (rev l) = ELL (PRE (length l - n)) l"
+lemma ELL_REVERSE: "ALL (n::nat) l::'a::type list.
+ n < length l --> ELL n (rev l) = ELL (PRE (length l - n)) l"
by (import rich_list ELL_REVERSE)
-lemma ELL_REVERSE_EL: "ALL n l. n < length l --> ELL n (rev l) = EL n l"
+lemma ELL_REVERSE_EL: "ALL (n::nat) l::'a::type list. n < length l --> ELL n (rev l) = EL n l"
by (import rich_list ELL_REVERSE_EL)
-lemma FIRSTN_BUTLASTN: "ALL n l. n <= length l --> FIRSTN n l = BUTLASTN (length l - n) l"
+lemma FIRSTN_BUTLASTN: "ALL (n::nat) l::'a::type list.
+ n <= length l --> FIRSTN n l = BUTLASTN (length l - n) l"
by (import rich_list FIRSTN_BUTLASTN)
-lemma BUTLASTN_FIRSTN: "ALL n l. n <= length l --> BUTLASTN n l = FIRSTN (length l - n) l"
+lemma BUTLASTN_FIRSTN: "ALL (n::nat) l::'a::type list.
+ n <= length l --> BUTLASTN n l = FIRSTN (length l - n) l"
by (import rich_list BUTLASTN_FIRSTN)
-lemma LASTN_BUTFIRSTN: "ALL n l. n <= length l --> LASTN n l = BUTFIRSTN (length l - n) l"
+lemma LASTN_BUTFIRSTN: "ALL (n::nat) l::'a::type list.
+ n <= length l --> LASTN n l = BUTFIRSTN (length l - n) l"
by (import rich_list LASTN_BUTFIRSTN)
-lemma BUTFIRSTN_LASTN: "ALL n l. n <= length l --> BUTFIRSTN n l = LASTN (length l - n) l"
+lemma BUTFIRSTN_LASTN: "ALL (n::nat) l::'a::type list.
+ n <= length l --> BUTFIRSTN n l = LASTN (length l - n) l"
by (import rich_list BUTFIRSTN_LASTN)
-lemma SEG_LASTN_BUTLASTN: "ALL n m l.
+lemma SEG_LASTN_BUTLASTN: "ALL (n::nat) (m::nat) l::'a::type list.
n + m <= length l -->
SEG n m l = LASTN n (BUTLASTN (length l - (n + m)) l)"
by (import rich_list SEG_LASTN_BUTLASTN)
-lemma BUTFIRSTN_REVERSE: "ALL n l. n <= length l --> BUTFIRSTN n (rev l) = rev (BUTLASTN n l)"
+lemma BUTFIRSTN_REVERSE: "ALL (n::nat) l::'a::type list.
+ n <= length l --> BUTFIRSTN n (rev l) = rev (BUTLASTN n l)"
by (import rich_list BUTFIRSTN_REVERSE)
-lemma BUTLASTN_REVERSE: "ALL n l. n <= length l --> BUTLASTN n (rev l) = rev (BUTFIRSTN n l)"
+lemma BUTLASTN_REVERSE: "ALL (n::nat) l::'a::type list.
+ n <= length l --> BUTLASTN n (rev l) = rev (BUTFIRSTN n l)"
by (import rich_list BUTLASTN_REVERSE)
-lemma LASTN_REVERSE: "ALL n l. n <= length l --> LASTN n (rev l) = rev (FIRSTN n l)"
+lemma LASTN_REVERSE: "ALL (n::nat) l::'a::type list.
+ n <= length l --> LASTN n (rev l) = rev (FIRSTN n l)"
by (import rich_list LASTN_REVERSE)
-lemma FIRSTN_REVERSE: "ALL n l. n <= length l --> FIRSTN n (rev l) = rev (LASTN n l)"
+lemma FIRSTN_REVERSE: "ALL (n::nat) l::'a::type list.
+ n <= length l --> FIRSTN n (rev l) = rev (LASTN n l)"
by (import rich_list FIRSTN_REVERSE)
-lemma SEG_REVERSE: "ALL n m l.
+lemma SEG_REVERSE: "ALL (n::nat) (m::nat) l::'a::type list.
n + m <= length l -->
SEG n m (rev l) = rev (SEG n (length l - (n + m)) l)"
by (import rich_list SEG_REVERSE)
-lemma LENGTH_GENLIST: "ALL f n. length (GENLIST f n) = n"
+lemma LENGTH_GENLIST: "ALL (f::nat => 'a::type) n::nat. length (GENLIST f n) = n"
by (import rich_list LENGTH_GENLIST)
-lemma LENGTH_REPLICATE: "ALL n x. length (REPLICATE n x) = n"
+lemma LENGTH_REPLICATE: "ALL (n::nat) x::'a::type. length (REPLICATE n x) = n"
by (import rich_list LENGTH_REPLICATE)
-lemma IS_EL_REPLICATE: "ALL n>0. ALL x. x mem REPLICATE n x"
+lemma IS_EL_REPLICATE: "ALL n>0::nat. ALL x::'a::type. x mem REPLICATE n x"
by (import rich_list IS_EL_REPLICATE)
-lemma ALL_EL_REPLICATE: "ALL x n. list_all (op = x) (REPLICATE n x)"
+lemma ALL_EL_REPLICATE: "ALL (x::'a::type) n::nat. list_all (op = x) (REPLICATE n x)"
by (import rich_list ALL_EL_REPLICATE)
-lemma AND_EL_FOLDL: "ALL l. AND_EL l = foldl op & True l"
+lemma AND_EL_FOLDL: "ALL l::bool list. AND_EL l = foldl op & True l"
by (import rich_list AND_EL_FOLDL)
-lemma AND_EL_FOLDR: "ALL l. AND_EL l = foldr op & l True"
+lemma AND_EL_FOLDR: "ALL l::bool list. AND_EL l = foldr op & l True"
by (import rich_list AND_EL_FOLDR)
-lemma OR_EL_FOLDL: "ALL l. OR_EL l = foldl op | False l"
+lemma OR_EL_FOLDL: "ALL l::bool list. OR_EL l = foldl op | False l"
by (import rich_list OR_EL_FOLDL)
-lemma OR_EL_FOLDR: "ALL l. OR_EL l = foldr op | l False"
+lemma OR_EL_FOLDR: "ALL l::bool list. OR_EL l = foldr op | l False"
by (import rich_list OR_EL_FOLDR)
;end_setup
@@ -4861,71 +5749,106 @@
;setup_theory state_transformer
constdefs
- UNIT :: "'b => 'a => 'b * 'a"
- "(op ==::('b => 'a => 'b * 'a) => ('b => 'a => 'b * 'a) => prop)
- (UNIT::'b => 'a => 'b * 'a) (Pair::'b => 'a => 'b * 'a)"
-
-lemma UNIT_DEF: "ALL x::'b. UNIT x = Pair x"
+ UNIT :: "'b::type => 'a::type => 'b::type * 'a::type"
+ "(op ==::('b::type => 'a::type => 'b::type * 'a::type)
+ => ('b::type => 'a::type => 'b::type * 'a::type) => prop)
+ (UNIT::'b::type => 'a::type => 'b::type * 'a::type)
+ (Pair::'b::type => 'a::type => 'b::type * 'a::type)"
+
+lemma UNIT_DEF: "ALL x::'b::type. UNIT x = Pair x"
by (import state_transformer UNIT_DEF)
constdefs
- BIND :: "('a => 'b * 'a) => ('b => 'a => 'c * 'a) => 'a => 'c * 'a"
- "(op ==::(('a => 'b * 'a) => ('b => 'a => 'c * 'a) => 'a => 'c * 'a)
- => (('a => 'b * 'a) => ('b => 'a => 'c * 'a) => 'a => 'c * 'a)
+ BIND :: "('a::type => 'b::type * 'a::type)
+=> ('b::type => 'a::type => 'c::type * 'a::type)
+ => 'a::type => 'c::type * 'a::type"
+ "(op ==::(('a::type => 'b::type * 'a::type)
+ => ('b::type => 'a::type => 'c::type * 'a::type)
+ => 'a::type => 'c::type * 'a::type)
+ => (('a::type => 'b::type * 'a::type)
+ => ('b::type => 'a::type => 'c::type * 'a::type)
+ => 'a::type => 'c::type * 'a::type)
=> prop)
- (BIND::('a => 'b * 'a) => ('b => 'a => 'c * 'a) => 'a => 'c * 'a)
- (%(g::'a => 'b * 'a) f::'b => 'a => 'c * 'a.
- (op o::('b * 'a => 'c * 'a) => ('a => 'b * 'a) => 'a => 'c * 'a)
- ((split::('b => 'a => 'c * 'a) => 'b * 'a => 'c * 'a) f) g)"
-
-lemma BIND_DEF: "(All::(('a => 'b * 'a) => bool) => bool)
- (%g::'a => 'b * 'a.
- (All::(('b => 'a => 'c * 'a) => bool) => bool)
- (%f::'b => 'a => 'c * 'a.
- (op =::('a => 'c * 'a) => ('a => 'c * 'a) => bool)
- ((BIND::('a => 'b * 'a)
- => ('b => 'a => 'c * 'a) => 'a => 'c * 'a)
+ (BIND::('a::type => 'b::type * 'a::type)
+ => ('b::type => 'a::type => 'c::type * 'a::type)
+ => 'a::type => 'c::type * 'a::type)
+ (%(g::'a::type => 'b::type * 'a::type)
+ f::'b::type => 'a::type => 'c::type * 'a::type.
+ (op o::('b::type * 'a::type => 'c::type * 'a::type)
+ => ('a::type => 'b::type * 'a::type)
+ => 'a::type => 'c::type * 'a::type)
+ ((split::('b::type => 'a::type => 'c::type * 'a::type)
+ => 'b::type * 'a::type => 'c::type * 'a::type)
+ f)
+ g)"
+
+lemma BIND_DEF: "(All::(('a::type => 'b::type * 'a::type) => bool) => bool)
+ (%g::'a::type => 'b::type * 'a::type.
+ (All::(('b::type => 'a::type => 'c::type * 'a::type) => bool) => bool)
+ (%f::'b::type => 'a::type => 'c::type * 'a::type.
+ (op =::('a::type => 'c::type * 'a::type)
+ => ('a::type => 'c::type * 'a::type) => bool)
+ ((BIND::('a::type => 'b::type * 'a::type)
+ => ('b::type => 'a::type => 'c::type * 'a::type)
+ => 'a::type => 'c::type * 'a::type)
g f)
- ((op o::('b * 'a => 'c * 'a) => ('a => 'b * 'a) => 'a => 'c * 'a)
- ((split::('b => 'a => 'c * 'a) => 'b * 'a => 'c * 'a) f) g)))"
+ ((op o::('b::type * 'a::type => 'c::type * 'a::type)
+ => ('a::type => 'b::type * 'a::type)
+ => 'a::type => 'c::type * 'a::type)
+ ((split::('b::type => 'a::type => 'c::type * 'a::type)
+ => 'b::type * 'a::type => 'c::type * 'a::type)
+ f)
+ g)))"
by (import state_transformer BIND_DEF)
constdefs
- MMAP :: "('c => 'b) => ('a => 'c * 'a) => 'a => 'b * 'a"
- "MMAP == %(f::'c => 'b) m::'a => 'c * 'a. BIND m (UNIT o f)"
-
-lemma MMAP_DEF: "ALL (f::'c => 'b) m::'a => 'c * 'a. MMAP f m = BIND m (UNIT o f)"
+ MMAP :: "('c::type => 'b::type)
+=> ('a::type => 'c::type * 'a::type) => 'a::type => 'b::type * 'a::type"
+ "MMAP ==
+%(f::'c::type => 'b::type) m::'a::type => 'c::type * 'a::type.
+ BIND m (UNIT o f)"
+
+lemma MMAP_DEF: "ALL (f::'c::type => 'b::type) m::'a::type => 'c::type * 'a::type.
+ MMAP f m = BIND m (UNIT o f)"
by (import state_transformer MMAP_DEF)
constdefs
- JOIN :: "('a => ('a => 'b * 'a) * 'a) => 'a => 'b * 'a"
- "JOIN == %z. BIND z I"
-
-lemma JOIN_DEF: "ALL z. JOIN z = BIND z I"
+ JOIN :: "('a::type => ('a::type => 'b::type * 'a::type) * 'a::type)
+=> 'a::type => 'b::type * 'a::type"
+ "JOIN ==
+%z::'a::type => ('a::type => 'b::type * 'a::type) * 'a::type. BIND z I"
+
+lemma JOIN_DEF: "ALL z::'a::type => ('a::type => 'b::type * 'a::type) * 'a::type.
+ JOIN z = BIND z I"
by (import state_transformer JOIN_DEF)
-lemma BIND_LEFT_UNIT: "ALL k x. BIND (UNIT x) k = k x"
+lemma BIND_LEFT_UNIT: "ALL (k::'a::type => 'b::type => 'c::type * 'b::type) x::'a::type.
+ BIND (UNIT x) k = k x"
by (import state_transformer BIND_LEFT_UNIT)
-lemma UNIT_UNCURRY: "ALL x. split UNIT x = x"
+lemma UNIT_UNCURRY: "ALL x::'a::type * 'b::type. split UNIT x = x"
by (import state_transformer UNIT_UNCURRY)
-lemma BIND_RIGHT_UNIT: "ALL k. BIND k UNIT = k"
+lemma BIND_RIGHT_UNIT: "ALL k::'a::type => 'b::type * 'a::type. BIND k UNIT = k"
by (import state_transformer BIND_RIGHT_UNIT)
-lemma BIND_ASSOC: "ALL x xa xb. BIND x (%a. BIND (xa a) xb) = BIND (BIND x xa) xb"
+lemma BIND_ASSOC: "ALL (x::'a::type => 'b::type * 'a::type)
+ (xa::'b::type => 'a::type => 'c::type * 'a::type)
+ xb::'c::type => 'a::type => 'd::type * 'a::type.
+ BIND x (%a::'b::type. BIND (xa a) xb) = BIND (BIND x xa) xb"
by (import state_transformer BIND_ASSOC)
lemma MMAP_ID: "MMAP I = I"
by (import state_transformer MMAP_ID)
-lemma MMAP_COMP: "ALL (f::'c => 'd) g::'b => 'c. MMAP (f o g) = MMAP f o MMAP g"
+lemma MMAP_COMP: "ALL (f::'c::type => 'd::type) g::'b::type => 'c::type.
+ MMAP (f o g) = MMAP f o MMAP g"
by (import state_transformer MMAP_COMP)
-lemma MMAP_UNIT: "ALL f::'b => 'c. MMAP f o UNIT = UNIT o f"
+lemma MMAP_UNIT: "ALL f::'b::type => 'c::type. MMAP f o UNIT = UNIT o f"
by (import state_transformer MMAP_UNIT)
-lemma MMAP_JOIN: "ALL f::'b => 'c. MMAP f o JOIN = JOIN o MMAP (MMAP f)"
+lemma MMAP_JOIN: "ALL f::'b::type => 'c::type. MMAP f o JOIN = JOIN o MMAP (MMAP f)"
by (import state_transformer MMAP_JOIN)
lemma JOIN_UNIT: "JOIN o UNIT = I"
@@ -4937,16 +5860,19 @@
lemma JOIN_MAP_JOIN: "JOIN o MMAP JOIN = JOIN o JOIN"
by (import state_transformer JOIN_MAP_JOIN)
-lemma JOIN_MAP: "ALL x xa. BIND x xa = JOIN (MMAP xa x)"
+lemma JOIN_MAP: "ALL (x::'a::type => 'b::type * 'a::type)
+ xa::'b::type => 'a::type => 'c::type * 'a::type.
+ BIND x xa = JOIN (MMAP xa x)"
by (import state_transformer JOIN_MAP)
-lemma FST_o_UNIT: "ALL x. fst o UNIT x = K x"
+lemma FST_o_UNIT: "ALL x::'a::type. fst o UNIT x = K x"
by (import state_transformer FST_o_UNIT)
-lemma SND_o_UNIT: "ALL x. snd o UNIT x = I"
+lemma SND_o_UNIT: "ALL x::'a::type. snd o UNIT x = I"
by (import state_transformer SND_o_UNIT)
-lemma FST_o_MMAP: "ALL x xa. fst o MMAP x xa = x o (fst o xa)"
+lemma FST_o_MMAP: "ALL (x::'a::type => 'b::type) xa::'c::type => 'a::type * 'c::type.
+ fst o MMAP x xa = x o (fst o xa)"
by (import state_transformer FST_o_MMAP)
;end_setup
--- a/src/HOL/Import/HOL/HOL4Prob.thy Mon Sep 26 02:06:44 2005 +0200
+++ b/src/HOL/Import/HOL/HOL4Prob.thy Mon Sep 26 02:27:14 2005 +0200
@@ -4,16 +4,22 @@
;setup_theory prob_extra
-lemma BOOL_BOOL_CASES_THM: "ALL f. f = (%b. False) | f = (%b. True) | f = (%b. b) | f = Not"
+lemma BOOL_BOOL_CASES_THM: "ALL f::bool => bool.
+ f = (%b::bool. False) |
+ f = (%b::bool. True) | f = (%b::bool. b) | f = Not"
by (import prob_extra BOOL_BOOL_CASES_THM)
-lemma EVEN_ODD_BASIC: "EVEN 0 & ~ EVEN 1 & EVEN 2 & ~ ODD 0 & ODD 1 & ~ ODD 2"
+lemma EVEN_ODD_BASIC: "EVEN (0::nat) &
+~ EVEN (1::nat) &
+EVEN (2::nat) & ~ ODD (0::nat) & ODD (1::nat) & ~ ODD (2::nat)"
by (import prob_extra EVEN_ODD_BASIC)
-lemma EVEN_ODD_EXISTS_EQ: "ALL n. EVEN n = (EX m. n = 2 * m) & ODD n = (EX m. n = Suc (2 * m))"
+lemma EVEN_ODD_EXISTS_EQ: "ALL n::nat.
+ EVEN n = (EX m::nat. n = (2::nat) * m) &
+ ODD n = (EX m::nat. n = Suc ((2::nat) * m))"
by (import prob_extra EVEN_ODD_EXISTS_EQ)
-lemma DIV_THEN_MULT: "ALL p q. Suc q * (p div Suc q) <= p"
+lemma DIV_THEN_MULT: "ALL (p::nat) q::nat. Suc q * (p div Suc q) <= p"
by (import prob_extra DIV_THEN_MULT)
lemma DIV_TWO_UNIQUE: "(All::(nat => bool) => bool)
@@ -62,7 +68,8 @@
lemma DIV_TWO: "ALL n::nat. n = (2::nat) * (n div (2::nat)) + n mod (2::nat)"
by (import prob_extra DIV_TWO)
-lemma MOD_TWO: "ALL n. n mod 2 = (if EVEN n then 0 else 1)"
+lemma MOD_TWO: "(ALL (n::nat).
+ ((n mod (2::nat)) = (if (EVEN n) then (0::nat) else (1::nat))))"
by (import prob_extra MOD_TWO)
lemma DIV_TWO_BASIC: "(0::nat) div (2::nat) = (0::nat) &
@@ -112,13 +119,14 @@
((op <::nat => nat => bool) m n))))"
by (import prob_extra DIV_TWO_MONO_EVEN)
-lemma DIV_TWO_CANCEL: "ALL n. 2 * n div 2 = n & Suc (2 * n) div 2 = n"
+lemma DIV_TWO_CANCEL: "ALL n::nat.
+ (2::nat) * n div (2::nat) = n & Suc ((2::nat) * n) div (2::nat) = n"
by (import prob_extra DIV_TWO_CANCEL)
lemma EXP_DIV_TWO: "ALL n::nat. (2::nat) ^ Suc n div (2::nat) = (2::nat) ^ n"
by (import prob_extra EXP_DIV_TWO)
-lemma EVEN_EXP_TWO: "ALL n. EVEN (2 ^ n) = (n ~= 0)"
+lemma EVEN_EXP_TWO: "ALL n::nat. EVEN ((2::nat) ^ n) = (n ~= (0::nat))"
by (import prob_extra EVEN_EXP_TWO)
lemma DIV_TWO_EXP: "ALL (n::nat) k::nat.
@@ -129,12 +137,12 @@
inf :: "(real => bool) => real"
defs
- inf_primdef: "inf == %P. - sup (IMAGE uminus P)"
-
-lemma inf_def: "ALL P. inf P = - sup (IMAGE uminus P)"
+ inf_primdef: "inf == %P::real => bool. - sup (IMAGE uminus P)"
+
+lemma inf_def: "ALL P::real => bool. inf P = - sup (IMAGE uminus P)"
by (import prob_extra inf_def)
-lemma INF_DEF_ALT: "ALL P. inf P = - sup (%r. P (- r))"
+lemma INF_DEF_ALT: "ALL P::real => bool. inf P = - sup (%r::real. P (- r))"
by (import prob_extra INF_DEF_ALT)
lemma REAL_SUP_EXISTS_UNIQUE: "(All::((real => bool) => bool) => bool)
@@ -275,13 +283,15 @@
lemma POW_HALF_EXP: "ALL n::nat. ((1::real) / (2::real)) ^ n = inverse (real ((2::nat) ^ n))"
by (import prob_extra POW_HALF_EXP)
-lemma INV_SUC_POS: "ALL n. 0 < 1 / real (Suc n)"
+lemma INV_SUC_POS: "ALL n::nat. (0::real) < (1::real) / real (Suc n)"
by (import prob_extra INV_SUC_POS)
-lemma INV_SUC_MAX: "ALL x. 1 / real (Suc x) <= 1"
+lemma INV_SUC_MAX: "ALL x::nat. (1::real) / real (Suc x) <= (1::real)"
by (import prob_extra INV_SUC_MAX)
-lemma INV_SUC: "ALL n. 0 < 1 / real (Suc n) & 1 / real (Suc n) <= 1"
+lemma INV_SUC: "ALL n::nat.
+ (0::real) < (1::real) / real (Suc n) &
+ (1::real) / real (Suc n) <= (1::real)"
by (import prob_extra INV_SUC)
lemma ABS_UNIT_INTERVAL: "(All::(real => bool) => bool)
@@ -301,181 +311,200 @@
(1::real))))"
by (import prob_extra ABS_UNIT_INTERVAL)
-lemma MEM_NIL: "ALL l. (ALL x. ~ x mem l) = (l = [])"
+lemma MEM_NIL: "ALL l::'a::type list. (ALL x::'a::type. ~ x mem l) = (l = [])"
by (import prob_extra MEM_NIL)
-lemma MAP_MEM: "ALL f l x. x mem map f l = (EX y. y mem l & x = f y)"
+lemma MAP_MEM: "ALL (f::'a::type => 'b::type) (l::'a::type list) x::'b::type.
+ x mem map f l = (EX y::'a::type. y mem l & x = f y)"
by (import prob_extra MAP_MEM)
-lemma MEM_NIL_MAP_CONS: "ALL x l. ~ [] mem map (op # x) l"
+lemma MEM_NIL_MAP_CONS: "ALL (x::'a::type) l::'a::type list list. ~ [] mem map (op # x) l"
by (import prob_extra MEM_NIL_MAP_CONS)
-lemma FILTER_TRUE: "ALL l. [x:l. True] = l"
+lemma FILTER_TRUE: "ALL l::'a::type list. [x::'a::type:l. True] = l"
by (import prob_extra FILTER_TRUE)
-lemma FILTER_FALSE: "ALL l. [x:l. False] = []"
+lemma FILTER_FALSE: "ALL l::'a::type list. [x::'a::type:l. False] = []"
by (import prob_extra FILTER_FALSE)
-lemma FILTER_MEM: "(All::(('a => bool) => bool) => bool)
- (%P::'a => bool.
- (All::('a => bool) => bool)
- (%x::'a.
- (All::('a list => bool) => bool)
- (%l::'a list.
+lemma FILTER_MEM: "(All::(('a::type => bool) => bool) => bool)
+ (%P::'a::type => bool.
+ (All::('a::type => bool) => bool)
+ (%x::'a::type.
+ (All::('a::type list => bool) => bool)
+ (%l::'a::type list.
(op -->::bool => bool => bool)
- ((op mem::'a => 'a list => bool) x
- ((filter::('a => bool) => 'a list => 'a list) P l))
+ ((op mem::'a::type => 'a::type list => bool) x
+ ((filter::('a::type => bool)
+ => 'a::type list => 'a::type list)
+ P l))
(P x))))"
by (import prob_extra FILTER_MEM)
-lemma MEM_FILTER: "(All::(('a => bool) => bool) => bool)
- (%P::'a => bool.
- (All::('a list => bool) => bool)
- (%l::'a list.
- (All::('a => bool) => bool)
- (%x::'a.
+lemma MEM_FILTER: "(All::(('a::type => bool) => bool) => bool)
+ (%P::'a::type => bool.
+ (All::('a::type list => bool) => bool)
+ (%l::'a::type list.
+ (All::('a::type => bool) => bool)
+ (%x::'a::type.
(op -->::bool => bool => bool)
- ((op mem::'a => 'a list => bool) x
- ((filter::('a => bool) => 'a list => 'a list) P l))
- ((op mem::'a => 'a list => bool) x l))))"
+ ((op mem::'a::type => 'a::type list => bool) x
+ ((filter::('a::type => bool)
+ => 'a::type list => 'a::type list)
+ P l))
+ ((op mem::'a::type => 'a::type list => bool) x l))))"
by (import prob_extra MEM_FILTER)
-lemma FILTER_OUT_ELT: "ALL x l. x mem l | [y:l. y ~= x] = l"
+lemma FILTER_OUT_ELT: "ALL (x::'a::type) l::'a::type list. x mem l | [y::'a::type:l. y ~= x] = l"
by (import prob_extra FILTER_OUT_ELT)
-lemma IS_PREFIX_NIL: "ALL x. IS_PREFIX x [] & IS_PREFIX [] x = (x = [])"
+lemma IS_PREFIX_NIL: "ALL x::'a::type list. IS_PREFIX x [] & IS_PREFIX [] x = (x = [])"
by (import prob_extra IS_PREFIX_NIL)
-lemma IS_PREFIX_REFL: "ALL x. IS_PREFIX x x"
+lemma IS_PREFIX_REFL: "ALL x::'a::type list. IS_PREFIX x x"
by (import prob_extra IS_PREFIX_REFL)
-lemma IS_PREFIX_ANTISYM: "(All::('a list => bool) => bool)
- (%x::'a list.
- (All::('a list => bool) => bool)
- (%y::'a list.
+lemma IS_PREFIX_ANTISYM: "(All::('a::type list => bool) => bool)
+ (%x::'a::type list.
+ (All::('a::type list => bool) => bool)
+ (%y::'a::type list.
(op -->::bool => bool => bool)
((op &::bool => bool => bool)
- ((IS_PREFIX::'a list => 'a list => bool) y x)
- ((IS_PREFIX::'a list => 'a list => bool) x y))
- ((op =::'a list => 'a list => bool) x y)))"
+ ((IS_PREFIX::'a::type list => 'a::type list => bool) y x)
+ ((IS_PREFIX::'a::type list => 'a::type list => bool) x y))
+ ((op =::'a::type list => 'a::type list => bool) x y)))"
by (import prob_extra IS_PREFIX_ANTISYM)
-lemma IS_PREFIX_TRANS: "(All::('a list => bool) => bool)
- (%x::'a list.
- (All::('a list => bool) => bool)
- (%y::'a list.
- (All::('a list => bool) => bool)
- (%z::'a list.
+lemma IS_PREFIX_TRANS: "(All::('a::type list => bool) => bool)
+ (%x::'a::type list.
+ (All::('a::type list => bool) => bool)
+ (%y::'a::type list.
+ (All::('a::type list => bool) => bool)
+ (%z::'a::type list.
(op -->::bool => bool => bool)
((op &::bool => bool => bool)
- ((IS_PREFIX::'a list => 'a list => bool) x y)
- ((IS_PREFIX::'a list => 'a list => bool) y z))
- ((IS_PREFIX::'a list => 'a list => bool) x z))))"
+ ((IS_PREFIX::'a::type list => 'a::type list => bool) x y)
+ ((IS_PREFIX::'a::type list => 'a::type list => bool) y z))
+ ((IS_PREFIX::'a::type list => 'a::type list => bool) x z))))"
by (import prob_extra IS_PREFIX_TRANS)
-lemma IS_PREFIX_BUTLAST: "ALL x y. IS_PREFIX (x # y) (butlast (x # y))"
+lemma IS_PREFIX_BUTLAST: "ALL (x::'a::type) y::'a::type list. IS_PREFIX (x # y) (butlast (x # y))"
by (import prob_extra IS_PREFIX_BUTLAST)
-lemma IS_PREFIX_LENGTH: "(All::('a list => bool) => bool)
- (%x::'a list.
- (All::('a list => bool) => bool)
- (%y::'a list.
+lemma IS_PREFIX_LENGTH: "(All::('a::type list => bool) => bool)
+ (%x::'a::type list.
+ (All::('a::type list => bool) => bool)
+ (%y::'a::type list.
(op -->::bool => bool => bool)
- ((IS_PREFIX::'a list => 'a list => bool) y x)
- ((op <=::nat => nat => bool) ((size::'a list => nat) x)
- ((size::'a list => nat) y))))"
+ ((IS_PREFIX::'a::type list => 'a::type list => bool) y x)
+ ((op <=::nat => nat => bool) ((size::'a::type list => nat) x)
+ ((size::'a::type list => nat) y))))"
by (import prob_extra IS_PREFIX_LENGTH)
-lemma IS_PREFIX_LENGTH_ANTI: "(All::('a list => bool) => bool)
- (%x::'a list.
- (All::('a list => bool) => bool)
- (%y::'a list.
+lemma IS_PREFIX_LENGTH_ANTI: "(All::('a::type list => bool) => bool)
+ (%x::'a::type list.
+ (All::('a::type list => bool) => bool)
+ (%y::'a::type list.
(op -->::bool => bool => bool)
((op &::bool => bool => bool)
- ((IS_PREFIX::'a list => 'a list => bool) y x)
- ((op =::nat => nat => bool) ((size::'a list => nat) x)
- ((size::'a list => nat) y)))
- ((op =::'a list => 'a list => bool) x y)))"
+ ((IS_PREFIX::'a::type list => 'a::type list => bool) y x)
+ ((op =::nat => nat => bool) ((size::'a::type list => nat) x)
+ ((size::'a::type list => nat) y)))
+ ((op =::'a::type list => 'a::type list => bool) x y)))"
by (import prob_extra IS_PREFIX_LENGTH_ANTI)
-lemma IS_PREFIX_SNOC: "ALL x y z. IS_PREFIX (SNOC x y) z = (IS_PREFIX y z | z = SNOC x y)"
+lemma IS_PREFIX_SNOC: "ALL (x::'a::type) (y::'a::type list) z::'a::type list.
+ IS_PREFIX (SNOC x y) z = (IS_PREFIX y z | z = SNOC x y)"
by (import prob_extra IS_PREFIX_SNOC)
-lemma FOLDR_MAP: "ALL (f::'b => 'c => 'c) (e::'c) (g::'a => 'b) l::'a list.
- foldr f (map g l) e = foldr (%x::'a. f (g x)) l e"
+lemma FOLDR_MAP: "ALL (f::'b::type => 'c::type => 'c::type) (e::'c::type)
+ (g::'a::type => 'b::type) l::'a::type list.
+ foldr f (map g l) e = foldr (%x::'a::type. f (g x)) l e"
by (import prob_extra FOLDR_MAP)
-lemma LAST_MEM: "ALL h t. last (h # t) mem h # t"
+lemma LAST_MEM: "ALL (h::'a::type) t::'a::type list. last (h # t) mem h # t"
by (import prob_extra LAST_MEM)
lemma LAST_MAP_CONS: "ALL (b::bool) (h::bool list) t::bool list list.
EX x::bool list. last (map (op # b) (h # t)) = b # x"
by (import prob_extra LAST_MAP_CONS)
-lemma EXISTS_LONGEST: "(All::('a list => bool) => bool)
- (%x::'a list.
- (All::('a list list => bool) => bool)
- (%y::'a list list.
- (Ex::('a list => bool) => bool)
- (%z::'a list.
+lemma EXISTS_LONGEST: "(All::('a::type list => bool) => bool)
+ (%x::'a::type list.
+ (All::('a::type list list => bool) => bool)
+ (%y::'a::type list list.
+ (Ex::('a::type list => bool) => bool)
+ (%z::'a::type list.
(op &::bool => bool => bool)
- ((op mem::'a list => 'a list list => bool) z
- ((op #::'a list => 'a list list => 'a list list) x y))
- ((All::('a list => bool) => bool)
- (%w::'a list.
+ ((op mem::'a::type list => 'a::type list list => bool) z
+ ((op #::'a::type list
+ => 'a::type list list => 'a::type list list)
+ x y))
+ ((All::('a::type list => bool) => bool)
+ (%w::'a::type list.
(op -->::bool => bool => bool)
- ((op mem::'a list => 'a list list => bool) w
- ((op #::'a list => 'a list list => 'a list list) x
- y))
+ ((op mem::'a::type list
+ => 'a::type list list => bool)
+ w ((op #::'a::type list
+ => 'a::type list list
+=> 'a::type list list)
+ x y))
((op <=::nat => nat => bool)
- ((size::'a list => nat) w)
- ((size::'a list => nat) z)))))))"
+ ((size::'a::type list => nat) w)
+ ((size::'a::type list => nat) z)))))))"
by (import prob_extra EXISTS_LONGEST)
-lemma UNION_DEF_ALT: "ALL s t. pred_set.UNION s t = (%x. s x | t x)"
+lemma UNION_DEF_ALT: "ALL (s::'a::type => bool) t::'a::type => bool.
+ pred_set.UNION s t = (%x::'a::type. s x | t x)"
by (import prob_extra UNION_DEF_ALT)
-lemma INTER_UNION_RDISTRIB: "ALL p q r.
+lemma INTER_UNION_RDISTRIB: "ALL (p::'a::type => bool) (q::'a::type => bool) r::'a::type => bool.
pred_set.INTER (pred_set.UNION p q) r =
pred_set.UNION (pred_set.INTER p r) (pred_set.INTER q r)"
by (import prob_extra INTER_UNION_RDISTRIB)
-lemma SUBSET_EQ: "ALL x xa. (x = xa) = (SUBSET x xa & SUBSET xa x)"
+lemma SUBSET_EQ: "ALL (x::'a::type => bool) xa::'a::type => bool.
+ (x = xa) = (SUBSET x xa & SUBSET xa x)"
by (import prob_extra SUBSET_EQ)
-lemma INTER_IS_EMPTY: "ALL s t. (pred_set.INTER s t = EMPTY) = (ALL x. ~ s x | ~ t x)"
+lemma INTER_IS_EMPTY: "ALL (s::'a::type => bool) t::'a::type => bool.
+ (pred_set.INTER s t = EMPTY) = (ALL x::'a::type. ~ s x | ~ t x)"
by (import prob_extra INTER_IS_EMPTY)
-lemma UNION_DISJOINT_SPLIT: "(All::(('a => bool) => bool) => bool)
- (%s::'a => bool.
- (All::(('a => bool) => bool) => bool)
- (%t::'a => bool.
- (All::(('a => bool) => bool) => bool)
- (%u::'a => bool.
+lemma UNION_DISJOINT_SPLIT: "(All::(('a::type => bool) => bool) => bool)
+ (%s::'a::type => bool.
+ (All::(('a::type => bool) => bool) => bool)
+ (%t::'a::type => bool.
+ (All::(('a::type => bool) => bool) => bool)
+ (%u::'a::type => bool.
(op -->::bool => bool => bool)
((op &::bool => bool => bool)
- ((op =::('a => bool) => ('a => bool) => bool)
- ((pred_set.UNION::('a => bool)
-=> ('a => bool) => 'a => bool)
+ ((op =::('a::type => bool) => ('a::type => bool) => bool)
+ ((pred_set.UNION::('a::type => bool)
+=> ('a::type => bool) => 'a::type => bool)
s t)
- ((pred_set.UNION::('a => bool)
-=> ('a => bool) => 'a => bool)
+ ((pred_set.UNION::('a::type => bool)
+=> ('a::type => bool) => 'a::type => bool)
s u))
((op &::bool => bool => bool)
- ((op =::('a => bool) => ('a => bool) => bool)
- ((pred_set.INTER::('a => bool)
- => ('a => bool) => 'a => bool)
+ ((op =::('a::type => bool)
+ => ('a::type => bool) => bool)
+ ((pred_set.INTER::('a::type => bool)
+ => ('a::type => bool) => 'a::type => bool)
s t)
- (EMPTY::'a => bool))
- ((op =::('a => bool) => ('a => bool) => bool)
- ((pred_set.INTER::('a => bool)
- => ('a => bool) => 'a => bool)
+ (EMPTY::'a::type => bool))
+ ((op =::('a::type => bool)
+ => ('a::type => bool) => bool)
+ ((pred_set.INTER::('a::type => bool)
+ => ('a::type => bool) => 'a::type => bool)
s u)
- (EMPTY::'a => bool))))
- ((op =::('a => bool) => ('a => bool) => bool) t u))))"
+ (EMPTY::'a::type => bool))))
+ ((op =::('a::type => bool) => ('a::type => bool) => bool) t
+ u))))"
by (import prob_extra UNION_DISJOINT_SPLIT)
-lemma GSPEC_DEF_ALT: "ALL f. GSPEC f = (%v. EX x. (v, True) = f x)"
+lemma GSPEC_DEF_ALT: "ALL f::'a::type => 'b::type * bool.
+ GSPEC f = (%v::'b::type. EX x::'a::type. (v, True) = f x)"
by (import prob_extra GSPEC_DEF_ALT)
;end_setup
@@ -486,9 +515,12 @@
alg_twin :: "bool list => bool list => bool"
defs
- alg_twin_primdef: "alg_twin == %x y. EX l. x = SNOC True l & y = SNOC False l"
-
-lemma alg_twin_def: "ALL x y. alg_twin x y = (EX l. x = SNOC True l & y = SNOC False l)"
+ alg_twin_primdef: "alg_twin ==
+%(x::bool list) y::bool list.
+ EX l::bool list. x = SNOC True l & y = SNOC False l"
+
+lemma alg_twin_def: "ALL (x::bool list) y::bool list.
+ alg_twin x y = (EX l::bool list. x = SNOC True l & y = SNOC False l)"
by (import prob_canon alg_twin_def)
constdefs
@@ -618,9 +650,9 @@
alg_order :: "bool list => bool list => bool"
defs
- alg_order_primdef: "alg_order == %x x1. alg_order_tupled (x, x1)"
-
-lemma alg_order_curried_def: "ALL x x1. alg_order x x1 = alg_order_tupled (x, x1)"
+ alg_order_primdef: "alg_order == %(x::bool list) x1::bool list. alg_order_tupled (x, x1)"
+
+lemma alg_order_curried_def: "ALL (x::bool list) x1::bool list. alg_order x x1 = alg_order_tupled (x, x1)"
by (import prob_canon alg_order_curried_def)
lemma alg_order_ind: "(All::((bool list => bool list => bool) => bool) => bool)
@@ -658,10 +690,10 @@
(%x::bool list. (All::(bool list => bool) => bool) (P x))))"
by (import prob_canon alg_order_ind)
-lemma alg_order_def: "alg_order [] (v6 # v7) = True &
+lemma alg_order_def: "alg_order [] ((v6::bool) # (v7::bool list)) = True &
alg_order [] [] = True &
-alg_order (v2 # v3) [] = False &
-alg_order (h # t) (h' # t') =
+alg_order ((v2::bool) # (v3::bool list)) [] = False &
+alg_order ((h::bool) # (t::bool list)) ((h'::bool) # (t'::bool list)) =
(h = True & h' = False | h = h' & alg_order t t')"
by (import prob_canon alg_order_def)
@@ -670,18 +702,30 @@
defs
alg_sorted_primdef: "alg_sorted ==
-WFREC (SOME R. WF R & (ALL x z y. R (y # z) (x # y # z)))
- (%alg_sorted.
+WFREC
+ (SOME R::bool list list => bool list list => bool.
+ WF R &
+ (ALL (x::bool list) (z::bool list list) y::bool list.
+ R (y # z) (x # y # z)))
+ (%alg_sorted::bool list list => bool.
list_case True
- (%v2. list_case True
- (%v6 v7. alg_order v2 v6 & alg_sorted (v6 # v7))))"
+ (%v2::bool list.
+ list_case True
+ (%(v6::bool list) v7::bool list list.
+ alg_order v2 v6 & alg_sorted (v6 # v7))))"
lemma alg_sorted_primitive_def: "alg_sorted =
-WFREC (SOME R. WF R & (ALL x z y. R (y # z) (x # y # z)))
- (%alg_sorted.
+WFREC
+ (SOME R::bool list list => bool list list => bool.
+ WF R &
+ (ALL (x::bool list) (z::bool list list) y::bool list.
+ R (y # z) (x # y # z)))
+ (%alg_sorted::bool list list => bool.
list_case True
- (%v2. list_case True
- (%v6 v7. alg_order v2 v6 & alg_sorted (v6 # v7))))"
+ (%v2::bool list.
+ list_case True
+ (%(v6::bool list) v7::bool list list.
+ alg_order v2 v6 & alg_sorted (v6 # v7))))"
by (import prob_canon alg_sorted_primitive_def)
lemma alg_sorted_ind: "(All::((bool list list => bool) => bool) => bool)
@@ -712,8 +756,9 @@
((All::(bool list list => bool) => bool) P))"
by (import prob_canon alg_sorted_ind)
-lemma alg_sorted_def: "alg_sorted (x # y # z) = (alg_order x y & alg_sorted (y # z)) &
-alg_sorted [v] = True & alg_sorted [] = True"
+lemma alg_sorted_def: "alg_sorted ((x::bool list) # (y::bool list) # (z::bool list list)) =
+(alg_order x y & alg_sorted (y # z)) &
+alg_sorted [v::bool list] = True & alg_sorted [] = True"
by (import prob_canon alg_sorted_def)
consts
@@ -721,18 +766,30 @@
defs
alg_prefixfree_primdef: "alg_prefixfree ==
-WFREC (SOME R. WF R & (ALL x z y. R (y # z) (x # y # z)))
- (%alg_prefixfree.
+WFREC
+ (SOME R::bool list list => bool list list => bool.
+ WF R &
+ (ALL (x::bool list) (z::bool list list) y::bool list.
+ R (y # z) (x # y # z)))
+ (%alg_prefixfree::bool list list => bool.
list_case True
- (%v2. list_case True
- (%v6 v7. ~ IS_PREFIX v6 v2 & alg_prefixfree (v6 # v7))))"
+ (%v2::bool list.
+ list_case True
+ (%(v6::bool list) v7::bool list list.
+ ~ IS_PREFIX v6 v2 & alg_prefixfree (v6 # v7))))"
lemma alg_prefixfree_primitive_def: "alg_prefixfree =
-WFREC (SOME R. WF R & (ALL x z y. R (y # z) (x # y # z)))
- (%alg_prefixfree.
+WFREC
+ (SOME R::bool list list => bool list list => bool.
+ WF R &
+ (ALL (x::bool list) (z::bool list list) y::bool list.
+ R (y # z) (x # y # z)))
+ (%alg_prefixfree::bool list list => bool.
list_case True
- (%v2. list_case True
- (%v6 v7. ~ IS_PREFIX v6 v2 & alg_prefixfree (v6 # v7))))"
+ (%v2::bool list.
+ list_case True
+ (%(v6::bool list) v7::bool list list.
+ ~ IS_PREFIX v6 v2 & alg_prefixfree (v6 # v7))))"
by (import prob_canon alg_prefixfree_primitive_def)
lemma alg_prefixfree_ind: "(All::((bool list list => bool) => bool) => bool)
@@ -763,8 +820,9 @@
((All::(bool list list => bool) => bool) P))"
by (import prob_canon alg_prefixfree_ind)
-lemma alg_prefixfree_def: "alg_prefixfree (x # y # z) = (~ IS_PREFIX y x & alg_prefixfree (y # z)) &
-alg_prefixfree [v] = True & alg_prefixfree [] = True"
+lemma alg_prefixfree_def: "alg_prefixfree ((x::bool list) # (y::bool list) # (z::bool list list)) =
+(~ IS_PREFIX y x & alg_prefixfree (y # z)) &
+alg_prefixfree [v::bool list] = True & alg_prefixfree [] = True"
by (import prob_canon alg_prefixfree_def)
consts
@@ -772,18 +830,30 @@
defs
alg_twinfree_primdef: "alg_twinfree ==
-WFREC (SOME R. WF R & (ALL x z y. R (y # z) (x # y # z)))
- (%alg_twinfree.
+WFREC
+ (SOME R::bool list list => bool list list => bool.
+ WF R &
+ (ALL (x::bool list) (z::bool list list) y::bool list.
+ R (y # z) (x # y # z)))
+ (%alg_twinfree::bool list list => bool.
list_case True
- (%v2. list_case True
- (%v6 v7. ~ alg_twin v2 v6 & alg_twinfree (v6 # v7))))"
+ (%v2::bool list.
+ list_case True
+ (%(v6::bool list) v7::bool list list.
+ ~ alg_twin v2 v6 & alg_twinfree (v6 # v7))))"
lemma alg_twinfree_primitive_def: "alg_twinfree =
-WFREC (SOME R. WF R & (ALL x z y. R (y # z) (x # y # z)))
- (%alg_twinfree.
+WFREC
+ (SOME R::bool list list => bool list list => bool.
+ WF R &
+ (ALL (x::bool list) (z::bool list list) y::bool list.
+ R (y # z) (x # y # z)))
+ (%alg_twinfree::bool list list => bool.
list_case True
- (%v2. list_case True
- (%v6 v7. ~ alg_twin v2 v6 & alg_twinfree (v6 # v7))))"
+ (%v2::bool list.
+ list_case True
+ (%(v6::bool list) v7::bool list list.
+ ~ alg_twin v2 v6 & alg_twinfree (v6 # v7))))"
by (import prob_canon alg_twinfree_primitive_def)
lemma alg_twinfree_ind: "(All::((bool list list => bool) => bool) => bool)
@@ -814,24 +884,29 @@
((All::(bool list list => bool) => bool) P))"
by (import prob_canon alg_twinfree_ind)
-lemma alg_twinfree_def: "alg_twinfree (x # y # z) = (~ alg_twin x y & alg_twinfree (y # z)) &
-alg_twinfree [v] = True & alg_twinfree [] = True"
+lemma alg_twinfree_def: "alg_twinfree ((x::bool list) # (y::bool list) # (z::bool list list)) =
+(~ alg_twin x y & alg_twinfree (y # z)) &
+alg_twinfree [v::bool list] = True & alg_twinfree [] = True"
by (import prob_canon alg_twinfree_def)
consts
alg_longest :: "bool list list => nat"
defs
- alg_longest_primdef: "alg_longest == FOLDR (%h t. if t <= length h then length h else t) 0"
-
-lemma alg_longest_def: "alg_longest = FOLDR (%h t. if t <= length h then length h else t) 0"
+ alg_longest_primdef: "alg_longest ==
+FOLDR (%(h::bool list) t::nat. if t <= length h then length h else t)
+ (0::nat)"
+
+lemma alg_longest_def: "alg_longest =
+FOLDR (%(h::bool list) t::nat. if t <= length h then length h else t)
+ (0::nat)"
by (import prob_canon alg_longest_def)
consts
alg_canon_prefs :: "bool list => bool list list => bool list list"
-specification (alg_canon_prefs_primdef: alg_canon_prefs) alg_canon_prefs_def: "(ALL l. alg_canon_prefs l [] = [l]) &
-(ALL l h t.
+specification (alg_canon_prefs_primdef: alg_canon_prefs) alg_canon_prefs_def: "(ALL l::bool list. alg_canon_prefs l [] = [l]) &
+(ALL (l::bool list) (h::bool list) t::bool list list.
alg_canon_prefs l (h # t) =
(if IS_PREFIX h l then alg_canon_prefs l t else l # h # t))"
by (import prob_canon alg_canon_prefs_def)
@@ -839,8 +914,8 @@
consts
alg_canon_find :: "bool list => bool list list => bool list list"
-specification (alg_canon_find_primdef: alg_canon_find) alg_canon_find_def: "(ALL l. alg_canon_find l [] = [l]) &
-(ALL l h t.
+specification (alg_canon_find_primdef: alg_canon_find) alg_canon_find_def: "(ALL l::bool list. alg_canon_find l [] = [l]) &
+(ALL (l::bool list) (h::bool list) t::bool list list.
alg_canon_find l (h # t) =
(if alg_order h l
then if IS_PREFIX l h then h # t else h # alg_canon_find l t
@@ -859,8 +934,8 @@
consts
alg_canon_merge :: "bool list => bool list list => bool list list"
-specification (alg_canon_merge_primdef: alg_canon_merge) alg_canon_merge_def: "(ALL l. alg_canon_merge l [] = [l]) &
-(ALL l h t.
+specification (alg_canon_merge_primdef: alg_canon_merge) alg_canon_merge_def: "(ALL l::bool list. alg_canon_merge l [] = [l]) &
+(ALL (l::bool list) (h::bool list) t::bool list list.
alg_canon_merge l (h # t) =
(if alg_twin l h then alg_canon_merge (butlast h) t else l # h # t))"
by (import prob_canon alg_canon_merge_def)
@@ -878,34 +953,35 @@
alg_canon :: "bool list list => bool list list"
defs
- alg_canon_primdef: "alg_canon == %l. alg_canon2 (alg_canon1 l)"
-
-lemma alg_canon_def: "ALL l. alg_canon l = alg_canon2 (alg_canon1 l)"
+ alg_canon_primdef: "alg_canon == %l::bool list list. alg_canon2 (alg_canon1 l)"
+
+lemma alg_canon_def: "ALL l::bool list list. alg_canon l = alg_canon2 (alg_canon1 l)"
by (import prob_canon alg_canon_def)
consts
algebra_canon :: "bool list list => bool"
defs
- algebra_canon_primdef: "algebra_canon == %l. alg_canon l = l"
-
-lemma algebra_canon_def: "ALL l. algebra_canon l = (alg_canon l = l)"
+ algebra_canon_primdef: "algebra_canon == %l::bool list list. alg_canon l = l"
+
+lemma algebra_canon_def: "ALL l::bool list list. algebra_canon l = (alg_canon l = l)"
by (import prob_canon algebra_canon_def)
-lemma ALG_TWIN_NIL: "ALL l. ~ alg_twin l [] & ~ alg_twin [] l"
+lemma ALG_TWIN_NIL: "ALL l::bool list. ~ alg_twin l [] & ~ alg_twin [] l"
by (import prob_canon ALG_TWIN_NIL)
-lemma ALG_TWIN_SING: "ALL x l.
+lemma ALG_TWIN_SING: "ALL (x::bool) l::bool list.
alg_twin [x] l = (x = True & l = [False]) &
alg_twin l [x] = (l = [True] & x = False)"
by (import prob_canon ALG_TWIN_SING)
-lemma ALG_TWIN_CONS: "ALL x y z h t.
+lemma ALG_TWIN_CONS: "ALL (x::bool) (y::bool) (z::bool list) (h::bool) t::bool list.
alg_twin (x # y # z) (h # t) = (x = h & alg_twin (y # z) t) &
alg_twin (h # t) (x # y # z) = (x = h & alg_twin t (y # z))"
by (import prob_canon ALG_TWIN_CONS)
-lemma ALG_TWIN_REDUCE: "ALL h t t'. alg_twin (h # t) (h # t') = alg_twin t t'"
+lemma ALG_TWIN_REDUCE: "ALL (h::bool) (t::bool list) t'::bool list.
+ alg_twin (h # t) (h # t') = alg_twin t t'"
by (import prob_canon ALG_TWIN_REDUCE)
lemma ALG_TWINS_PREFIX: "(All::(bool list => bool) => bool)
@@ -924,10 +1000,10 @@
l))))))"
by (import prob_canon ALG_TWINS_PREFIX)
-lemma ALG_ORDER_NIL: "ALL x. alg_order [] x & alg_order x [] = (x = [])"
+lemma ALG_ORDER_NIL: "ALL x::bool list. alg_order [] x & alg_order x [] = (x = [])"
by (import prob_canon ALG_ORDER_NIL)
-lemma ALG_ORDER_REFL: "ALL x. alg_order x x"
+lemma ALG_ORDER_REFL: "ALL x::bool list. alg_order x x"
by (import prob_canon ALG_ORDER_REFL)
lemma ALG_ORDER_ANTISYM: "(All::(bool list => bool) => bool)
@@ -954,7 +1030,7 @@
((alg_order::bool list => bool list => bool) x z))))"
by (import prob_canon ALG_ORDER_TRANS)
-lemma ALG_ORDER_TOTAL: "ALL x y. alg_order x y | alg_order y x"
+lemma ALG_ORDER_TOTAL: "ALL (x::bool list) y::bool list. alg_order x y | alg_order y x"
by (import prob_canon ALG_ORDER_TOTAL)
lemma ALG_ORDER_PREFIX: "(All::(bool list => bool) => bool)
@@ -1007,7 +1083,7 @@
((IS_PREFIX::bool list => bool list => bool) x z)))))"
by (import prob_canon ALG_ORDER_PREFIX_TRANS)
-lemma ALG_ORDER_SNOC: "ALL x l. ~ alg_order (SNOC x l) l"
+lemma ALG_ORDER_SNOC: "ALL (x::bool) l::bool list. ~ alg_order (SNOC x l) l"
by (import prob_canon ALG_ORDER_SNOC)
lemma ALG_SORTED_MIN: "(All::(bool list => bool) => bool)
@@ -1066,15 +1142,15 @@
z)))))"
by (import prob_canon ALG_SORTED_MONO)
-lemma ALG_SORTED_TLS: "ALL l b. alg_sorted (map (op # b) l) = alg_sorted l"
+lemma ALG_SORTED_TLS: "ALL (l::bool list list) b::bool. alg_sorted (map (op # b) l) = alg_sorted l"
by (import prob_canon ALG_SORTED_TLS)
-lemma ALG_SORTED_STEP: "ALL l1 l2.
+lemma ALG_SORTED_STEP: "ALL (l1::bool list list) l2::bool list list.
alg_sorted (map (op # True) l1 @ map (op # False) l2) =
(alg_sorted l1 & alg_sorted l2)"
by (import prob_canon ALG_SORTED_STEP)
-lemma ALG_SORTED_APPEND: "ALL h h' t t'.
+lemma ALG_SORTED_APPEND: "ALL (h::bool list) (h'::bool list) (t::bool list list) t'::bool list list.
alg_sorted ((h # t) @ h' # t') =
(alg_sorted (h # t) & alg_sorted (h' # t') & alg_order (last (h # t)) h')"
by (import prob_canon ALG_SORTED_APPEND)
@@ -1144,15 +1220,16 @@
x)))))))"
by (import prob_canon ALG_PREFIXFREE_ELT)
-lemma ALG_PREFIXFREE_TLS: "ALL l b. alg_prefixfree (map (op # b) l) = alg_prefixfree l"
+lemma ALG_PREFIXFREE_TLS: "ALL (l::bool list list) b::bool.
+ alg_prefixfree (map (op # b) l) = alg_prefixfree l"
by (import prob_canon ALG_PREFIXFREE_TLS)
-lemma ALG_PREFIXFREE_STEP: "ALL l1 l2.
+lemma ALG_PREFIXFREE_STEP: "ALL (l1::bool list list) l2::bool list list.
alg_prefixfree (map (op # True) l1 @ map (op # False) l2) =
(alg_prefixfree l1 & alg_prefixfree l2)"
by (import prob_canon ALG_PREFIXFREE_STEP)
-lemma ALG_PREFIXFREE_APPEND: "ALL h h' t t'.
+lemma ALG_PREFIXFREE_APPEND: "ALL (h::bool list) (h'::bool list) (t::bool list list) t'::bool list list.
alg_prefixfree ((h # t) @ h' # t') =
(alg_prefixfree (h # t) &
alg_prefixfree (h' # t') & ~ IS_PREFIX h' (last (h # t)))"
@@ -1182,7 +1259,8 @@
((alg_twinfree::bool list list => bool) t)))"
by (import prob_canon ALG_TWINFREE_TL)
-lemma ALG_TWINFREE_TLS: "ALL l b. alg_twinfree (map (op # b) l) = alg_twinfree l"
+lemma ALG_TWINFREE_TLS: "ALL (l::bool list list) b::bool.
+ alg_twinfree (map (op # b) l) = alg_twinfree l"
by (import prob_canon ALG_TWINFREE_TLS)
lemma ALG_TWINFREE_STEP1: "(All::(bool list list => bool) => bool)
@@ -1258,21 +1336,22 @@
((alg_twinfree::bool list list => bool) l2)))))"
by (import prob_canon ALG_TWINFREE_STEP)
-lemma ALG_LONGEST_HD: "ALL h t. length h <= alg_longest (h # t)"
+lemma ALG_LONGEST_HD: "ALL (h::bool list) t::bool list list. length h <= alg_longest (h # t)"
by (import prob_canon ALG_LONGEST_HD)
-lemma ALG_LONGEST_TL: "ALL h t. alg_longest t <= alg_longest (h # t)"
+lemma ALG_LONGEST_TL: "ALL (h::bool list) t::bool list list. alg_longest t <= alg_longest (h # t)"
by (import prob_canon ALG_LONGEST_TL)
-lemma ALG_LONGEST_TLS: "ALL h t b. alg_longest (map (op # b) (h # t)) = Suc (alg_longest (h # t))"
+lemma ALG_LONGEST_TLS: "ALL (h::bool list) (t::bool list list) b::bool.
+ alg_longest (map (op # b) (h # t)) = Suc (alg_longest (h # t))"
by (import prob_canon ALG_LONGEST_TLS)
-lemma ALG_LONGEST_APPEND: "ALL l1 l2.
+lemma ALG_LONGEST_APPEND: "ALL (l1::bool list list) l2::bool list list.
alg_longest l1 <= alg_longest (l1 @ l2) &
alg_longest l2 <= alg_longest (l1 @ l2)"
by (import prob_canon ALG_LONGEST_APPEND)
-lemma ALG_CANON_PREFS_HD: "ALL l b. hd (alg_canon_prefs l b) = l"
+lemma ALG_CANON_PREFS_HD: "ALL (l::bool list) b::bool list list. hd (alg_canon_prefs l b) = l"
by (import prob_canon ALG_CANON_PREFS_HD)
lemma ALG_CANON_PREFS_DELETES: "(All::(bool list => bool) => bool)
@@ -1332,7 +1411,7 @@
((op #::bool list => bool list list => bool list list) l b))))"
by (import prob_canon ALG_CANON_PREFS_CONSTANT)
-lemma ALG_CANON_FIND_HD: "ALL l h t.
+lemma ALG_CANON_FIND_HD: "ALL (l::bool list) (h::bool list) t::bool list list.
hd (alg_canon_find l (h # t)) = l | hd (alg_canon_find l (h # t)) = h"
by (import prob_canon ALG_CANON_FIND_HD)
@@ -1395,10 +1474,10 @@
((op #::bool list => bool list list => bool list list) l b))))"
by (import prob_canon ALG_CANON_FIND_CONSTANT)
-lemma ALG_CANON1_SORTED: "ALL x. alg_sorted (alg_canon1 x)"
+lemma ALG_CANON1_SORTED: "ALL x::bool list list. alg_sorted (alg_canon1 x)"
by (import prob_canon ALG_CANON1_SORTED)
-lemma ALG_CANON1_PREFIXFREE: "ALL l. alg_prefixfree (alg_canon1 l)"
+lemma ALG_CANON1_PREFIXFREE: "ALL l::bool list list. alg_prefixfree (alg_canon1 l)"
by (import prob_canon ALG_CANON1_PREFIXFREE)
lemma ALG_CANON1_CONSTANT: "(All::(bool list list => bool) => bool)
@@ -1577,7 +1656,7 @@
((alg_canon2::bool list list => bool list list) l) l))"
by (import prob_canon ALG_CANON2_CONSTANT)
-lemma ALG_CANON_SORTED_PREFIXFREE_TWINFREE: "ALL l.
+lemma ALG_CANON_SORTED_PREFIXFREE_TWINFREE: "ALL l::bool list list.
alg_sorted (alg_canon l) &
alg_prefixfree (alg_canon l) & alg_twinfree (alg_canon l)"
by (import prob_canon ALG_CANON_SORTED_PREFIXFREE_TWINFREE)
@@ -1593,16 +1672,19 @@
((alg_canon::bool list list => bool list list) l) l))"
by (import prob_canon ALG_CANON_CONSTANT)
-lemma ALG_CANON_IDEMPOT: "ALL l. alg_canon (alg_canon l) = alg_canon l"
+lemma ALG_CANON_IDEMPOT: "ALL l::bool list list. alg_canon (alg_canon l) = alg_canon l"
by (import prob_canon ALG_CANON_IDEMPOT)
-lemma ALGEBRA_CANON_DEF_ALT: "ALL l. algebra_canon l = (alg_sorted l & alg_prefixfree l & alg_twinfree l)"
+lemma ALGEBRA_CANON_DEF_ALT: "ALL l::bool list list.
+ algebra_canon l = (alg_sorted l & alg_prefixfree l & alg_twinfree l)"
by (import prob_canon ALGEBRA_CANON_DEF_ALT)
-lemma ALGEBRA_CANON_BASIC: "algebra_canon [] & algebra_canon [[]] & (ALL x. algebra_canon [x])"
+lemma ALGEBRA_CANON_BASIC: "algebra_canon [] &
+algebra_canon [[]] & (ALL x::bool list. algebra_canon [x])"
by (import prob_canon ALGEBRA_CANON_BASIC)
-lemma ALG_CANON_BASIC: "alg_canon [] = [] & alg_canon [[]] = [[]] & (ALL x. alg_canon [x] = [x])"
+lemma ALG_CANON_BASIC: "alg_canon [] = [] &
+alg_canon [[]] = [[]] & (ALL x::bool list. alg_canon [x] = [x])"
by (import prob_canon ALG_CANON_BASIC)
lemma ALGEBRA_CANON_TL: "(All::(bool list => bool) => bool)
@@ -1615,10 +1697,11 @@
((algebra_canon::bool list list => bool) t)))"
by (import prob_canon ALGEBRA_CANON_TL)
-lemma ALGEBRA_CANON_NIL_MEM: "ALL l. (algebra_canon l & [] mem l) = (l = [[]])"
+lemma ALGEBRA_CANON_NIL_MEM: "ALL l::bool list list. (algebra_canon l & [] mem l) = (l = [[]])"
by (import prob_canon ALGEBRA_CANON_NIL_MEM)
-lemma ALGEBRA_CANON_TLS: "ALL l b. algebra_canon (map (op # b) l) = algebra_canon l"
+lemma ALGEBRA_CANON_TLS: "ALL (l::bool list list) b::bool.
+ algebra_canon (map (op # b) l) = algebra_canon l"
by (import prob_canon ALGEBRA_CANON_TLS)
lemma ALGEBRA_CANON_STEP1: "(All::(bool list list => bool) => bool)
@@ -1828,10 +1911,12 @@
((algebra_canon::bool list list => bool) l) (P l))))"
by (import prob_canon ALGEBRA_CANON_INDUCTION)
-lemma MEM_NIL_STEP: "ALL l1 l2. ~ [] mem map (op # True) l1 @ map (op # False) l2"
+lemma MEM_NIL_STEP: "ALL (l1::bool list list) l2::bool list list.
+ ~ [] mem map (op # True) l1 @ map (op # False) l2"
by (import prob_canon MEM_NIL_STEP)
-lemma ALG_SORTED_PREFIXFREE_MEM_NIL: "ALL l. (alg_sorted l & alg_prefixfree l & [] mem l) = (l = [[]])"
+lemma ALG_SORTED_PREFIXFREE_MEM_NIL: "ALL l::bool list list.
+ (alg_sorted l & alg_prefixfree l & [] mem l) = (l = [[]])"
by (import prob_canon ALG_SORTED_PREFIXFREE_MEM_NIL)
lemma ALG_SORTED_PREFIXFREE_EQUALITY: "(All::(bool list list => bool) => bool)
@@ -1863,33 +1948,34 @@
SHD :: "(nat => bool) => bool"
defs
- SHD_primdef: "SHD == %f. f 0"
-
-lemma SHD_def: "ALL f. SHD f = f 0"
+ SHD_primdef: "SHD == %f::nat => bool. f (0::nat)"
+
+lemma SHD_def: "ALL f::nat => bool. SHD f = f (0::nat)"
by (import boolean_sequence SHD_def)
consts
STL :: "(nat => bool) => nat => bool"
defs
- STL_primdef: "STL == %f n. f (Suc n)"
-
-lemma STL_def: "ALL f n. STL f n = f (Suc n)"
+ STL_primdef: "STL == %(f::nat => bool) n::nat. f (Suc n)"
+
+lemma STL_def: "ALL (f::nat => bool) n::nat. STL f n = f (Suc n)"
by (import boolean_sequence STL_def)
consts
SCONS :: "bool => (nat => bool) => nat => bool"
-specification (SCONS_primdef: SCONS) SCONS_def: "(ALL h t. SCONS h t 0 = h) & (ALL h t n. SCONS h t (Suc n) = t n)"
+specification (SCONS_primdef: SCONS) SCONS_def: "(ALL (h::bool) t::nat => bool. SCONS h t (0::nat) = h) &
+(ALL (h::bool) (t::nat => bool) n::nat. SCONS h t (Suc n) = t n)"
by (import boolean_sequence SCONS_def)
consts
SDEST :: "(nat => bool) => bool * (nat => bool)"
defs
- SDEST_primdef: "SDEST == %s. (SHD s, STL s)"
-
-lemma SDEST_def: "SDEST = (%s. (SHD s, STL s))"
+ SDEST_primdef: "SDEST == %s::nat => bool. (SHD s, STL s)"
+
+lemma SDEST_def: "SDEST = (%s::nat => bool. (SHD s, STL s))"
by (import boolean_sequence SDEST_def)
consts
@@ -1904,32 +1990,32 @@
consts
STAKE :: "nat => (nat => bool) => bool list"
-specification (STAKE_primdef: STAKE) STAKE_def: "(ALL s. STAKE 0 s = []) &
-(ALL n s. STAKE (Suc n) s = SHD s # STAKE n (STL s))"
+specification (STAKE_primdef: STAKE) STAKE_def: "(ALL s::nat => bool. STAKE (0::nat) s = []) &
+(ALL (n::nat) s::nat => bool. STAKE (Suc n) s = SHD s # STAKE n (STL s))"
by (import boolean_sequence STAKE_def)
consts
SDROP :: "nat => (nat => bool) => nat => bool"
-specification (SDROP_primdef: SDROP) SDROP_def: "SDROP 0 = I & (ALL n. SDROP (Suc n) = SDROP n o STL)"
+specification (SDROP_primdef: SDROP) SDROP_def: "SDROP (0::nat) = I & (ALL n::nat. SDROP (Suc n) = SDROP n o STL)"
by (import boolean_sequence SDROP_def)
-lemma SCONS_SURJ: "ALL x. EX xa t. x = SCONS xa t"
+lemma SCONS_SURJ: "ALL x::nat => bool. EX (xa::bool) t::nat => bool. x = SCONS xa t"
by (import boolean_sequence SCONS_SURJ)
-lemma SHD_STL_ISO: "ALL h t. EX x. SHD x = h & STL x = t"
+lemma SHD_STL_ISO: "ALL (h::bool) t::nat => bool. EX x::nat => bool. SHD x = h & STL x = t"
by (import boolean_sequence SHD_STL_ISO)
-lemma SHD_SCONS: "ALL h t. SHD (SCONS h t) = h"
+lemma SHD_SCONS: "ALL (h::bool) t::nat => bool. SHD (SCONS h t) = h"
by (import boolean_sequence SHD_SCONS)
-lemma STL_SCONS: "ALL h t. STL (SCONS h t) = t"
+lemma STL_SCONS: "ALL (h::bool) t::nat => bool. STL (SCONS h t) = t"
by (import boolean_sequence STL_SCONS)
-lemma SHD_SCONST: "ALL b. SHD (SCONST b) = b"
+lemma SHD_SCONST: "ALL b::bool. SHD (SCONST b) = b"
by (import boolean_sequence SHD_SCONST)
-lemma STL_SCONST: "ALL b. STL (SCONST b) = SCONST b"
+lemma STL_SCONST: "ALL b::bool. STL (SCONST b) = SCONST b"
by (import boolean_sequence STL_SCONST)
;end_setup
@@ -1939,15 +2025,16 @@
consts
alg_embed :: "bool list => (nat => bool) => bool"
-specification (alg_embed_primdef: alg_embed) alg_embed_def: "(ALL s. alg_embed [] s = True) &
-(ALL h t s. alg_embed (h # t) s = (h = SHD s & alg_embed t (STL s)))"
+specification (alg_embed_primdef: alg_embed) alg_embed_def: "(ALL s::nat => bool. alg_embed [] s = True) &
+(ALL (h::bool) (t::bool list) s::nat => bool.
+ alg_embed (h # t) s = (h = SHD s & alg_embed t (STL s)))"
by (import prob_algebra alg_embed_def)
consts
algebra_embed :: "bool list list => (nat => bool) => bool"
specification (algebra_embed_primdef: algebra_embed) algebra_embed_def: "algebra_embed [] = EMPTY &
-(ALL h t.
+(ALL (h::bool list) t::bool list list.
algebra_embed (h # t) = pred_set.UNION (alg_embed h) (algebra_embed t))"
by (import prob_algebra algebra_embed_def)
@@ -1955,29 +2042,36 @@
measurable :: "((nat => bool) => bool) => bool"
defs
- measurable_primdef: "measurable == %s. EX b. s = algebra_embed b"
-
-lemma measurable_def: "ALL s. measurable s = (EX b. s = algebra_embed b)"
+ measurable_primdef: "measurable ==
+%s::(nat => bool) => bool. EX b::bool list list. s = algebra_embed b"
+
+lemma measurable_def: "ALL s::(nat => bool) => bool.
+ measurable s = (EX b::bool list list. s = algebra_embed b)"
by (import prob_algebra measurable_def)
-lemma HALVES_INTER: "pred_set.INTER (%x. SHD x = True) (%x. SHD x = False) = EMPTY"
+lemma HALVES_INTER: "pred_set.INTER (%x::nat => bool. SHD x = True)
+ (%x::nat => bool. SHD x = False) =
+EMPTY"
by (import prob_algebra HALVES_INTER)
-lemma INTER_STL: "ALL p q. pred_set.INTER p q o STL = pred_set.INTER (p o STL) (q o STL)"
+lemma INTER_STL: "ALL (p::(nat => bool) => bool) q::(nat => bool) => bool.
+ pred_set.INTER p q o STL = pred_set.INTER (p o STL) (q o STL)"
by (import prob_algebra INTER_STL)
-lemma COMPL_SHD: "ALL b. COMPL (%x. SHD x = b) = (%x. SHD x = (~ b))"
+lemma COMPL_SHD: "ALL b::bool.
+ COMPL (%x::nat => bool. SHD x = b) = (%x::nat => bool. SHD x = (~ b))"
by (import prob_algebra COMPL_SHD)
lemma ALG_EMBED_BASIC: "alg_embed [] = pred_set.UNIV &
-(ALL h t.
- alg_embed (h # t) = pred_set.INTER (%x. SHD x = h) (alg_embed t o STL))"
+(ALL (h::bool) t::bool list.
+ alg_embed (h # t) =
+ pred_set.INTER (%x::nat => bool. SHD x = h) (alg_embed t o STL))"
by (import prob_algebra ALG_EMBED_BASIC)
-lemma ALG_EMBED_NIL: "ALL c. All (alg_embed c) = (c = [])"
+lemma ALG_EMBED_NIL: "ALL c::bool list. All (alg_embed c) = (c = [])"
by (import prob_algebra ALG_EMBED_NIL)
-lemma ALG_EMBED_POPULATED: "ALL b. Ex (alg_embed b)"
+lemma ALG_EMBED_POPULATED: "ALL b::bool list. Ex (alg_embed b)"
by (import prob_algebra ALG_EMBED_POPULATED)
lemma ALG_EMBED_PREFIX: "(All::(bool list => bool) => bool)
@@ -1995,17 +2089,18 @@
((IS_PREFIX::bool list => bool list => bool) c b)))))"
by (import prob_algebra ALG_EMBED_PREFIX)
-lemma ALG_EMBED_PREFIX_SUBSET: "ALL b c. SUBSET (alg_embed b) (alg_embed c) = IS_PREFIX b c"
+lemma ALG_EMBED_PREFIX_SUBSET: "ALL (b::bool list) c::bool list.
+ SUBSET (alg_embed b) (alg_embed c) = IS_PREFIX b c"
by (import prob_algebra ALG_EMBED_PREFIX_SUBSET)
-lemma ALG_EMBED_TWINS: "ALL l.
+lemma ALG_EMBED_TWINS: "ALL l::bool list.
pred_set.UNION (alg_embed (SNOC True l)) (alg_embed (SNOC False l)) =
alg_embed l"
by (import prob_algebra ALG_EMBED_TWINS)
lemma ALGEBRA_EMBED_BASIC: "algebra_embed [] = EMPTY &
algebra_embed [[]] = pred_set.UNIV &
-(ALL b. algebra_embed [[b]] = (%s. SHD s = b))"
+(ALL b::bool. algebra_embed [[b]] = (%s::nat => bool. SHD s = b))"
by (import prob_algebra ALGEBRA_EMBED_BASIC)
lemma ALGEBRA_EMBED_MEM: "(All::(bool list list => bool) => bool)
@@ -2021,31 +2116,35 @@
((alg_embed::bool list => (nat => bool) => bool) l x)))))"
by (import prob_algebra ALGEBRA_EMBED_MEM)
-lemma ALGEBRA_EMBED_APPEND: "ALL l1 l2.
+lemma ALGEBRA_EMBED_APPEND: "ALL (l1::bool list list) l2::bool list list.
algebra_embed (l1 @ l2) =
pred_set.UNION (algebra_embed l1) (algebra_embed l2)"
by (import prob_algebra ALGEBRA_EMBED_APPEND)
-lemma ALGEBRA_EMBED_TLS: "ALL l b.
- algebra_embed (map (op # b) l) (SCONS h t) = (h = b & algebra_embed l t)"
+lemma ALGEBRA_EMBED_TLS: "ALL (l::bool list list) b::bool.
+ algebra_embed (map (op # b) l) (SCONS (h::bool) (t::nat => bool)) =
+ (h = b & algebra_embed l t)"
by (import prob_algebra ALGEBRA_EMBED_TLS)
-lemma ALG_CANON_PREFS_EMBED: "ALL l b. algebra_embed (alg_canon_prefs l b) = algebra_embed (l # b)"
+lemma ALG_CANON_PREFS_EMBED: "ALL (l::bool list) b::bool list list.
+ algebra_embed (alg_canon_prefs l b) = algebra_embed (l # b)"
by (import prob_algebra ALG_CANON_PREFS_EMBED)
-lemma ALG_CANON_FIND_EMBED: "ALL l b. algebra_embed (alg_canon_find l b) = algebra_embed (l # b)"
+lemma ALG_CANON_FIND_EMBED: "ALL (l::bool list) b::bool list list.
+ algebra_embed (alg_canon_find l b) = algebra_embed (l # b)"
by (import prob_algebra ALG_CANON_FIND_EMBED)
-lemma ALG_CANON1_EMBED: "ALL x. algebra_embed (alg_canon1 x) = algebra_embed x"
+lemma ALG_CANON1_EMBED: "ALL x::bool list list. algebra_embed (alg_canon1 x) = algebra_embed x"
by (import prob_algebra ALG_CANON1_EMBED)
-lemma ALG_CANON_MERGE_EMBED: "ALL l b. algebra_embed (alg_canon_merge l b) = algebra_embed (l # b)"
+lemma ALG_CANON_MERGE_EMBED: "ALL (l::bool list) b::bool list list.
+ algebra_embed (alg_canon_merge l b) = algebra_embed (l # b)"
by (import prob_algebra ALG_CANON_MERGE_EMBED)
-lemma ALG_CANON2_EMBED: "ALL x. algebra_embed (alg_canon2 x) = algebra_embed x"
+lemma ALG_CANON2_EMBED: "ALL x::bool list list. algebra_embed (alg_canon2 x) = algebra_embed x"
by (import prob_algebra ALG_CANON2_EMBED)
-lemma ALG_CANON_EMBED: "ALL l. algebra_embed (alg_canon l) = algebra_embed l"
+lemma ALG_CANON_EMBED: "ALL l::bool list list. algebra_embed (alg_canon l) = algebra_embed l"
by (import prob_algebra ALG_CANON_EMBED)
lemma ALGEBRA_CANON_UNIV: "(All::(bool list list => bool) => bool)
@@ -2061,7 +2160,8 @@
([]::bool list) ([]::bool list list)))))"
by (import prob_algebra ALGEBRA_CANON_UNIV)
-lemma ALG_CANON_REP: "ALL b c. (alg_canon b = alg_canon c) = (algebra_embed b = algebra_embed c)"
+lemma ALG_CANON_REP: "ALL (b::bool list list) c::bool list list.
+ (alg_canon b = alg_canon c) = (algebra_embed b = algebra_embed c)"
by (import prob_algebra ALG_CANON_REP)
lemma ALGEBRA_CANON_EMBED_EMPTY: "(All::(bool list list => bool) => bool)
@@ -2090,20 +2190,22 @@
([]::bool list) ([]::bool list list)))))"
by (import prob_algebra ALGEBRA_CANON_EMBED_UNIV)
-lemma MEASURABLE_ALGEBRA: "ALL b. measurable (algebra_embed b)"
+lemma MEASURABLE_ALGEBRA: "ALL b::bool list list. measurable (algebra_embed b)"
by (import prob_algebra MEASURABLE_ALGEBRA)
lemma MEASURABLE_BASIC: "measurable EMPTY &
-measurable pred_set.UNIV & (ALL b. measurable (%s. SHD s = b))"
+measurable pred_set.UNIV &
+(ALL b::bool. measurable (%s::nat => bool. SHD s = b))"
by (import prob_algebra MEASURABLE_BASIC)
-lemma MEASURABLE_SHD: "ALL b. measurable (%s. SHD s = b)"
+lemma MEASURABLE_SHD: "ALL b::bool. measurable (%s::nat => bool. SHD s = b)"
by (import prob_algebra MEASURABLE_SHD)
-lemma ALGEBRA_EMBED_COMPL: "ALL l. EX l'. COMPL (algebra_embed l) = algebra_embed l'"
+lemma ALGEBRA_EMBED_COMPL: "ALL l::bool list list.
+ EX l'::bool list list. COMPL (algebra_embed l) = algebra_embed l'"
by (import prob_algebra ALGEBRA_EMBED_COMPL)
-lemma MEASURABLE_COMPL: "ALL s. measurable (COMPL s) = measurable s"
+lemma MEASURABLE_COMPL: "ALL s::(nat => bool) => bool. measurable (COMPL s) = measurable s"
by (import prob_algebra MEASURABLE_COMPL)
lemma MEASURABLE_UNION: "(All::(((nat => bool) => bool) => bool) => bool)
@@ -2136,28 +2238,30 @@
s t))))"
by (import prob_algebra MEASURABLE_INTER)
-lemma MEASURABLE_STL: "ALL p. measurable (p o STL) = measurable p"
+lemma MEASURABLE_STL: "ALL p::(nat => bool) => bool. measurable (p o STL) = measurable p"
by (import prob_algebra MEASURABLE_STL)
-lemma MEASURABLE_SDROP: "ALL n p. measurable (p o SDROP n) = measurable p"
+lemma MEASURABLE_SDROP: "ALL (n::nat) p::(nat => bool) => bool.
+ measurable (p o SDROP n) = measurable p"
by (import prob_algebra MEASURABLE_SDROP)
-lemma MEASURABLE_INTER_HALVES: "ALL p.
- (measurable (pred_set.INTER (%x. SHD x = True) p) &
- measurable (pred_set.INTER (%x. SHD x = False) p)) =
+lemma MEASURABLE_INTER_HALVES: "ALL p::(nat => bool) => bool.
+ (measurable (pred_set.INTER (%x::nat => bool. SHD x = True) p) &
+ measurable (pred_set.INTER (%x::nat => bool. SHD x = False) p)) =
measurable p"
by (import prob_algebra MEASURABLE_INTER_HALVES)
-lemma MEASURABLE_HALVES: "ALL p q.
+lemma MEASURABLE_HALVES: "ALL (p::(nat => bool) => bool) q::(nat => bool) => bool.
measurable
- (pred_set.UNION (pred_set.INTER (%x. SHD x = True) p)
- (pred_set.INTER (%x. SHD x = False) q)) =
- (measurable (pred_set.INTER (%x. SHD x = True) p) &
- measurable (pred_set.INTER (%x. SHD x = False) q))"
+ (pred_set.UNION (pred_set.INTER (%x::nat => bool. SHD x = True) p)
+ (pred_set.INTER (%x::nat => bool. SHD x = False) q)) =
+ (measurable (pred_set.INTER (%x::nat => bool. SHD x = True) p) &
+ measurable (pred_set.INTER (%x::nat => bool. SHD x = False) q))"
by (import prob_algebra MEASURABLE_HALVES)
-lemma MEASURABLE_INTER_SHD: "ALL b p.
- measurable (pred_set.INTER (%x. SHD x = b) (p o STL)) = measurable p"
+lemma MEASURABLE_INTER_SHD: "ALL (b::bool) p::(nat => bool) => bool.
+ measurable (pred_set.INTER (%x::nat => bool. SHD x = b) (p o STL)) =
+ measurable p"
by (import prob_algebra MEASURABLE_INTER_SHD)
;end_setup
@@ -2167,8 +2271,10 @@
consts
alg_measure :: "bool list list => real"
-specification (alg_measure_primdef: alg_measure) alg_measure_def: "alg_measure [] = 0 &
-(ALL l rest. alg_measure (l # rest) = (1 / 2) ^ length l + alg_measure rest)"
+specification (alg_measure_primdef: alg_measure) alg_measure_def: "alg_measure [] = (0::real) &
+(ALL (l::bool list) rest::bool list list.
+ alg_measure (l # rest) =
+ ((1::real) / (2::real)) ^ length l + alg_measure rest)"
by (import prob alg_measure_def)
consts
@@ -2176,11 +2282,16 @@
defs
algebra_measure_primdef: "algebra_measure ==
-%b. inf (%r. EX c. algebra_embed b = algebra_embed c & alg_measure c = r)"
-
-lemma algebra_measure_def: "ALL b.
+%b::bool list list.
+ inf (%r::real.
+ EX c::bool list list.
+ algebra_embed b = algebra_embed c & alg_measure c = r)"
+
+lemma algebra_measure_def: "ALL b::bool list list.
algebra_measure b =
- inf (%r. EX c. algebra_embed b = algebra_embed c & alg_measure c = r)"
+ inf (%r::real.
+ EX c::bool list list.
+ algebra_embed b = algebra_embed c & alg_measure c = r)"
by (import prob algebra_measure_def)
consts
@@ -2188,11 +2299,16 @@
defs
prob_primdef: "prob ==
-%s. sup (%r. EX b. algebra_measure b = r & SUBSET (algebra_embed b) s)"
-
-lemma prob_def: "ALL s.
+%s::(nat => bool) => bool.
+ sup (%r::real.
+ EX b::bool list list.
+ algebra_measure b = r & SUBSET (algebra_embed b) s)"
+
+lemma prob_def: "ALL s::(nat => bool) => bool.
prob s =
- sup (%r. EX b. algebra_measure b = r & SUBSET (algebra_embed b) s)"
+ sup (%r::real.
+ EX b::bool list list.
+ algebra_measure b = r & SUBSET (algebra_embed b) s)"
by (import prob prob_def)
lemma ALG_TWINS_MEASURE: "ALL l::bool list.
@@ -2201,42 +2317,49 @@
((1::real) / (2::real)) ^ length l"
by (import prob ALG_TWINS_MEASURE)
-lemma ALG_MEASURE_BASIC: "alg_measure [] = 0 &
-alg_measure [[]] = 1 & (ALL b. alg_measure [[b]] = 1 / 2)"
+lemma ALG_MEASURE_BASIC: "alg_measure [] = (0::real) &
+alg_measure [[]] = (1::real) &
+(ALL b::bool. alg_measure [[b]] = (1::real) / (2::real))"
by (import prob ALG_MEASURE_BASIC)
-lemma ALG_MEASURE_POS: "ALL l. 0 <= alg_measure l"
+lemma ALG_MEASURE_POS: "ALL l::bool list list. (0::real) <= alg_measure l"
by (import prob ALG_MEASURE_POS)
-lemma ALG_MEASURE_APPEND: "ALL l1 l2. alg_measure (l1 @ l2) = alg_measure l1 + alg_measure l2"
+lemma ALG_MEASURE_APPEND: "ALL (l1::bool list list) l2::bool list list.
+ alg_measure (l1 @ l2) = alg_measure l1 + alg_measure l2"
by (import prob ALG_MEASURE_APPEND)
-lemma ALG_MEASURE_TLS: "ALL l b. 2 * alg_measure (map (op # b) l) = alg_measure l"
+lemma ALG_MEASURE_TLS: "ALL (l::bool list list) b::bool.
+ (2::real) * alg_measure (map (op # b) l) = alg_measure l"
by (import prob ALG_MEASURE_TLS)
-lemma ALG_CANON_PREFS_MONO: "ALL l b. alg_measure (alg_canon_prefs l b) <= alg_measure (l # b)"
+lemma ALG_CANON_PREFS_MONO: "ALL (l::bool list) b::bool list list.
+ alg_measure (alg_canon_prefs l b) <= alg_measure (l # b)"
by (import prob ALG_CANON_PREFS_MONO)
-lemma ALG_CANON_FIND_MONO: "ALL l b. alg_measure (alg_canon_find l b) <= alg_measure (l # b)"
+lemma ALG_CANON_FIND_MONO: "ALL (l::bool list) b::bool list list.
+ alg_measure (alg_canon_find l b) <= alg_measure (l # b)"
by (import prob ALG_CANON_FIND_MONO)
-lemma ALG_CANON1_MONO: "ALL x. alg_measure (alg_canon1 x) <= alg_measure x"
+lemma ALG_CANON1_MONO: "ALL x::bool list list. alg_measure (alg_canon1 x) <= alg_measure x"
by (import prob ALG_CANON1_MONO)
-lemma ALG_CANON_MERGE_MONO: "ALL l b. alg_measure (alg_canon_merge l b) <= alg_measure (l # b)"
+lemma ALG_CANON_MERGE_MONO: "ALL (l::bool list) b::bool list list.
+ alg_measure (alg_canon_merge l b) <= alg_measure (l # b)"
by (import prob ALG_CANON_MERGE_MONO)
-lemma ALG_CANON2_MONO: "ALL x. alg_measure (alg_canon2 x) <= alg_measure x"
+lemma ALG_CANON2_MONO: "ALL x::bool list list. alg_measure (alg_canon2 x) <= alg_measure x"
by (import prob ALG_CANON2_MONO)
-lemma ALG_CANON_MONO: "ALL l. alg_measure (alg_canon l) <= alg_measure l"
+lemma ALG_CANON_MONO: "ALL l::bool list list. alg_measure (alg_canon l) <= alg_measure l"
by (import prob ALG_CANON_MONO)
-lemma ALGEBRA_MEASURE_DEF_ALT: "ALL l. algebra_measure l = alg_measure (alg_canon l)"
+lemma ALGEBRA_MEASURE_DEF_ALT: "ALL l::bool list list. algebra_measure l = alg_measure (alg_canon l)"
by (import prob ALGEBRA_MEASURE_DEF_ALT)
-lemma ALGEBRA_MEASURE_BASIC: "algebra_measure [] = 0 &
-algebra_measure [[]] = 1 & (ALL b. algebra_measure [[b]] = 1 / 2)"
+lemma ALGEBRA_MEASURE_BASIC: "algebra_measure [] = (0::real) &
+algebra_measure [[]] = (1::real) &
+(ALL b::bool. algebra_measure [[b]] = (1::real) / (2::real))"
by (import prob ALGEBRA_MEASURE_BASIC)
lemma ALGEBRA_CANON_MEASURE_MAX: "(All::(bool list list => bool) => bool)
@@ -2247,7 +2370,7 @@
((alg_measure::bool list list => real) l) (1::real)))"
by (import prob ALGEBRA_CANON_MEASURE_MAX)
-lemma ALGEBRA_MEASURE_MAX: "ALL l. algebra_measure l <= 1"
+lemma ALGEBRA_MEASURE_MAX: "ALL l::bool list list. algebra_measure l <= (1::real)"
by (import prob ALGEBRA_MEASURE_MAX)
lemma ALGEBRA_MEASURE_MONO_EMBED: "(All::(bool list list => bool) => bool)
@@ -2332,11 +2455,12 @@
((alg_measure::bool list list => real) d)))))))))"
by (import prob ALG_MEASURE_ADDITIVE)
-lemma PROB_ALGEBRA: "ALL l. prob (algebra_embed l) = algebra_measure l"
+lemma PROB_ALGEBRA: "ALL l::bool list list. prob (algebra_embed l) = algebra_measure l"
by (import prob PROB_ALGEBRA)
-lemma PROB_BASIC: "prob EMPTY = 0 &
-prob pred_set.UNIV = 1 & (ALL b. prob (%s. SHD s = b) = 1 / 2)"
+lemma PROB_BASIC: "prob EMPTY = (0::real) &
+prob pred_set.UNIV = (1::real) &
+(ALL b::bool. prob (%s::nat => bool. SHD s = b) = (1::real) / (2::real))"
by (import prob PROB_BASIC)
lemma PROB_ADDITIVE: "(All::(((nat => bool) => bool) => bool) => bool)
@@ -2377,7 +2501,9 @@
((prob::((nat => bool) => bool) => real) s))))"
by (import prob PROB_COMPL)
-lemma PROB_SUP_EXISTS1: "ALL s. EX x b. algebra_measure b = x & SUBSET (algebra_embed b) s"
+lemma PROB_SUP_EXISTS1: "ALL s::(nat => bool) => bool.
+ EX (x::real) b::bool list list.
+ algebra_measure b = x & SUBSET (algebra_embed b) s"
by (import prob PROB_SUP_EXISTS1)
lemma PROB_SUP_EXISTS2: "(All::(((nat => bool) => bool) => bool) => bool)
@@ -2452,7 +2578,7 @@
((prob::((nat => bool) => bool) => real) t))))"
by (import prob PROB_SUBSET_MONO)
-lemma PROB_ALG: "ALL x. prob (alg_embed x) = (1 / 2) ^ length x"
+lemma PROB_ALG: "ALL x::bool list. prob (alg_embed x) = ((1::real) / (2::real)) ^ length x"
by (import prob PROB_ALG)
lemma PROB_STL: "(All::(((nat => bool) => bool) => bool) => bool)
@@ -2536,25 +2662,26 @@
((prob::((nat => bool) => bool) => real) p)))))"
by (import prob PROB_INTER_SHD)
-lemma ALGEBRA_MEASURE_POS: "ALL l. 0 <= algebra_measure l"
+lemma ALGEBRA_MEASURE_POS: "ALL l::bool list list. (0::real) <= algebra_measure l"
by (import prob ALGEBRA_MEASURE_POS)
-lemma ALGEBRA_MEASURE_RANGE: "ALL l. 0 <= algebra_measure l & algebra_measure l <= 1"
+lemma ALGEBRA_MEASURE_RANGE: "ALL l::bool list list.
+ (0::real) <= algebra_measure l & algebra_measure l <= (1::real)"
by (import prob ALGEBRA_MEASURE_RANGE)
-lemma PROB_POS: "ALL p. 0 <= prob p"
+lemma PROB_POS: "ALL p::(nat => bool) => bool. (0::real) <= prob p"
by (import prob PROB_POS)
-lemma PROB_MAX: "ALL p. prob p <= 1"
+lemma PROB_MAX: "ALL p::(nat => bool) => bool. prob p <= (1::real)"
by (import prob PROB_MAX)
-lemma PROB_RANGE: "ALL p. 0 <= prob p & prob p <= 1"
+lemma PROB_RANGE: "ALL p::(nat => bool) => bool. (0::real) <= prob p & prob p <= (1::real)"
by (import prob PROB_RANGE)
-lemma ABS_PROB: "ALL p. abs (prob p) = prob p"
+lemma ABS_PROB: "ALL p::(nat => bool) => bool. abs (prob p) = prob p"
by (import prob ABS_PROB)
-lemma PROB_SHD: "ALL b. prob (%s. SHD s = b) = 1 / 2"
+lemma PROB_SHD: "ALL b::bool. prob (%s::nat => bool. SHD s = b) = (1::real) / (2::real)"
by (import prob PROB_SHD)
lemma PROB_COMPL_LE1: "(All::(((nat => bool) => bool) => bool) => bool)
@@ -2591,41 +2718,42 @@
pseudo_linear_tl :: "nat => nat => nat => nat => nat"
defs
- pseudo_linear_tl_primdef: "pseudo_linear_tl == %a b n x. (a * x + b) mod (2 * n + 1)"
-
-lemma pseudo_linear_tl_def: "ALL a b n x. pseudo_linear_tl a b n x = (a * x + b) mod (2 * n + 1)"
+ pseudo_linear_tl_primdef: "pseudo_linear_tl ==
+%(a::nat) (b::nat) (n::nat) x::nat.
+ (a * x + b) mod ((2::nat) * n + (1::nat))"
+
+lemma pseudo_linear_tl_def: "ALL (a::nat) (b::nat) (n::nat) x::nat.
+ pseudo_linear_tl a b n x = (a * x + b) mod ((2::nat) * n + (1::nat))"
by (import prob_pseudo pseudo_linear_tl_def)
-lemma PSEUDO_LINEAR1_EXECUTE: "EX x. (ALL xa. SHD (x xa) = pseudo_linear_hd xa) &
- (ALL xa.
- STL (x xa) =
- x (pseudo_linear_tl
- (NUMERAL
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT2
- (NUMERAL_BIT1 (NUMERAL_BIT2 ALT_ZERO)))))))
- (NUMERAL
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1 (NUMERAL_BIT2 ALT_ZERO)))))))
- (NUMERAL
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT2 (NUMERAL_BIT1 ALT_ZERO)))))))
- xa))"
+lemma PSEUDO_LINEAR1_EXECUTE: "EX x::nat => nat => bool.
+ (ALL xa::nat. SHD (x xa) = pseudo_linear_hd xa) &
+ (ALL xa::nat.
+ STL (x xa) =
+ x (pseudo_linear_tl
+ (NUMERAL
+ (NUMERAL_BIT1
+ (NUMERAL_BIT1
+ (NUMERAL_BIT1
+ (NUMERAL_BIT2 (NUMERAL_BIT1 (NUMERAL_BIT2 ALT_ZERO)))))))
+ (NUMERAL
+ (NUMERAL_BIT1
+ (NUMERAL_BIT1
+ (NUMERAL_BIT1
+ (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT2 ALT_ZERO)))))))
+ (NUMERAL
+ (NUMERAL_BIT1
+ (NUMERAL_BIT1
+ (NUMERAL_BIT1
+ (NUMERAL_BIT1 (NUMERAL_BIT2 (NUMERAL_BIT1 ALT_ZERO)))))))
+ xa))"
by (import prob_pseudo PSEUDO_LINEAR1_EXECUTE)
consts
pseudo_linear1 :: "nat => nat => bool"
-specification (pseudo_linear1_primdef: pseudo_linear1) pseudo_linear1_def: "(ALL x. SHD (pseudo_linear1 x) = pseudo_linear_hd x) &
-(ALL x.
+specification (pseudo_linear1_primdef: pseudo_linear1) pseudo_linear1_def: "(ALL x::nat. SHD (pseudo_linear1 x) = pseudo_linear_hd x) &
+(ALL x::nat.
STL (pseudo_linear1 x) =
pseudo_linear1
(pseudo_linear_tl
@@ -2665,10 +2793,10 @@
defs
indep_set_primdef: "indep_set ==
-%p q. measurable p &
- measurable q & prob (pred_set.INTER p q) = prob p * prob q"
-
-lemma indep_set_def: "ALL p q.
+%(p::(nat => bool) => bool) q::(nat => bool) => bool.
+ measurable p & measurable q & prob (pred_set.INTER p q) = prob p * prob q"
+
+lemma indep_set_def: "ALL (p::(nat => bool) => bool) q::(nat => bool) => bool.
indep_set p q =
(measurable p &
measurable q & prob (pred_set.INTER p q) = prob p * prob q)"
@@ -2679,9 +2807,10 @@
defs
alg_cover_set_primdef: "alg_cover_set ==
-%l. alg_sorted l & alg_prefixfree l & algebra_embed l = pred_set.UNIV"
-
-lemma alg_cover_set_def: "ALL l.
+%l::bool list list.
+ alg_sorted l & alg_prefixfree l & algebra_embed l = pred_set.UNIV"
+
+lemma alg_cover_set_def: "ALL l::bool list list.
alg_cover_set l =
(alg_sorted l & alg_prefixfree l & algebra_embed l = pred_set.UNIV)"
by (import prob_indep alg_cover_set_def)
@@ -2690,25 +2819,33 @@
alg_cover :: "bool list list => (nat => bool) => bool list"
defs
- alg_cover_primdef: "alg_cover == %l x. SOME b. b mem l & alg_embed b x"
-
-lemma alg_cover_def: "ALL l x. alg_cover l x = (SOME b. b mem l & alg_embed b x)"
+ alg_cover_primdef: "alg_cover ==
+%(l::bool list list) x::nat => bool.
+ SOME b::bool list. b mem l & alg_embed b x"
+
+lemma alg_cover_def: "ALL (l::bool list list) x::nat => bool.
+ alg_cover l x = (SOME b::bool list. b mem l & alg_embed b x)"
by (import prob_indep alg_cover_def)
consts
- indep :: "((nat => bool) => 'a * (nat => bool)) => bool"
+ indep :: "((nat => bool) => 'a::type * (nat => bool)) => bool"
defs
indep_primdef: "indep ==
-%f. EX l r.
+%f::(nat => bool) => 'a::type * (nat => bool).
+ EX (l::bool list list) r::bool list => 'a::type.
+ alg_cover_set l &
+ (ALL s::nat => bool.
+ f s =
+ (let c::bool list = alg_cover l s in (r c, SDROP (length c) s)))"
+
+lemma indep_def: "ALL f::(nat => bool) => 'a::type * (nat => bool).
+ indep f =
+ (EX (l::bool list list) r::bool list => 'a::type.
alg_cover_set l &
- (ALL s. f s = (let c = alg_cover l s in (r c, SDROP (length c) s)))"
-
-lemma indep_def: "ALL f.
- indep f =
- (EX l r.
- alg_cover_set l &
- (ALL s. f s = (let c = alg_cover l s in (r c, SDROP (length c) s))))"
+ (ALL s::nat => bool.
+ f s =
+ (let c::bool list = alg_cover l s in (r c, SDROP (length c) s))))"
by (import prob_indep indep_def)
lemma INDEP_SET_BASIC: "(All::(((nat => bool) => bool) => bool) => bool)
@@ -2724,7 +2861,8 @@
(pred_set.UNIV::(nat => bool) => bool) p)))"
by (import prob_indep INDEP_SET_BASIC)
-lemma INDEP_SET_SYM: "ALL p q. indep_set p q = indep_set p q"
+lemma INDEP_SET_SYM: "ALL (p::(nat => bool) => bool) q::(nat => bool) => bool.
+ indep_set p q = indep_set p q"
by (import prob_indep INDEP_SET_SYM)
lemma INDEP_SET_DISJOINT_DECOMP: "(All::(((nat => bool) => bool) => bool) => bool)
@@ -2809,10 +2947,10 @@
l))))"
by (import prob_indep MAP_CONS_TL_FILTER)
-lemma ALG_COVER_SET_CASES_THM: "ALL l.
+lemma ALG_COVER_SET_CASES_THM: "ALL l::bool list list.
alg_cover_set l =
(l = [[]] |
- (EX x xa.
+ (EX (x::bool list list) xa::bool list list.
alg_cover_set x &
alg_cover_set xa & l = map (op # True) x @ map (op # False) xa))"
by (import prob_indep ALG_COVER_SET_CASES_THM)
@@ -3191,144 +3329,162 @@
q)))"
by (import prob_indep INDEP_SET_LIST)
-lemma INDEP_INDEP_SET: "(All::(((nat => bool) => 'a * (nat => bool)) => bool) => bool)
- (%f::(nat => bool) => 'a * (nat => bool).
- (All::(('a => bool) => bool) => bool)
- (%p::'a => bool.
+lemma INDEP_INDEP_SET: "(All::(((nat => bool) => 'a::type * (nat => bool)) => bool) => bool)
+ (%f::(nat => bool) => 'a::type * (nat => bool).
+ (All::(('a::type => bool) => bool) => bool)
+ (%p::'a::type => bool.
(All::(((nat => bool) => bool) => bool) => bool)
(%q::(nat => bool) => bool.
(op -->::bool => bool => bool)
((op &::bool => bool => bool)
- ((indep::((nat => bool) => 'a * (nat => bool)) => bool) f)
+ ((indep::((nat => bool) => 'a::type * (nat => bool))
+ => bool)
+ f)
((measurable::((nat => bool) => bool) => bool) q))
((indep_set::((nat => bool) => bool)
=> ((nat => bool) => bool) => bool)
- ((op o::('a => bool)
- => ((nat => bool) => 'a) => (nat => bool) => bool)
- p ((op o::('a * (nat => bool) => 'a)
- => ((nat => bool) => 'a * (nat => bool))
- => (nat => bool) => 'a)
- (fst::'a * (nat => bool) => 'a) f))
+ ((op o::('a::type => bool)
+ => ((nat => bool) => 'a::type)
+ => (nat => bool) => bool)
+ p ((op o::('a::type * (nat => bool) => 'a::type)
+ => ((nat => bool) => 'a::type * (nat => bool))
+ => (nat => bool) => 'a::type)
+ (fst::'a::type * (nat => bool) => 'a::type) f))
((op o::((nat => bool) => bool)
=> ((nat => bool) => nat => bool)
=> (nat => bool) => bool)
- q ((op o::('a * (nat => bool) => nat => bool)
- => ((nat => bool) => 'a * (nat => bool))
+ q ((op o::('a::type * (nat => bool) => nat => bool)
+ => ((nat => bool) => 'a::type * (nat => bool))
=> (nat => bool) => nat => bool)
- (snd::'a * (nat => bool) => nat => bool) f))))))"
+ (snd::'a::type * (nat => bool) => nat => bool)
+ f))))))"
by (import prob_indep INDEP_INDEP_SET)
-lemma INDEP_UNIT: "ALL x. indep (UNIT x)"
+lemma INDEP_UNIT: "ALL x::'a::type. indep (UNIT x)"
by (import prob_indep INDEP_UNIT)
lemma INDEP_SDEST: "indep SDEST"
by (import prob_indep INDEP_SDEST)
-lemma BIND_STEP: "ALL f. BIND SDEST (%k. f o SCONS k) = f"
+lemma BIND_STEP: "ALL f::(nat => bool) => 'a::type * (nat => bool).
+ BIND SDEST (%k::bool. f o SCONS k) = f"
by (import prob_indep BIND_STEP)
-lemma INDEP_BIND_SDEST: "(All::((bool => (nat => bool) => 'a * (nat => bool)) => bool) => bool)
- (%f::bool => (nat => bool) => 'a * (nat => bool).
+lemma INDEP_BIND_SDEST: "(All::((bool => (nat => bool) => 'a::type * (nat => bool)) => bool) => bool)
+ (%f::bool => (nat => bool) => 'a::type * (nat => bool).
(op -->::bool => bool => bool)
((All::(bool => bool) => bool)
(%x::bool.
- (indep::((nat => bool) => 'a * (nat => bool)) => bool) (f x)))
- ((indep::((nat => bool) => 'a * (nat => bool)) => bool)
+ (indep::((nat => bool) => 'a::type * (nat => bool)) => bool)
+ (f x)))
+ ((indep::((nat => bool) => 'a::type * (nat => bool)) => bool)
((BIND::((nat => bool) => bool * (nat => bool))
- => (bool => (nat => bool) => 'a * (nat => bool))
- => (nat => bool) => 'a * (nat => bool))
+ => (bool => (nat => bool) => 'a::type * (nat => bool))
+ => (nat => bool) => 'a::type * (nat => bool))
(SDEST::(nat => bool) => bool * (nat => bool)) f)))"
by (import prob_indep INDEP_BIND_SDEST)
-lemma INDEP_BIND: "(All::(((nat => bool) => 'a * (nat => bool)) => bool) => bool)
- (%f::(nat => bool) => 'a * (nat => bool).
- (All::(('a => (nat => bool) => 'b * (nat => bool)) => bool) => bool)
- (%g::'a => (nat => bool) => 'b * (nat => bool).
+lemma INDEP_BIND: "(All::(((nat => bool) => 'a::type * (nat => bool)) => bool) => bool)
+ (%f::(nat => bool) => 'a::type * (nat => bool).
+ (All::(('a::type => (nat => bool) => 'b::type * (nat => bool)) => bool)
+ => bool)
+ (%g::'a::type => (nat => bool) => 'b::type * (nat => bool).
(op -->::bool => bool => bool)
((op &::bool => bool => bool)
- ((indep::((nat => bool) => 'a * (nat => bool)) => bool) f)
- ((All::('a => bool) => bool)
- (%x::'a.
- (indep::((nat => bool) => 'b * (nat => bool)) => bool)
+ ((indep::((nat => bool) => 'a::type * (nat => bool)) => bool)
+ f)
+ ((All::('a::type => bool) => bool)
+ (%x::'a::type.
+ (indep::((nat => bool) => 'b::type * (nat => bool))
+ => bool)
(g x))))
- ((indep::((nat => bool) => 'b * (nat => bool)) => bool)
- ((BIND::((nat => bool) => 'a * (nat => bool))
- => ('a => (nat => bool) => 'b * (nat => bool))
- => (nat => bool) => 'b * (nat => bool))
+ ((indep::((nat => bool) => 'b::type * (nat => bool)) => bool)
+ ((BIND::((nat => bool) => 'a::type * (nat => bool))
+ => ('a::type
+ => (nat => bool) => 'b::type * (nat => bool))
+ => (nat => bool) => 'b::type * (nat => bool))
f g))))"
by (import prob_indep INDEP_BIND)
-lemma INDEP_PROB: "(All::(((nat => bool) => 'a * (nat => bool)) => bool) => bool)
- (%f::(nat => bool) => 'a * (nat => bool).
- (All::(('a => bool) => bool) => bool)
- (%p::'a => bool.
+lemma INDEP_PROB: "(All::(((nat => bool) => 'a::type * (nat => bool)) => bool) => bool)
+ (%f::(nat => bool) => 'a::type * (nat => bool).
+ (All::(('a::type => bool) => bool) => bool)
+ (%p::'a::type => bool.
(All::(((nat => bool) => bool) => bool) => bool)
(%q::(nat => bool) => bool.
(op -->::bool => bool => bool)
((op &::bool => bool => bool)
- ((indep::((nat => bool) => 'a * (nat => bool)) => bool) f)
+ ((indep::((nat => bool) => 'a::type * (nat => bool))
+ => bool)
+ f)
((measurable::((nat => bool) => bool) => bool) q))
((op =::real => real => bool)
((prob::((nat => bool) => bool) => real)
((pred_set.INTER::((nat => bool) => bool)
=> ((nat => bool) => bool) => (nat => bool) => bool)
- ((op o::('a => bool)
- => ((nat => bool) => 'a)
+ ((op o::('a::type => bool)
+ => ((nat => bool) => 'a::type)
=> (nat => bool) => bool)
- p ((op o::('a * (nat => bool) => 'a)
- => ((nat => bool) => 'a * (nat => bool))
- => (nat => bool) => 'a)
- (fst::'a * (nat => bool) => 'a) f))
+ p ((op o::('a::type * (nat => bool) => 'a::type)
+ => ((nat => bool)
+=> 'a::type * (nat => bool))
+ => (nat => bool) => 'a::type)
+ (fst::'a::type * (nat => bool) => 'a::type) f))
((op o::((nat => bool) => bool)
=> ((nat => bool) => nat => bool)
=> (nat => bool) => bool)
- q ((op o::('a * (nat => bool) => nat => bool)
- => ((nat => bool) => 'a * (nat => bool))
+ q ((op o::('a::type * (nat => bool) => nat => bool)
+ => ((nat => bool)
+=> 'a::type * (nat => bool))
=> (nat => bool) => nat => bool)
- (snd::'a * (nat => bool) => nat => bool) f))))
+ (snd::'a::type * (nat => bool) => nat => bool)
+ f))))
((op *::real => real => real)
((prob::((nat => bool) => bool) => real)
- ((op o::('a => bool)
- => ((nat => bool) => 'a)
+ ((op o::('a::type => bool)
+ => ((nat => bool) => 'a::type)
=> (nat => bool) => bool)
- p ((op o::('a * (nat => bool) => 'a)
- => ((nat => bool) => 'a * (nat => bool))
- => (nat => bool) => 'a)
- (fst::'a * (nat => bool) => 'a) f)))
+ p ((op o::('a::type * (nat => bool) => 'a::type)
+ => ((nat => bool)
+=> 'a::type * (nat => bool))
+ => (nat => bool) => 'a::type)
+ (fst::'a::type * (nat => bool) => 'a::type) f)))
((prob::((nat => bool) => bool) => real) q))))))"
by (import prob_indep INDEP_PROB)
-lemma INDEP_MEASURABLE1: "(All::(((nat => bool) => 'a * (nat => bool)) => bool) => bool)
- (%f::(nat => bool) => 'a * (nat => bool).
- (All::(('a => bool) => bool) => bool)
- (%p::'a => bool.
+lemma INDEP_MEASURABLE1: "(All::(((nat => bool) => 'a::type * (nat => bool)) => bool) => bool)
+ (%f::(nat => bool) => 'a::type * (nat => bool).
+ (All::(('a::type => bool) => bool) => bool)
+ (%p::'a::type => bool.
(op -->::bool => bool => bool)
- ((indep::((nat => bool) => 'a * (nat => bool)) => bool) f)
+ ((indep::((nat => bool) => 'a::type * (nat => bool)) => bool) f)
((measurable::((nat => bool) => bool) => bool)
- ((op o::('a => bool)
- => ((nat => bool) => 'a) => (nat => bool) => bool)
- p ((op o::('a * (nat => bool) => 'a)
- => ((nat => bool) => 'a * (nat => bool))
- => (nat => bool) => 'a)
- (fst::'a * (nat => bool) => 'a) f)))))"
+ ((op o::('a::type => bool)
+ => ((nat => bool) => 'a::type)
+ => (nat => bool) => bool)
+ p ((op o::('a::type * (nat => bool) => 'a::type)
+ => ((nat => bool) => 'a::type * (nat => bool))
+ => (nat => bool) => 'a::type)
+ (fst::'a::type * (nat => bool) => 'a::type) f)))))"
by (import prob_indep INDEP_MEASURABLE1)
-lemma INDEP_MEASURABLE2: "(All::(((nat => bool) => 'a * (nat => bool)) => bool) => bool)
- (%f::(nat => bool) => 'a * (nat => bool).
+lemma INDEP_MEASURABLE2: "(All::(((nat => bool) => 'a::type * (nat => bool)) => bool) => bool)
+ (%f::(nat => bool) => 'a::type * (nat => bool).
(All::(((nat => bool) => bool) => bool) => bool)
(%q::(nat => bool) => bool.
(op -->::bool => bool => bool)
((op &::bool => bool => bool)
- ((indep::((nat => bool) => 'a * (nat => bool)) => bool) f)
+ ((indep::((nat => bool) => 'a::type * (nat => bool)) => bool)
+ f)
((measurable::((nat => bool) => bool) => bool) q))
((measurable::((nat => bool) => bool) => bool)
((op o::((nat => bool) => bool)
=> ((nat => bool) => nat => bool)
=> (nat => bool) => bool)
- q ((op o::('a * (nat => bool) => nat => bool)
- => ((nat => bool) => 'a * (nat => bool))
+ q ((op o::('a::type * (nat => bool) => nat => bool)
+ => ((nat => bool) => 'a::type * (nat => bool))
=> (nat => bool) => nat => bool)
- (snd::'a * (nat => bool) => nat => bool) f)))))"
+ (snd::'a::type * (nat => bool) => nat => bool) f)))))"
by (import prob_indep INDEP_MEASURABLE2)
lemma PROB_INDEP_BOUND: "(All::(((nat => bool) => nat * (nat => bool)) => bool) => bool)
@@ -3363,15 +3519,22 @@
defs
unif_bound_primdef: "unif_bound ==
-WFREC (SOME R. WF R & (ALL v. R (Suc v div 2) (Suc v)))
- (%unif_bound. nat_case 0 (%v1. Suc (unif_bound (Suc v1 div 2))))"
+WFREC
+ (SOME R::nat => nat => bool.
+ WF R & (ALL v::nat. R (Suc v div (2::nat)) (Suc v)))
+ (%unif_bound::nat => nat.
+ nat_case (0::nat) (%v1::nat. Suc (unif_bound (Suc v1 div (2::nat)))))"
lemma unif_bound_primitive_def: "unif_bound =
-WFREC (SOME R. WF R & (ALL v. R (Suc v div 2) (Suc v)))
- (%unif_bound. nat_case 0 (%v1. Suc (unif_bound (Suc v1 div 2))))"
+WFREC
+ (SOME R::nat => nat => bool.
+ WF R & (ALL v::nat. R (Suc v div (2::nat)) (Suc v)))
+ (%unif_bound::nat => nat.
+ nat_case (0::nat) (%v1::nat. Suc (unif_bound (Suc v1 div (2::nat)))))"
by (import prob_uniform unif_bound_primitive_def)
-lemma unif_bound_def: "unif_bound 0 = 0 & unif_bound (Suc v) = Suc (unif_bound (Suc v div 2))"
+lemma unif_bound_def: "unif_bound (0::nat) = (0::nat) &
+unif_bound (Suc (v::nat)) = Suc (unif_bound (Suc v div (2::nat)))"
by (import prob_uniform unif_bound_def)
lemma unif_bound_ind: "(All::((nat => bool) => bool) => bool)
@@ -3394,35 +3557,47 @@
constdefs
unif_tupled :: "nat * (nat => bool) => nat * (nat => bool)"
"unif_tupled ==
-WFREC (SOME R. WF R & (ALL s v2. R (Suc v2 div 2, s) (Suc v2, s)))
- (%unif_tupled (v, v1).
- case v of 0 => (0, v1)
- | Suc v3 =>
- let (m, s') = unif_tupled (Suc v3 div 2, v1)
- in (if SHD s' then 2 * m + 1 else 2 * m, STL s'))"
+WFREC
+ (SOME R::nat * (nat => bool) => nat * (nat => bool) => bool.
+ WF R &
+ (ALL (s::nat => bool) v2::nat. R (Suc v2 div (2::nat), s) (Suc v2, s)))
+ (%(unif_tupled::nat * (nat => bool) => nat * (nat => bool)) (v::nat,
+ v1::nat => bool).
+ case v of 0 => (0::nat, v1)
+ | Suc (v3::nat) =>
+ let (m::nat, s'::nat => bool) =
+ unif_tupled (Suc v3 div (2::nat), v1)
+ in (if SHD s' then (2::nat) * m + (1::nat) else (2::nat) * m,
+ STL s'))"
lemma unif_tupled_primitive_def: "unif_tupled =
-WFREC (SOME R. WF R & (ALL s v2. R (Suc v2 div 2, s) (Suc v2, s)))
- (%unif_tupled (v, v1).
- case v of 0 => (0, v1)
- | Suc v3 =>
- let (m, s') = unif_tupled (Suc v3 div 2, v1)
- in (if SHD s' then 2 * m + 1 else 2 * m, STL s'))"
+WFREC
+ (SOME R::nat * (nat => bool) => nat * (nat => bool) => bool.
+ WF R &
+ (ALL (s::nat => bool) v2::nat. R (Suc v2 div (2::nat), s) (Suc v2, s)))
+ (%(unif_tupled::nat * (nat => bool) => nat * (nat => bool)) (v::nat,
+ v1::nat => bool).
+ case v of 0 => (0::nat, v1)
+ | Suc (v3::nat) =>
+ let (m::nat, s'::nat => bool) =
+ unif_tupled (Suc v3 div (2::nat), v1)
+ in (if SHD s' then (2::nat) * m + (1::nat) else (2::nat) * m,
+ STL s'))"
by (import prob_uniform unif_tupled_primitive_def)
consts
unif :: "nat => (nat => bool) => nat * (nat => bool)"
defs
- unif_primdef: "unif == %x x1. unif_tupled (x, x1)"
-
-lemma unif_curried_def: "ALL x x1. unif x x1 = unif_tupled (x, x1)"
+ unif_primdef: "unif == %(x::nat) x1::nat => bool. unif_tupled (x, x1)"
+
+lemma unif_curried_def: "ALL (x::nat) x1::nat => bool. unif x x1 = unif_tupled (x, x1)"
by (import prob_uniform unif_curried_def)
-lemma unif_def: "unif 0 s = (0, s) &
-unif (Suc v2) s =
-(let (m, s') = unif (Suc v2 div 2) s
- in (if SHD s' then 2 * m + 1 else 2 * m, STL s'))"
+lemma unif_def: "unif (0::nat) (s::nat => bool) = (0::nat, s) &
+unif (Suc (v2::nat)) s =
+(let (m::nat, s'::nat => bool) = unif (Suc v2 div (2::nat)) s
+ in (if SHD s' then (2::nat) * m + (1::nat) else (2::nat) * m, STL s'))"
by (import prob_uniform unif_def)
lemma unif_ind: "(All::((nat => (nat => bool) => bool) => bool) => bool)
@@ -3648,9 +3823,10 @@
uniform :: "nat => nat => (nat => bool) => nat * (nat => bool)"
defs
- uniform_primdef: "uniform == %x x1 x2. uniform_tupled (x, x1, x2)"
-
-lemma uniform_curried_def: "ALL x x1 x2. uniform x x1 x2 = uniform_tupled (x, x1, x2)"
+ uniform_primdef: "uniform == %(x::nat) (x1::nat) x2::nat => bool. uniform_tupled (x, x1, x2)"
+
+lemma uniform_curried_def: "ALL (x::nat) (x1::nat) x2::nat => bool.
+ uniform x x1 x2 = uniform_tupled (x, x1, x2)"
by (import prob_uniform uniform_curried_def)
lemma uniform_ind: "(All::((nat => nat => (nat => bool) => bool) => bool) => bool)
@@ -3695,19 +3871,19 @@
(%xa::nat. (All::((nat => bool) => bool) => bool) (P x xa)))))"
by (import prob_uniform uniform_ind)
-lemma uniform_def: "uniform 0 (Suc n) s = (0, s) &
-uniform (Suc t) (Suc n) s =
-(let (xa, x) = unif n s
+lemma uniform_def: "uniform (0::nat) (Suc (n::nat)) (s::nat => bool) = (0::nat, s) &
+uniform (Suc (t::nat)) (Suc n) s =
+(let (xa::nat, x::nat => bool) = unif n s
in if xa < Suc n then (xa, x) else uniform t (Suc n) x)"
by (import prob_uniform uniform_def)
-lemma SUC_DIV_TWO_ZERO: "ALL n. (Suc n div 2 = 0) = (n = 0)"
+lemma SUC_DIV_TWO_ZERO: "ALL n::nat. (Suc n div (2::nat) = (0::nat)) = (n = (0::nat))"
by (import prob_uniform SUC_DIV_TWO_ZERO)
-lemma UNIF_BOUND_LOWER: "ALL n. n < 2 ^ unif_bound n"
+lemma UNIF_BOUND_LOWER: "ALL n::nat. n < (2::nat) ^ unif_bound n"
by (import prob_uniform UNIF_BOUND_LOWER)
-lemma UNIF_BOUND_LOWER_SUC: "ALL n. Suc n <= 2 ^ unif_bound n"
+lemma UNIF_BOUND_LOWER_SUC: "ALL n::nat. Suc n <= (2::nat) ^ unif_bound n"
by (import prob_uniform UNIF_BOUND_LOWER_SUC)
lemma UNIF_BOUND_UPPER: "(All::(nat => bool) => bool)
@@ -3729,39 +3905,71 @@
n)))"
by (import prob_uniform UNIF_BOUND_UPPER)
-lemma UNIF_BOUND_UPPER_SUC: "ALL n. 2 ^ unif_bound n <= Suc (2 * n)"
+lemma UNIF_BOUND_UPPER_SUC: "ALL n::nat. (2::nat) ^ unif_bound n <= Suc ((2::nat) * n)"
by (import prob_uniform UNIF_BOUND_UPPER_SUC)
-lemma UNIF_DEF_MONAD: "unif 0 = UNIT 0 &
-(ALL n.
+lemma UNIF_DEF_MONAD: "unif (0::nat) = UNIT (0::nat) &
+(ALL n::nat.
unif (Suc n) =
- BIND (unif (Suc n div 2))
- (%m. BIND SDEST (%b. UNIT (if b then 2 * m + 1 else 2 * m))))"
+ BIND (unif (Suc n div (2::nat)))
+ (%m::nat.
+ BIND SDEST
+ (%b::bool.
+ UNIT (if b then (2::nat) * m + (1::nat) else (2::nat) * m))))"
by (import prob_uniform UNIF_DEF_MONAD)
-lemma UNIFORM_DEF_MONAD: "(ALL x. uniform 0 (Suc x) = UNIT 0) &
-(ALL x xa.
+lemma UNIFORM_DEF_MONAD: "(ALL x::nat. uniform (0::nat) (Suc x) = UNIT (0::nat)) &
+(ALL (x::nat) xa::nat.
uniform (Suc x) (Suc xa) =
- BIND (unif xa) (%m. if m < Suc xa then UNIT m else uniform x (Suc xa)))"
+ BIND (unif xa)
+ (%m::nat. if m < Suc xa then UNIT m else uniform x (Suc xa)))"
by (import prob_uniform UNIFORM_DEF_MONAD)
-lemma INDEP_UNIF: "ALL n. indep (unif n)"
+lemma INDEP_UNIF: "ALL n::nat. indep (unif n)"
by (import prob_uniform INDEP_UNIF)
-lemma INDEP_UNIFORM: "ALL t n. indep (uniform t (Suc n))"
+lemma INDEP_UNIFORM: "ALL (t::nat) n::nat. indep (uniform t (Suc n))"
by (import prob_uniform INDEP_UNIFORM)
-lemma PROB_UNIF: "ALL n k.
- prob (%s. fst (unif n s) = k) =
- (if k < 2 ^ unif_bound n then (1 / 2) ^ unif_bound n else 0)"
+lemma PROB_UNIF: "(All::(nat => bool) => bool)
+ (%n::nat.
+ (All::(nat => bool) => bool)
+ (%k::nat.
+ (op =::real => real => bool)
+ ((prob::((nat => bool) => bool) => real)
+ (%s::nat => bool.
+ (op =::nat => nat => bool)
+ ((fst::nat * (nat => bool) => nat)
+ ((unif::nat => (nat => bool) => nat * (nat => bool)) n
+ s))
+ k))
+ ((If::bool => real => real => real)
+ ((op <::nat => nat => bool) k
+ ((op ^::nat => nat => nat)
+ ((number_of::bin => nat)
+ ((op BIT::bin => bit => bin)
+ ((op BIT::bin => bit => bin) (Numeral.Pls::bin)
+ (bit.B1::bit))
+ (bit.B0::bit)))
+ ((unif_bound::nat => nat) n)))
+ ((op ^::real => nat => real)
+ ((op /::real => real => real) (1::real)
+ ((number_of::bin => real)
+ ((op BIT::bin => bit => bin)
+ ((op BIT::bin => bit => bin) (Numeral.Pls::bin)
+ (bit.B1::bit))
+ (bit.B0::bit))))
+ ((unif_bound::nat => nat) n))
+ (0::real))))"
by (import prob_uniform PROB_UNIF)
-lemma UNIF_RANGE: "ALL n s. fst (unif n s) < 2 ^ unif_bound n"
+lemma UNIF_RANGE: "ALL (n::nat) s::nat => bool. fst (unif n s) < (2::nat) ^ unif_bound n"
by (import prob_uniform UNIF_RANGE)
-lemma PROB_UNIF_PAIR: "ALL n k k'.
- (prob (%s. fst (unif n s) = k) = prob (%s. fst (unif n s) = k')) =
- ((k < 2 ^ unif_bound n) = (k' < 2 ^ unif_bound n))"
+lemma PROB_UNIF_PAIR: "ALL (n::nat) (k::nat) k'::nat.
+ (prob (%s::nat => bool. fst (unif n s) = k) =
+ prob (%s::nat => bool. fst (unif n s) = k')) =
+ ((k < (2::nat) ^ unif_bound n) = (k' < (2::nat) ^ unif_bound n))"
by (import prob_uniform PROB_UNIF_PAIR)
lemma PROB_UNIF_BOUND: "(All::(nat => bool) => bool)
@@ -3796,10 +4004,11 @@
((unif_bound::nat => nat) n))))))"
by (import prob_uniform PROB_UNIF_BOUND)
-lemma PROB_UNIF_GOOD: "ALL n. 1 / 2 <= prob (%s. fst (unif n s) < Suc n)"
+lemma PROB_UNIF_GOOD: "ALL n::nat.
+ (1::real) / (2::real) <= prob (%s::nat => bool. fst (unif n s) < Suc n)"
by (import prob_uniform PROB_UNIF_GOOD)
-lemma UNIFORM_RANGE: "ALL t n s. fst (uniform t (Suc n) s) < Suc n"
+lemma UNIFORM_RANGE: "ALL (t::nat) (n::nat) s::nat => bool. fst (uniform t (Suc n) s) < Suc n"
by (import prob_uniform UNIFORM_RANGE)
lemma PROB_UNIFORM_LOWER_BOUND: "(All::(real => bool) => bool)
--- a/src/HOL/Import/HOL/HOL4Real.thy Mon Sep 26 02:06:44 2005 +0200
+++ b/src/HOL/Import/HOL/HOL4Real.thy Mon Sep 26 02:27:14 2005 +0200
@@ -4,37 +4,39 @@
;setup_theory realax
-lemma HREAL_RDISTRIB: "ALL x y z.
+lemma HREAL_RDISTRIB: "ALL (x::hreal) (y::hreal) z::hreal.
hreal_mul (hreal_add x y) z = hreal_add (hreal_mul x z) (hreal_mul y z)"
by (import realax HREAL_RDISTRIB)
-lemma HREAL_EQ_ADDL: "ALL x y. x ~= hreal_add x y"
+lemma HREAL_EQ_ADDL: "ALL (x::hreal) y::hreal. x ~= hreal_add x y"
by (import realax HREAL_EQ_ADDL)
-lemma HREAL_EQ_LADD: "ALL x y z. (hreal_add x y = hreal_add x z) = (y = z)"
+lemma HREAL_EQ_LADD: "ALL (x::hreal) (y::hreal) z::hreal.
+ (hreal_add x y = hreal_add x z) = (y = z)"
by (import realax HREAL_EQ_LADD)
-lemma HREAL_LT_REFL: "ALL x. ~ hreal_lt x x"
+lemma HREAL_LT_REFL: "ALL x::hreal. ~ hreal_lt x x"
by (import realax HREAL_LT_REFL)
-lemma HREAL_LT_ADDL: "ALL x y. hreal_lt x (hreal_add x y)"
+lemma HREAL_LT_ADDL: "ALL (x::hreal) y::hreal. hreal_lt x (hreal_add x y)"
by (import realax HREAL_LT_ADDL)
-lemma HREAL_LT_NE: "ALL x y. hreal_lt x y --> x ~= y"
+lemma HREAL_LT_NE: "ALL (x::hreal) y::hreal. hreal_lt x y --> x ~= y"
by (import realax HREAL_LT_NE)
-lemma HREAL_LT_ADDR: "ALL x y. ~ hreal_lt (hreal_add x y) x"
+lemma HREAL_LT_ADDR: "ALL (x::hreal) y::hreal. ~ hreal_lt (hreal_add x y) x"
by (import realax HREAL_LT_ADDR)
-lemma HREAL_LT_GT: "ALL x y. hreal_lt x y --> ~ hreal_lt y x"
+lemma HREAL_LT_GT: "ALL (x::hreal) y::hreal. hreal_lt x y --> ~ hreal_lt y x"
by (import realax HREAL_LT_GT)
-lemma HREAL_LT_ADD2: "ALL x1 x2 y1 y2.
+lemma HREAL_LT_ADD2: "ALL (x1::hreal) (x2::hreal) (y1::hreal) y2::hreal.
hreal_lt x1 y1 & hreal_lt x2 y2 -->
hreal_lt (hreal_add x1 x2) (hreal_add y1 y2)"
by (import realax HREAL_LT_ADD2)
-lemma HREAL_LT_LADD: "ALL x y z. hreal_lt (hreal_add x y) (hreal_add x z) = hreal_lt y z"
+lemma HREAL_LT_LADD: "ALL (x::hreal) (y::hreal) z::hreal.
+ hreal_lt (hreal_add x y) (hreal_add x z) = hreal_lt y z"
by (import realax HREAL_LT_LADD)
constdefs
@@ -53,27 +55,29 @@
constdefs
treal_neg :: "hreal * hreal => hreal * hreal"
- "treal_neg == %(x, y). (y, x)"
-
-lemma treal_neg: "ALL x y. treal_neg (x, y) = (y, x)"
+ "treal_neg == %(x::hreal, y::hreal). (y, x)"
+
+lemma treal_neg: "ALL (x::hreal) y::hreal. treal_neg (x, y) = (y, x)"
by (import realax treal_neg)
constdefs
treal_add :: "hreal * hreal => hreal * hreal => hreal * hreal"
- "treal_add == %(x1, y1) (x2, y2). (hreal_add x1 x2, hreal_add y1 y2)"
-
-lemma treal_add: "ALL x1 y1 x2 y2.
+ "treal_add ==
+%(x1::hreal, y1::hreal) (x2::hreal, y2::hreal).
+ (hreal_add x1 x2, hreal_add y1 y2)"
+
+lemma treal_add: "ALL (x1::hreal) (y1::hreal) (x2::hreal) y2::hreal.
treal_add (x1, y1) (x2, y2) = (hreal_add x1 x2, hreal_add y1 y2)"
by (import realax treal_add)
constdefs
treal_mul :: "hreal * hreal => hreal * hreal => hreal * hreal"
"treal_mul ==
-%(x1, y1) (x2, y2).
+%(x1::hreal, y1::hreal) (x2::hreal, y2::hreal).
(hreal_add (hreal_mul x1 x2) (hreal_mul y1 y2),
hreal_add (hreal_mul x1 y2) (hreal_mul y1 x2))"
-lemma treal_mul: "ALL x1 y1 x2 y2.
+lemma treal_mul: "ALL (x1::hreal) (y1::hreal) (x2::hreal) y2::hreal.
treal_mul (x1, y1) (x2, y2) =
(hreal_add (hreal_mul x1 x2) (hreal_mul y1 y2),
hreal_add (hreal_mul x1 y2) (hreal_mul y1 x2))"
@@ -81,22 +85,24 @@
constdefs
treal_lt :: "hreal * hreal => hreal * hreal => bool"
- "treal_lt == %(x1, y1) (x2, y2). hreal_lt (hreal_add x1 y2) (hreal_add x2 y1)"
-
-lemma treal_lt: "ALL x1 y1 x2 y2.
+ "treal_lt ==
+%(x1::hreal, y1::hreal) (x2::hreal, y2::hreal).
+ hreal_lt (hreal_add x1 y2) (hreal_add x2 y1)"
+
+lemma treal_lt: "ALL (x1::hreal) (y1::hreal) (x2::hreal) y2::hreal.
treal_lt (x1, y1) (x2, y2) = hreal_lt (hreal_add x1 y2) (hreal_add x2 y1)"
by (import realax treal_lt)
constdefs
treal_inv :: "hreal * hreal => hreal * hreal"
"treal_inv ==
-%(x, y).
+%(x::hreal, y::hreal).
if x = y then treal_0
else if hreal_lt y x
then (hreal_add (hreal_inv (hreal_sub x y)) hreal_1, hreal_1)
else (hreal_1, hreal_add (hreal_inv (hreal_sub y x)) hreal_1)"
-lemma treal_inv: "ALL x y.
+lemma treal_inv: "ALL (x::hreal) y::hreal.
treal_inv (x, y) =
(if x = y then treal_0
else if hreal_lt y x
@@ -106,132 +112,155 @@
constdefs
treal_eq :: "hreal * hreal => hreal * hreal => bool"
- "treal_eq == %(x1, y1) (x2, y2). hreal_add x1 y2 = hreal_add x2 y1"
-
-lemma treal_eq: "ALL x1 y1 x2 y2.
+ "treal_eq ==
+%(x1::hreal, y1::hreal) (x2::hreal, y2::hreal).
+ hreal_add x1 y2 = hreal_add x2 y1"
+
+lemma treal_eq: "ALL (x1::hreal) (y1::hreal) (x2::hreal) y2::hreal.
treal_eq (x1, y1) (x2, y2) = (hreal_add x1 y2 = hreal_add x2 y1)"
by (import realax treal_eq)
-lemma TREAL_EQ_REFL: "ALL x. treal_eq x x"
+lemma TREAL_EQ_REFL: "ALL x::hreal * hreal. treal_eq x x"
by (import realax TREAL_EQ_REFL)
-lemma TREAL_EQ_SYM: "ALL x y. treal_eq x y = treal_eq y x"
+lemma TREAL_EQ_SYM: "ALL (x::hreal * hreal) y::hreal * hreal. treal_eq x y = treal_eq y x"
by (import realax TREAL_EQ_SYM)
-lemma TREAL_EQ_TRANS: "ALL x y z. treal_eq x y & treal_eq y z --> treal_eq x z"
+lemma TREAL_EQ_TRANS: "ALL (x::hreal * hreal) (y::hreal * hreal) z::hreal * hreal.
+ treal_eq x y & treal_eq y z --> treal_eq x z"
by (import realax TREAL_EQ_TRANS)
-lemma TREAL_EQ_EQUIV: "ALL p q. treal_eq p q = (treal_eq p = treal_eq q)"
+lemma TREAL_EQ_EQUIV: "ALL (p::hreal * hreal) q::hreal * hreal.
+ treal_eq p q = (treal_eq p = treal_eq q)"
by (import realax TREAL_EQ_EQUIV)
-lemma TREAL_EQ_AP: "ALL p q. p = q --> treal_eq p q"
+lemma TREAL_EQ_AP: "ALL (p::hreal * hreal) q::hreal * hreal. p = q --> treal_eq p q"
by (import realax TREAL_EQ_AP)
lemma TREAL_10: "~ treal_eq treal_1 treal_0"
by (import realax TREAL_10)
-lemma TREAL_ADD_SYM: "ALL x y. treal_add x y = treal_add y x"
+lemma TREAL_ADD_SYM: "ALL (x::hreal * hreal) y::hreal * hreal. treal_add x y = treal_add y x"
by (import realax TREAL_ADD_SYM)
-lemma TREAL_MUL_SYM: "ALL x y. treal_mul x y = treal_mul y x"
+lemma TREAL_MUL_SYM: "ALL (x::hreal * hreal) y::hreal * hreal. treal_mul x y = treal_mul y x"
by (import realax TREAL_MUL_SYM)
-lemma TREAL_ADD_ASSOC: "ALL x y z. treal_add x (treal_add y z) = treal_add (treal_add x y) z"
+lemma TREAL_ADD_ASSOC: "ALL (x::hreal * hreal) (y::hreal * hreal) z::hreal * hreal.
+ treal_add x (treal_add y z) = treal_add (treal_add x y) z"
by (import realax TREAL_ADD_ASSOC)
-lemma TREAL_MUL_ASSOC: "ALL x y z. treal_mul x (treal_mul y z) = treal_mul (treal_mul x y) z"
+lemma TREAL_MUL_ASSOC: "ALL (x::hreal * hreal) (y::hreal * hreal) z::hreal * hreal.
+ treal_mul x (treal_mul y z) = treal_mul (treal_mul x y) z"
by (import realax TREAL_MUL_ASSOC)
-lemma TREAL_LDISTRIB: "ALL x y z.
+lemma TREAL_LDISTRIB: "ALL (x::hreal * hreal) (y::hreal * hreal) z::hreal * hreal.
treal_mul x (treal_add y z) = treal_add (treal_mul x y) (treal_mul x z)"
by (import realax TREAL_LDISTRIB)
-lemma TREAL_ADD_LID: "ALL x. treal_eq (treal_add treal_0 x) x"
+lemma TREAL_ADD_LID: "ALL x::hreal * hreal. treal_eq (treal_add treal_0 x) x"
by (import realax TREAL_ADD_LID)
-lemma TREAL_MUL_LID: "ALL x. treal_eq (treal_mul treal_1 x) x"
+lemma TREAL_MUL_LID: "ALL x::hreal * hreal. treal_eq (treal_mul treal_1 x) x"
by (import realax TREAL_MUL_LID)
-lemma TREAL_ADD_LINV: "ALL x. treal_eq (treal_add (treal_neg x) x) treal_0"
+lemma TREAL_ADD_LINV: "ALL x::hreal * hreal. treal_eq (treal_add (treal_neg x) x) treal_0"
by (import realax TREAL_ADD_LINV)
lemma TREAL_INV_0: "treal_eq (treal_inv treal_0) treal_0"
by (import realax TREAL_INV_0)
-lemma TREAL_MUL_LINV: "ALL x. ~ treal_eq x treal_0 --> treal_eq (treal_mul (treal_inv x) x) treal_1"
+lemma TREAL_MUL_LINV: "ALL x::hreal * hreal.
+ ~ treal_eq x treal_0 --> treal_eq (treal_mul (treal_inv x) x) treal_1"
by (import realax TREAL_MUL_LINV)
-lemma TREAL_LT_TOTAL: "ALL x y. treal_eq x y | treal_lt x y | treal_lt y x"
+lemma TREAL_LT_TOTAL: "ALL (x::hreal * hreal) y::hreal * hreal.
+ treal_eq x y | treal_lt x y | treal_lt y x"
by (import realax TREAL_LT_TOTAL)
-lemma TREAL_LT_REFL: "ALL x. ~ treal_lt x x"
+lemma TREAL_LT_REFL: "ALL x::hreal * hreal. ~ treal_lt x x"
by (import realax TREAL_LT_REFL)
-lemma TREAL_LT_TRANS: "ALL x y z. treal_lt x y & treal_lt y z --> treal_lt x z"
+lemma TREAL_LT_TRANS: "ALL (x::hreal * hreal) (y::hreal * hreal) z::hreal * hreal.
+ treal_lt x y & treal_lt y z --> treal_lt x z"
by (import realax TREAL_LT_TRANS)
-lemma TREAL_LT_ADD: "ALL x y z. treal_lt y z --> treal_lt (treal_add x y) (treal_add x z)"
+lemma TREAL_LT_ADD: "ALL (x::hreal * hreal) (y::hreal * hreal) z::hreal * hreal.
+ treal_lt y z --> treal_lt (treal_add x y) (treal_add x z)"
by (import realax TREAL_LT_ADD)
-lemma TREAL_LT_MUL: "ALL x y.
+lemma TREAL_LT_MUL: "ALL (x::hreal * hreal) y::hreal * hreal.
treal_lt treal_0 x & treal_lt treal_0 y -->
treal_lt treal_0 (treal_mul x y)"
by (import realax TREAL_LT_MUL)
constdefs
treal_of_hreal :: "hreal => hreal * hreal"
- "treal_of_hreal == %x. (hreal_add x hreal_1, hreal_1)"
-
-lemma treal_of_hreal: "ALL x. treal_of_hreal x = (hreal_add x hreal_1, hreal_1)"
+ "treal_of_hreal == %x::hreal. (hreal_add x hreal_1, hreal_1)"
+
+lemma treal_of_hreal: "ALL x::hreal. treal_of_hreal x = (hreal_add x hreal_1, hreal_1)"
by (import realax treal_of_hreal)
constdefs
hreal_of_treal :: "hreal * hreal => hreal"
- "hreal_of_treal == %(x, y). SOME d. x = hreal_add y d"
-
-lemma hreal_of_treal: "ALL x y. hreal_of_treal (x, y) = (SOME d. x = hreal_add y d)"
+ "hreal_of_treal == %(x::hreal, y::hreal). SOME d::hreal. x = hreal_add y d"
+
+lemma hreal_of_treal: "ALL (x::hreal) y::hreal.
+ hreal_of_treal (x, y) = (SOME d::hreal. x = hreal_add y d)"
by (import realax hreal_of_treal)
-lemma TREAL_BIJ: "(ALL h. hreal_of_treal (treal_of_hreal h) = h) &
-(ALL r. treal_lt treal_0 r = treal_eq (treal_of_hreal (hreal_of_treal r)) r)"
+lemma TREAL_BIJ: "(ALL h::hreal. hreal_of_treal (treal_of_hreal h) = h) &
+(ALL r::hreal * hreal.
+ treal_lt treal_0 r = treal_eq (treal_of_hreal (hreal_of_treal r)) r)"
by (import realax TREAL_BIJ)
-lemma TREAL_ISO: "ALL h i. hreal_lt h i --> treal_lt (treal_of_hreal h) (treal_of_hreal i)"
+lemma TREAL_ISO: "ALL (h::hreal) i::hreal.
+ hreal_lt h i --> treal_lt (treal_of_hreal h) (treal_of_hreal i)"
by (import realax TREAL_ISO)
-lemma TREAL_BIJ_WELLDEF: "ALL h i. treal_eq h i --> hreal_of_treal h = hreal_of_treal i"
+lemma TREAL_BIJ_WELLDEF: "ALL (h::hreal * hreal) i::hreal * hreal.
+ treal_eq h i --> hreal_of_treal h = hreal_of_treal i"
by (import realax TREAL_BIJ_WELLDEF)
-lemma TREAL_NEG_WELLDEF: "ALL x1 x2. treal_eq x1 x2 --> treal_eq (treal_neg x1) (treal_neg x2)"
+lemma TREAL_NEG_WELLDEF: "ALL (x1::hreal * hreal) x2::hreal * hreal.
+ treal_eq x1 x2 --> treal_eq (treal_neg x1) (treal_neg x2)"
by (import realax TREAL_NEG_WELLDEF)
-lemma TREAL_ADD_WELLDEFR: "ALL x1 x2 y. treal_eq x1 x2 --> treal_eq (treal_add x1 y) (treal_add x2 y)"
+lemma TREAL_ADD_WELLDEFR: "ALL (x1::hreal * hreal) (x2::hreal * hreal) y::hreal * hreal.
+ treal_eq x1 x2 --> treal_eq (treal_add x1 y) (treal_add x2 y)"
by (import realax TREAL_ADD_WELLDEFR)
-lemma TREAL_ADD_WELLDEF: "ALL x1 x2 y1 y2.
+lemma TREAL_ADD_WELLDEF: "ALL (x1::hreal * hreal) (x2::hreal * hreal) (y1::hreal * hreal)
+ y2::hreal * hreal.
treal_eq x1 x2 & treal_eq y1 y2 -->
treal_eq (treal_add x1 y1) (treal_add x2 y2)"
by (import realax TREAL_ADD_WELLDEF)
-lemma TREAL_MUL_WELLDEFR: "ALL x1 x2 y. treal_eq x1 x2 --> treal_eq (treal_mul x1 y) (treal_mul x2 y)"
+lemma TREAL_MUL_WELLDEFR: "ALL (x1::hreal * hreal) (x2::hreal * hreal) y::hreal * hreal.
+ treal_eq x1 x2 --> treal_eq (treal_mul x1 y) (treal_mul x2 y)"
by (import realax TREAL_MUL_WELLDEFR)
-lemma TREAL_MUL_WELLDEF: "ALL x1 x2 y1 y2.
+lemma TREAL_MUL_WELLDEF: "ALL (x1::hreal * hreal) (x2::hreal * hreal) (y1::hreal * hreal)
+ y2::hreal * hreal.
treal_eq x1 x2 & treal_eq y1 y2 -->
treal_eq (treal_mul x1 y1) (treal_mul x2 y2)"
by (import realax TREAL_MUL_WELLDEF)
-lemma TREAL_LT_WELLDEFR: "ALL x1 x2 y. treal_eq x1 x2 --> treal_lt x1 y = treal_lt x2 y"
+lemma TREAL_LT_WELLDEFR: "ALL (x1::hreal * hreal) (x2::hreal * hreal) y::hreal * hreal.
+ treal_eq x1 x2 --> treal_lt x1 y = treal_lt x2 y"
by (import realax TREAL_LT_WELLDEFR)
-lemma TREAL_LT_WELLDEFL: "ALL x y1 y2. treal_eq y1 y2 --> treal_lt x y1 = treal_lt x y2"
+lemma TREAL_LT_WELLDEFL: "ALL (x::hreal * hreal) (y1::hreal * hreal) y2::hreal * hreal.
+ treal_eq y1 y2 --> treal_lt x y1 = treal_lt x y2"
by (import realax TREAL_LT_WELLDEFL)
-lemma TREAL_LT_WELLDEF: "ALL x1 x2 y1 y2.
+lemma TREAL_LT_WELLDEF: "ALL (x1::hreal * hreal) (x2::hreal * hreal) (y1::hreal * hreal)
+ y2::hreal * hreal.
treal_eq x1 x2 & treal_eq y1 y2 --> treal_lt x1 y1 = treal_lt x2 y2"
by (import realax TREAL_LT_WELLDEF)
-lemma TREAL_INV_WELLDEF: "ALL x1 x2. treal_eq x1 x2 --> treal_eq (treal_inv x1) (treal_inv x2)"
+lemma TREAL_INV_WELLDEF: "ALL (x1::hreal * hreal) x2::hreal * hreal.
+ treal_eq x1 x2 --> treal_eq (treal_inv x1) (treal_inv x2)"
by (import realax TREAL_INV_WELLDEF)
;end_setup
@@ -413,7 +442,7 @@
x ~= (0::real) & x * xa = x * xb --> xa = xb"
by (import real REAL_EQ_LMUL_IMP)
-lemma REAL_FACT_NZ: "ALL n. real (FACT n) ~= 0"
+lemma REAL_FACT_NZ: "ALL n::nat. real (FACT n) ~= (0::real)"
by (import real REAL_FACT_NZ)
lemma REAL_DIFFSQ: "ALL (x::real) y::real. (x + y) * (x - y) = x * x - y * y"
@@ -477,7 +506,7 @@
x < y"
by (import real ABS_BETWEEN2)
-lemma POW_PLUS1: "ALL e>0. ALL n. 1 + real n * e <= (1 + e) ^ n"
+lemma POW_PLUS1: "ALL e>0::real. ALL n::nat. (1::real) + real n * e <= ((1::real) + e) ^ n"
by (import real POW_PLUS1)
lemma POW_M1: "ALL n::nat. abs ((- (1::real)) ^ n) = (1::real)"
@@ -533,17 +562,22 @@
constdefs
sup :: "(real => bool) => real"
- "sup == %P. SOME s. ALL y. (EX x. P x & y < x) = (y < s)"
-
-lemma sup: "ALL P. sup P = (SOME s. ALL y. (EX x. P x & y < x) = (y < s))"
+ "sup ==
+%P::real => bool.
+ SOME s::real. ALL y::real. (EX x::real. P x & y < x) = (y < s)"
+
+lemma sup: "ALL P::real => bool.
+ sup P = (SOME s::real. ALL y::real. (EX x::real. P x & y < x) = (y < s))"
by (import real sup)
-lemma REAL_SUP: "ALL P.
- Ex P & (EX z. ALL x. P x --> x < z) -->
- (ALL y. (EX x. P x & y < x) = (y < sup P))"
+lemma REAL_SUP: "ALL P::real => bool.
+ Ex P & (EX z::real. ALL x::real. P x --> x < z) -->
+ (ALL y::real. (EX x::real. P x & y < x) = (y < sup P))"
by (import real REAL_SUP)
-lemma REAL_SUP_UBOUND: "ALL P. Ex P & (EX z. ALL x. P x --> x < z) --> (ALL y. P y --> y <= sup P)"
+lemma REAL_SUP_UBOUND: "ALL P::real => bool.
+ Ex P & (EX z::real. ALL x::real. P x --> x < z) -->
+ (ALL y::real. P y --> y <= sup P)"
by (import real REAL_SUP_UBOUND)
lemma SETOK_LE_LT: "ALL P::real => bool.
@@ -551,22 +585,26 @@
(Ex P & (EX z::real. ALL x::real. P x --> x < z))"
by (import real SETOK_LE_LT)
-lemma REAL_SUP_LE: "ALL P.
- Ex P & (EX z. ALL x. P x --> x <= z) -->
- (ALL y. (EX x. P x & y < x) = (y < sup P))"
+lemma REAL_SUP_LE: "ALL P::real => bool.
+ Ex P & (EX z::real. ALL x::real. P x --> x <= z) -->
+ (ALL y::real. (EX x::real. P x & y < x) = (y < sup P))"
by (import real REAL_SUP_LE)
-lemma REAL_SUP_UBOUND_LE: "ALL P. Ex P & (EX z. ALL x. P x --> x <= z) --> (ALL y. P y --> y <= sup P)"
+lemma REAL_SUP_UBOUND_LE: "ALL P::real => bool.
+ Ex P & (EX z::real. ALL x::real. P x --> x <= z) -->
+ (ALL y::real. P y --> y <= sup P)"
by (import real REAL_SUP_UBOUND_LE)
-lemma REAL_ARCH_LEAST: "ALL y>0. ALL x>=0. EX n. real n * y <= x & x < real (Suc n) * y"
+lemma REAL_ARCH_LEAST: "ALL y>0::real.
+ ALL x>=0::real. EX n::nat. real n * y <= x & x < real (Suc n) * y"
by (import real REAL_ARCH_LEAST)
consts
sumc :: "nat => nat => (nat => real) => real"
-specification (sumc) sumc: "(ALL n f. sumc n 0 f = 0) &
-(ALL n m f. sumc n (Suc m) f = sumc n m f + f (n + m))"
+specification (sumc) sumc: "(ALL (n::nat) f::nat => real. sumc n (0::nat) f = (0::real)) &
+(ALL (n::nat) (m::nat) f::nat => real.
+ sumc n (Suc m) f = sumc n m f + f (n + m))"
by (import real sumc)
consts
@@ -580,97 +618,114 @@
=> nat * nat => (nat => real) => real)
(sumc::nat => nat => (nat => real) => real))"
-lemma SUM_DEF: "ALL m n f. real.sum (m, n) f = sumc m n f"
+lemma SUM_DEF: "ALL (m::nat) (n::nat) f::nat => real. real.sum (m, n) f = sumc m n f"
by (import real SUM_DEF)
-lemma sum: "ALL x xa xb.
- real.sum (xa, 0) x = 0 &
+lemma sum: "ALL (x::nat => real) (xa::nat) xb::nat.
+ real.sum (xa, 0::nat) x = (0::real) &
real.sum (xa, Suc xb) x = real.sum (xa, xb) x + x (xa + xb)"
by (import real sum)
-lemma SUM_TWO: "ALL f n p. real.sum (0, n) f + real.sum (n, p) f = real.sum (0, n + p) f"
+lemma SUM_TWO: "ALL (f::nat => real) (n::nat) p::nat.
+ real.sum (0::nat, n) f + real.sum (n, p) f = real.sum (0::nat, n + p) f"
by (import real SUM_TWO)
-lemma SUM_DIFF: "ALL f m n. real.sum (m, n) f = real.sum (0, m + n) f - real.sum (0, m) f"
+lemma SUM_DIFF: "ALL (f::nat => real) (m::nat) n::nat.
+ real.sum (m, n) f = real.sum (0::nat, m + n) f - real.sum (0::nat, m) f"
by (import real SUM_DIFF)
-lemma ABS_SUM: "ALL f m n. abs (real.sum (m, n) f) <= real.sum (m, n) (%n. abs (f n))"
+lemma ABS_SUM: "ALL (f::nat => real) (m::nat) n::nat.
+ abs (real.sum (m, n) f) <= real.sum (m, n) (%n::nat. abs (f n))"
by (import real ABS_SUM)
-lemma SUM_LE: "ALL f g m n.
- (ALL r. m <= r & r < n + m --> f r <= g r) -->
+lemma SUM_LE: "ALL (f::nat => real) (g::nat => real) (m::nat) n::nat.
+ (ALL r::nat. m <= r & r < n + m --> f r <= g r) -->
real.sum (m, n) f <= real.sum (m, n) g"
by (import real SUM_LE)
-lemma SUM_EQ: "ALL f g m n.
- (ALL r. m <= r & r < n + m --> f r = g r) -->
+lemma SUM_EQ: "ALL (f::nat => real) (g::nat => real) (m::nat) n::nat.
+ (ALL r::nat. m <= r & r < n + m --> f r = g r) -->
real.sum (m, n) f = real.sum (m, n) g"
by (import real SUM_EQ)
-lemma SUM_POS: "ALL f. (ALL n. 0 <= f n) --> (ALL m n. 0 <= real.sum (m, n) f)"
+lemma SUM_POS: "ALL f::nat => real.
+ (ALL n::nat. (0::real) <= f n) -->
+ (ALL (m::nat) n::nat. (0::real) <= real.sum (m, n) f)"
by (import real SUM_POS)
-lemma SUM_POS_GEN: "ALL f m. (ALL n. m <= n --> 0 <= f n) --> (ALL n. 0 <= real.sum (m, n) f)"
+lemma SUM_POS_GEN: "ALL (f::nat => real) m::nat.
+ (ALL n::nat. m <= n --> (0::real) <= f n) -->
+ (ALL n::nat. (0::real) <= real.sum (m, n) f)"
by (import real SUM_POS_GEN)
-lemma SUM_ABS: "ALL f m x.
- abs (real.sum (m, x) (%m. abs (f m))) = real.sum (m, x) (%m. abs (f m))"
+lemma SUM_ABS: "ALL (f::nat => real) (m::nat) x::nat.
+ abs (real.sum (m, x) (%m::nat. abs (f m))) =
+ real.sum (m, x) (%m::nat. abs (f m))"
by (import real SUM_ABS)
-lemma SUM_ABS_LE: "ALL f m n. abs (real.sum (m, n) f) <= real.sum (m, n) (%n. abs (f n))"
+lemma SUM_ABS_LE: "ALL (f::nat => real) (m::nat) n::nat.
+ abs (real.sum (m, n) f) <= real.sum (m, n) (%n::nat. abs (f n))"
by (import real SUM_ABS_LE)
-lemma SUM_ZERO: "ALL f N.
- (ALL n. N <= n --> f n = 0) -->
- (ALL m n. N <= m --> real.sum (m, n) f = 0)"
+lemma SUM_ZERO: "ALL (f::nat => real) N::nat.
+ (ALL n::nat. N <= n --> f n = (0::real)) -->
+ (ALL (m::nat) n::nat. N <= m --> real.sum (m, n) f = (0::real))"
by (import real SUM_ZERO)
-lemma SUM_ADD: "ALL f g m n.
- real.sum (m, n) (%n. f n + g n) = real.sum (m, n) f + real.sum (m, n) g"
+lemma SUM_ADD: "ALL (f::nat => real) (g::nat => real) (m::nat) n::nat.
+ real.sum (m, n) (%n::nat. f n + g n) =
+ real.sum (m, n) f + real.sum (m, n) g"
by (import real SUM_ADD)
-lemma SUM_CMUL: "ALL f c m n. real.sum (m, n) (%n. c * f n) = c * real.sum (m, n) f"
+lemma SUM_CMUL: "ALL (f::nat => real) (c::real) (m::nat) n::nat.
+ real.sum (m, n) (%n::nat. c * f n) = c * real.sum (m, n) f"
by (import real SUM_CMUL)
-lemma SUM_NEG: "ALL f n d. real.sum (n, d) (%n. - f n) = - real.sum (n, d) f"
+lemma SUM_NEG: "ALL (f::nat => real) (n::nat) d::nat.
+ real.sum (n, d) (%n::nat. - f n) = - real.sum (n, d) f"
by (import real SUM_NEG)
-lemma SUM_SUB: "ALL f g m n.
- real.sum (m, n) (%x. f x - g x) = real.sum (m, n) f - real.sum (m, n) g"
+lemma SUM_SUB: "ALL (f::nat => real) (g::nat => real) (m::nat) n::nat.
+ real.sum (m, n) (%x::nat. f x - g x) =
+ real.sum (m, n) f - real.sum (m, n) g"
by (import real SUM_SUB)
-lemma SUM_SUBST: "ALL f g m n.
- (ALL p. m <= p & p < m + n --> f p = g p) -->
+lemma SUM_SUBST: "ALL (f::nat => real) (g::nat => real) (m::nat) n::nat.
+ (ALL p::nat. m <= p & p < m + n --> f p = g p) -->
real.sum (m, n) f = real.sum (m, n) g"
by (import real SUM_SUBST)
-lemma SUM_NSUB: "ALL n f c. real.sum (0, n) f - real n * c = real.sum (0, n) (%p. f p - c)"
+lemma SUM_NSUB: "ALL (n::nat) (f::nat => real) c::real.
+ real.sum (0::nat, n) f - real n * c =
+ real.sum (0::nat, n) (%p::nat. f p - c)"
by (import real SUM_NSUB)
-lemma SUM_BOUND: "ALL f k m n.
- (ALL p. m <= p & p < m + n --> f p <= k) -->
+lemma SUM_BOUND: "ALL (f::nat => real) (k::real) (m::nat) n::nat.
+ (ALL p::nat. m <= p & p < m + n --> f p <= k) -->
real.sum (m, n) f <= real n * k"
by (import real SUM_BOUND)
-lemma SUM_GROUP: "ALL n k f.
- real.sum (0, n) (%m. real.sum (m * k, k) f) = real.sum (0, n * k) f"
+lemma SUM_GROUP: "ALL (n::nat) (k::nat) f::nat => real.
+ real.sum (0::nat, n) (%m::nat. real.sum (m * k, k) f) =
+ real.sum (0::nat, n * k) f"
by (import real SUM_GROUP)
-lemma SUM_1: "ALL f n. real.sum (n, 1) f = f n"
+lemma SUM_1: "ALL (f::nat => real) n::nat. real.sum (n, 1::nat) f = f n"
by (import real SUM_1)
-lemma SUM_2: "ALL f n. real.sum (n, 2) f = f n + f (n + 1)"
+lemma SUM_2: "ALL (f::nat => real) n::nat. real.sum (n, 2::nat) f = f n + f (n + (1::nat))"
by (import real SUM_2)
-lemma SUM_OFFSET: "ALL f n k.
- real.sum (0, n) (%m. f (m + k)) =
- real.sum (0, n + k) f - real.sum (0, k) f"
+lemma SUM_OFFSET: "ALL (f::nat => real) (n::nat) k::nat.
+ real.sum (0::nat, n) (%m::nat. f (m + k)) =
+ real.sum (0::nat, n + k) f - real.sum (0::nat, k) f"
by (import real SUM_OFFSET)
-lemma SUM_REINDEX: "ALL f m k n. real.sum (m + k, n) f = real.sum (m, n) (%r. f (r + k))"
+lemma SUM_REINDEX: "ALL (f::nat => real) (m::nat) (k::nat) n::nat.
+ real.sum (m + k, n) f = real.sum (m, n) (%r::nat. f (r + k))"
by (import real SUM_REINDEX)
-lemma SUM_0: "ALL m n. real.sum (m, n) (%r. 0) = 0"
+lemma SUM_0: "ALL (m::nat) n::nat. real.sum (m, n) (%r::nat. 0::real) = (0::real)"
by (import real SUM_0)
lemma SUM_PERMUTE_0: "(All::(nat => bool) => bool)
@@ -697,7 +752,8 @@
((Pair::nat => nat => nat * nat) (0::nat) n) f)))))"
by (import real SUM_PERMUTE_0)
-lemma SUM_CANCEL: "ALL f n d. real.sum (n, d) (%n. f (Suc n) - f n) = f (n + d) - f n"
+lemma SUM_CANCEL: "ALL (f::nat => real) (n::nat) d::nat.
+ real.sum (n, d) (%n::nat. f (Suc n) - f n) = f (n + d) - f n"
by (import real SUM_CANCEL)
lemma REAL_EQ_RDIV_EQ: "ALL (x::real) (xa::real) xb::real.
@@ -713,267 +769,328 @@
;setup_theory topology
constdefs
- re_Union :: "(('a => bool) => bool) => 'a => bool"
- "re_Union == %P x. EX s. P s & s x"
-
-lemma re_Union: "ALL P. re_Union P = (%x. EX s. P s & s x)"
+ re_Union :: "(('a::type => bool) => bool) => 'a::type => bool"
+ "re_Union ==
+%(P::('a::type => bool) => bool) x::'a::type.
+ EX s::'a::type => bool. P s & s x"
+
+lemma re_Union: "ALL P::('a::type => bool) => bool.
+ re_Union P = (%x::'a::type. EX s::'a::type => bool. P s & s x)"
by (import topology re_Union)
constdefs
- re_union :: "('a => bool) => ('a => bool) => 'a => bool"
- "re_union == %P Q x. P x | Q x"
-
-lemma re_union: "ALL P Q. re_union P Q = (%x. P x | Q x)"
+ re_union :: "('a::type => bool) => ('a::type => bool) => 'a::type => bool"
+ "re_union ==
+%(P::'a::type => bool) (Q::'a::type => bool) x::'a::type. P x | Q x"
+
+lemma re_union: "ALL (P::'a::type => bool) Q::'a::type => bool.
+ re_union P Q = (%x::'a::type. P x | Q x)"
by (import topology re_union)
constdefs
- re_intersect :: "('a => bool) => ('a => bool) => 'a => bool"
- "re_intersect == %P Q x. P x & Q x"
-
-lemma re_intersect: "ALL P Q. re_intersect P Q = (%x. P x & Q x)"
+ re_intersect :: "('a::type => bool) => ('a::type => bool) => 'a::type => bool"
+ "re_intersect ==
+%(P::'a::type => bool) (Q::'a::type => bool) x::'a::type. P x & Q x"
+
+lemma re_intersect: "ALL (P::'a::type => bool) Q::'a::type => bool.
+ re_intersect P Q = (%x::'a::type. P x & Q x)"
by (import topology re_intersect)
constdefs
- re_null :: "'a => bool"
- "re_null == %x. False"
-
-lemma re_null: "re_null = (%x. False)"
+ re_null :: "'a::type => bool"
+ "re_null == %x::'a::type. False"
+
+lemma re_null: "re_null = (%x::'a::type. False)"
by (import topology re_null)
constdefs
- re_universe :: "'a => bool"
- "re_universe == %x. True"
-
-lemma re_universe: "re_universe = (%x. True)"
+ re_universe :: "'a::type => bool"
+ "re_universe == %x::'a::type. True"
+
+lemma re_universe: "re_universe = (%x::'a::type. True)"
by (import topology re_universe)
constdefs
- re_subset :: "('a => bool) => ('a => bool) => bool"
- "re_subset == %P Q. ALL x. P x --> Q x"
-
-lemma re_subset: "ALL P Q. re_subset P Q = (ALL x. P x --> Q x)"
+ re_subset :: "('a::type => bool) => ('a::type => bool) => bool"
+ "re_subset ==
+%(P::'a::type => bool) Q::'a::type => bool. ALL x::'a::type. P x --> Q x"
+
+lemma re_subset: "ALL (P::'a::type => bool) Q::'a::type => bool.
+ re_subset P Q = (ALL x::'a::type. P x --> Q x)"
by (import topology re_subset)
constdefs
- re_compl :: "('a => bool) => 'a => bool"
- "re_compl == %P x. ~ P x"
-
-lemma re_compl: "ALL P. re_compl P = (%x. ~ P x)"
+ re_compl :: "('a::type => bool) => 'a::type => bool"
+ "re_compl == %(P::'a::type => bool) x::'a::type. ~ P x"
+
+lemma re_compl: "ALL P::'a::type => bool. re_compl P = (%x::'a::type. ~ P x)"
by (import topology re_compl)
-lemma SUBSET_REFL: "ALL P. re_subset P P"
+lemma SUBSET_REFL: "ALL P::'a::type => bool. re_subset P P"
by (import topology SUBSET_REFL)
-lemma COMPL_MEM: "ALL P x. P x = (~ re_compl P x)"
+lemma COMPL_MEM: "ALL (P::'a::type => bool) x::'a::type. P x = (~ re_compl P x)"
by (import topology COMPL_MEM)
-lemma SUBSET_ANTISYM: "ALL P Q. (re_subset P Q & re_subset Q P) = (P = Q)"
+lemma SUBSET_ANTISYM: "ALL (P::'a::type => bool) Q::'a::type => bool.
+ (re_subset P Q & re_subset Q P) = (P = Q)"
by (import topology SUBSET_ANTISYM)
-lemma SUBSET_TRANS: "ALL P Q R. re_subset P Q & re_subset Q R --> re_subset P R"
+lemma SUBSET_TRANS: "ALL (P::'a::type => bool) (Q::'a::type => bool) R::'a::type => bool.
+ re_subset P Q & re_subset Q R --> re_subset P R"
by (import topology SUBSET_TRANS)
constdefs
- istopology :: "(('a => bool) => bool) => bool"
+ istopology :: "(('a::type => bool) => bool) => bool"
"istopology ==
-%L. L re_null &
- L re_universe &
- (ALL a b. L a & L b --> L (re_intersect a b)) &
- (ALL P. re_subset P L --> L (re_Union P))"
-
-lemma istopology: "ALL L.
+%L::('a::type => bool) => bool.
+ L re_null &
+ L re_universe &
+ (ALL (a::'a::type => bool) b::'a::type => bool.
+ L a & L b --> L (re_intersect a b)) &
+ (ALL P::('a::type => bool) => bool. re_subset P L --> L (re_Union P))"
+
+lemma istopology: "ALL L::('a::type => bool) => bool.
istopology L =
(L re_null &
L re_universe &
- (ALL a b. L a & L b --> L (re_intersect a b)) &
- (ALL P. re_subset P L --> L (re_Union P)))"
+ (ALL (a::'a::type => bool) b::'a::type => bool.
+ L a & L b --> L (re_intersect a b)) &
+ (ALL P::('a::type => bool) => bool. re_subset P L --> L (re_Union P)))"
by (import topology istopology)
-typedef (open) ('a) topology = "(Collect::((('a => bool) => bool) => bool) => (('a => bool) => bool) set)
- (istopology::(('a => bool) => bool) => bool)"
+typedef (open) ('a) topology = "(Collect::((('a::type => bool) => bool) => bool)
+ => (('a::type => bool) => bool) set)
+ (istopology::(('a::type => bool) => bool) => bool)"
by (rule typedef_helper,import topology topology_TY_DEF)
lemmas topology_TY_DEF = typedef_hol2hol4 [OF type_definition_topology]
consts
- topology :: "(('a => bool) => bool) => 'a topology"
- "open" :: "'a topology => ('a => bool) => bool"
-
-specification ("open" topology) topology_tybij: "(ALL a::'a topology. topology (open a) = a) &
-(ALL r::('a => bool) => bool. istopology r = (open (topology r) = r))"
+ topology :: "(('a::type => bool) => bool) => 'a::type topology"
+ "open" :: "'a::type topology => ('a::type => bool) => bool"
+
+specification ("open" topology) topology_tybij: "(ALL a::'a::type topology. topology (open a) = a) &
+(ALL r::('a::type => bool) => bool. istopology r = (open (topology r) = r))"
by (import topology topology_tybij)
-lemma TOPOLOGY: "ALL L.
+lemma TOPOLOGY: "ALL L::'a::type topology.
open L re_null &
open L re_universe &
- (ALL a b. open L a & open L b --> open L (re_intersect a b)) &
- (ALL P. re_subset P (open L) --> open L (re_Union P))"
+ (ALL (a::'a::type => bool) b::'a::type => bool.
+ open L a & open L b --> open L (re_intersect a b)) &
+ (ALL P::('a::type => bool) => bool.
+ re_subset P (open L) --> open L (re_Union P))"
by (import topology TOPOLOGY)
-lemma TOPOLOGY_UNION: "ALL x xa. re_subset xa (open x) --> open x (re_Union xa)"
+lemma TOPOLOGY_UNION: "ALL (x::'a::type topology) xa::('a::type => bool) => bool.
+ re_subset xa (open x) --> open x (re_Union xa)"
by (import topology TOPOLOGY_UNION)
constdefs
- neigh :: "'a topology => ('a => bool) * 'a => bool"
- "neigh == %top (N, x). EX P. open top P & re_subset P N & P x"
-
-lemma neigh: "ALL top N x. neigh top (N, x) = (EX P. open top P & re_subset P N & P x)"
+ neigh :: "'a::type topology => ('a::type => bool) * 'a::type => bool"
+ "neigh ==
+%(top::'a::type topology) (N::'a::type => bool, x::'a::type).
+ EX P::'a::type => bool. open top P & re_subset P N & P x"
+
+lemma neigh: "ALL (top::'a::type topology) (N::'a::type => bool) x::'a::type.
+ neigh top (N, x) =
+ (EX P::'a::type => bool. open top P & re_subset P N & P x)"
by (import topology neigh)
-lemma OPEN_OWN_NEIGH: "ALL S' top x. open top S' & S' x --> neigh top (S', x)"
+lemma OPEN_OWN_NEIGH: "ALL (S'::'a::type => bool) (top::'a::type topology) x::'a::type.
+ open top S' & S' x --> neigh top (S', x)"
by (import topology OPEN_OWN_NEIGH)
-lemma OPEN_UNOPEN: "ALL S' top. open top S' = (re_Union (%P. open top P & re_subset P S') = S')"
+lemma OPEN_UNOPEN: "ALL (S'::'a::type => bool) top::'a::type topology.
+ open top S' =
+ (re_Union (%P::'a::type => bool. open top P & re_subset P S') = S')"
by (import topology OPEN_UNOPEN)
-lemma OPEN_SUBOPEN: "ALL S' top.
- open top S' = (ALL x. S' x --> (EX P. P x & open top P & re_subset P S'))"
+lemma OPEN_SUBOPEN: "ALL (S'::'a::type => bool) top::'a::type topology.
+ open top S' =
+ (ALL x::'a::type.
+ S' x --> (EX P::'a::type => bool. P x & open top P & re_subset P S'))"
by (import topology OPEN_SUBOPEN)
-lemma OPEN_NEIGH: "ALL S' top.
- open top S' = (ALL x. S' x --> (EX N. neigh top (N, x) & re_subset N S'))"
+lemma OPEN_NEIGH: "ALL (S'::'a::type => bool) top::'a::type topology.
+ open top S' =
+ (ALL x::'a::type.
+ S' x --> (EX N::'a::type => bool. neigh top (N, x) & re_subset N S'))"
by (import topology OPEN_NEIGH)
constdefs
- closed :: "'a topology => ('a => bool) => bool"
- "closed == %L S'. open L (re_compl S')"
-
-lemma closed: "ALL L S'. closed L S' = open L (re_compl S')"
+ closed :: "'a::type topology => ('a::type => bool) => bool"
+ "closed == %(L::'a::type topology) S'::'a::type => bool. open L (re_compl S')"
+
+lemma closed: "ALL (L::'a::type topology) S'::'a::type => bool.
+ closed L S' = open L (re_compl S')"
by (import topology closed)
constdefs
- limpt :: "'a topology => 'a => ('a => bool) => bool"
- "limpt == %top x S'. ALL N. neigh top (N, x) --> (EX y. x ~= y & S' y & N y)"
-
-lemma limpt: "ALL top x S'.
+ limpt :: "'a::type topology => 'a::type => ('a::type => bool) => bool"
+ "limpt ==
+%(top::'a::type topology) (x::'a::type) S'::'a::type => bool.
+ ALL N::'a::type => bool.
+ neigh top (N, x) --> (EX y::'a::type. x ~= y & S' y & N y)"
+
+lemma limpt: "ALL (top::'a::type topology) (x::'a::type) S'::'a::type => bool.
limpt top x S' =
- (ALL N. neigh top (N, x) --> (EX y. x ~= y & S' y & N y))"
+ (ALL N::'a::type => bool.
+ neigh top (N, x) --> (EX y::'a::type. x ~= y & S' y & N y))"
by (import topology limpt)
-lemma CLOSED_LIMPT: "ALL top S'. closed top S' = (ALL x. limpt top x S' --> S' x)"
+lemma CLOSED_LIMPT: "ALL (top::'a::type topology) S'::'a::type => bool.
+ closed top S' = (ALL x::'a::type. limpt top x S' --> S' x)"
by (import topology CLOSED_LIMPT)
constdefs
- ismet :: "('a * 'a => real) => bool"
+ ismet :: "('a::type * 'a::type => real) => bool"
"ismet ==
-%m. (ALL x y. (m (x, y) = 0) = (x = y)) &
- (ALL x y z. m (y, z) <= m (x, y) + m (x, z))"
-
-lemma ismet: "ALL m.
+%m::'a::type * 'a::type => real.
+ (ALL (x::'a::type) y::'a::type. (m (x, y) = (0::real)) = (x = y)) &
+ (ALL (x::'a::type) (y::'a::type) z::'a::type.
+ m (y, z) <= m (x, y) + m (x, z))"
+
+lemma ismet: "ALL m::'a::type * 'a::type => real.
ismet m =
- ((ALL x y. (m (x, y) = 0) = (x = y)) &
- (ALL x y z. m (y, z) <= m (x, y) + m (x, z)))"
+ ((ALL (x::'a::type) y::'a::type. (m (x, y) = (0::real)) = (x = y)) &
+ (ALL (x::'a::type) (y::'a::type) z::'a::type.
+ m (y, z) <= m (x, y) + m (x, z)))"
by (import topology ismet)
-typedef (open) ('a) metric = "(Collect::(('a * 'a => real) => bool) => ('a * 'a => real) set)
- (ismet::('a * 'a => real) => bool)"
+typedef (open) ('a) metric = "(Collect::(('a::type * 'a::type => real) => bool)
+ => ('a::type * 'a::type => real) set)
+ (ismet::('a::type * 'a::type => real) => bool)"
by (rule typedef_helper,import topology metric_TY_DEF)
lemmas metric_TY_DEF = typedef_hol2hol4 [OF type_definition_metric]
consts
- metric :: "('a * 'a => real) => 'a metric"
- dist :: "'a metric => 'a * 'a => real"
-
-specification (dist metric) metric_tybij: "(ALL a::'a metric. metric (dist a) = a) &
-(ALL r::'a * 'a => real. ismet r = (dist (metric r) = r))"
+ metric :: "('a::type * 'a::type => real) => 'a::type metric"
+ dist :: "'a::type metric => 'a::type * 'a::type => real"
+
+specification (dist metric) metric_tybij: "(ALL a::'a::type metric. metric (dist a) = a) &
+(ALL r::'a::type * 'a::type => real. ismet r = (dist (metric r) = r))"
by (import topology metric_tybij)
-lemma METRIC_ISMET: "ALL m. ismet (dist m)"
+lemma METRIC_ISMET: "ALL m::'a::type metric. ismet (dist m)"
by (import topology METRIC_ISMET)
-lemma METRIC_ZERO: "ALL m x y. (dist m (x, y) = 0) = (x = y)"
+lemma METRIC_ZERO: "ALL (m::'a::type metric) (x::'a::type) y::'a::type.
+ (dist m (x, y) = (0::real)) = (x = y)"
by (import topology METRIC_ZERO)
-lemma METRIC_SAME: "ALL m x. dist m (x, x) = 0"
+lemma METRIC_SAME: "ALL (m::'a::type metric) x::'a::type. dist m (x, x) = (0::real)"
by (import topology METRIC_SAME)
-lemma METRIC_POS: "ALL m x y. 0 <= dist m (x, y)"
+lemma METRIC_POS: "ALL (m::'a::type metric) (x::'a::type) y::'a::type.
+ (0::real) <= dist m (x, y)"
by (import topology METRIC_POS)
-lemma METRIC_SYM: "ALL m x y. dist m (x, y) = dist m (y, x)"
+lemma METRIC_SYM: "ALL (m::'a::type metric) (x::'a::type) y::'a::type.
+ dist m (x, y) = dist m (y, x)"
by (import topology METRIC_SYM)
-lemma METRIC_TRIANGLE: "ALL m x y z. dist m (x, z) <= dist m (x, y) + dist m (y, z)"
+lemma METRIC_TRIANGLE: "ALL (m::'a::type metric) (x::'a::type) (y::'a::type) z::'a::type.
+ dist m (x, z) <= dist m (x, y) + dist m (y, z)"
by (import topology METRIC_TRIANGLE)
-lemma METRIC_NZ: "ALL m x y. x ~= y --> 0 < dist m (x, y)"
+lemma METRIC_NZ: "ALL (m::'a::type metric) (x::'a::type) y::'a::type.
+ x ~= y --> (0::real) < dist m (x, y)"
by (import topology METRIC_NZ)
constdefs
- mtop :: "'a metric => 'a topology"
+ mtop :: "'a::type metric => 'a::type topology"
"mtop ==
-%m. topology
- (%S'. ALL x. S' x --> (EX e>0. ALL y. dist m (x, y) < e --> S' y))"
-
-lemma mtop: "ALL m.
+%m::'a::type metric.
+ topology
+ (%S'::'a::type => bool.
+ ALL x::'a::type.
+ S' x -->
+ (EX e>0::real. ALL y::'a::type. dist m (x, y) < e --> S' y))"
+
+lemma mtop: "ALL m::'a::type metric.
mtop m =
topology
- (%S'. ALL x. S' x --> (EX e>0. ALL y. dist m (x, y) < e --> S' y))"
+ (%S'::'a::type => bool.
+ ALL x::'a::type.
+ S' x -->
+ (EX e>0::real. ALL y::'a::type. dist m (x, y) < e --> S' y))"
by (import topology mtop)
-lemma mtop_istopology: "ALL m.
+lemma mtop_istopology: "ALL m::'a::type metric.
istopology
- (%S'. ALL x. S' x --> (EX e>0. ALL y. dist m (x, y) < e --> S' y))"
+ (%S'::'a::type => bool.
+ ALL x::'a::type.
+ S' x -->
+ (EX e>0::real. ALL y::'a::type. dist m (x, y) < e --> S' y))"
by (import topology mtop_istopology)
-lemma MTOP_OPEN: "ALL S' x.
+lemma MTOP_OPEN: "ALL (S'::'a::type => bool) x::'a::type metric.
open (mtop x) S' =
- (ALL xa. S' xa --> (EX e>0. ALL y. dist x (xa, y) < e --> S' y))"
+ (ALL xa::'a::type.
+ S' xa -->
+ (EX e>0::real. ALL y::'a::type. dist x (xa, y) < e --> S' y))"
by (import topology MTOP_OPEN)
constdefs
- B :: "'a metric => 'a * real => 'a => bool"
- "B == %m (x, e) y. dist m (x, y) < e"
-
-lemma ball: "ALL m x e. B m (x, e) = (%y. dist m (x, y) < e)"
+ B :: "'a::type metric => 'a::type * real => 'a::type => bool"
+ "B ==
+%(m::'a::type metric) (x::'a::type, e::real) y::'a::type. dist m (x, y) < e"
+
+lemma ball: "ALL (m::'a::type metric) (x::'a::type) e::real.
+ B m (x, e) = (%y::'a::type. dist m (x, y) < e)"
by (import topology ball)
-lemma BALL_OPEN: "ALL m x e. 0 < e --> open (mtop m) (B m (x, e))"
+lemma BALL_OPEN: "ALL (m::'a::type metric) (x::'a::type) e::real.
+ (0::real) < e --> open (mtop m) (B m (x, e))"
by (import topology BALL_OPEN)
-lemma BALL_NEIGH: "ALL m x e. 0 < e --> neigh (mtop m) (B m (x, e), x)"
+lemma BALL_NEIGH: "ALL (m::'a::type metric) (x::'a::type) e::real.
+ (0::real) < e --> neigh (mtop m) (B m (x, e), x)"
by (import topology BALL_NEIGH)
-lemma MTOP_LIMPT: "ALL m x S'.
- limpt (mtop m) x S' = (ALL e>0. EX y. x ~= y & S' y & dist m (x, y) < e)"
+lemma MTOP_LIMPT: "ALL (m::'a::type metric) (x::'a::type) S'::'a::type => bool.
+ limpt (mtop m) x S' =
+ (ALL e>0::real. EX y::'a::type. x ~= y & S' y & dist m (x, y) < e)"
by (import topology MTOP_LIMPT)
-lemma ISMET_R1: "ismet (%(x, y). abs (y - x))"
+lemma ISMET_R1: "ismet (%(x::real, y::real). abs (y - x))"
by (import topology ISMET_R1)
constdefs
mr1 :: "real metric"
- "mr1 == metric (%(x, y). abs (y - x))"
-
-lemma mr1: "mr1 = metric (%(x, y). abs (y - x))"
+ "mr1 == metric (%(x::real, y::real). abs (y - x))"
+
+lemma mr1: "mr1 = metric (%(x::real, y::real). abs (y - x))"
by (import topology mr1)
-lemma MR1_DEF: "ALL x y. dist mr1 (x, y) = abs (y - x)"
+lemma MR1_DEF: "ALL (x::real) y::real. dist mr1 (x, y) = abs (y - x)"
by (import topology MR1_DEF)
-lemma MR1_ADD: "ALL x d. dist mr1 (x, x + d) = abs d"
+lemma MR1_ADD: "ALL (x::real) d::real. dist mr1 (x, x + d) = abs d"
by (import topology MR1_ADD)
-lemma MR1_SUB: "ALL x d. dist mr1 (x, x - d) = abs d"
+lemma MR1_SUB: "ALL (x::real) d::real. dist mr1 (x, x - d) = abs d"
by (import topology MR1_SUB)
-lemma MR1_ADD_POS: "ALL x d. 0 <= d --> dist mr1 (x, x + d) = d"
+lemma MR1_ADD_POS: "ALL (x::real) d::real. (0::real) <= d --> dist mr1 (x, x + d) = d"
by (import topology MR1_ADD_POS)
-lemma MR1_SUB_LE: "ALL x d. 0 <= d --> dist mr1 (x, x - d) = d"
+lemma MR1_SUB_LE: "ALL (x::real) d::real. (0::real) <= d --> dist mr1 (x, x - d) = d"
by (import topology MR1_SUB_LE)
-lemma MR1_ADD_LT: "ALL x d. 0 < d --> dist mr1 (x, x + d) = d"
+lemma MR1_ADD_LT: "ALL (x::real) d::real. (0::real) < d --> dist mr1 (x, x + d) = d"
by (import topology MR1_ADD_LT)
-lemma MR1_SUB_LT: "ALL x d. 0 < d --> dist mr1 (x, x - d) = d"
+lemma MR1_SUB_LT: "ALL (x::real) d::real. (0::real) < d --> dist mr1 (x, x - d) = d"
by (import topology MR1_SUB_LT)
-lemma MR1_BETWEEN1: "ALL x y z. x < z & dist mr1 (x, y) < z - x --> y < z"
+lemma MR1_BETWEEN1: "ALL (x::real) (y::real) z::real. x < z & dist mr1 (x, y) < z - x --> y < z"
by (import topology MR1_BETWEEN1)
-lemma MR1_LIMPT: "ALL x. limpt (mtop mr1) x re_universe"
+lemma MR1_LIMPT: "ALL x::real. limpt (mtop mr1) x re_universe"
by (import topology MR1_LIMPT)
;end_setup
@@ -981,189 +1098,220 @@
;setup_theory nets
constdefs
- dorder :: "('a => 'a => bool) => bool"
+ dorder :: "('a::type => 'a::type => bool) => bool"
"dorder ==
-%g. ALL x y.
- g x x & g y y --> (EX z. g z z & (ALL w. g w z --> g w x & g w y))"
-
-lemma dorder: "ALL g.
+%g::'a::type => 'a::type => bool.
+ ALL (x::'a::type) y::'a::type.
+ g x x & g y y -->
+ (EX z::'a::type. g z z & (ALL w::'a::type. g w z --> g w x & g w y))"
+
+lemma dorder: "ALL g::'a::type => 'a::type => bool.
dorder g =
- (ALL x y.
- g x x & g y y --> (EX z. g z z & (ALL w. g w z --> g w x & g w y)))"
+ (ALL (x::'a::type) y::'a::type.
+ g x x & g y y -->
+ (EX z::'a::type. g z z & (ALL w::'a::type. g w z --> g w x & g w y)))"
by (import nets dorder)
constdefs
- tends :: "('b => 'a) => 'a => 'a topology * ('b => 'b => bool) => bool"
+ tends :: "('b::type => 'a::type)
+=> 'a::type => 'a::type topology * ('b::type => 'b::type => bool) => bool"
"tends ==
-%(s::'b => 'a) (l::'a) (top::'a topology, g::'b => 'b => bool).
- ALL N::'a => bool.
+%(s::'b::type => 'a::type) (l::'a::type) (top::'a::type topology,
+ g::'b::type => 'b::type => bool).
+ ALL N::'a::type => bool.
neigh top (N, l) -->
- (EX n::'b. g n n & (ALL m::'b. g m n --> N (s m)))"
-
-lemma tends: "ALL (s::'b => 'a) (l::'a) (top::'a topology) g::'b => 'b => bool.
+ (EX n::'b::type. g n n & (ALL m::'b::type. g m n --> N (s m)))"
+
+lemma tends: "ALL (s::'b::type => 'a::type) (l::'a::type) (top::'a::type topology)
+ g::'b::type => 'b::type => bool.
tends s l (top, g) =
- (ALL N::'a => bool.
+ (ALL N::'a::type => bool.
neigh top (N, l) -->
- (EX n::'b. g n n & (ALL m::'b. g m n --> N (s m))))"
+ (EX n::'b::type. g n n & (ALL m::'b::type. g m n --> N (s m))))"
by (import nets tends)
constdefs
- bounded :: "'a metric * ('b => 'b => bool) => ('b => 'a) => bool"
+ bounded :: "'a::type metric * ('b::type => 'b::type => bool)
+=> ('b::type => 'a::type) => bool"
"bounded ==
-%(m, g) f. EX k x N. g N N & (ALL n. g n N --> dist m (f n, x) < k)"
-
-lemma bounded: "ALL m g f.
+%(m::'a::type metric, g::'b::type => 'b::type => bool)
+ f::'b::type => 'a::type.
+ EX (k::real) (x::'a::type) N::'b::type.
+ g N N & (ALL n::'b::type. g n N --> dist m (f n, x) < k)"
+
+lemma bounded: "ALL (m::'a::type metric) (g::'b::type => 'b::type => bool)
+ f::'b::type => 'a::type.
bounded (m, g) f =
- (EX k x N. g N N & (ALL n. g n N --> dist m (f n, x) < k))"
+ (EX (k::real) (x::'a::type) N::'b::type.
+ g N N & (ALL n::'b::type. g n N --> dist m (f n, x) < k))"
by (import nets bounded)
constdefs
- tendsto :: "'a metric * 'a => 'a => 'a => bool"
- "tendsto == %(m, x) y z. 0 < dist m (x, y) & dist m (x, y) <= dist m (x, z)"
-
-lemma tendsto: "ALL m x y z.
- tendsto (m, x) y z = (0 < dist m (x, y) & dist m (x, y) <= dist m (x, z))"
+ tendsto :: "'a::type metric * 'a::type => 'a::type => 'a::type => bool"
+ "tendsto ==
+%(m::'a::type metric, x::'a::type) (y::'a::type) z::'a::type.
+ (0::real) < dist m (x, y) & dist m (x, y) <= dist m (x, z)"
+
+lemma tendsto: "ALL (m::'a::type metric) (x::'a::type) (y::'a::type) z::'a::type.
+ tendsto (m, x) y z =
+ ((0::real) < dist m (x, y) & dist m (x, y) <= dist m (x, z))"
by (import nets tendsto)
-lemma DORDER_LEMMA: "ALL g.
+lemma DORDER_LEMMA: "ALL g::'a::type => 'a::type => bool.
dorder g -->
- (ALL P Q.
- (EX n. g n n & (ALL m. g m n --> P m)) &
- (EX n. g n n & (ALL m. g m n --> Q m)) -->
- (EX n. g n n & (ALL m. g m n --> P m & Q m)))"
+ (ALL (P::'a::type => bool) Q::'a::type => bool.
+ (EX n::'a::type. g n n & (ALL m::'a::type. g m n --> P m)) &
+ (EX n::'a::type. g n n & (ALL m::'a::type. g m n --> Q m)) -->
+ (EX n::'a::type. g n n & (ALL m::'a::type. g m n --> P m & Q m)))"
by (import nets DORDER_LEMMA)
lemma DORDER_NGE: "dorder nat_ge"
by (import nets DORDER_NGE)
-lemma DORDER_TENDSTO: "ALL m x. dorder (tendsto (m, x))"
+lemma DORDER_TENDSTO: "ALL (m::'a::type metric) x::'a::type. dorder (tendsto (m, x))"
by (import nets DORDER_TENDSTO)
-lemma MTOP_TENDS: "ALL d g x x0.
+lemma MTOP_TENDS: "ALL (d::'a::type metric) (g::'b::type => 'b::type => bool)
+ (x::'b::type => 'a::type) x0::'a::type.
tends x x0 (mtop d, g) =
- (ALL e>0. EX n. g n n & (ALL m. g m n --> dist d (x m, x0) < e))"
+ (ALL e>0::real.
+ EX n::'b::type.
+ g n n & (ALL m::'b::type. g m n --> dist d (x m, x0) < e))"
by (import nets MTOP_TENDS)
-lemma MTOP_TENDS_UNIQ: "ALL (g::'b => 'b => bool) d::'a metric.
+lemma MTOP_TENDS_UNIQ: "ALL (g::'b::type => 'b::type => bool) d::'a::type metric.
dorder g -->
- tends (x::'b => 'a) (x0::'a) (mtop d, g) &
- tends x (x1::'a) (mtop d, g) -->
+ tends (x::'b::type => 'a::type) (x0::'a::type) (mtop d, g) &
+ tends x (x1::'a::type) (mtop d, g) -->
x0 = x1"
by (import nets MTOP_TENDS_UNIQ)
-lemma SEQ_TENDS: "ALL d x x0.
+lemma SEQ_TENDS: "ALL (d::'a::type metric) (x::nat => 'a::type) x0::'a::type.
tends x x0 (mtop d, nat_ge) =
- (ALL xa>0. EX xb. ALL xc. xb <= xc --> dist d (x xc, x0) < xa)"
+ (ALL xa>0::real.
+ EX xb::nat. ALL xc::nat. xb <= xc --> dist d (x xc, x0) < xa)"
by (import nets SEQ_TENDS)
-lemma LIM_TENDS: "ALL m1 m2 f x0 y0.
+lemma LIM_TENDS: "ALL (m1::'a::type metric) (m2::'b::type metric) (f::'a::type => 'b::type)
+ (x0::'a::type) y0::'b::type.
limpt (mtop m1) x0 re_universe -->
tends f y0 (mtop m2, tendsto (m1, x0)) =
- (ALL e>0.
- EX d>0.
- ALL x.
- 0 < dist m1 (x, x0) & dist m1 (x, x0) <= d -->
+ (ALL e>0::real.
+ EX d>0::real.
+ ALL x::'a::type.
+ (0::real) < dist m1 (x, x0) & dist m1 (x, x0) <= d -->
dist m2 (f x, y0) < e)"
by (import nets LIM_TENDS)
-lemma LIM_TENDS2: "ALL m1 m2 f x0 y0.
+lemma LIM_TENDS2: "ALL (m1::'a::type metric) (m2::'b::type metric) (f::'a::type => 'b::type)
+ (x0::'a::type) y0::'b::type.
limpt (mtop m1) x0 re_universe -->
tends f y0 (mtop m2, tendsto (m1, x0)) =
- (ALL e>0.
- EX d>0.
- ALL x.
- 0 < dist m1 (x, x0) & dist m1 (x, x0) < d -->
+ (ALL e>0::real.
+ EX d>0::real.
+ ALL x::'a::type.
+ (0::real) < dist m1 (x, x0) & dist m1 (x, x0) < d -->
dist m2 (f x, y0) < e)"
by (import nets LIM_TENDS2)
-lemma MR1_BOUNDED: "ALL g f.
- bounded (mr1, g) f = (EX k N. g N N & (ALL n. g n N --> abs (f n) < k))"
+lemma MR1_BOUNDED: "ALL (g::'a::type => 'a::type => bool) f::'a::type => real.
+ bounded (mr1, g) f =
+ (EX (k::real) N::'a::type.
+ g N N & (ALL n::'a::type. g n N --> abs (f n) < k))"
by (import nets MR1_BOUNDED)
-lemma NET_NULL: "ALL g x x0. tends x x0 (mtop mr1, g) = tends (%n. x n - x0) 0 (mtop mr1, g)"
+lemma NET_NULL: "ALL (g::'a::type => 'a::type => bool) (x::'a::type => real) x0::real.
+ tends x x0 (mtop mr1, g) =
+ tends (%n::'a::type. x n - x0) (0::real) (mtop mr1, g)"
by (import nets NET_NULL)
-lemma NET_CONV_BOUNDED: "ALL g x x0. tends x x0 (mtop mr1, g) --> bounded (mr1, g) x"
+lemma NET_CONV_BOUNDED: "ALL (g::'a::type => 'a::type => bool) (x::'a::type => real) x0::real.
+ tends x x0 (mtop mr1, g) --> bounded (mr1, g) x"
by (import nets NET_CONV_BOUNDED)
-lemma NET_CONV_NZ: "ALL g x x0.
- tends x x0 (mtop mr1, g) & x0 ~= 0 -->
- (EX N. g N N & (ALL n. g n N --> x n ~= 0))"
+lemma NET_CONV_NZ: "ALL (g::'a::type => 'a::type => bool) (x::'a::type => real) x0::real.
+ tends x x0 (mtop mr1, g) & x0 ~= (0::real) -->
+ (EX N::'a::type. g N N & (ALL n::'a::type. g n N --> x n ~= (0::real)))"
by (import nets NET_CONV_NZ)
-lemma NET_CONV_IBOUNDED: "ALL g x x0.
- tends x x0 (mtop mr1, g) & x0 ~= 0 -->
- bounded (mr1, g) (%n. inverse (x n))"
+lemma NET_CONV_IBOUNDED: "ALL (g::'a::type => 'a::type => bool) (x::'a::type => real) x0::real.
+ tends x x0 (mtop mr1, g) & x0 ~= (0::real) -->
+ bounded (mr1, g) (%n::'a::type. inverse (x n))"
by (import nets NET_CONV_IBOUNDED)
-lemma NET_NULL_ADD: "ALL g.
+lemma NET_NULL_ADD: "ALL g::'a::type => 'a::type => bool.
dorder g -->
- (ALL x y.
- tends x 0 (mtop mr1, g) & tends y 0 (mtop mr1, g) -->
- tends (%n. x n + y n) 0 (mtop mr1, g))"
+ (ALL (x::'a::type => real) y::'a::type => real.
+ tends x (0::real) (mtop mr1, g) & tends y (0::real) (mtop mr1, g) -->
+ tends (%n::'a::type. x n + y n) (0::real) (mtop mr1, g))"
by (import nets NET_NULL_ADD)
-lemma NET_NULL_MUL: "ALL g.
+lemma NET_NULL_MUL: "ALL g::'a::type => 'a::type => bool.
dorder g -->
- (ALL x y.
- bounded (mr1, g) x & tends y 0 (mtop mr1, g) -->
- tends (%n. x n * y n) 0 (mtop mr1, g))"
+ (ALL (x::'a::type => real) y::'a::type => real.
+ bounded (mr1, g) x & tends y (0::real) (mtop mr1, g) -->
+ tends (%n::'a::type. x n * y n) (0::real) (mtop mr1, g))"
by (import nets NET_NULL_MUL)
-lemma NET_NULL_CMUL: "ALL g k x. tends x 0 (mtop mr1, g) --> tends (%n. k * x n) 0 (mtop mr1, g)"
+lemma NET_NULL_CMUL: "ALL (g::'a::type => 'a::type => bool) (k::real) x::'a::type => real.
+ tends x (0::real) (mtop mr1, g) -->
+ tends (%n::'a::type. k * x n) (0::real) (mtop mr1, g)"
by (import nets NET_NULL_CMUL)
-lemma NET_ADD: "ALL g.
+lemma NET_ADD: "ALL g::'a::type => 'a::type => bool.
dorder g -->
- (ALL x x0 y y0.
+ (ALL (x::'a::type => real) (x0::real) (y::'a::type => real) y0::real.
tends x x0 (mtop mr1, g) & tends y y0 (mtop mr1, g) -->
- tends (%n. x n + y n) (x0 + y0) (mtop mr1, g))"
+ tends (%n::'a::type. x n + y n) (x0 + y0) (mtop mr1, g))"
by (import nets NET_ADD)
-lemma NET_NEG: "ALL g.
+lemma NET_NEG: "ALL g::'a::type => 'a::type => bool.
dorder g -->
- (ALL x x0.
- tends x x0 (mtop mr1, g) = tends (%n. - x n) (- x0) (mtop mr1, g))"
+ (ALL (x::'a::type => real) x0::real.
+ tends x x0 (mtop mr1, g) =
+ tends (%n::'a::type. - x n) (- x0) (mtop mr1, g))"
by (import nets NET_NEG)
-lemma NET_SUB: "ALL g.
+lemma NET_SUB: "ALL g::'a::type => 'a::type => bool.
dorder g -->
- (ALL x x0 y y0.
+ (ALL (x::'a::type => real) (x0::real) (y::'a::type => real) y0::real.
tends x x0 (mtop mr1, g) & tends y y0 (mtop mr1, g) -->
- tends (%xa. x xa - y xa) (x0 - y0) (mtop mr1, g))"
+ tends (%xa::'a::type. x xa - y xa) (x0 - y0) (mtop mr1, g))"
by (import nets NET_SUB)
-lemma NET_MUL: "ALL g.
+lemma NET_MUL: "ALL g::'a::type => 'a::type => bool.
dorder g -->
- (ALL x y x0 y0.
+ (ALL (x::'a::type => real) (y::'a::type => real) (x0::real) y0::real.
tends x x0 (mtop mr1, g) & tends y y0 (mtop mr1, g) -->
- tends (%n. x n * y n) (x0 * y0) (mtop mr1, g))"
+ tends (%n::'a::type. x n * y n) (x0 * y0) (mtop mr1, g))"
by (import nets NET_MUL)
-lemma NET_INV: "ALL g.
+lemma NET_INV: "ALL g::'a::type => 'a::type => bool.
dorder g -->
- (ALL x x0.
- tends x x0 (mtop mr1, g) & x0 ~= 0 -->
- tends (%n. inverse (x n)) (inverse x0) (mtop mr1, g))"
+ (ALL (x::'a::type => real) x0::real.
+ tends x x0 (mtop mr1, g) & x0 ~= (0::real) -->
+ tends (%n::'a::type. inverse (x n)) (inverse x0) (mtop mr1, g))"
by (import nets NET_INV)
-lemma NET_DIV: "ALL g.
+lemma NET_DIV: "ALL g::'a::type => 'a::type => bool.
dorder g -->
- (ALL x x0 y y0.
- tends x x0 (mtop mr1, g) & tends y y0 (mtop mr1, g) & y0 ~= 0 -->
- tends (%xa. x xa / y xa) (x0 / y0) (mtop mr1, g))"
+ (ALL (x::'a::type => real) (x0::real) (y::'a::type => real) y0::real.
+ tends x x0 (mtop mr1, g) &
+ tends y y0 (mtop mr1, g) & y0 ~= (0::real) -->
+ tends (%xa::'a::type. x xa / y xa) (x0 / y0) (mtop mr1, g))"
by (import nets NET_DIV)
-lemma NET_ABS: "ALL g x x0.
- tends x x0 (mtop mr1, g) --> tends (%n. abs (x n)) (abs x0) (mtop mr1, g)"
+lemma NET_ABS: "ALL (g::'a::type => 'a::type => bool) (x::'a::type => real) x0::real.
+ tends x x0 (mtop mr1, g) -->
+ tends (%n::'a::type. abs (x n)) (abs x0) (mtop mr1, g)"
by (import nets NET_ABS)
-lemma NET_LE: "ALL g.
+lemma NET_LE: "ALL g::'a::type => 'a::type => bool.
dorder g -->
- (ALL x x0 y y0.
+ (ALL (x::'a::type => real) (x0::real) (y::'a::type => real) y0::real.
tends x x0 (mtop mr1, g) &
tends y y0 (mtop mr1, g) &
- (EX N. g N N & (ALL n. g n N --> x n <= y n)) -->
+ (EX N::'a::type. g N N & (ALL n::'a::type. g n N --> x n <= y n)) -->
x0 <= y0)"
by (import nets NET_LE)
@@ -1175,9 +1323,9 @@
"-->" :: "(nat => real) => real => bool" ("-->")
defs
- "-->_def": "--> == %x x0. tends x x0 (mtop mr1, nat_ge)"
-
-lemma tends_num_real: "ALL x x0. --> x x0 = tends x x0 (mtop mr1, nat_ge)"
+ "-->_def": "--> == %(x::nat => real) x0::real. tends x x0 (mtop mr1, nat_ge)"
+
+lemma tends_num_real: "ALL (x::nat => real) x0::real. --> x x0 = tends x x0 (mtop mr1, nat_ge)"
by (import seq tends_num_real)
lemma SEQ: "(All::((nat => real) => bool) => bool)
@@ -1202,7 +1350,7 @@
e))))))))"
by (import seq SEQ)
-lemma SEQ_CONST: "ALL k. --> (%x. k) k"
+lemma SEQ_CONST: "ALL k::real. --> (%x::nat. k) k"
by (import seq SEQ_CONST)
lemma SEQ_ADD: "(All::((nat => real) => bool) => bool)
@@ -1239,7 +1387,7 @@
((op *::real => real => real) x0 y0))))))"
by (import seq SEQ_MUL)
-lemma SEQ_NEG: "ALL x x0. --> x x0 = --> (%n. - x n) (- x0)"
+lemma SEQ_NEG: "ALL (x::nat => real) x0::real. --> x x0 = --> (%n::nat. - x n) (- x0)"
by (import seq SEQ_NEG)
lemma SEQ_INV: "(All::((nat => real) => bool) => bool)
@@ -1308,9 +1456,9 @@
constdefs
convergent :: "(nat => real) => bool"
- "convergent == %f. Ex (--> f)"
-
-lemma convergent: "ALL f. convergent f = Ex (--> f)"
+ "convergent == %f::nat => real. Ex (--> f)"
+
+lemma convergent: "ALL f::nat => real. convergent f = Ex (--> f)"
by (import seq convergent)
constdefs
@@ -1363,12 +1511,12 @@
constdefs
lim :: "(nat => real) => real"
- "lim == %f. Eps (--> f)"
-
-lemma lim: "ALL f. lim f = Eps (--> f)"
+ "lim == %f::nat => real. Eps (--> f)"
+
+lemma lim: "ALL f::nat => real. lim f = Eps (--> f)"
by (import seq lim)
-lemma SEQ_LIM: "ALL f. convergent f = --> f (lim f)"
+lemma SEQ_LIM: "ALL f::nat => real. convergent f = --> f (lim f)"
by (import seq SEQ_LIM)
constdefs
@@ -1396,7 +1544,7 @@
((op <::nat => nat => bool) (f m) (f n))))))"
by (import seq subseq)
-lemma SUBSEQ_SUC: "ALL f. subseq f = (ALL n. f n < f (Suc n))"
+lemma SUBSEQ_SUC: "ALL f::nat => nat. subseq f = (ALL n::nat. f n < f (Suc n))"
by (import seq SUBSEQ_SUC)
consts
@@ -1442,7 +1590,9 @@
((op <=::real => real => bool) (f n) (f m)))))))"
by (import seq mono)
-lemma MONO_SUC: "ALL f. seq.mono f = ((ALL x. f x <= f (Suc x)) | (ALL n. f (Suc n) <= f n))"
+lemma MONO_SUC: "ALL f::nat => real.
+ seq.mono f =
+ ((ALL x::nat. f x <= f (Suc x)) | (ALL n::nat. f (Suc n) <= f n))"
by (import seq MONO_SUC)
lemma MAX_LEMMA: "(All::((nat => real) => bool) => bool)
@@ -1459,7 +1609,8 @@
((abs::real => real) (s n)) k)))))"
by (import seq MAX_LEMMA)
-lemma SEQ_BOUNDED: "ALL s. bounded (mr1, nat_ge) s = (EX k. ALL n. abs (s n) < k)"
+lemma SEQ_BOUNDED: "ALL s::nat => real.
+ bounded (mr1, nat_ge) s = (EX k::real. ALL n::nat. abs (s n) < k)"
by (import seq SEQ_BOUNDED)
lemma SEQ_BOUNDED_2: "(All::((nat => real) => bool) => bool)
@@ -1516,10 +1667,11 @@
((convergent::(nat => real) => bool) f))"
by (import seq SEQ_ICONV)
-lemma SEQ_NEG_CONV: "ALL f. convergent f = convergent (%n. - f n)"
+lemma SEQ_NEG_CONV: "ALL f::nat => real. convergent f = convergent (%n::nat. - f n)"
by (import seq SEQ_NEG_CONV)
-lemma SEQ_NEG_BOUNDED: "ALL f. bounded (mr1, nat_ge) (%n. - f n) = bounded (mr1, nat_ge) f"
+lemma SEQ_NEG_BOUNDED: "ALL f::nat => real.
+ bounded (mr1, nat_ge) (%n::nat. - f n) = bounded (mr1, nat_ge) f"
by (import seq SEQ_NEG_BOUNDED)
lemma SEQ_BCONV: "(All::((nat => real) => bool) => bool)
@@ -1537,7 +1689,7 @@
((convergent::(nat => real) => bool) f))"
by (import seq SEQ_BCONV)
-lemma SEQ_MONOSUB: "ALL s. EX f. subseq f & seq.mono (%n. s (f n))"
+lemma SEQ_MONOSUB: "ALL s::nat => real. EX f::nat => nat. subseq f & seq.mono (%n::nat. s (f n))"
by (import seq SEQ_MONOSUB)
lemma SEQ_SBOUNDED: "(All::((nat => real) => bool) => bool)
@@ -1582,7 +1734,7 @@
((op <=::nat => nat => bool) N2 (f x)))))))"
by (import seq SEQ_DIRECT)
-lemma SEQ_CAUCHY: "ALL f. cauchy f = convergent f"
+lemma SEQ_CAUCHY: "ALL f::nat => real. cauchy f = convergent f"
by (import seq SEQ_CAUCHY)
lemma SEQ_LE: "(All::((nat => real) => bool) => bool)
@@ -1609,10 +1761,10 @@
((op <=::real => real => bool) l m)))))"
by (import seq SEQ_LE)
-lemma SEQ_SUC: "ALL f l. --> f l = --> (%n. f (Suc n)) l"
+lemma SEQ_SUC: "ALL (f::nat => real) l::real. --> f l = --> (%n::nat. f (Suc n)) l"
by (import seq SEQ_SUC)
-lemma SEQ_ABS: "ALL f. --> (%n. abs (f n)) 0 = --> f 0"
+lemma SEQ_ABS: "ALL f::nat => real. --> (%n::nat. abs (f n)) (0::real) = --> f (0::real)"
by (import seq SEQ_ABS)
lemma SEQ_ABS_IMP: "(All::((nat => real) => bool) => bool)
@@ -1777,23 +1929,24 @@
constdefs
sums :: "(nat => real) => real => bool"
- "sums == %f. --> (%n. real.sum (0, n) f)"
-
-lemma sums: "ALL f s. sums f s = --> (%n. real.sum (0, n) f) s"
+ "sums == %f::nat => real. --> (%n::nat. real.sum (0::nat, n) f)"
+
+lemma sums: "ALL (f::nat => real) s::real.
+ sums f s = --> (%n::nat. real.sum (0::nat, n) f) s"
by (import seq sums)
constdefs
summable :: "(nat => real) => bool"
- "summable == %f. Ex (sums f)"
-
-lemma summable: "ALL f. summable f = Ex (sums f)"
+ "summable == %f::nat => real. Ex (sums f)"
+
+lemma summable: "ALL f::nat => real. summable f = Ex (sums f)"
by (import seq summable)
constdefs
suminf :: "(nat => real) => real"
- "suminf == %f. Eps (sums f)"
-
-lemma suminf: "ALL f. suminf f = Eps (sums f)"
+ "suminf == %f::nat => real. Eps (sums f)"
+
+lemma suminf: "ALL f::nat => real. suminf f = Eps (sums f)"
by (import seq suminf)
lemma SUM_SUMMABLE: "(All::((nat => real) => bool) => bool)
@@ -2219,9 +2372,12 @@
constdefs
tends_real_real :: "(real => real) => real => real => bool"
- "tends_real_real == %f l x0. tends f l (mtop mr1, tendsto (mr1, x0))"
-
-lemma tends_real_real: "ALL f l x0. tends_real_real f l x0 = tends f l (mtop mr1, tendsto (mr1, x0))"
+ "tends_real_real ==
+%(f::real => real) (l::real) x0::real.
+ tends f l (mtop mr1, tendsto (mr1, x0))"
+
+lemma tends_real_real: "ALL (f::real => real) (l::real) x0::real.
+ tends_real_real f l x0 = tends f l (mtop mr1, tendsto (mr1, x0))"
by (import lim tends_real_real)
lemma LIM: "(All::((real => real) => bool) => bool)
@@ -2253,7 +2409,7 @@
((abs::real => real) ((op -::real => real => real) (f x) y0)) e))))))))))"
by (import lim LIM)
-lemma LIM_CONST: "ALL k. All (tends_real_real (%x. k) k)"
+lemma LIM_CONST: "ALL k::real. All (tends_real_real (%x::real. k) k)"
by (import lim LIM_CONST)
lemma LIM_ADD: "(All::((real => real) => bool) => bool)
@@ -2306,7 +2462,8 @@
((op *::real => real => real) l m) x))))))"
by (import lim LIM_MUL)
-lemma LIM_NEG: "ALL f l x. tends_real_real f l x = tends_real_real (%x. - f x) (- l) x"
+lemma LIM_NEG: "ALL (f::real => real) (l::real) x::real.
+ tends_real_real f l x = tends_real_real (%x::real. - f x) (- l) x"
by (import lim LIM_NEG)
lemma LIM_INV: "(All::((real => real) => bool) => bool)
@@ -2380,10 +2537,11 @@
((op /::real => real => real) l m) x))))))"
by (import lim LIM_DIV)
-lemma LIM_NULL: "ALL f l x. tends_real_real f l x = tends_real_real (%x. f x - l) 0 x"
+lemma LIM_NULL: "ALL (f::real => real) (l::real) x::real.
+ tends_real_real f l x = tends_real_real (%x::real. f x - l) (0::real) x"
by (import lim LIM_NULL)
-lemma LIM_X: "ALL x0. tends_real_real (%x. x) x0 x0"
+lemma LIM_X: "ALL x0::real. tends_real_real (%x::real. x) x0 x0"
by (import lim LIM_X)
lemma LIM_UNIQ: "(All::((real => real) => bool) => bool)
@@ -2454,23 +2612,31 @@
constdefs
diffl :: "(real => real) => real => real => bool"
- "diffl == %f l x. tends_real_real (%h. (f (x + h) - f x) / h) l 0"
-
-lemma diffl: "ALL f l x. diffl f l x = tends_real_real (%h. (f (x + h) - f x) / h) l 0"
+ "diffl ==
+%(f::real => real) (l::real) x::real.
+ tends_real_real (%h::real. (f (x + h) - f x) / h) l (0::real)"
+
+lemma diffl: "ALL (f::real => real) (l::real) x::real.
+ diffl f l x =
+ tends_real_real (%h::real. (f (x + h) - f x) / h) l (0::real)"
by (import lim diffl)
constdefs
contl :: "(real => real) => real => bool"
- "contl == %f x. tends_real_real (%h. f (x + h)) (f x) 0"
-
-lemma contl: "ALL f x. contl f x = tends_real_real (%h. f (x + h)) (f x) 0"
+ "contl ==
+%(f::real => real) x::real.
+ tends_real_real (%h::real. f (x + h)) (f x) (0::real)"
+
+lemma contl: "ALL (f::real => real) x::real.
+ contl f x = tends_real_real (%h::real. f (x + h)) (f x) (0::real)"
by (import lim contl)
constdefs
differentiable :: "(real => real) => real => bool"
- "differentiable == %f x. EX l. diffl f l x"
-
-lemma differentiable: "ALL f x. differentiable f x = (EX l. diffl f l x)"
+ "differentiable == %(f::real => real) x::real. EX l::real. diffl f l x"
+
+lemma differentiable: "ALL (f::real => real) x::real.
+ differentiable f x = (EX l::real. diffl f l x)"
by (import lim differentiable)
lemma DIFF_UNIQ: "(All::((real => real) => bool) => bool)
@@ -2501,15 +2667,16 @@
((contl::(real => real) => real => bool) f x))))"
by (import lim DIFF_CONT)
-lemma CONTL_LIM: "ALL f x. contl f x = tends_real_real f (f x) x"
+lemma CONTL_LIM: "ALL (f::real => real) x::real. contl f x = tends_real_real f (f x) x"
by (import lim CONTL_LIM)
-lemma DIFF_CARAT: "ALL f l x.
+lemma DIFF_CARAT: "ALL (f::real => real) (l::real) x::real.
diffl f l x =
- (EX g. (ALL z. f z - f x = g z * (z - x)) & contl g x & g x = l)"
+ (EX g::real => real.
+ (ALL z::real. f z - f x = g z * (z - x)) & contl g x & g x = l)"
by (import lim DIFF_CARAT)
-lemma CONT_CONST: "ALL k. All (contl (%x. k))"
+lemma CONT_CONST: "ALL k::real. All (contl (%x::real. k))"
by (import lim CONT_CONST)
lemma CONT_ADD: "(All::((real => real) => bool) => bool)
@@ -2672,7 +2839,7 @@
((op =::real => real => bool) (f x) y))))))))"
by (import lim IVT2)
-lemma DIFF_CONST: "ALL k. All (diffl (%x. k) 0)"
+lemma DIFF_CONST: "ALL k::real. All (diffl (%x::real. k) (0::real))"
by (import lim DIFF_CONST)
lemma DIFF_ADD: "(All::((real => real) => bool) => bool)
@@ -2793,10 +2960,11 @@
((op *::real => real => real) l m) x))))))"
by (import lim DIFF_CHAIN)
-lemma DIFF_X: "All (diffl (%x. x) 1)"
+lemma DIFF_X: "All (diffl (%x::real. x) (1::real))"
by (import lim DIFF_X)
-lemma DIFF_POW: "ALL n x. diffl (%x. x ^ n) (real n * x ^ (n - 1)) x"
+lemma DIFF_POW: "ALL (n::nat) x::real.
+ diffl (%x::real. x ^ n) (real n * x ^ (n - (1::nat))) x"
by (import lim DIFF_POW)
lemma DIFF_XM1: "(All::(real => bool) => bool)
@@ -3708,19 +3876,19 @@
;setup_theory powser
-lemma POWDIFF_LEMMA: "ALL n x y.
- real.sum (0, Suc n) (%p. x ^ p * y ^ (Suc n - p)) =
- y * real.sum (0, Suc n) (%p. x ^ p * y ^ (n - p))"
+lemma POWDIFF_LEMMA: "ALL (n::nat) (x::real) y::real.
+ real.sum (0::nat, Suc n) (%p::nat. x ^ p * y ^ (Suc n - p)) =
+ y * real.sum (0::nat, Suc n) (%p::nat. x ^ p * y ^ (n - p))"
by (import powser POWDIFF_LEMMA)
-lemma POWDIFF: "ALL n x y.
+lemma POWDIFF: "ALL (n::nat) (x::real) y::real.
x ^ Suc n - y ^ Suc n =
- (x - y) * real.sum (0, Suc n) (%p. x ^ p * y ^ (n - p))"
+ (x - y) * real.sum (0::nat, Suc n) (%p::nat. x ^ p * y ^ (n - p))"
by (import powser POWDIFF)
-lemma POWREV: "ALL n x y.
- real.sum (0, Suc n) (%xa. x ^ xa * y ^ (n - xa)) =
- real.sum (0, Suc n) (%xa. x ^ (n - xa) * y ^ xa)"
+lemma POWREV: "ALL (n::nat) (x::real) y::real.
+ real.sum (0::nat, Suc n) (%xa::nat. x ^ xa * y ^ (n - xa)) =
+ real.sum (0::nat, Suc n) (%xa::nat. x ^ (n - xa) * y ^ xa)"
by (import powser POWREV)
lemma POWSER_INSIDEA: "(All::((nat => real) => bool) => bool)
@@ -3766,23 +3934,24 @@
constdefs
diffs :: "(nat => real) => nat => real"
- "diffs == %c n. real (Suc n) * c (Suc n)"
-
-lemma diffs: "ALL c. diffs c = (%n. real (Suc n) * c (Suc n))"
+ "diffs == %(c::nat => real) n::nat. real (Suc n) * c (Suc n)"
+
+lemma diffs: "ALL c::nat => real. diffs c = (%n::nat. real (Suc n) * c (Suc n))"
by (import powser diffs)
-lemma DIFFS_NEG: "ALL c. diffs (%n. - c n) = (%x. - diffs c x)"
+lemma DIFFS_NEG: "ALL c::nat => real. diffs (%n::nat. - c n) = (%x::nat. - diffs c x)"
by (import powser DIFFS_NEG)
-lemma DIFFS_LEMMA: "ALL n c x.
- real.sum (0, n) (%n. diffs c n * x ^ n) =
- real.sum (0, n) (%n. real n * (c n * x ^ (n - 1))) +
- real n * (c n * x ^ (n - 1))"
+lemma DIFFS_LEMMA: "ALL (n::nat) (c::nat => real) x::real.
+ real.sum (0::nat, n) (%n::nat. diffs c n * x ^ n) =
+ real.sum (0::nat, n) (%n::nat. real n * (c n * x ^ (n - (1::nat)))) +
+ real n * (c n * x ^ (n - (1::nat)))"
by (import powser DIFFS_LEMMA)
-lemma DIFFS_LEMMA2: "ALL n c x.
- real.sum (0, n) (%n. real n * (c n * x ^ (n - 1))) =
- real.sum (0, n) (%n. diffs c n * x ^ n) - real n * (c n * x ^ (n - 1))"
+lemma DIFFS_LEMMA2: "ALL (n::nat) (c::nat => real) x::real.
+ real.sum (0::nat, n) (%n::nat. real n * (c n * x ^ (n - (1::nat)))) =
+ real.sum (0::nat, n) (%n::nat. diffs c n * x ^ n) -
+ real n * (c n * x ^ (n - (1::nat)))"
by (import powser DIFFS_LEMMA2)
lemma DIFFS_EQUIV: "(All::((nat => real) => bool) => bool)
@@ -3808,9 +3977,9 @@
((op ^::real => nat => real) x n))))))"
by (import powser DIFFS_EQUIV)
-lemma TERMDIFF_LEMMA1: "ALL m z h.
- real.sum (0, m) (%p. (z + h) ^ (m - p) * z ^ p - z ^ m) =
- real.sum (0, m) (%p. z ^ p * ((z + h) ^ (m - p) - z ^ (m - p)))"
+lemma TERMDIFF_LEMMA1: "ALL (m::nat) (z::real) h::real.
+ real.sum (0::nat, m) (%p::nat. (z + h) ^ (m - p) * z ^ p - z ^ m) =
+ real.sum (0::nat, m) (%p::nat. z ^ p * ((z + h) ^ (m - p) - z ^ (m - p)))"
by (import powser TERMDIFF_LEMMA1)
lemma TERMDIFF_LEMMA2: "(All::(real => bool) => bool)
@@ -4009,79 +4178,119 @@
constdefs
exp :: "real => real"
- "exp == %x. suminf (%n. inverse (real (FACT n)) * x ^ n)"
-
-lemma exp: "ALL x. exp x = suminf (%n. inverse (real (FACT n)) * x ^ n)"
+ "exp == %x::real. suminf (%n::nat. inverse (real (FACT n)) * x ^ n)"
+
+lemma exp: "ALL x::real. exp x = suminf (%n::nat. inverse (real (FACT n)) * x ^ n)"
by (import transc exp)
constdefs
cos :: "real => real"
- "cos ==
-%x. suminf
- (%n. (if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0) * x ^ n)"
-
-lemma cos: "ALL x.
- cos x =
- suminf
- (%n. (if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0) * x ^ n)"
+ "(cos ==
+ (%(x::real).
+ (suminf
+ (%(n::nat).
+ ((if (EVEN n)
+ then (((- (1::real)) ^ (n div (2::nat))) / (real (FACT n)))
+ else (0::real)) *
+ (x ^ n))))))"
+
+lemma cos: "(ALL (x::real).
+ ((cos x) =
+ (suminf
+ (%(n::nat).
+ ((if (EVEN n)
+ then (((- (1::real)) ^ (n div (2::nat))) / (real (FACT n)))
+ else (0::real)) *
+ (x ^ n))))))"
by (import transc cos)
constdefs
sin :: "real => real"
"sin ==
-%x. suminf
- (%n. (if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) *
- x ^ n)"
-
-lemma sin: "ALL x.
+%x::real.
+ suminf
+ (%n::nat.
+ (if EVEN n then 0::real
+ else (- (1::real)) ^ ((n - (1::nat)) div (2::nat)) /
+ real (FACT n)) *
+ x ^ n)"
+
+lemma sin: "ALL x::real.
sin x =
suminf
- (%n. (if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) *
- x ^ n)"
+ (%n::nat.
+ (if EVEN n then 0::real
+ else (- (1::real)) ^ ((n - (1::nat)) div (2::nat)) /
+ real (FACT n)) *
+ x ^ n)"
by (import transc sin)
-lemma EXP_CONVERGES: "ALL x. sums (%n. inverse (real (FACT n)) * x ^ n) (exp x)"
+lemma EXP_CONVERGES: "ALL x::real. sums (%n::nat. inverse (real (FACT n)) * x ^ n) (exp x)"
by (import transc EXP_CONVERGES)
-lemma SIN_CONVERGES: "ALL x.
+lemma SIN_CONVERGES: "ALL x::real.
sums
- (%n. (if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) *
- x ^ n)
+ (%n::nat.
+ (if EVEN n then 0::real
+ else (- (1::real)) ^ ((n - (1::nat)) div (2::nat)) /
+ real (FACT n)) *
+ x ^ n)
(sin x)"
by (import transc SIN_CONVERGES)
-lemma COS_CONVERGES: "ALL x.
- sums
- (%n. (if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0) * x ^ n)
- (cos x)"
+lemma COS_CONVERGES: "(ALL (x::real).
+ (sums
+ (%(n::nat).
+ ((if (EVEN n)
+ then (((- (1::real)) ^ (n div (2::nat))) / (real (FACT n)))
+ else (0::real)) *
+ (x ^ n)))
+ (cos x)))"
by (import transc COS_CONVERGES)
-lemma EXP_FDIFF: "diffs (%n. inverse (real (FACT n))) = (%n. inverse (real (FACT n)))"
+lemma EXP_FDIFF: "diffs (%n::nat. inverse (real (FACT n))) =
+(%n::nat. inverse (real (FACT n)))"
by (import transc EXP_FDIFF)
-lemma SIN_FDIFF: "diffs (%n. if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) =
-(%n. if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0)"
+lemma SIN_FDIFF: "((diffs
+ (%(n::nat).
+ (if (EVEN n) then (0::real)
+ else (((- (1::real)) ^ ((n - (1::nat)) div (2::nat))) /
+ (real (FACT n)))))) =
+ (%(n::nat).
+ (if (EVEN n)
+ then (((- (1::real)) ^ (n div (2::nat))) / (real (FACT n)))
+ else (0::real))))"
by (import transc SIN_FDIFF)
-lemma COS_FDIFF: "diffs (%n. if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0) =
-(%n. - (if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)))"
+lemma COS_FDIFF: "((diffs
+ (%(n::nat).
+ (if (EVEN n)
+ then (((- (1::real)) ^ (n div (2::nat))) / (real (FACT n)))
+ else (0::real)))) =
+ (%(n::nat).
+ (- (if (EVEN n) then (0::real)
+ else (((- (1::real)) ^ ((n - (1::nat)) div (2::nat))) /
+ (real (FACT n)))))))"
by (import transc COS_FDIFF)
-lemma SIN_NEGLEMMA: "ALL x.
+lemma SIN_NEGLEMMA: "ALL x::real.
- sin x =
suminf
- (%n. - ((if EVEN n then 0
- else (- 1) ^ ((n - 1) div 2) / real (FACT n)) *
- x ^ n))"
+ (%n::nat.
+ - ((if EVEN n then 0::real
+ else (- (1::real)) ^ ((n - (1::nat)) div (2::nat)) /
+ real (FACT n)) *
+ x ^ n))"
by (import transc SIN_NEGLEMMA)
-lemma DIFF_EXP: "ALL x. diffl exp (exp x) x"
+lemma DIFF_EXP: "ALL x::real. diffl exp (exp x) x"
by (import transc DIFF_EXP)
-lemma DIFF_SIN: "ALL x. diffl sin (cos x) x"
+lemma DIFF_SIN: "ALL x::real. diffl sin (cos x) x"
by (import transc DIFF_SIN)
-lemma DIFF_COS: "ALL x. diffl cos (- sin x) x"
+lemma DIFF_COS: "ALL x::real. diffl cos (- sin x) x"
by (import transc DIFF_COS)
lemma DIFF_COMPOSITE: "(op &::bool => bool => bool)
@@ -4193,43 +4402,43 @@
x))))))))))"
by (import transc DIFF_COMPOSITE)
-lemma EXP_0: "exp 0 = 1"
+lemma EXP_0: "exp (0::real) = (1::real)"
by (import transc EXP_0)
-lemma EXP_LE_X: "ALL x>=0. 1 + x <= exp x"
+lemma EXP_LE_X: "ALL x>=0::real. (1::real) + x <= exp x"
by (import transc EXP_LE_X)
-lemma EXP_LT_1: "ALL x>0. 1 < exp x"
+lemma EXP_LT_1: "ALL x>0::real. (1::real) < exp x"
by (import transc EXP_LT_1)
-lemma EXP_ADD_MUL: "ALL x y. exp (x + y) * exp (- x) = exp y"
+lemma EXP_ADD_MUL: "ALL (x::real) y::real. exp (x + y) * exp (- x) = exp y"
by (import transc EXP_ADD_MUL)
-lemma EXP_NEG_MUL: "ALL x. exp x * exp (- x) = 1"
+lemma EXP_NEG_MUL: "ALL x::real. exp x * exp (- x) = (1::real)"
by (import transc EXP_NEG_MUL)
-lemma EXP_NEG_MUL2: "ALL x. exp (- x) * exp x = 1"
+lemma EXP_NEG_MUL2: "ALL x::real. exp (- x) * exp x = (1::real)"
by (import transc EXP_NEG_MUL2)
-lemma EXP_NEG: "ALL x. exp (- x) = inverse (exp x)"
+lemma EXP_NEG: "ALL x::real. exp (- x) = inverse (exp x)"
by (import transc EXP_NEG)
-lemma EXP_ADD: "ALL x y. exp (x + y) = exp x * exp y"
+lemma EXP_ADD: "ALL (x::real) y::real. exp (x + y) = exp x * exp y"
by (import transc EXP_ADD)
-lemma EXP_POS_LE: "ALL x. 0 <= exp x"
+lemma EXP_POS_LE: "ALL x::real. (0::real) <= exp x"
by (import transc EXP_POS_LE)
-lemma EXP_NZ: "ALL x. exp x ~= 0"
+lemma EXP_NZ: "ALL x::real. exp x ~= (0::real)"
by (import transc EXP_NZ)
-lemma EXP_POS_LT: "ALL x. 0 < exp x"
+lemma EXP_POS_LT: "ALL x::real. (0::real) < exp x"
by (import transc EXP_POS_LT)
-lemma EXP_N: "ALL n x. exp (real n * x) = exp x ^ n"
+lemma EXP_N: "ALL (n::nat) x::real. exp (real n * x) = exp x ^ n"
by (import transc EXP_N)
-lemma EXP_SUB: "ALL x y. exp (x - y) = exp x / exp y"
+lemma EXP_SUB: "ALL (x::real) y::real. exp (x - y) = exp x / exp y"
by (import transc EXP_SUB)
lemma EXP_MONO_IMP: "(All::(real => bool) => bool)
@@ -4241,32 +4450,32 @@
((exp::real => real) y))))"
by (import transc EXP_MONO_IMP)
-lemma EXP_MONO_LT: "ALL x y. (exp x < exp y) = (x < y)"
+lemma EXP_MONO_LT: "ALL (x::real) y::real. (exp x < exp y) = (x < y)"
by (import transc EXP_MONO_LT)
-lemma EXP_MONO_LE: "ALL x y. (exp x <= exp y) = (x <= y)"
+lemma EXP_MONO_LE: "ALL (x::real) y::real. (exp x <= exp y) = (x <= y)"
by (import transc EXP_MONO_LE)
-lemma EXP_INJ: "ALL x y. (exp x = exp y) = (x = y)"
+lemma EXP_INJ: "ALL (x::real) y::real. (exp x = exp y) = (x = y)"
by (import transc EXP_INJ)
-lemma EXP_TOTAL_LEMMA: "ALL y>=1. EX x>=0. x <= y - 1 & exp x = y"
+lemma EXP_TOTAL_LEMMA: "ALL y>=1::real. EX x>=0::real. x <= y - (1::real) & exp x = y"
by (import transc EXP_TOTAL_LEMMA)
-lemma EXP_TOTAL: "ALL y>0. EX x. exp x = y"
+lemma EXP_TOTAL: "ALL y>0::real. EX x::real. exp x = y"
by (import transc EXP_TOTAL)
constdefs
ln :: "real => real"
- "ln == %x. SOME u. exp u = x"
-
-lemma ln: "ALL x. ln x = (SOME u. exp u = x)"
+ "ln == %x::real. SOME u::real. exp u = x"
+
+lemma ln: "ALL x::real. ln x = (SOME u::real. exp u = x)"
by (import transc ln)
-lemma LN_EXP: "ALL x. ln (exp x) = x"
+lemma LN_EXP: "ALL x::real. ln (exp x) = x"
by (import transc LN_EXP)
-lemma EXP_LN: "ALL x. (exp (ln x) = x) = (0 < x)"
+lemma EXP_LN: "ALL x::real. (exp (ln x) = x) = ((0::real) < x)"
by (import transc EXP_LN)
lemma LN_MUL: "(All::(real => bool) => bool)
@@ -4297,10 +4506,10 @@
((op =::real => real => bool) x y))))"
by (import transc LN_INJ)
-lemma LN_1: "ln 1 = 0"
+lemma LN_1: "ln (1::real) = (0::real)"
by (import transc LN_1)
-lemma LN_INV: "ALL x>0. ln (inverse x) = - ln x"
+lemma LN_INV: "ALL x>0::real. ln (inverse x) = - ln x"
by (import transc LN_INV)
lemma LN_DIV: "(All::(real => bool) => bool)
@@ -4357,13 +4566,13 @@
((ln::real => real) x)))))"
by (import transc LN_POW)
-lemma LN_LE: "ALL x>=0. ln (1 + x) <= x"
+lemma LN_LE: "ALL x>=0::real. ln ((1::real) + x) <= x"
by (import transc LN_LE)
-lemma LN_LT_X: "ALL x>0. ln x < x"
+lemma LN_LT_X: "ALL x>0::real. ln x < x"
by (import transc LN_LT_X)
-lemma LN_POS: "ALL x>=1. 0 <= ln x"
+lemma LN_POS: "ALL x>=1::real. (0::real) <= ln x"
by (import transc LN_POS)
constdefs
@@ -4397,9 +4606,9 @@
constdefs
sqrt :: "real => real"
- "sqrt == root 2"
-
-lemma sqrt: "ALL x. sqrt x = root 2 x"
+ "sqrt == root (2::nat)"
+
+lemma sqrt: "ALL x::real. sqrt x = root (2::nat) x"
by (import transc sqrt)
lemma ROOT_LT_LEMMA: "(All::(nat => bool) => bool)
@@ -4430,10 +4639,10 @@
((real::nat => real) ((Suc::nat => nat) n)))))))"
by (import transc ROOT_LN)
-lemma ROOT_0: "ALL n. root (Suc n) 0 = 0"
+lemma ROOT_0: "ALL n::nat. root (Suc n) (0::real) = (0::real)"
by (import transc ROOT_0)
-lemma ROOT_1: "ALL n. root (Suc n) 1 = 1"
+lemma ROOT_1: "ALL n::nat. root (Suc n) (1::real) = (1::real)"
by (import transc ROOT_1)
lemma ROOT_POS_LT: "(All::(nat => bool) => bool)
@@ -4564,22 +4773,22 @@
((root::nat => real => real) ((Suc::nat => nat) n) y))))"
by (import transc ROOT_MONO_LE)
-lemma SQRT_0: "sqrt 0 = 0"
+lemma SQRT_0: "sqrt (0::real) = (0::real)"
by (import transc SQRT_0)
-lemma SQRT_1: "sqrt 1 = 1"
+lemma SQRT_1: "sqrt (1::real) = (1::real)"
by (import transc SQRT_1)
-lemma SQRT_POS_LT: "ALL x>0. 0 < sqrt x"
+lemma SQRT_POS_LT: "ALL x>0::real. (0::real) < sqrt x"
by (import transc SQRT_POS_LT)
-lemma SQRT_POS_LE: "ALL x>=0. 0 <= sqrt x"
+lemma SQRT_POS_LE: "ALL x>=0::real. (0::real) <= sqrt x"
by (import transc SQRT_POS_LE)
-lemma SQRT_POW2: "ALL x. (sqrt x ^ 2 = x) = (0 <= x)"
+lemma SQRT_POW2: "ALL x::real. (sqrt x ^ 2 = x) = ((0::real) <= x)"
by (import transc SQRT_POW2)
-lemma SQRT_POW_2: "ALL x>=0. sqrt x ^ 2 = x"
+lemma SQRT_POW_2: "ALL x>=0::real. sqrt x ^ 2 = x"
by (import transc SQRT_POW_2)
lemma POW_2_SQRT: "(op -->::bool => bool => bool)
@@ -4628,7 +4837,7 @@
((sqrt::real => real) xa)))))"
by (import transc SQRT_MUL)
-lemma SQRT_INV: "ALL x>=0. sqrt (inverse x) = inverse (sqrt x)"
+lemma SQRT_INV: "ALL x>=0::real. sqrt (inverse x) = inverse (sqrt x)"
by (import transc SQRT_INV)
lemma SQRT_DIV: "(All::(real => bool) => bool)
@@ -4682,7 +4891,7 @@
(bit.B0::bit)))))))"
by (import transc SQRT_EVEN_POW2)
-lemma REAL_DIV_SQRT: "ALL x>=0. x / sqrt x = sqrt x"
+lemma REAL_DIV_SQRT: "ALL x>=0::real. x / sqrt x = sqrt x"
by (import transc REAL_DIV_SQRT)
lemma SQRT_EQ: "(All::(real => bool) => bool)
@@ -4703,56 +4912,60 @@
((op =::real => real => bool) x ((sqrt::real => real) y))))"
by (import transc SQRT_EQ)
-lemma SIN_0: "sin 0 = 0"
+lemma SIN_0: "sin (0::real) = (0::real)"
by (import transc SIN_0)
-lemma COS_0: "cos 0 = 1"
+lemma COS_0: "cos (0::real) = (1::real)"
by (import transc COS_0)
-lemma SIN_CIRCLE: "ALL x. sin x ^ 2 + cos x ^ 2 = 1"
+lemma SIN_CIRCLE: "ALL x::real. sin x ^ 2 + cos x ^ 2 = (1::real)"
by (import transc SIN_CIRCLE)
-lemma SIN_BOUND: "ALL x. abs (sin x) <= 1"
+lemma SIN_BOUND: "ALL x::real. abs (sin x) <= (1::real)"
by (import transc SIN_BOUND)
-lemma SIN_BOUNDS: "ALL x. - 1 <= sin x & sin x <= 1"
+lemma SIN_BOUNDS: "ALL x::real. - (1::real) <= sin x & sin x <= (1::real)"
by (import transc SIN_BOUNDS)
-lemma COS_BOUND: "ALL x. abs (cos x) <= 1"
+lemma COS_BOUND: "ALL x::real. abs (cos x) <= (1::real)"
by (import transc COS_BOUND)
-lemma COS_BOUNDS: "ALL x. - 1 <= cos x & cos x <= 1"
+lemma COS_BOUNDS: "ALL x::real. - (1::real) <= cos x & cos x <= (1::real)"
by (import transc COS_BOUNDS)
-lemma SIN_COS_ADD: "ALL x y.
+lemma SIN_COS_ADD: "ALL (x::real) y::real.
(sin (x + y) - (sin x * cos y + cos x * sin y)) ^ 2 +
(cos (x + y) - (cos x * cos y - sin x * sin y)) ^ 2 =
- 0"
+ (0::real)"
by (import transc SIN_COS_ADD)
-lemma SIN_COS_NEG: "ALL x. (sin (- x) + sin x) ^ 2 + (cos (- x) - cos x) ^ 2 = 0"
+lemma SIN_COS_NEG: "ALL x::real. (sin (- x) + sin x) ^ 2 + (cos (- x) - cos x) ^ 2 = (0::real)"
by (import transc SIN_COS_NEG)
-lemma SIN_ADD: "ALL x y. sin (x + y) = sin x * cos y + cos x * sin y"
+lemma SIN_ADD: "ALL (x::real) y::real. sin (x + y) = sin x * cos y + cos x * sin y"
by (import transc SIN_ADD)
-lemma COS_ADD: "ALL x y. cos (x + y) = cos x * cos y - sin x * sin y"
+lemma COS_ADD: "ALL (x::real) y::real. cos (x + y) = cos x * cos y - sin x * sin y"
by (import transc COS_ADD)
-lemma SIN_NEG: "ALL x. sin (- x) = - sin x"
+lemma SIN_NEG: "ALL x::real. sin (- x) = - sin x"
by (import transc SIN_NEG)
-lemma COS_NEG: "ALL x. cos (- x) = cos x"
+lemma COS_NEG: "ALL x::real. cos (- x) = cos x"
by (import transc COS_NEG)
-lemma SIN_DOUBLE: "ALL x. sin (2 * x) = 2 * (sin x * cos x)"
+lemma SIN_DOUBLE: "ALL x::real. sin ((2::real) * x) = (2::real) * (sin x * cos x)"
by (import transc SIN_DOUBLE)
-lemma COS_DOUBLE: "ALL x. cos (2 * x) = cos x ^ 2 - sin x ^ 2"
+lemma COS_DOUBLE: "ALL x::real. cos ((2::real) * x) = cos x ^ 2 - sin x ^ 2"
by (import transc COS_DOUBLE)
-lemma SIN_PAIRED: "ALL x.
- sums (%n. (- 1) ^ n / real (FACT (2 * n + 1)) * x ^ (2 * n + 1)) (sin x)"
+lemma SIN_PAIRED: "ALL x::real.
+ sums
+ (%n::nat.
+ (- (1::real)) ^ n / real (FACT ((2::nat) * n + (1::nat))) *
+ x ^ ((2::nat) * n + (1::nat)))
+ (sin x)"
by (import transc SIN_PAIRED)
lemma SIN_POS: "(All::(real => bool) => bool)
@@ -4768,62 +4981,71 @@
((op <::real => real => bool) (0::real) ((sin::real => real) x)))"
by (import transc SIN_POS)
-lemma COS_PAIRED: "ALL x. sums (%n. (- 1) ^ n / real (FACT (2 * n)) * x ^ (2 * n)) (cos x)"
+lemma COS_PAIRED: "ALL x::real.
+ sums
+ (%n::nat.
+ (- (1::real)) ^ n / real (FACT ((2::nat) * n)) * x ^ ((2::nat) * n))
+ (cos x)"
by (import transc COS_PAIRED)
-lemma COS_2: "cos 2 < 0"
+lemma COS_2: "cos (2::real) < (0::real)"
by (import transc COS_2)
-lemma COS_ISZERO: "EX! x. 0 <= x & x <= 2 & cos x = 0"
+lemma COS_ISZERO: "EX! x::real. (0::real) <= x & x <= (2::real) & cos x = (0::real)"
by (import transc COS_ISZERO)
constdefs
pi :: "real"
- "pi == 2 * (SOME x. 0 <= x & x <= 2 & cos x = 0)"
-
-lemma pi: "pi = 2 * (SOME x. 0 <= x & x <= 2 & cos x = 0)"
+ "pi ==
+(2::real) *
+(SOME x::real. (0::real) <= x & x <= (2::real) & cos x = (0::real))"
+
+lemma pi: "pi =
+(2::real) *
+(SOME x::real. (0::real) <= x & x <= (2::real) & cos x = (0::real))"
by (import transc pi)
-lemma PI2: "pi / 2 = (SOME x. 0 <= x & x <= 2 & cos x = 0)"
+lemma PI2: "pi / (2::real) =
+(SOME x::real. (0::real) <= x & x <= (2::real) & cos x = (0::real))"
by (import transc PI2)
-lemma COS_PI2: "cos (pi / 2) = 0"
+lemma COS_PI2: "cos (pi / (2::real)) = (0::real)"
by (import transc COS_PI2)
-lemma PI2_BOUNDS: "0 < pi / 2 & pi / 2 < 2"
+lemma PI2_BOUNDS: "(0::real) < pi / (2::real) & pi / (2::real) < (2::real)"
by (import transc PI2_BOUNDS)
-lemma PI_POS: "0 < pi"
+lemma PI_POS: "(0::real) < pi"
by (import transc PI_POS)
-lemma SIN_PI2: "sin (pi / 2) = 1"
+lemma SIN_PI2: "sin (pi / (2::real)) = (1::real)"
by (import transc SIN_PI2)
-lemma COS_PI: "cos pi = - 1"
+lemma COS_PI: "cos pi = - (1::real)"
by (import transc COS_PI)
-lemma SIN_PI: "sin pi = 0"
+lemma SIN_PI: "sin pi = (0::real)"
by (import transc SIN_PI)
-lemma SIN_COS: "ALL x. sin x = cos (pi / 2 - x)"
+lemma SIN_COS: "ALL x::real. sin x = cos (pi / (2::real) - x)"
by (import transc SIN_COS)
-lemma COS_SIN: "ALL x. cos x = sin (pi / 2 - x)"
+lemma COS_SIN: "ALL x::real. cos x = sin (pi / (2::real) - x)"
by (import transc COS_SIN)
-lemma SIN_PERIODIC_PI: "ALL x. sin (x + pi) = - sin x"
+lemma SIN_PERIODIC_PI: "ALL x::real. sin (x + pi) = - sin x"
by (import transc SIN_PERIODIC_PI)
-lemma COS_PERIODIC_PI: "ALL x. cos (x + pi) = - cos x"
+lemma COS_PERIODIC_PI: "ALL x::real. cos (x + pi) = - cos x"
by (import transc COS_PERIODIC_PI)
-lemma SIN_PERIODIC: "ALL x. sin (x + 2 * pi) = sin x"
+lemma SIN_PERIODIC: "ALL x::real. sin (x + (2::real) * pi) = sin x"
by (import transc SIN_PERIODIC)
-lemma COS_PERIODIC: "ALL x. cos (x + 2 * pi) = cos x"
+lemma COS_PERIODIC: "ALL x::real. cos (x + (2::real) * pi) = cos x"
by (import transc COS_PERIODIC)
-lemma COS_NPI: "ALL n. cos (real n * pi) = (- 1) ^ n"
+lemma COS_NPI: "ALL n::nat. cos (real n * pi) = (- (1::real)) ^ n"
by (import transc COS_NPI)
lemma SIN_NPI: "ALL n::nat. sin (real n * pi) = (0::real)"
@@ -5036,38 +5258,38 @@
(bit.B0::bit)))))))))"
by (import transc SIN_ZERO_LEMMA)
-lemma COS_ZERO: "ALL x.
- (cos x = 0) =
- ((EX n. ~ EVEN n & x = real n * (pi / 2)) |
- (EX n. ~ EVEN n & x = - (real n * (pi / 2))))"
+lemma COS_ZERO: "ALL x::real.
+ (cos x = (0::real)) =
+ ((EX n::nat. ~ EVEN n & x = real n * (pi / (2::real))) |
+ (EX n::nat. ~ EVEN n & x = - (real n * (pi / (2::real)))))"
by (import transc COS_ZERO)
-lemma SIN_ZERO: "ALL x.
- (sin x = 0) =
- ((EX n. EVEN n & x = real n * (pi / 2)) |
- (EX n. EVEN n & x = - (real n * (pi / 2))))"
+lemma SIN_ZERO: "ALL x::real.
+ (sin x = (0::real)) =
+ ((EX n::nat. EVEN n & x = real n * (pi / (2::real))) |
+ (EX n::nat. EVEN n & x = - (real n * (pi / (2::real)))))"
by (import transc SIN_ZERO)
constdefs
tan :: "real => real"
- "tan == %x. sin x / cos x"
-
-lemma tan: "ALL x. tan x = sin x / cos x"
+ "tan == %x::real. sin x / cos x"
+
+lemma tan: "ALL x::real. tan x = sin x / cos x"
by (import transc tan)
-lemma TAN_0: "tan 0 = 0"
+lemma TAN_0: "tan (0::real) = (0::real)"
by (import transc TAN_0)
-lemma TAN_PI: "tan pi = 0"
+lemma TAN_PI: "tan pi = (0::real)"
by (import transc TAN_PI)
lemma TAN_NPI: "ALL n::nat. tan (real n * pi) = (0::real)"
by (import transc TAN_NPI)
-lemma TAN_NEG: "ALL x. tan (- x) = - tan x"
+lemma TAN_NEG: "ALL x::real. tan (- x) = - tan x"
by (import transc TAN_NEG)
-lemma TAN_PERIODIC: "ALL x. tan (x + 2 * pi) = tan x"
+lemma TAN_PERIODIC: "ALL x::real. tan (x + (2::real) * pi) = tan x"
by (import transc TAN_PERIODIC)
lemma TAN_ADD: "(All::(real => bool) => bool)
@@ -5171,34 +5393,43 @@
x))"
by (import transc DIFF_TAN)
-lemma TAN_TOTAL_LEMMA: "ALL y>0. EX x>0. x < pi / 2 & y < tan x"
+lemma TAN_TOTAL_LEMMA: "ALL y>0::real. EX x>0::real. x < pi / (2::real) & y < tan x"
by (import transc TAN_TOTAL_LEMMA)
-lemma TAN_TOTAL_POS: "ALL y>=0. EX x>=0. x < pi / 2 & tan x = y"
+lemma TAN_TOTAL_POS: "ALL y>=0::real. EX x>=0::real. x < pi / (2::real) & tan x = y"
by (import transc TAN_TOTAL_POS)
-lemma TAN_TOTAL: "ALL y. EX! x. - (pi / 2) < x & x < pi / 2 & tan x = y"
+lemma TAN_TOTAL: "ALL y::real.
+ EX! x::real. - (pi / (2::real)) < x & x < pi / (2::real) & tan x = y"
by (import transc TAN_TOTAL)
constdefs
asn :: "real => real"
- "asn == %y. SOME x. - (pi / 2) <= x & x <= pi / 2 & sin x = y"
-
-lemma asn: "ALL y. asn y = (SOME x. - (pi / 2) <= x & x <= pi / 2 & sin x = y)"
+ "asn ==
+%y::real.
+ SOME x::real. - (pi / (2::real)) <= x & x <= pi / (2::real) & sin x = y"
+
+lemma asn: "ALL y::real.
+ asn y =
+ (SOME x::real. - (pi / (2::real)) <= x & x <= pi / (2::real) & sin x = y)"
by (import transc asn)
constdefs
acs :: "real => real"
- "acs == %y. SOME x. 0 <= x & x <= pi & cos x = y"
-
-lemma acs: "ALL y. acs y = (SOME x. 0 <= x & x <= pi & cos x = y)"
+ "acs == %y::real. SOME x::real. (0::real) <= x & x <= pi & cos x = y"
+
+lemma acs: "ALL y::real. acs y = (SOME x::real. (0::real) <= x & x <= pi & cos x = y)"
by (import transc acs)
constdefs
atn :: "real => real"
- "atn == %y. SOME x. - (pi / 2) < x & x < pi / 2 & tan x = y"
-
-lemma atn: "ALL y. atn y = (SOME x. - (pi / 2) < x & x < pi / 2 & tan x = y)"
+ "atn ==
+%y::real.
+ SOME x::real. - (pi / (2::real)) < x & x < pi / (2::real) & tan x = y"
+
+lemma atn: "ALL y::real.
+ atn y =
+ (SOME x::real. - (pi / (2::real)) < x & x < pi / (2::real) & tan x = y)"
by (import transc atn)
lemma ASN: "(All::(real => bool) => bool)
@@ -5369,13 +5600,14 @@
((acs::real => real) ((cos::real => real) x)) x))"
by (import transc COS_ACS)
-lemma ATN: "ALL y. - (pi / 2) < atn y & atn y < pi / 2 & tan (atn y) = y"
+lemma ATN: "ALL y::real.
+ - (pi / (2::real)) < atn y & atn y < pi / (2::real) & tan (atn y) = y"
by (import transc ATN)
-lemma ATN_TAN: "ALL x. tan (atn x) = x"
+lemma ATN_TAN: "ALL x::real. tan (atn x) = x"
by (import transc ATN_TAN)
-lemma ATN_BOUNDS: "ALL x. - (pi / 2) < atn x & atn x < pi / 2"
+lemma ATN_BOUNDS: "ALL x::real. - (pi / (2::real)) < atn x & atn x < pi / (2::real)"
by (import transc ATN_BOUNDS)
lemma TAN_ATN: "(All::(real => bool) => bool)
@@ -5471,7 +5703,7 @@
(bit.B0::bit))))))))"
by (import transc COS_SIN_SQ)
-lemma COS_ATN_NZ: "ALL x. cos (atn x) ~= 0"
+lemma COS_ATN_NZ: "ALL x::real. cos (atn x) ~= (0::real)"
by (import transc COS_ATN_NZ)
lemma COS_ASN_NZ: "(All::(real => bool) => bool)
@@ -5526,7 +5758,7 @@
(bit.B0::bit))))))))"
by (import transc SIN_COS_SQRT)
-lemma DIFF_LN: "ALL x>0. diffl ln (inverse x) x"
+lemma DIFF_LN: "ALL x>0::real. diffl ln (inverse x) x"
by (import transc DIFF_LN)
lemma DIFF_ASN_LEMMA: "(All::(real => bool) => bool)
@@ -5593,7 +5825,7 @@
x))"
by (import transc DIFF_ACS)
-lemma DIFF_ATN: "ALL x. diffl atn (inverse (1 + x ^ 2)) x"
+lemma DIFF_ATN: "ALL x::real. diffl atn (inverse ((1::real) + x ^ 2)) x"
by (import transc DIFF_ATN)
constdefs
@@ -5691,11 +5923,12 @@
constdefs
tdiv :: "real * real => (nat => real) * (nat => real) => bool"
"tdiv ==
-%(a, b) (D, p). division (a, b) D & (ALL n. D n <= p n & p n <= D (Suc n))"
-
-lemma tdiv: "ALL a b D p.
+%(a::real, b::real) (D::nat => real, p::nat => real).
+ division (a, b) D & (ALL n::nat. D n <= p n & p n <= D (Suc n))"
+
+lemma tdiv: "ALL (a::real) (b::real) (D::nat => real) p::nat => real.
tdiv (a, b) (D, p) =
- (division (a, b) D & (ALL n. D n <= p n & p n <= D (Suc n)))"
+ (division (a, b) D & (ALL n::nat. D n <= p n & p n <= D (Suc n)))"
by (import transc tdiv)
constdefs
@@ -5767,10 +6000,13 @@
constdefs
rsum :: "(nat => real) * (nat => real) => (real => real) => real"
- "rsum == %(D, p) f. real.sum (0, dsize D) (%n. f (p n) * (D (Suc n) - D n))"
-
-lemma rsum: "ALL D p f.
- rsum (D, p) f = real.sum (0, dsize D) (%n. f (p n) * (D (Suc n) - D n))"
+ "rsum ==
+%(D::nat => real, p::nat => real) f::real => real.
+ real.sum (0::nat, dsize D) (%n::nat. f (p n) * (D (Suc n) - D n))"
+
+lemma rsum: "ALL (D::nat => real) (p::nat => real) f::real => real.
+ rsum (D, p) f =
+ real.sum (0::nat, dsize D) (%n::nat. f (p n) * (D (Suc n) - D n))"
by (import transc rsum)
constdefs
@@ -6283,7 +6519,7 @@
((op =::real => real => bool) k1 k2))))))"
by (import transc DINT_UNIQ)
-lemma INTEGRAL_NULL: "ALL f a. Dint (a, a) f 0"
+lemma INTEGRAL_NULL: "ALL (f::real => real) a::real. Dint (a, a) f (0::real)"
by (import transc INTEGRAL_NULL)
lemma FTC1: "(All::((real => real) => bool) => bool)
@@ -6555,11 +6791,11 @@
((op ^::real => nat => real) x n)))))))))"
by (import transc MCLAURIN_EXP_LT)
-lemma MCLAURIN_EXP_LE: "ALL x n.
- EX xa.
+lemma MCLAURIN_EXP_LE: "ALL (x::real) n::nat.
+ EX xa::real.
abs xa <= abs x &
exp x =
- real.sum (0, n) (%m. x ^ m / real (FACT m)) +
+ real.sum (0::nat, n) (%m::nat. x ^ m / real (FACT m)) +
exp xa / real (FACT n) * x ^ n"
by (import transc MCLAURIN_EXP_LE)
@@ -6587,14 +6823,15 @@
consts
poly :: "real list => real => real"
-specification (poly_primdef: poly) poly_def: "(ALL x. poly [] x = 0) & (ALL h t x. poly (h # t) x = h + x * poly t x)"
+specification (poly_primdef: poly) poly_def: "(ALL x::real. poly [] x = (0::real)) &
+(ALL (h::real) (t::real list) x::real. poly (h # t) x = h + x * poly t x)"
by (import poly poly_def)
consts
poly_add :: "real list => real list => real list"
-specification (poly_add_primdef: poly_add) poly_add_def: "(ALL l2. poly_add [] l2 = l2) &
-(ALL h t l2.
+specification (poly_add_primdef: poly_add) poly_add_def: "(ALL l2::real list. poly_add [] l2 = l2) &
+(ALL (h::real) (t::real list) l2::real list.
poly_add (h # t) l2 =
(if l2 = [] then h # t else (h + hd l2) # poly_add t (tl l2)))"
by (import poly poly_add_def)
@@ -6602,94 +6839,104 @@
consts
"##" :: "real => real list => real list" ("##")
-specification ("##") poly_cmul_def: "(ALL c. ## c [] = []) & (ALL c h t. ## c (h # t) = c * h # ## c t)"
+specification ("##") poly_cmul_def: "(ALL c::real. ## c [] = []) &
+(ALL (c::real) (h::real) t::real list. ## c (h # t) = c * h # ## c t)"
by (import poly poly_cmul_def)
consts
poly_neg :: "real list => real list"
defs
- poly_neg_primdef: "poly_neg == ## (- 1)"
-
-lemma poly_neg_def: "poly_neg = ## (- 1)"
+ poly_neg_primdef: "poly_neg == ## (- (1::real))"
+
+lemma poly_neg_def: "poly_neg = ## (- (1::real))"
by (import poly poly_neg_def)
consts
poly_mul :: "real list => real list => real list"
-specification (poly_mul_primdef: poly_mul) poly_mul_def: "(ALL l2. poly_mul [] l2 = []) &
-(ALL h t l2.
+specification (poly_mul_primdef: poly_mul) poly_mul_def: "(ALL l2::real list. poly_mul [] l2 = []) &
+(ALL (h::real) (t::real list) l2::real list.
poly_mul (h # t) l2 =
- (if t = [] then ## h l2 else poly_add (## h l2) (0 # poly_mul t l2)))"
+ (if t = [] then ## h l2
+ else poly_add (## h l2) ((0::real) # poly_mul t l2)))"
by (import poly poly_mul_def)
consts
poly_exp :: "real list => nat => real list"
-specification (poly_exp_primdef: poly_exp) poly_exp_def: "(ALL p. poly_exp p 0 = [1]) &
-(ALL p n. poly_exp p (Suc n) = poly_mul p (poly_exp p n))"
+specification (poly_exp_primdef: poly_exp) poly_exp_def: "(ALL p::real list. poly_exp p (0::nat) = [1::real]) &
+(ALL (p::real list) n::nat. poly_exp p (Suc n) = poly_mul p (poly_exp p n))"
by (import poly poly_exp_def)
consts
poly_diff_aux :: "nat => real list => real list"
-specification (poly_diff_aux_primdef: poly_diff_aux) poly_diff_aux_def: "(ALL n. poly_diff_aux n [] = []) &
-(ALL n h t. poly_diff_aux n (h # t) = real n * h # poly_diff_aux (Suc n) t)"
+specification (poly_diff_aux_primdef: poly_diff_aux) poly_diff_aux_def: "(ALL n::nat. poly_diff_aux n [] = []) &
+(ALL (n::nat) (h::real) t::real list.
+ poly_diff_aux n (h # t) = real n * h # poly_diff_aux (Suc n) t)"
by (import poly poly_diff_aux_def)
constdefs
diff :: "real list => real list"
- "diff == %l. if l = [] then [] else poly_diff_aux 1 (tl l)"
-
-lemma poly_diff_def: "ALL l. diff l = (if l = [] then [] else poly_diff_aux 1 (tl l))"
+ "diff == %l::real list. if l = [] then [] else poly_diff_aux (1::nat) (tl l)"
+
+lemma poly_diff_def: "ALL l::real list.
+ diff l = (if l = [] then [] else poly_diff_aux (1::nat) (tl l))"
by (import poly poly_diff_def)
-lemma POLY_ADD_CLAUSES: "poly_add [] p2 = p2 &
-poly_add p1 [] = p1 &
-poly_add (h1 # t1) (h2 # t2) = (h1 + h2) # poly_add t1 t2"
+lemma POLY_ADD_CLAUSES: "poly_add [] (p2::real list) = p2 &
+poly_add (p1::real list) [] = p1 &
+poly_add ((h1::real) # (t1::real list)) ((h2::real) # (t2::real list)) =
+(h1 + h2) # poly_add t1 t2"
by (import poly POLY_ADD_CLAUSES)
-lemma POLY_CMUL_CLAUSES: "## c [] = [] & ## c (h # t) = c * h # ## c t"
+lemma POLY_CMUL_CLAUSES: "## (c::real) [] = [] & ## c ((h::real) # (t::real list)) = c * h # ## c t"
by (import poly POLY_CMUL_CLAUSES)
-lemma POLY_NEG_CLAUSES: "poly_neg [] = [] & poly_neg (h # t) = - h # poly_neg t"
+lemma POLY_NEG_CLAUSES: "poly_neg [] = [] & poly_neg ((h::real) # (t::real list)) = - h # poly_neg t"
by (import poly POLY_NEG_CLAUSES)
-lemma POLY_MUL_CLAUSES: "poly_mul [] p2 = [] &
-poly_mul [h1] p2 = ## h1 p2 &
-poly_mul (h1 # k1 # t1) p2 = poly_add (## h1 p2) (0 # poly_mul (k1 # t1) p2)"
+lemma POLY_MUL_CLAUSES: "poly_mul [] (p2::real list) = [] &
+poly_mul [h1::real] p2 = ## h1 p2 &
+poly_mul (h1 # (k1::real) # (t1::real list)) p2 =
+poly_add (## h1 p2) ((0::real) # poly_mul (k1 # t1) p2)"
by (import poly POLY_MUL_CLAUSES)
-lemma POLY_DIFF_CLAUSES: "diff [] = [] & diff [c] = [] & diff (h # t) = poly_diff_aux 1 t"
+lemma POLY_DIFF_CLAUSES: "diff [] = [] &
+diff [c::real] = [] &
+diff ((h::real) # (t::real list)) = poly_diff_aux (1::nat) t"
by (import poly POLY_DIFF_CLAUSES)
-lemma POLY_ADD: "ALL t p2 x. poly (poly_add t p2) x = poly t x + poly p2 x"
+lemma POLY_ADD: "ALL (t::real list) (p2::real list) x::real.
+ poly (poly_add t p2) x = poly t x + poly p2 x"
by (import poly POLY_ADD)
-lemma POLY_CMUL: "ALL t c x. poly (## c t) x = c * poly t x"
+lemma POLY_CMUL: "ALL (t::real list) (c::real) x::real. poly (## c t) x = c * poly t x"
by (import poly POLY_CMUL)
-lemma POLY_NEG: "ALL x xa. poly (poly_neg x) xa = - poly x xa"
+lemma POLY_NEG: "ALL (x::real list) xa::real. poly (poly_neg x) xa = - poly x xa"
by (import poly POLY_NEG)
-lemma POLY_MUL: "ALL x t p2. poly (poly_mul t p2) x = poly t x * poly p2 x"
+lemma POLY_MUL: "ALL (x::real) (t::real list) p2::real list.
+ poly (poly_mul t p2) x = poly t x * poly p2 x"
by (import poly POLY_MUL)
-lemma POLY_EXP: "ALL p n x. poly (poly_exp p n) x = poly p x ^ n"
+lemma POLY_EXP: "ALL (p::real list) (n::nat) x::real. poly (poly_exp p n) x = poly p x ^ n"
by (import poly POLY_EXP)
-lemma POLY_DIFF_LEMMA: "ALL t n x.
- diffl (%x. x ^ Suc n * poly t x)
+lemma POLY_DIFF_LEMMA: "ALL (t::real list) (n::nat) x::real.
+ diffl (%x::real. x ^ Suc n * poly t x)
(x ^ n * poly (poly_diff_aux (Suc n) t) x) x"
by (import poly POLY_DIFF_LEMMA)
-lemma POLY_DIFF: "ALL t x. diffl (poly t) (poly (diff t) x) x"
+lemma POLY_DIFF: "ALL (t::real list) x::real. diffl (poly t) (poly (diff t) x) x"
by (import poly POLY_DIFF)
-lemma POLY_DIFFERENTIABLE: "ALL l. All (differentiable (poly l))"
+lemma POLY_DIFFERENTIABLE: "ALL l::real list. All (differentiable (poly l))"
by (import poly POLY_DIFFERENTIABLE)
-lemma POLY_CONT: "ALL l. All (contl (poly l))"
+lemma POLY_CONT: "ALL l::real list. All (contl (poly l))"
by (import poly POLY_CONT)
lemma POLY_IVT_POS: "(All::(real list => bool) => bool)
@@ -6766,69 +7013,77 @@
((diff::real list => real list) p) x)))))))))"
by (import poly POLY_MVT)
-lemma POLY_ADD_RZERO: "ALL x. poly (poly_add x []) = poly x"
+lemma POLY_ADD_RZERO: "ALL x::real list. poly (poly_add x []) = poly x"
by (import poly POLY_ADD_RZERO)
-lemma POLY_MUL_ASSOC: "ALL x xa xb.
+lemma POLY_MUL_ASSOC: "ALL (x::real list) (xa::real list) xb::real list.
poly (poly_mul x (poly_mul xa xb)) = poly (poly_mul (poly_mul x xa) xb)"
by (import poly POLY_MUL_ASSOC)
-lemma POLY_EXP_ADD: "ALL x xa xb.
+lemma POLY_EXP_ADD: "ALL (x::nat) (xa::nat) xb::real list.
poly (poly_exp xb (xa + x)) =
poly (poly_mul (poly_exp xb xa) (poly_exp xb x))"
by (import poly POLY_EXP_ADD)
-lemma POLY_DIFF_AUX_ADD: "ALL t p2 n.
+lemma POLY_DIFF_AUX_ADD: "ALL (t::real list) (p2::real list) n::nat.
poly (poly_diff_aux n (poly_add t p2)) =
poly (poly_add (poly_diff_aux n t) (poly_diff_aux n p2))"
by (import poly POLY_DIFF_AUX_ADD)
-lemma POLY_DIFF_AUX_CMUL: "ALL t c n. poly (poly_diff_aux n (## c t)) = poly (## c (poly_diff_aux n t))"
+lemma POLY_DIFF_AUX_CMUL: "ALL (t::real list) (c::real) n::nat.
+ poly (poly_diff_aux n (## c t)) = poly (## c (poly_diff_aux n t))"
by (import poly POLY_DIFF_AUX_CMUL)
-lemma POLY_DIFF_AUX_NEG: "ALL x xa.
+lemma POLY_DIFF_AUX_NEG: "ALL (x::real list) xa::nat.
poly (poly_diff_aux xa (poly_neg x)) =
poly (poly_neg (poly_diff_aux xa x))"
by (import poly POLY_DIFF_AUX_NEG)
-lemma POLY_DIFF_AUX_MUL_LEMMA: "ALL t n.
+lemma POLY_DIFF_AUX_MUL_LEMMA: "ALL (t::real list) n::nat.
poly (poly_diff_aux (Suc n) t) = poly (poly_add (poly_diff_aux n t) t)"
by (import poly POLY_DIFF_AUX_MUL_LEMMA)
-lemma POLY_DIFF_ADD: "ALL t p2. poly (diff (poly_add t p2)) = poly (poly_add (diff t) (diff p2))"
+lemma POLY_DIFF_ADD: "ALL (t::real list) p2::real list.
+ poly (diff (poly_add t p2)) = poly (poly_add (diff t) (diff p2))"
by (import poly POLY_DIFF_ADD)
-lemma POLY_DIFF_CMUL: "ALL t c. poly (diff (## c t)) = poly (## c (diff t))"
+lemma POLY_DIFF_CMUL: "ALL (t::real list) c::real. poly (diff (## c t)) = poly (## c (diff t))"
by (import poly POLY_DIFF_CMUL)
-lemma POLY_DIFF_NEG: "ALL x. poly (diff (poly_neg x)) = poly (poly_neg (diff x))"
+lemma POLY_DIFF_NEG: "ALL x::real list. poly (diff (poly_neg x)) = poly (poly_neg (diff x))"
by (import poly POLY_DIFF_NEG)
-lemma POLY_DIFF_MUL_LEMMA: "ALL x xa. poly (diff (xa # x)) = poly (poly_add (0 # diff x) x)"
+lemma POLY_DIFF_MUL_LEMMA: "ALL (x::real list) xa::real.
+ poly (diff (xa # x)) = poly (poly_add ((0::real) # diff x) x)"
by (import poly POLY_DIFF_MUL_LEMMA)
-lemma POLY_DIFF_MUL: "ALL t p2.
+lemma POLY_DIFF_MUL: "ALL (t::real list) p2::real list.
poly (diff (poly_mul t p2)) =
poly (poly_add (poly_mul t (diff p2)) (poly_mul (diff t) p2))"
by (import poly POLY_DIFF_MUL)
-lemma POLY_DIFF_EXP: "ALL p n.
+lemma POLY_DIFF_EXP: "ALL (p::real list) n::nat.
poly (diff (poly_exp p (Suc n))) =
poly (poly_mul (## (real (Suc n)) (poly_exp p n)) (diff p))"
by (import poly POLY_DIFF_EXP)
-lemma POLY_DIFF_EXP_PRIME: "ALL n a.
- poly (diff (poly_exp [- a, 1] (Suc n))) =
- poly (## (real (Suc n)) (poly_exp [- a, 1] n))"
+lemma POLY_DIFF_EXP_PRIME: "ALL (n::nat) a::real.
+ poly (diff (poly_exp [- a, 1::real] (Suc n))) =
+ poly (## (real (Suc n)) (poly_exp [- a, 1::real] n))"
by (import poly POLY_DIFF_EXP_PRIME)
-lemma POLY_LINEAR_REM: "ALL t h. EX q r. h # t = poly_add [r] (poly_mul [- a, 1] q)"
+lemma POLY_LINEAR_REM: "ALL (t::real list) h::real.
+ EX (q::real list) r::real.
+ h # t = poly_add [r] (poly_mul [- (a::real), 1::real] q)"
by (import poly POLY_LINEAR_REM)
-lemma POLY_LINEAR_DIVIDES: "ALL a t. (poly t a = 0) = (t = [] | (EX q. t = poly_mul [- a, 1] q))"
+lemma POLY_LINEAR_DIVIDES: "ALL (a::real) t::real list.
+ (poly t a = (0::real)) =
+ (t = [] | (EX q::real list. t = poly_mul [- a, 1::real] q))"
by (import poly POLY_LINEAR_DIVIDES)
-lemma POLY_LENGTH_MUL: "ALL x. length (poly_mul [- a, 1] x) = Suc (length x)"
+lemma POLY_LENGTH_MUL: "ALL x::real list.
+ length (poly_mul [- (a::real), 1::real] x) = Suc (length x)"
by (import poly POLY_LENGTH_MUL)
lemma POLY_ROOTS_INDEX_LEMMA: "(All::(nat => bool) => bool)
@@ -6968,22 +7223,23 @@
((poly::real list => real => real) ([]::real list))))))"
by (import poly POLY_ENTIRE_LEMMA)
-lemma POLY_ENTIRE: "ALL p q.
+lemma POLY_ENTIRE: "ALL (p::real list) q::real list.
(poly (poly_mul p q) = poly []) = (poly p = poly [] | poly q = poly [])"
by (import poly POLY_ENTIRE)
-lemma POLY_MUL_LCANCEL: "ALL x xa xb.
+lemma POLY_MUL_LCANCEL: "ALL (x::real list) (xa::real list) xb::real list.
(poly (poly_mul x xa) = poly (poly_mul x xb)) =
(poly x = poly [] | poly xa = poly xb)"
by (import poly POLY_MUL_LCANCEL)
-lemma POLY_EXP_EQ_0: "ALL p n. (poly (poly_exp p n) = poly []) = (poly p = poly [] & n ~= 0)"
+lemma POLY_EXP_EQ_0: "ALL (p::real list) n::nat.
+ (poly (poly_exp p n) = poly []) = (poly p = poly [] & n ~= (0::nat))"
by (import poly POLY_EXP_EQ_0)
-lemma POLY_PRIME_EQ_0: "ALL a. poly [a, 1] ~= poly []"
+lemma POLY_PRIME_EQ_0: "ALL a::real. poly [a, 1::real] ~= poly []"
by (import poly POLY_PRIME_EQ_0)
-lemma POLY_EXP_PRIME_EQ_0: "ALL a n. poly (poly_exp [a, 1] n) ~= poly []"
+lemma POLY_EXP_PRIME_EQ_0: "ALL (a::real) n::nat. poly (poly_exp [a, 1::real] n) ~= poly []"
by (import poly POLY_EXP_PRIME_EQ_0)
lemma POLY_ZERO_LEMMA: "(All::(real => bool) => bool)
@@ -7002,11 +7258,12 @@
((poly::real list => real => real) ([]::real list))))))"
by (import poly POLY_ZERO_LEMMA)
-lemma POLY_ZERO: "ALL t. (poly t = poly []) = list_all (%c. c = 0) t"
+lemma POLY_ZERO: "ALL t::real list. (poly t = poly []) = list_all (%c::real. c = (0::real)) t"
by (import poly POLY_ZERO)
-lemma POLY_DIFF_AUX_ISZERO: "ALL t n.
- list_all (%c. c = 0) (poly_diff_aux (Suc n) t) = list_all (%c. c = 0) t"
+lemma POLY_DIFF_AUX_ISZERO: "ALL (t::real list) n::nat.
+ list_all (%c::real. c = (0::real)) (poly_diff_aux (Suc n) t) =
+ list_all (%c::real. c = (0::real)) t"
by (import poly POLY_DIFF_AUX_ISZERO)
lemma POLY_DIFF_ISZERO: "(All::(real list => bool) => bool)
@@ -7054,17 +7311,20 @@
constdefs
poly_divides :: "real list => real list => bool"
- "poly_divides == %p1 p2. EX q. poly p2 = poly (poly_mul p1 q)"
-
-lemma poly_divides: "ALL p1 p2. poly_divides p1 p2 = (EX q. poly p2 = poly (poly_mul p1 q))"
+ "poly_divides ==
+%(p1::real list) p2::real list.
+ EX q::real list. poly p2 = poly (poly_mul p1 q)"
+
+lemma poly_divides: "ALL (p1::real list) p2::real list.
+ poly_divides p1 p2 = (EX q::real list. poly p2 = poly (poly_mul p1 q))"
by (import poly poly_divides)
-lemma POLY_PRIMES: "ALL a p q.
- poly_divides [a, 1] (poly_mul p q) =
- (poly_divides [a, 1] p | poly_divides [a, 1] q)"
+lemma POLY_PRIMES: "ALL (a::real) (p::real list) q::real list.
+ poly_divides [a, 1::real] (poly_mul p q) =
+ (poly_divides [a, 1::real] p | poly_divides [a, 1::real] q)"
by (import poly POLY_PRIMES)
-lemma POLY_DIVIDES_REFL: "ALL p. poly_divides p p"
+lemma POLY_DIVIDES_REFL: "ALL p::real list. poly_divides p p"
by (import poly POLY_DIVIDES_REFL)
lemma POLY_DIVIDES_TRANS: "(All::(real list => bool) => bool)
@@ -7234,20 +7494,21 @@
constdefs
poly_order :: "real => real list => nat"
"poly_order ==
-%a p. SOME n.
- poly_divides (poly_exp [- a, 1] n) p &
- ~ poly_divides (poly_exp [- a, 1] (Suc n)) p"
-
-lemma poly_order: "ALL a p.
+%(a::real) p::real list.
+ SOME n::nat.
+ poly_divides (poly_exp [- a, 1::real] n) p &
+ ~ poly_divides (poly_exp [- a, 1::real] (Suc n)) p"
+
+lemma poly_order: "ALL (a::real) p::real list.
poly_order a p =
- (SOME n.
- poly_divides (poly_exp [- a, 1] n) p &
- ~ poly_divides (poly_exp [- a, 1] (Suc n)) p)"
+ (SOME n::nat.
+ poly_divides (poly_exp [- a, 1::real] n) p &
+ ~ poly_divides (poly_exp [- a, 1::real] (Suc n)) p)"
by (import poly poly_order)
-lemma ORDER: "ALL p a n.
- (poly_divides (poly_exp [- a, 1] n) p &
- ~ poly_divides (poly_exp [- a, 1] (Suc n)) p) =
+lemma ORDER: "ALL (p::real list) (a::real) n::nat.
+ (poly_divides (poly_exp [- a, 1::real] n) p &
+ ~ poly_divides (poly_exp [- a, 1::real] (Suc n)) p) =
(n = poly_order a p & poly p ~= poly [])"
by (import poly ORDER)
@@ -7330,11 +7591,12 @@
((poly_order::real => real list => nat) a q)))))"
by (import poly ORDER_POLY)
-lemma ORDER_ROOT: "ALL p a. (poly p a = 0) = (poly p = poly [] | poly_order a p ~= 0)"
+lemma ORDER_ROOT: "ALL (p::real list) a::real.
+ (poly p a = (0::real)) = (poly p = poly [] | poly_order a p ~= (0::nat))"
by (import poly ORDER_ROOT)
-lemma ORDER_DIVIDES: "ALL p a n.
- poly_divides (poly_exp [- a, 1] n) p =
+lemma ORDER_DIVIDES: "ALL (p::real list) (a::real) n::nat.
+ poly_divides (poly_exp [- a, 1::real] n) p =
(poly p = poly [] | n <= poly_order a p)"
by (import poly ORDER_DIVIDES)
@@ -7465,14 +7727,19 @@
constdefs
rsquarefree :: "real list => bool"
"rsquarefree ==
-%p. poly p ~= poly [] & (ALL a. poly_order a p = 0 | poly_order a p = 1)"
-
-lemma rsquarefree: "ALL p.
+%p::real list.
+ poly p ~= poly [] &
+ (ALL a::real. poly_order a p = (0::nat) | poly_order a p = (1::nat))"
+
+lemma rsquarefree: "ALL p::real list.
rsquarefree p =
- (poly p ~= poly [] & (ALL a. poly_order a p = 0 | poly_order a p = 1))"
+ (poly p ~= poly [] &
+ (ALL a::real. poly_order a p = (0::nat) | poly_order a p = (1::nat)))"
by (import poly rsquarefree)
-lemma RSQUAREFREE_ROOTS: "ALL p. rsquarefree p = (ALL a. ~ (poly p a = 0 & poly (diff p) a = 0))"
+lemma RSQUAREFREE_ROOTS: "ALL p::real list.
+ rsquarefree p =
+ (ALL a::real. ~ (poly p a = (0::real) & poly (diff p) a = (0::real)))"
by (import poly RSQUAREFREE_ROOTS)
lemma RSQUAREFREE_DECOMP: "(All::(real list => bool) => bool)
@@ -7558,20 +7825,20 @@
normalize :: "real list => real list"
specification (normalize) normalize: "normalize [] = [] &
-(ALL h t.
+(ALL (h::real) t::real list.
normalize (h # t) =
- (if normalize t = [] then if h = 0 then [] else [h]
+ (if normalize t = [] then if h = (0::real) then [] else [h]
else h # normalize t))"
by (import poly normalize)
-lemma POLY_NORMALIZE: "ALL t. poly (normalize t) = poly t"
+lemma POLY_NORMALIZE: "ALL t::real list. poly (normalize t) = poly t"
by (import poly POLY_NORMALIZE)
constdefs
degree :: "real list => nat"
- "degree == %p. PRE (length (normalize p))"
-
-lemma degree: "ALL p. degree p = PRE (length (normalize p))"
+ "degree == %p::real list. PRE (length (normalize p))"
+
+lemma degree: "ALL p::real list. degree p = PRE (length (normalize p))"
by (import poly degree)
lemma DEGREE_ZERO: "(All::(real list => bool) => bool)
--- a/src/HOL/Import/HOL/HOL4Vec.thy Mon Sep 26 02:06:44 2005 +0200
+++ b/src/HOL/Import/HOL/HOL4Vec.thy Mon Sep 26 02:27:14 2005 +0200
@@ -4,113 +4,137 @@
;setup_theory res_quan
-lemma RES_FORALL_CONJ_DIST: "ALL P Q R. RES_FORALL P (%i. Q i & R i) = (RES_FORALL P Q & RES_FORALL P R)"
+lemma RES_FORALL_CONJ_DIST: "ALL (P::'a::type => bool) (Q::'a::type => bool) R::'a::type => bool.
+ RES_FORALL P (%i::'a::type. Q i & R i) =
+ (RES_FORALL P Q & RES_FORALL P R)"
by (import res_quan RES_FORALL_CONJ_DIST)
-lemma RES_FORALL_DISJ_DIST: "ALL P Q R. RES_FORALL (%j. P j | Q j) R = (RES_FORALL P R & RES_FORALL Q R)"
+lemma RES_FORALL_DISJ_DIST: "ALL (P::'a::type => bool) (Q::'a::type => bool) R::'a::type => bool.
+ RES_FORALL (%j::'a::type. P j | Q j) R =
+ (RES_FORALL P R & RES_FORALL Q R)"
by (import res_quan RES_FORALL_DISJ_DIST)
-lemma RES_FORALL_UNIQUE: "ALL x xa. RES_FORALL (op = xa) x = x xa"
+lemma RES_FORALL_UNIQUE: "ALL (x::'a::type => bool) xa::'a::type. RES_FORALL (op = xa) x = x xa"
by (import res_quan RES_FORALL_UNIQUE)
-lemma RES_FORALL_FORALL: "ALL (P::'a => bool) (R::'a => 'b => bool) x::'b.
- (ALL x::'b. RES_FORALL P (%i::'a. R i x)) =
- RES_FORALL P (%i::'a. All (R i))"
+lemma RES_FORALL_FORALL: "ALL (P::'a::type => bool) (R::'a::type => 'b::type => bool) x::'b::type.
+ (ALL x::'b::type. RES_FORALL P (%i::'a::type. R i x)) =
+ RES_FORALL P (%i::'a::type. All (R i))"
by (import res_quan RES_FORALL_FORALL)
-lemma RES_FORALL_REORDER: "ALL P Q R.
- RES_FORALL P (%i. RES_FORALL Q (R i)) =
- RES_FORALL Q (%j. RES_FORALL P (%i. R i j))"
+lemma RES_FORALL_REORDER: "ALL (P::'a::type => bool) (Q::'b::type => bool)
+ R::'a::type => 'b::type => bool.
+ RES_FORALL P (%i::'a::type. RES_FORALL Q (R i)) =
+ RES_FORALL Q (%j::'b::type. RES_FORALL P (%i::'a::type. R i j))"
by (import res_quan RES_FORALL_REORDER)
lemma RES_FORALL_EMPTY: "All (RES_FORALL EMPTY)"
by (import res_quan RES_FORALL_EMPTY)
-lemma RES_FORALL_UNIV: "ALL p. RES_FORALL pred_set.UNIV p = All p"
+lemma RES_FORALL_UNIV: "ALL p::'a::type => bool. RES_FORALL pred_set.UNIV p = All p"
by (import res_quan RES_FORALL_UNIV)
-lemma RES_FORALL_NULL: "ALL p m. RES_FORALL p (%x. m) = (p = EMPTY | m)"
+lemma RES_FORALL_NULL: "ALL (p::'a::type => bool) m::bool.
+ RES_FORALL p (%x::'a::type. m) = (p = EMPTY | m)"
by (import res_quan RES_FORALL_NULL)
-lemma RES_EXISTS_DISJ_DIST: "ALL P Q R. RES_EXISTS P (%i. Q i | R i) = (RES_EXISTS P Q | RES_EXISTS P R)"
+lemma RES_EXISTS_DISJ_DIST: "ALL (P::'a::type => bool) (Q::'a::type => bool) R::'a::type => bool.
+ RES_EXISTS P (%i::'a::type. Q i | R i) =
+ (RES_EXISTS P Q | RES_EXISTS P R)"
by (import res_quan RES_EXISTS_DISJ_DIST)
-lemma RES_DISJ_EXISTS_DIST: "ALL P Q R. RES_EXISTS (%i. P i | Q i) R = (RES_EXISTS P R | RES_EXISTS Q R)"
+lemma RES_DISJ_EXISTS_DIST: "ALL (P::'a::type => bool) (Q::'a::type => bool) R::'a::type => bool.
+ RES_EXISTS (%i::'a::type. P i | Q i) R =
+ (RES_EXISTS P R | RES_EXISTS Q R)"
by (import res_quan RES_DISJ_EXISTS_DIST)
-lemma RES_EXISTS_EQUAL: "ALL x xa. RES_EXISTS (op = xa) x = x xa"
+lemma RES_EXISTS_EQUAL: "ALL (x::'a::type => bool) xa::'a::type. RES_EXISTS (op = xa) x = x xa"
by (import res_quan RES_EXISTS_EQUAL)
-lemma RES_EXISTS_REORDER: "ALL P Q R.
- RES_EXISTS P (%i. RES_EXISTS Q (R i)) =
- RES_EXISTS Q (%j. RES_EXISTS P (%i. R i j))"
+lemma RES_EXISTS_REORDER: "ALL (P::'a::type => bool) (Q::'b::type => bool)
+ R::'a::type => 'b::type => bool.
+ RES_EXISTS P (%i::'a::type. RES_EXISTS Q (R i)) =
+ RES_EXISTS Q (%j::'b::type. RES_EXISTS P (%i::'a::type. R i j))"
by (import res_quan RES_EXISTS_REORDER)
-lemma RES_EXISTS_EMPTY: "ALL p. ~ RES_EXISTS EMPTY p"
+lemma RES_EXISTS_EMPTY: "ALL p::'a::type => bool. ~ RES_EXISTS EMPTY p"
by (import res_quan RES_EXISTS_EMPTY)
-lemma RES_EXISTS_UNIV: "ALL p. RES_EXISTS pred_set.UNIV p = Ex p"
+lemma RES_EXISTS_UNIV: "ALL p::'a::type => bool. RES_EXISTS pred_set.UNIV p = Ex p"
by (import res_quan RES_EXISTS_UNIV)
-lemma RES_EXISTS_NULL: "ALL p m. RES_EXISTS p (%x. m) = (p ~= EMPTY & m)"
+lemma RES_EXISTS_NULL: "ALL (p::'a::type => bool) m::bool.
+ RES_EXISTS p (%x::'a::type. m) = (p ~= EMPTY & m)"
by (import res_quan RES_EXISTS_NULL)
-lemma RES_EXISTS_ALT: "ALL p m. RES_EXISTS p m = (IN (RES_SELECT p m) p & m (RES_SELECT p m))"
+lemma RES_EXISTS_ALT: "ALL (p::'a::type => bool) m::'a::type => bool.
+ RES_EXISTS p m = (IN (RES_SELECT p m) p & m (RES_SELECT p m))"
by (import res_quan RES_EXISTS_ALT)
-lemma RES_EXISTS_UNIQUE_EMPTY: "ALL p. ~ RES_EXISTS_UNIQUE EMPTY p"
+lemma RES_EXISTS_UNIQUE_EMPTY: "ALL p::'a::type => bool. ~ RES_EXISTS_UNIQUE EMPTY p"
by (import res_quan RES_EXISTS_UNIQUE_EMPTY)
-lemma RES_EXISTS_UNIQUE_UNIV: "ALL p. RES_EXISTS_UNIQUE pred_set.UNIV p = Ex1 p"
+lemma RES_EXISTS_UNIQUE_UNIV: "ALL p::'a::type => bool. RES_EXISTS_UNIQUE pred_set.UNIV p = Ex1 p"
by (import res_quan RES_EXISTS_UNIQUE_UNIV)
-lemma RES_EXISTS_UNIQUE_NULL: "ALL p m. RES_EXISTS_UNIQUE p (%x. m) = ((EX x. p = INSERT x EMPTY) & m)"
+lemma RES_EXISTS_UNIQUE_NULL: "ALL (p::'a::type => bool) m::bool.
+ RES_EXISTS_UNIQUE p (%x::'a::type. m) =
+ ((EX x::'a::type. p = INSERT x EMPTY) & m)"
by (import res_quan RES_EXISTS_UNIQUE_NULL)
-lemma RES_EXISTS_UNIQUE_ALT: "ALL p m.
+lemma RES_EXISTS_UNIQUE_ALT: "ALL (p::'a::type => bool) m::'a::type => bool.
RES_EXISTS_UNIQUE p m =
- RES_EXISTS p (%x. m x & RES_FORALL p (%y. m y --> y = x))"
+ RES_EXISTS p
+ (%x::'a::type. m x & RES_FORALL p (%y::'a::type. m y --> y = x))"
by (import res_quan RES_EXISTS_UNIQUE_ALT)
-lemma RES_SELECT_EMPTY: "ALL p. RES_SELECT EMPTY p = (SOME x. False)"
+lemma RES_SELECT_EMPTY: "ALL p::'a::type => bool. RES_SELECT EMPTY p = (SOME x::'a::type. False)"
by (import res_quan RES_SELECT_EMPTY)
-lemma RES_SELECT_UNIV: "ALL p. RES_SELECT pred_set.UNIV p = Eps p"
+lemma RES_SELECT_UNIV: "ALL p::'a::type => bool. RES_SELECT pred_set.UNIV p = Eps p"
by (import res_quan RES_SELECT_UNIV)
-lemma RES_ABSTRACT: "ALL p m x. IN x p --> RES_ABSTRACT p m x = m x"
+lemma RES_ABSTRACT: "ALL (p::'a::type => bool) (m::'a::type => 'b::type) x::'a::type.
+ IN x p --> RES_ABSTRACT p m x = m x"
by (import res_quan RES_ABSTRACT)
-lemma RES_ABSTRACT_EQUAL: "ALL p m1 m2.
- (ALL x. IN x p --> m1 x = m2 x) --> RES_ABSTRACT p m1 = RES_ABSTRACT p m2"
+lemma RES_ABSTRACT_EQUAL: "ALL (p::'a::type => bool) (m1::'a::type => 'b::type)
+ m2::'a::type => 'b::type.
+ (ALL x::'a::type. IN x p --> m1 x = m2 x) -->
+ RES_ABSTRACT p m1 = RES_ABSTRACT p m2"
by (import res_quan RES_ABSTRACT_EQUAL)
-lemma RES_ABSTRACT_IDEMPOT: "ALL p m. RES_ABSTRACT p (RES_ABSTRACT p m) = RES_ABSTRACT p m"
+lemma RES_ABSTRACT_IDEMPOT: "ALL (p::'a::type => bool) m::'a::type => 'b::type.
+ RES_ABSTRACT p (RES_ABSTRACT p m) = RES_ABSTRACT p m"
by (import res_quan RES_ABSTRACT_IDEMPOT)
-lemma RES_ABSTRACT_EQUAL_EQ: "ALL p m1 m2.
- (RES_ABSTRACT p m1 = RES_ABSTRACT p m2) = (ALL x. IN x p --> m1 x = m2 x)"
+lemma RES_ABSTRACT_EQUAL_EQ: "ALL (p::'a::type => bool) (m1::'a::type => 'b::type)
+ m2::'a::type => 'b::type.
+ (RES_ABSTRACT p m1 = RES_ABSTRACT p m2) =
+ (ALL x::'a::type. IN x p --> m1 x = m2 x)"
by (import res_quan RES_ABSTRACT_EQUAL_EQ)
;end_setup
;setup_theory word_base
-typedef (open) ('a) word = "(Collect::('a list recspace => bool) => 'a list recspace set)
- (%x::'a list recspace.
- (All::(('a list recspace => bool) => bool) => bool)
- (%word::'a list recspace => bool.
+typedef (open) ('a) word = "(Collect::('a::type list recspace => bool) => 'a::type list recspace set)
+ (%x::'a::type list recspace.
+ (All::(('a::type list recspace => bool) => bool) => bool)
+ (%word::'a::type list recspace => bool.
(op -->::bool => bool => bool)
- ((All::('a list recspace => bool) => bool)
- (%a0::'a list recspace.
+ ((All::('a::type list recspace => bool) => bool)
+ (%a0::'a::type list recspace.
(op -->::bool => bool => bool)
- ((Ex::('a list => bool) => bool)
- (%a::'a list.
- (op =::'a list recspace => 'a list recspace => bool)
+ ((Ex::('a::type list => bool) => bool)
+ (%a::'a::type list.
+ (op =::'a::type list recspace
+ => 'a::type list recspace => bool)
a0 ((CONSTR::nat
-=> 'a list => (nat => 'a list recspace) => 'a list recspace)
+=> 'a::type list
+ => (nat => 'a::type list recspace) => 'a::type list recspace)
(0::nat) a
- (%n::nat. BOTTOM::'a list recspace))))
+ (%n::nat. BOTTOM::'a::type list recspace))))
(word a0)))
(word x)))"
by (rule typedef_helper,import word_base word_TY_DEF)
@@ -118,449 +142,543 @@
lemmas word_TY_DEF = typedef_hol2hol4 [OF type_definition_word]
consts
- mk_word :: "'a list recspace => 'a word"
- dest_word :: "'a word => 'a list recspace"
+ mk_word :: "'a::type list recspace => 'a::type word"
+ dest_word :: "'a::type word => 'a::type list recspace"
-specification (dest_word mk_word) word_repfns: "(ALL a::'a word. mk_word (dest_word a) = a) &
-(ALL r::'a list recspace.
- (ALL word::'a list recspace => bool.
- (ALL a0::'a list recspace.
- (EX a::'a list. a0 = CONSTR (0::nat) a (%n::nat. BOTTOM)) -->
+specification (dest_word mk_word) word_repfns: "(ALL a::'a::type word. mk_word (dest_word a) = a) &
+(ALL r::'a::type list recspace.
+ (ALL word::'a::type list recspace => bool.
+ (ALL a0::'a::type list recspace.
+ (EX a::'a::type list.
+ a0 = CONSTR (0::nat) a (%n::nat. BOTTOM)) -->
word a0) -->
word r) =
(dest_word (mk_word r) = r))"
by (import word_base word_repfns)
consts
- word_base0 :: "'a list => 'a word"
+ word_base0 :: "'a::type list => 'a::type word"
defs
- word_base0_primdef: "word_base0 == %a. mk_word (CONSTR 0 a (%n. BOTTOM))"
+ word_base0_primdef: "word_base0 ==
+%a::'a::type list. mk_word (CONSTR (0::nat) a (%n::nat. BOTTOM))"
-lemma word_base0_def: "word_base0 = (%a. mk_word (CONSTR 0 a (%n. BOTTOM)))"
+lemma word_base0_def: "word_base0 =
+(%a::'a::type list. mk_word (CONSTR (0::nat) a (%n::nat. BOTTOM)))"
by (import word_base word_base0_def)
constdefs
- WORD :: "'a list => 'a word"
+ WORD :: "'a::type list => 'a::type word"
"WORD == word_base0"
lemma WORD: "WORD = word_base0"
by (import word_base WORD)
consts
- word_case :: "('a list => 'b) => 'a word => 'b"
+ word_case :: "('a::type list => 'b::type) => 'a::type word => 'b::type"
-specification (word_case_primdef: word_case) word_case_def: "ALL f a. word_case f (WORD a) = f a"
+specification (word_case_primdef: word_case) word_case_def: "ALL (f::'a::type list => 'b::type) a::'a::type list.
+ word_case f (WORD a) = f a"
by (import word_base word_case_def)
consts
- word_size :: "('a => nat) => 'a word => nat"
+ word_size :: "('a::type => nat) => 'a::type word => nat"
-specification (word_size_primdef: word_size) word_size_def: "ALL f a. word_size f (WORD a) = 1 + list_size f a"
+specification (word_size_primdef: word_size) word_size_def: "ALL (f::'a::type => nat) a::'a::type list.
+ word_size f (WORD a) = (1::nat) + list_size f a"
by (import word_base word_size_def)
-lemma word_11: "ALL a a'. (WORD a = WORD a') = (a = a')"
+lemma word_11: "ALL (a::'a::type list) a'::'a::type list. (WORD a = WORD a') = (a = a')"
by (import word_base word_11)
-lemma word_case_cong: "ALL M M' f.
- M = M' & (ALL a. M' = WORD a --> f a = f' a) -->
+lemma word_case_cong: "ALL (M::'a::type word) (M'::'a::type word) f::'a::type list => 'b::type.
+ M = M' &
+ (ALL a::'a::type list.
+ M' = WORD a --> f a = (f'::'a::type list => 'b::type) a) -->
word_case f M = word_case f' M'"
by (import word_base word_case_cong)
-lemma word_nchotomy: "ALL x. EX l. x = WORD l"
+lemma word_nchotomy: "ALL x::'a::type word. EX l::'a::type list. x = WORD l"
by (import word_base word_nchotomy)
-lemma word_Axiom: "ALL f. EX fn. ALL a. fn (WORD a) = f a"
+lemma word_Axiom: "ALL f::'a::type list => 'b::type.
+ EX fn::'a::type word => 'b::type. ALL a::'a::type list. fn (WORD a) = f a"
by (import word_base word_Axiom)
-lemma word_induction: "ALL P. (ALL a. P (WORD a)) --> All P"
+lemma word_induction: "ALL P::'a::type word => bool. (ALL a::'a::type list. P (WORD a)) --> All P"
by (import word_base word_induction)
-lemma word_Ax: "ALL f. EX fn. ALL a. fn (WORD a) = f a"
+lemma word_Ax: "ALL f::'a::type list => 'b::type.
+ EX fn::'a::type word => 'b::type. ALL a::'a::type list. fn (WORD a) = f a"
by (import word_base word_Ax)
-lemma WORD_11: "ALL x xa. (WORD x = WORD xa) = (x = xa)"
+lemma WORD_11: "ALL (x::'a::type list) xa::'a::type list. (WORD x = WORD xa) = (x = xa)"
by (import word_base WORD_11)
-lemma word_induct: "ALL x. (ALL l. x (WORD l)) --> All x"
+lemma word_induct: "ALL x::'a::type word => bool. (ALL l::'a::type list. x (WORD l)) --> All x"
by (import word_base word_induct)
-lemma word_cases: "ALL x. EX l. x = WORD l"
+lemma word_cases: "ALL x::'a::type word. EX l::'a::type list. x = WORD l"
by (import word_base word_cases)
consts
- WORDLEN :: "'a word => nat"
+ WORDLEN :: "'a::type word => nat"
-specification (WORDLEN) WORDLEN_DEF: "ALL l. WORDLEN (WORD l) = length l"
+specification (WORDLEN) WORDLEN_DEF: "ALL l::'a::type list. WORDLEN (WORD l) = length l"
by (import word_base WORDLEN_DEF)
consts
- PWORDLEN :: "nat => 'a word => bool"
+ PWORDLEN :: "nat => 'a::type word => bool"
defs
- PWORDLEN_primdef: "PWORDLEN == %n. GSPEC (%w. (w, WORDLEN w = n))"
+ PWORDLEN_primdef: "PWORDLEN == %n::nat. GSPEC (%w::'a::type word. (w, WORDLEN w = n))"
-lemma PWORDLEN_def: "ALL n. PWORDLEN n = GSPEC (%w. (w, WORDLEN w = n))"
+lemma PWORDLEN_def: "ALL n::nat. PWORDLEN n = GSPEC (%w::'a::type word. (w, WORDLEN w = n))"
by (import word_base PWORDLEN_def)
-lemma IN_PWORDLEN: "ALL n l. IN (WORD l) (PWORDLEN n) = (length l = n)"
+lemma IN_PWORDLEN: "ALL (n::nat) l::'a::type list. IN (WORD l) (PWORDLEN n) = (length l = n)"
by (import word_base IN_PWORDLEN)
-lemma PWORDLEN: "ALL n w. IN w (PWORDLEN n) = (WORDLEN w = n)"
+lemma PWORDLEN: "ALL (n::nat) w::'a::type word. IN w (PWORDLEN n) = (WORDLEN w = n)"
by (import word_base PWORDLEN)
-lemma PWORDLEN0: "ALL w. IN w (PWORDLEN 0) --> w = WORD []"
+lemma PWORDLEN0: "ALL w::'a::type word. IN w (PWORDLEN (0::nat)) --> w = WORD []"
by (import word_base PWORDLEN0)
-lemma PWORDLEN1: "ALL x. IN (WORD [x]) (PWORDLEN 1)"
+lemma PWORDLEN1: "ALL x::'a::type. IN (WORD [x]) (PWORDLEN (1::nat))"
by (import word_base PWORDLEN1)
consts
- WSEG :: "nat => nat => 'a word => 'a word"
+ WSEG :: "nat => nat => 'a::type word => 'a::type word"
-specification (WSEG) WSEG_DEF: "ALL m k l. WSEG m k (WORD l) = WORD (LASTN m (BUTLASTN k l))"
+specification (WSEG) WSEG_DEF: "ALL (m::nat) (k::nat) l::'a::type list.
+ WSEG m k (WORD l) = WORD (LASTN m (BUTLASTN k l))"
by (import word_base WSEG_DEF)
-lemma WSEG0: "ALL k w. WSEG 0 k w = WORD []"
+lemma WSEG0: "ALL (k::nat) w::'a::type word. WSEG (0::nat) k w = WORD []"
by (import word_base WSEG0)
-lemma WSEG_PWORDLEN: "ALL n.
+lemma WSEG_PWORDLEN: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL m k. m + k <= n --> IN (WSEG m k w) (PWORDLEN m))"
+ (%w::'a::type word.
+ ALL (m::nat) k::nat. m + k <= n --> IN (WSEG m k w) (PWORDLEN m))"
by (import word_base WSEG_PWORDLEN)
-lemma WSEG_WORDLEN: "ALL x.
+lemma WSEG_WORDLEN: "ALL x::nat.
RES_FORALL (PWORDLEN x)
- (%xa. ALL xb xc. xb + xc <= x --> WORDLEN (WSEG xb xc xa) = xb)"
+ (%xa::'a::type word.
+ ALL (xb::nat) xc::nat.
+ xb + xc <= x --> WORDLEN (WSEG xb xc xa) = xb)"
by (import word_base WSEG_WORDLEN)
-lemma WSEG_WORD_LENGTH: "ALL n. RES_FORALL (PWORDLEN n) (%w. WSEG n 0 w = w)"
+lemma WSEG_WORD_LENGTH: "ALL n::nat.
+ RES_FORALL (PWORDLEN n) (%w::'a::type word. WSEG n (0::nat) w = w)"
by (import word_base WSEG_WORD_LENGTH)
consts
- bit :: "nat => 'a word => 'a"
+ bit :: "nat => 'a::type word => 'a::type"
-specification (bit) BIT_DEF: "ALL k l. bit k (WORD l) = ELL k l"
+specification (bit) BIT_DEF: "ALL (k::nat) l::'a::type list. bit k (WORD l) = ELL k l"
by (import word_base BIT_DEF)
-lemma BIT0: "ALL x. bit 0 (WORD [x]) = x"
+lemma BIT0: "ALL x::'a::type. bit (0::nat) (WORD [x]) = x"
by (import word_base BIT0)
lemma WSEG_BIT: "(All::(nat => bool) => bool)
(%n::nat.
- (RES_FORALL::('a word => bool) => ('a word => bool) => bool)
- ((PWORDLEN::nat => 'a word => bool) n)
- (%w::'a word.
+ (RES_FORALL::('a::type word => bool)
+ => ('a::type word => bool) => bool)
+ ((PWORDLEN::nat => 'a::type word => bool) n)
+ (%w::'a::type word.
(All::(nat => bool) => bool)
(%k::nat.
(op -->::bool => bool => bool)
((op <::nat => nat => bool) k n)
- ((op =::'a word => 'a word => bool)
- ((WSEG::nat => nat => 'a word => 'a word) (1::nat) k w)
- ((WORD::'a list => 'a word)
- ((op #::'a => 'a list => 'a list)
- ((bit::nat => 'a word => 'a) k w) ([]::'a list)))))))"
+ ((op =::'a::type word => 'a::type word => bool)
+ ((WSEG::nat => nat => 'a::type word => 'a::type word)
+ (1::nat) k w)
+ ((WORD::'a::type list => 'a::type word)
+ ((op #::'a::type => 'a::type list => 'a::type list)
+ ((bit::nat => 'a::type word => 'a::type) k w)
+ ([]::'a::type list)))))))"
by (import word_base WSEG_BIT)
-lemma BIT_WSEG: "ALL n.
+lemma BIT_WSEG: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL m k j.
- m + k <= n --> j < m --> bit j (WSEG m k w) = bit (j + k) w)"
+ (%w::'a::type word.
+ ALL (m::nat) (k::nat) j::nat.
+ m + k <= n --> j < m --> bit j (WSEG m k w) = bit (j + k) w)"
by (import word_base BIT_WSEG)
consts
- MSB :: "'a word => 'a"
+ MSB :: "'a::type word => 'a::type"
-specification (MSB) MSB_DEF: "ALL l. MSB (WORD l) = hd l"
+specification (MSB) MSB_DEF: "ALL l::'a::type list. MSB (WORD l) = hd l"
by (import word_base MSB_DEF)
-lemma MSB: "ALL n. RES_FORALL (PWORDLEN n) (%w. 0 < n --> MSB w = bit (PRE n) w)"
+lemma MSB: "ALL n::nat.
+ RES_FORALL (PWORDLEN n)
+ (%w::'a::type word. (0::nat) < n --> MSB w = bit (PRE n) w)"
by (import word_base MSB)
consts
- LSB :: "'a word => 'a"
+ LSB :: "'a::type word => 'a::type"
-specification (LSB) LSB_DEF: "ALL l. LSB (WORD l) = last l"
+specification (LSB) LSB_DEF: "ALL l::'a::type list. LSB (WORD l) = last l"
by (import word_base LSB_DEF)
-lemma LSB: "ALL n. RES_FORALL (PWORDLEN n) (%w. 0 < n --> LSB w = bit 0 w)"
+lemma LSB: "ALL n::nat.
+ RES_FORALL (PWORDLEN n)
+ (%w::'a::type word. (0::nat) < n --> LSB w = bit (0::nat) w)"
by (import word_base LSB)
consts
- WSPLIT :: "nat => 'a word => 'a word * 'a word"
+ WSPLIT :: "nat => 'a::type word => 'a::type word * 'a::type word"
-specification (WSPLIT) WSPLIT_DEF: "ALL m l. WSPLIT m (WORD l) = (WORD (BUTLASTN m l), WORD (LASTN m l))"
+specification (WSPLIT) WSPLIT_DEF: "ALL (m::nat) l::'a::type list.
+ WSPLIT m (WORD l) = (WORD (BUTLASTN m l), WORD (LASTN m l))"
by (import word_base WSPLIT_DEF)
consts
- WCAT :: "'a word * 'a word => 'a word"
+ WCAT :: "'a::type word * 'a::type word => 'a::type word"
-specification (WCAT) WCAT_DEF: "ALL l1 l2. WCAT (WORD l1, WORD l2) = WORD (l1 @ l2)"
+specification (WCAT) WCAT_DEF: "ALL (l1::'a::type list) l2::'a::type list.
+ WCAT (WORD l1, WORD l2) = WORD (l1 @ l2)"
by (import word_base WCAT_DEF)
lemma WORD_PARTITION: "(op &::bool => bool => bool)
((All::(nat => bool) => bool)
(%n::nat.
- (RES_FORALL::('a word => bool) => ('a word => bool) => bool)
- ((PWORDLEN::nat => 'a word => bool) n)
- (%w::'a word.
+ (RES_FORALL::('a::type word => bool)
+ => ('a::type word => bool) => bool)
+ ((PWORDLEN::nat => 'a::type word => bool) n)
+ (%w::'a::type word.
(All::(nat => bool) => bool)
(%m::nat.
(op -->::bool => bool => bool)
((op <=::nat => nat => bool) m n)
- ((op =::'a word => 'a word => bool)
- ((WCAT::'a word * 'a word => 'a word)
- ((WSPLIT::nat => 'a word => 'a word * 'a word) m w))
+ ((op =::'a::type word => 'a::type word => bool)
+ ((WCAT::'a::type word * 'a::type word => 'a::type word)
+ ((WSPLIT::nat
+ => 'a::type word
+ => 'a::type word * 'a::type word)
+ m w))
w)))))
((All::(nat => bool) => bool)
(%n::nat.
(All::(nat => bool) => bool)
(%m::nat.
- (RES_FORALL::('a word => bool) => ('a word => bool) => bool)
- ((PWORDLEN::nat => 'a word => bool) n)
- (%w1::'a word.
- (RES_FORALL::('a word => bool)
- => ('a word => bool) => bool)
- ((PWORDLEN::nat => 'a word => bool) m)
- (%w2::'a word.
- (op =::'a word * 'a word => 'a word * 'a word => bool)
- ((WSPLIT::nat => 'a word => 'a word * 'a word) m
- ((WCAT::'a word * 'a word => 'a word)
- ((Pair::'a word => 'a word => 'a word * 'a word)
- w1 w2)))
- ((Pair::'a word => 'a word => 'a word * 'a word) w1
- w2))))))"
+ (RES_FORALL::('a::type word => bool)
+ => ('a::type word => bool) => bool)
+ ((PWORDLEN::nat => 'a::type word => bool) n)
+ (%w1::'a::type word.
+ (RES_FORALL::('a::type word => bool)
+ => ('a::type word => bool) => bool)
+ ((PWORDLEN::nat => 'a::type word => bool) m)
+ (%w2::'a::type word.
+ (op =::'a::type word * 'a::type word
+ => 'a::type word * 'a::type word => bool)
+ ((WSPLIT::nat
+ => 'a::type word
+ => 'a::type word * 'a::type word)
+ m ((WCAT::'a::type word * 'a::type word
+ => 'a::type word)
+ ((Pair::'a::type word
+ => 'a::type word
+ => 'a::type word * 'a::type word)
+ w1 w2)))
+ ((Pair::'a::type word
+ => 'a::type word
+ => 'a::type word * 'a::type word)
+ w1 w2))))))"
by (import word_base WORD_PARTITION)
-lemma WCAT_ASSOC: "ALL w1 w2 w3. WCAT (w1, WCAT (w2, w3)) = WCAT (WCAT (w1, w2), w3)"
+lemma WCAT_ASSOC: "ALL (w1::'a::type word) (w2::'a::type word) w3::'a::type word.
+ WCAT (w1, WCAT (w2, w3)) = WCAT (WCAT (w1, w2), w3)"
by (import word_base WCAT_ASSOC)
-lemma WCAT0: "ALL w. WCAT (WORD [], w) = w & WCAT (w, WORD []) = w"
+lemma WCAT0: "ALL w::'a::type word. WCAT (WORD [], w) = w & WCAT (w, WORD []) = w"
by (import word_base WCAT0)
-lemma WCAT_11: "ALL m n.
+lemma WCAT_11: "ALL (m::nat) n::nat.
RES_FORALL (PWORDLEN m)
- (%wm1. RES_FORALL (PWORDLEN m)
- (%wm2. RES_FORALL (PWORDLEN n)
- (%wn1. RES_FORALL (PWORDLEN n)
- (%wn2. (WCAT (wm1, wn1) = WCAT (wm2, wn2)) =
- (wm1 = wm2 & wn1 = wn2)))))"
+ (%wm1::'a::type word.
+ RES_FORALL (PWORDLEN m)
+ (%wm2::'a::type word.
+ RES_FORALL (PWORDLEN n)
+ (%wn1::'a::type word.
+ RES_FORALL (PWORDLEN n)
+ (%wn2::'a::type word.
+ (WCAT (wm1, wn1) = WCAT (wm2, wn2)) =
+ (wm1 = wm2 & wn1 = wn2)))))"
by (import word_base WCAT_11)
lemma WSPLIT_PWORDLEN: "(All::(nat => bool) => bool)
(%n::nat.
- (RES_FORALL::('a word => bool) => ('a word => bool) => bool)
- ((PWORDLEN::nat => 'a word => bool) n)
- (%w::'a word.
+ (RES_FORALL::('a::type word => bool)
+ => ('a::type word => bool) => bool)
+ ((PWORDLEN::nat => 'a::type word => bool) n)
+ (%w::'a::type word.
(All::(nat => bool) => bool)
(%m::nat.
(op -->::bool => bool => bool)
((op <=::nat => nat => bool) m n)
((op &::bool => bool => bool)
- ((IN::'a word => ('a word => bool) => bool)
- ((fst::'a word * 'a word => 'a word)
- ((WSPLIT::nat => 'a word => 'a word * 'a word) m w))
- ((PWORDLEN::nat => 'a word => bool)
+ ((IN::'a::type word => ('a::type word => bool) => bool)
+ ((fst::'a::type word * 'a::type word => 'a::type word)
+ ((WSPLIT::nat
+ => 'a::type word
+ => 'a::type word * 'a::type word)
+ m w))
+ ((PWORDLEN::nat => 'a::type word => bool)
((op -::nat => nat => nat) n m)))
- ((IN::'a word => ('a word => bool) => bool)
- ((snd::'a word * 'a word => 'a word)
- ((WSPLIT::nat => 'a word => 'a word * 'a word) m w))
- ((PWORDLEN::nat => 'a word => bool) m))))))"
+ ((IN::'a::type word => ('a::type word => bool) => bool)
+ ((snd::'a::type word * 'a::type word => 'a::type word)
+ ((WSPLIT::nat
+ => 'a::type word
+ => 'a::type word * 'a::type word)
+ m w))
+ ((PWORDLEN::nat => 'a::type word => bool) m))))))"
by (import word_base WSPLIT_PWORDLEN)
-lemma WCAT_PWORDLEN: "ALL n1.
+lemma WCAT_PWORDLEN: "ALL n1::nat.
RES_FORALL (PWORDLEN n1)
- (%w1. ALL n2.
- RES_FORALL (PWORDLEN n2)
- (%w2. IN (WCAT (w1, w2)) (PWORDLEN (n1 + n2))))"
+ (%w1::'a::type word.
+ ALL n2::nat.
+ RES_FORALL (PWORDLEN n2)
+ (%w2::'a::type word. IN (WCAT (w1, w2)) (PWORDLEN (n1 + n2))))"
by (import word_base WCAT_PWORDLEN)
-lemma WORDLEN_SUC_WCAT: "ALL n w.
+lemma WORDLEN_SUC_WCAT: "ALL (n::nat) w::'a::type word.
IN w (PWORDLEN (Suc n)) -->
- RES_EXISTS (PWORDLEN 1)
- (%b. RES_EXISTS (PWORDLEN n) (%w'. w = WCAT (b, w')))"
+ RES_EXISTS (PWORDLEN (1::nat))
+ (%b::'a::type word.
+ RES_EXISTS (PWORDLEN n) (%w'::'a::type word. w = WCAT (b, w')))"
by (import word_base WORDLEN_SUC_WCAT)
-lemma WSEG_WSEG: "ALL n.
+lemma WSEG_WSEG: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL m1 k1 m2 k2.
- m1 + k1 <= n & m2 + k2 <= m1 -->
- WSEG m2 k2 (WSEG m1 k1 w) = WSEG m2 (k1 + k2) w)"
+ (%w::'a::type word.
+ ALL (m1::nat) (k1::nat) (m2::nat) k2::nat.
+ m1 + k1 <= n & m2 + k2 <= m1 -->
+ WSEG m2 k2 (WSEG m1 k1 w) = WSEG m2 (k1 + k2) w)"
by (import word_base WSEG_WSEG)
lemma WSPLIT_WSEG: "(All::(nat => bool) => bool)
(%n::nat.
- (RES_FORALL::('a word => bool) => ('a word => bool) => bool)
- ((PWORDLEN::nat => 'a word => bool) n)
- (%w::'a word.
+ (RES_FORALL::('a::type word => bool)
+ => ('a::type word => bool) => bool)
+ ((PWORDLEN::nat => 'a::type word => bool) n)
+ (%w::'a::type word.
(All::(nat => bool) => bool)
(%k::nat.
(op -->::bool => bool => bool)
((op <=::nat => nat => bool) k n)
- ((op =::'a word * 'a word => 'a word * 'a word => bool)
- ((WSPLIT::nat => 'a word => 'a word * 'a word) k w)
- ((Pair::'a word => 'a word => 'a word * 'a word)
- ((WSEG::nat => nat => 'a word => 'a word)
+ ((op =::'a::type word * 'a::type word
+ => 'a::type word * 'a::type word => bool)
+ ((WSPLIT::nat
+ => 'a::type word
+ => 'a::type word * 'a::type word)
+ k w)
+ ((Pair::'a::type word
+ => 'a::type word => 'a::type word * 'a::type word)
+ ((WSEG::nat => nat => 'a::type word => 'a::type word)
((op -::nat => nat => nat) n k) k w)
- ((WSEG::nat => nat => 'a word => 'a word) k (0::nat)
- w))))))"
+ ((WSEG::nat => nat => 'a::type word => 'a::type word) k
+ (0::nat) w))))))"
by (import word_base WSPLIT_WSEG)
lemma WSPLIT_WSEG1: "(All::(nat => bool) => bool)
(%n::nat.
- (RES_FORALL::('a word => bool) => ('a word => bool) => bool)
- ((PWORDLEN::nat => 'a word => bool) n)
- (%w::'a word.
+ (RES_FORALL::('a::type word => bool)
+ => ('a::type word => bool) => bool)
+ ((PWORDLEN::nat => 'a::type word => bool) n)
+ (%w::'a::type word.
(All::(nat => bool) => bool)
(%k::nat.
(op -->::bool => bool => bool)
((op <=::nat => nat => bool) k n)
- ((op =::'a word => 'a word => bool)
- ((fst::'a word * 'a word => 'a word)
- ((WSPLIT::nat => 'a word => 'a word * 'a word) k w))
- ((WSEG::nat => nat => 'a word => 'a word)
+ ((op =::'a::type word => 'a::type word => bool)
+ ((fst::'a::type word * 'a::type word => 'a::type word)
+ ((WSPLIT::nat
+ => 'a::type word
+ => 'a::type word * 'a::type word)
+ k w))
+ ((WSEG::nat => nat => 'a::type word => 'a::type word)
((op -::nat => nat => nat) n k) k w)))))"
by (import word_base WSPLIT_WSEG1)
lemma WSPLIT_WSEG2: "(All::(nat => bool) => bool)
(%n::nat.
- (RES_FORALL::('a word => bool) => ('a word => bool) => bool)
- ((PWORDLEN::nat => 'a word => bool) n)
- (%w::'a word.
+ (RES_FORALL::('a::type word => bool)
+ => ('a::type word => bool) => bool)
+ ((PWORDLEN::nat => 'a::type word => bool) n)
+ (%w::'a::type word.
(All::(nat => bool) => bool)
(%k::nat.
(op -->::bool => bool => bool)
((op <=::nat => nat => bool) k n)
- ((op =::'a word => 'a word => bool)
- ((snd::'a word * 'a word => 'a word)
- ((WSPLIT::nat => 'a word => 'a word * 'a word) k w))
- ((WSEG::nat => nat => 'a word => 'a word) k (0::nat)
- w)))))"
+ ((op =::'a::type word => 'a::type word => bool)
+ ((snd::'a::type word * 'a::type word => 'a::type word)
+ ((WSPLIT::nat
+ => 'a::type word
+ => 'a::type word * 'a::type word)
+ k w))
+ ((WSEG::nat => nat => 'a::type word => 'a::type word) k
+ (0::nat) w)))))"
by (import word_base WSPLIT_WSEG2)
-lemma WCAT_WSEG_WSEG: "ALL n.
+lemma WCAT_WSEG_WSEG: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL m1 m2 k.
- m1 + (m2 + k) <= n -->
- WCAT (WSEG m2 (m1 + k) w, WSEG m1 k w) = WSEG (m1 + m2) k w)"
+ (%w::'a::type word.
+ ALL (m1::nat) (m2::nat) k::nat.
+ m1 + (m2 + k) <= n -->
+ WCAT (WSEG m2 (m1 + k) w, WSEG m1 k w) = WSEG (m1 + m2) k w)"
by (import word_base WCAT_WSEG_WSEG)
-lemma WORD_SPLIT: "ALL x xa.
- RES_FORALL (PWORDLEN (x + xa)) (%w. w = WCAT (WSEG x xa w, WSEG xa 0 w))"
+lemma WORD_SPLIT: "ALL (x::nat) xa::nat.
+ RES_FORALL (PWORDLEN (x + xa))
+ (%w::'a::type word. w = WCAT (WSEG x xa w, WSEG xa (0::nat) w))"
by (import word_base WORD_SPLIT)
-lemma WORDLEN_SUC_WCAT_WSEG_WSEG: "RES_FORALL (PWORDLEN (Suc n)) (%w. w = WCAT (WSEG 1 n w, WSEG n 0 w))"
+lemma WORDLEN_SUC_WCAT_WSEG_WSEG: "RES_FORALL (PWORDLEN (Suc (n::nat)))
+ (%w::'a::type word. w = WCAT (WSEG (1::nat) n w, WSEG n (0::nat) w))"
by (import word_base WORDLEN_SUC_WCAT_WSEG_WSEG)
-lemma WORDLEN_SUC_WCAT_WSEG_WSEG_RIGHT: "RES_FORALL (PWORDLEN (Suc n)) (%w. w = WCAT (WSEG n 1 w, WSEG 1 0 w))"
+lemma WORDLEN_SUC_WCAT_WSEG_WSEG_RIGHT: "RES_FORALL (PWORDLEN (Suc (n::nat)))
+ (%w::'a::type word. w = WCAT (WSEG n (1::nat) w, WSEG (1::nat) (0::nat) w))"
by (import word_base WORDLEN_SUC_WCAT_WSEG_WSEG_RIGHT)
-lemma WORDLEN_SUC_WCAT_BIT_WSEG: "ALL n.
- RES_FORALL (PWORDLEN (Suc n)) (%w. w = WCAT (WORD [bit n w], WSEG n 0 w))"
+lemma WORDLEN_SUC_WCAT_BIT_WSEG: "ALL n::nat.
+ RES_FORALL (PWORDLEN (Suc n))
+ (%w::'a::type word. w = WCAT (WORD [bit n w], WSEG n (0::nat) w))"
by (import word_base WORDLEN_SUC_WCAT_BIT_WSEG)
-lemma WORDLEN_SUC_WCAT_BIT_WSEG_RIGHT: "ALL n.
- RES_FORALL (PWORDLEN (Suc n)) (%w. w = WCAT (WSEG n 1 w, WORD [bit 0 w]))"
+lemma WORDLEN_SUC_WCAT_BIT_WSEG_RIGHT: "ALL n::nat.
+ RES_FORALL (PWORDLEN (Suc n))
+ (%w::'a::type word. w = WCAT (WSEG n (1::nat) w, WORD [bit (0::nat) w]))"
by (import word_base WORDLEN_SUC_WCAT_BIT_WSEG_RIGHT)
-lemma WSEG_WCAT1: "ALL n1 n2.
+lemma WSEG_WCAT1: "ALL (n1::nat) n2::nat.
RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2) (%w2. WSEG n1 n2 (WCAT (w1, w2)) = w1))"
+ (%w1::'a::type word.
+ RES_FORALL (PWORDLEN n2)
+ (%w2::'a::type word. WSEG n1 n2 (WCAT (w1, w2)) = w1))"
by (import word_base WSEG_WCAT1)
-lemma WSEG_WCAT2: "ALL n1 n2.
+lemma WSEG_WCAT2: "ALL (n1::nat) n2::nat.
RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2) (%w2. WSEG n2 0 (WCAT (w1, w2)) = w2))"
+ (%w1::'a::type word.
+ RES_FORALL (PWORDLEN n2)
+ (%w2::'a::type word. WSEG n2 (0::nat) (WCAT (w1, w2)) = w2))"
by (import word_base WSEG_WCAT2)
-lemma WSEG_SUC: "ALL n.
+lemma WSEG_SUC: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL k m1.
- k + Suc m1 < n -->
- WSEG (Suc m1) k w = WCAT (WSEG 1 (k + m1) w, WSEG m1 k w))"
+ (%w::'a::type word.
+ ALL (k::nat) m1::nat.
+ k + Suc m1 < n -->
+ WSEG (Suc m1) k w = WCAT (WSEG (1::nat) (k + m1) w, WSEG m1 k w))"
by (import word_base WSEG_SUC)
-lemma WORD_CONS_WCAT: "ALL x l. WORD (x # l) = WCAT (WORD [x], WORD l)"
+lemma WORD_CONS_WCAT: "ALL (x::'a::type) l::'a::type list. WORD (x # l) = WCAT (WORD [x], WORD l)"
by (import word_base WORD_CONS_WCAT)
-lemma WORD_SNOC_WCAT: "ALL l x. WORD (SNOC x l) = WCAT (WORD l, WORD [x])"
+lemma WORD_SNOC_WCAT: "ALL (l::'a::type list) x::'a::type.
+ WORD (SNOC x l) = WCAT (WORD l, WORD [x])"
by (import word_base WORD_SNOC_WCAT)
-lemma BIT_WCAT_FST: "ALL n1 n2.
+lemma BIT_WCAT_FST: "ALL (n1::nat) n2::nat.
RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2)
- (%w2. ALL k.
- n2 <= k & k < n1 + n2 -->
- bit k (WCAT (w1, w2)) = bit (k - n2) w1))"
+ (%w1::'a::type word.
+ RES_FORALL (PWORDLEN n2)
+ (%w2::'a::type word.
+ ALL k::nat.
+ n2 <= k & k < n1 + n2 -->
+ bit k (WCAT (w1, w2)) = bit (k - n2) w1))"
by (import word_base BIT_WCAT_FST)
lemma BIT_WCAT_SND: "(All::(nat => bool) => bool)
(%n1::nat.
(All::(nat => bool) => bool)
(%n2::nat.
- (RES_FORALL::('a word => bool) => ('a word => bool) => bool)
- ((PWORDLEN::nat => 'a word => bool) n1)
- (%w1::'a word.
- (RES_FORALL::('a word => bool) => ('a word => bool) => bool)
- ((PWORDLEN::nat => 'a word => bool) n2)
- (%w2::'a word.
+ (RES_FORALL::('a::type word => bool)
+ => ('a::type word => bool) => bool)
+ ((PWORDLEN::nat => 'a::type word => bool) n1)
+ (%w1::'a::type word.
+ (RES_FORALL::('a::type word => bool)
+ => ('a::type word => bool) => bool)
+ ((PWORDLEN::nat => 'a::type word => bool) n2)
+ (%w2::'a::type word.
(All::(nat => bool) => bool)
(%k::nat.
(op -->::bool => bool => bool)
((op <::nat => nat => bool) k n2)
- ((op =::'a => 'a => bool)
- ((bit::nat => 'a word => 'a) k
- ((WCAT::'a word * 'a word => 'a word)
- ((Pair::'a word
- => 'a word => 'a word * 'a word)
+ ((op =::'a::type => 'a::type => bool)
+ ((bit::nat => 'a::type word => 'a::type) k
+ ((WCAT::'a::type word * 'a::type word
+=> 'a::type word)
+ ((Pair::'a::type word
+ => 'a::type word => 'a::type word * 'a::type word)
w1 w2)))
- ((bit::nat => 'a word => 'a) k w2)))))))"
+ ((bit::nat => 'a::type word => 'a::type) k
+ w2)))))))"
by (import word_base BIT_WCAT_SND)
-lemma BIT_WCAT1: "ALL n. RES_FORALL (PWORDLEN n) (%w. ALL b. bit n (WCAT (WORD [b], w)) = b)"
+lemma BIT_WCAT1: "ALL n::nat.
+ RES_FORALL (PWORDLEN n)
+ (%w::'a::type word. ALL b::'a::type. bit n (WCAT (WORD [b], w)) = b)"
by (import word_base BIT_WCAT1)
-lemma WSEG_WCAT_WSEG1: "ALL n1 n2.
+lemma WSEG_WCAT_WSEG1: "ALL (n1::nat) n2::nat.
RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2)
- (%w2. ALL m k.
- m <= n1 & n2 <= k -->
- WSEG m k (WCAT (w1, w2)) = WSEG m (k - n2) w1))"
+ (%w1::'a::type word.
+ RES_FORALL (PWORDLEN n2)
+ (%w2::'a::type word.
+ ALL (m::nat) k::nat.
+ m <= n1 & n2 <= k -->
+ WSEG m k (WCAT (w1, w2)) = WSEG m (k - n2) w1))"
by (import word_base WSEG_WCAT_WSEG1)
-lemma WSEG_WCAT_WSEG2: "ALL n1 n2.
+lemma WSEG_WCAT_WSEG2: "ALL (n1::nat) n2::nat.
RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2)
- (%w2. ALL m k.
- m + k <= n2 --> WSEG m k (WCAT (w1, w2)) = WSEG m k w2))"
+ (%w1::'a::type word.
+ RES_FORALL (PWORDLEN n2)
+ (%w2::'a::type word.
+ ALL (m::nat) k::nat.
+ m + k <= n2 --> WSEG m k (WCAT (w1, w2)) = WSEG m k w2))"
by (import word_base WSEG_WCAT_WSEG2)
-lemma WSEG_WCAT_WSEG: "ALL n1 n2.
+lemma WSEG_WCAT_WSEG: "ALL (n1::nat) n2::nat.
RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2)
- (%w2. ALL m k.
- m + k <= n1 + n2 & k < n2 & n2 <= m + k -->
- WSEG m k (WCAT (w1, w2)) =
- WCAT (WSEG (m + k - n2) 0 w1, WSEG (n2 - k) k w2)))"
+ (%w1::'a::type word.
+ RES_FORALL (PWORDLEN n2)
+ (%w2::'a::type word.
+ ALL (m::nat) k::nat.
+ m + k <= n1 + n2 & k < n2 & n2 <= m + k -->
+ WSEG m k (WCAT (w1, w2)) =
+ WCAT (WSEG (m + k - n2) (0::nat) w1, WSEG (n2 - k) k w2)))"
by (import word_base WSEG_WCAT_WSEG)
lemma BIT_EQ_IMP_WORD_EQ: "(All::(nat => bool) => bool)
(%n::nat.
- (RES_FORALL::('a word => bool) => ('a word => bool) => bool)
- ((PWORDLEN::nat => 'a word => bool) n)
- (%w1::'a word.
- (RES_FORALL::('a word => bool) => ('a word => bool) => bool)
- ((PWORDLEN::nat => 'a word => bool) n)
- (%w2::'a word.
+ (RES_FORALL::('a::type word => bool)
+ => ('a::type word => bool) => bool)
+ ((PWORDLEN::nat => 'a::type word => bool) n)
+ (%w1::'a::type word.
+ (RES_FORALL::('a::type word => bool)
+ => ('a::type word => bool) => bool)
+ ((PWORDLEN::nat => 'a::type word => bool) n)
+ (%w2::'a::type word.
(op -->::bool => bool => bool)
((All::(nat => bool) => bool)
(%k::nat.
(op -->::bool => bool => bool)
((op <::nat => nat => bool) k n)
- ((op =::'a => 'a => bool)
- ((bit::nat => 'a word => 'a) k w1)
- ((bit::nat => 'a word => 'a) k w2))))
- ((op =::'a word => 'a word => bool) w1 w2))))"
+ ((op =::'a::type => 'a::type => bool)
+ ((bit::nat => 'a::type word => 'a::type) k w1)
+ ((bit::nat => 'a::type word => 'a::type) k w2))))
+ ((op =::'a::type word => 'a::type word => bool) w1 w2))))"
by (import word_base BIT_EQ_IMP_WORD_EQ)
;end_setup
@@ -568,80 +686,99 @@
;setup_theory word_num
constdefs
- LVAL :: "('a => nat) => nat => 'a list => nat"
- "LVAL == %f b. foldl (%e x. b * e + f x) 0"
+ LVAL :: "('a::type => nat) => nat => 'a::type list => nat"
+ "LVAL ==
+%(f::'a::type => nat) b::nat.
+ foldl (%(e::nat) x::'a::type. b * e + f x) (0::nat)"
-lemma LVAL_DEF: "ALL f b l. LVAL f b l = foldl (%e x. b * e + f x) 0 l"
+lemma LVAL_DEF: "ALL (f::'a::type => nat) (b::nat) l::'a::type list.
+ LVAL f b l = foldl (%(e::nat) x::'a::type. b * e + f x) (0::nat) l"
by (import word_num LVAL_DEF)
consts
- NVAL :: "('a => nat) => nat => 'a word => nat"
+ NVAL :: "('a::type => nat) => nat => 'a::type word => nat"
-specification (NVAL) NVAL_DEF: "ALL f b l. NVAL f b (WORD l) = LVAL f b l"
+specification (NVAL) NVAL_DEF: "ALL (f::'a::type => nat) (b::nat) l::'a::type list.
+ NVAL f b (WORD l) = LVAL f b l"
by (import word_num NVAL_DEF)
-lemma LVAL: "(ALL (x::'a => nat) xa::nat. LVAL x xa [] = (0::nat)) &
-(ALL (x::'a list) (xa::'a => nat) (xb::nat) xc::'a.
+lemma LVAL: "(ALL (x::'a::type => nat) xa::nat. LVAL x xa [] = (0::nat)) &
+(ALL (x::'a::type list) (xa::'a::type => nat) (xb::nat) xc::'a::type.
LVAL xa xb (xc # x) = xa xc * xb ^ length x + LVAL xa xb x)"
by (import word_num LVAL)
-lemma LVAL_SNOC: "ALL l h f b. LVAL f b (SNOC h l) = LVAL f b l * b + f h"
+lemma LVAL_SNOC: "ALL (l::'a::type list) (h::'a::type) (f::'a::type => nat) b::nat.
+ LVAL f b (SNOC h l) = LVAL f b l * b + f h"
by (import word_num LVAL_SNOC)
-lemma LVAL_MAX: "ALL l f b. (ALL x. f x < b) --> LVAL f b l < b ^ length l"
+lemma LVAL_MAX: "ALL (l::'a::type list) (f::'a::type => nat) b::nat.
+ (ALL x::'a::type. f x < b) --> LVAL f b l < b ^ length l"
by (import word_num LVAL_MAX)
-lemma NVAL_MAX: "ALL f b.
- (ALL x. f x < b) -->
- (ALL n. RES_FORALL (PWORDLEN n) (%w. NVAL f b w < b ^ n))"
+lemma NVAL_MAX: "ALL (f::'a::type => nat) b::nat.
+ (ALL x::'a::type. f x < b) -->
+ (ALL n::nat.
+ RES_FORALL (PWORDLEN n) (%w::'a::type word. NVAL f b w < b ^ n))"
by (import word_num NVAL_MAX)
-lemma NVAL0: "ALL x xa. NVAL x xa (WORD []) = 0"
+lemma NVAL0: "ALL (x::'a::type => nat) xa::nat. NVAL x xa (WORD []) = (0::nat)"
by (import word_num NVAL0)
-lemma NVAL1: "ALL x xa xb. NVAL x xa (WORD [xb]) = x xb"
+lemma NVAL1: "ALL (x::'a::type => nat) (xa::nat) xb::'a::type.
+ NVAL x xa (WORD [xb]) = x xb"
by (import word_num NVAL1)
-lemma NVAL_WORDLEN_0: "RES_FORALL (PWORDLEN 0) (%w. ALL fv r. NVAL fv r w = 0)"
+lemma NVAL_WORDLEN_0: "RES_FORALL (PWORDLEN (0::nat))
+ (%w::'a::type word.
+ ALL (fv::'a::type => nat) r::nat. NVAL fv r w = (0::nat))"
by (import word_num NVAL_WORDLEN_0)
-lemma NVAL_WCAT1: "ALL w f b x. NVAL f b (WCAT (w, WORD [x])) = NVAL f b w * b + f x"
+lemma NVAL_WCAT1: "ALL (w::'a::type word) (f::'a::type => nat) (b::nat) x::'a::type.
+ NVAL f b (WCAT (w, WORD [x])) = NVAL f b w * b + f x"
by (import word_num NVAL_WCAT1)
-lemma NVAL_WCAT2: "ALL n.
+lemma NVAL_WCAT2: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL f b x.
- NVAL f b (WCAT (WORD [x], w)) = f x * b ^ n + NVAL f b w)"
+ (%w::'a::type word.
+ ALL (f::'a::type => nat) (b::nat) x::'a::type.
+ NVAL f b (WCAT (WORD [x], w)) = f x * b ^ n + NVAL f b w)"
by (import word_num NVAL_WCAT2)
-lemma NVAL_WCAT: "ALL n m.
+lemma NVAL_WCAT: "ALL (n::nat) m::nat.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN m)
- (%w2. ALL f b.
- NVAL f b (WCAT (w1, w2)) =
- NVAL f b w1 * b ^ m + NVAL f b w2))"
+ (%w1::'a::type word.
+ RES_FORALL (PWORDLEN m)
+ (%w2::'a::type word.
+ ALL (f::'a::type => nat) b::nat.
+ NVAL f b (WCAT (w1, w2)) =
+ NVAL f b w1 * b ^ m + NVAL f b w2))"
by (import word_num NVAL_WCAT)
consts
- NLIST :: "nat => (nat => 'a) => nat => nat => 'a list"
+ NLIST :: "nat => (nat => 'a::type) => nat => nat => 'a::type list"
-specification (NLIST) NLIST_DEF: "(ALL (frep::nat => 'a) (b::nat) m::nat. NLIST (0::nat) frep b m = []) &
-(ALL (n::nat) (frep::nat => 'a) (b::nat) m::nat.
+specification (NLIST) NLIST_DEF: "(ALL (frep::nat => 'a::type) (b::nat) m::nat.
+ NLIST (0::nat) frep b m = []) &
+(ALL (n::nat) (frep::nat => 'a::type) (b::nat) m::nat.
NLIST (Suc n) frep b m =
SNOC (frep (m mod b)) (NLIST n frep b (m div b)))"
by (import word_num NLIST_DEF)
constdefs
- NWORD :: "nat => (nat => 'a) => nat => nat => 'a word"
- "NWORD == %n frep b m. WORD (NLIST n frep b m)"
+ NWORD :: "nat => (nat => 'a::type) => nat => nat => 'a::type word"
+ "NWORD ==
+%(n::nat) (frep::nat => 'a::type) (b::nat) m::nat. WORD (NLIST n frep b m)"
-lemma NWORD_DEF: "ALL n frep b m. NWORD n frep b m = WORD (NLIST n frep b m)"
+lemma NWORD_DEF: "ALL (n::nat) (frep::nat => 'a::type) (b::nat) m::nat.
+ NWORD n frep b m = WORD (NLIST n frep b m)"
by (import word_num NWORD_DEF)
-lemma NWORD_LENGTH: "ALL x xa xb xc. WORDLEN (NWORD x xa xb xc) = x"
+lemma NWORD_LENGTH: "ALL (x::nat) (xa::nat => 'a::type) (xb::nat) xc::nat.
+ WORDLEN (NWORD x xa xb xc) = x"
by (import word_num NWORD_LENGTH)
-lemma NWORD_PWORDLEN: "ALL x xa xb xc. IN (NWORD x xa xb xc) (PWORDLEN x)"
+lemma NWORD_PWORDLEN: "ALL (x::nat) (xa::nat => 'a::type) (xb::nat) xc::nat.
+ IN (NWORD x xa xb xc) (PWORDLEN x)"
by (import word_num NWORD_PWORDLEN)
;end_setup
@@ -649,362 +786,428 @@
;setup_theory word_bitop
consts
- PBITOP :: "('a word => 'b word) => bool"
+ PBITOP :: "('a::type word => 'b::type word) => bool"
defs
PBITOP_primdef: "PBITOP ==
GSPEC
- (%oper.
+ (%oper::'a::type word => 'b::type word.
(oper,
- ALL n.
+ ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. IN (oper w) (PWORDLEN n) &
- (ALL m k.
- m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w)))))"
+ (%w::'a::type word.
+ IN (oper w) (PWORDLEN n) &
+ (ALL (m::nat) k::nat.
+ m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w)))))"
lemma PBITOP_def: "PBITOP =
GSPEC
- (%oper.
+ (%oper::'a::type word => 'b::type word.
(oper,
- ALL n.
+ ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. IN (oper w) (PWORDLEN n) &
- (ALL m k.
- m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w)))))"
+ (%w::'a::type word.
+ IN (oper w) (PWORDLEN n) &
+ (ALL (m::nat) k::nat.
+ m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w)))))"
by (import word_bitop PBITOP_def)
-lemma IN_PBITOP: "ALL oper.
+lemma IN_PBITOP: "ALL oper::'a::type word => 'b::type word.
IN oper PBITOP =
- (ALL n.
+ (ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. IN (oper w) (PWORDLEN n) &
- (ALL m k.
- m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w))))"
+ (%w::'a::type word.
+ IN (oper w) (PWORDLEN n) &
+ (ALL (m::nat) k::nat.
+ m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w))))"
by (import word_bitop IN_PBITOP)
lemma PBITOP_PWORDLEN: "RES_FORALL PBITOP
- (%oper. ALL n. RES_FORALL (PWORDLEN n) (%w. IN (oper w) (PWORDLEN n)))"
+ (%oper::'a::type word => 'b::type word.
+ ALL n::nat.
+ RES_FORALL (PWORDLEN n)
+ (%w::'a::type word. IN (oper w) (PWORDLEN n)))"
by (import word_bitop PBITOP_PWORDLEN)
lemma PBITOP_WSEG: "RES_FORALL PBITOP
- (%oper.
- ALL n.
+ (%oper::'a::type word => 'b::type word.
+ ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL m k.
- m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w)))"
+ (%w::'a::type word.
+ ALL (m::nat) k::nat.
+ m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w)))"
by (import word_bitop PBITOP_WSEG)
-lemma PBITOP_BIT: "(RES_FORALL::(('a word => 'b word) => bool)
- => (('a word => 'b word) => bool) => bool)
- (PBITOP::('a word => 'b word) => bool)
- (%oper::'a word => 'b word.
+lemma PBITOP_BIT: "(RES_FORALL::(('a::type word => 'b::type word) => bool)
+ => (('a::type word => 'b::type word) => bool) => bool)
+ (PBITOP::('a::type word => 'b::type word) => bool)
+ (%oper::'a::type word => 'b::type word.
(All::(nat => bool) => bool)
(%n::nat.
- (RES_FORALL::('a word => bool) => ('a word => bool) => bool)
- ((PWORDLEN::nat => 'a word => bool) n)
- (%w::'a word.
+ (RES_FORALL::('a::type word => bool)
+ => ('a::type word => bool) => bool)
+ ((PWORDLEN::nat => 'a::type word => bool) n)
+ (%w::'a::type word.
(All::(nat => bool) => bool)
(%k::nat.
(op -->::bool => bool => bool)
((op <::nat => nat => bool) k n)
- ((op =::'b word => 'b word => bool)
+ ((op =::'b::type word => 'b::type word => bool)
(oper
- ((WORD::'a list => 'a word)
- ((op #::'a => 'a list => 'a list)
- ((bit::nat => 'a word => 'a) k w)
- ([]::'a list))))
- ((WORD::'b list => 'b word)
- ((op #::'b => 'b list => 'b list)
- ((bit::nat => 'b word => 'b) k (oper w))
- ([]::'b list))))))))"
+ ((WORD::'a::type list => 'a::type word)
+ ((op #::'a::type
+ => 'a::type list => 'a::type list)
+ ((bit::nat => 'a::type word => 'a::type) k w)
+ ([]::'a::type list))))
+ ((WORD::'b::type list => 'b::type word)
+ ((op #::'b::type => 'b::type list => 'b::type list)
+ ((bit::nat => 'b::type word => 'b::type) k
+ (oper w))
+ ([]::'b::type list))))))))"
by (import word_bitop PBITOP_BIT)
consts
- PBITBOP :: "('a word => 'b word => 'c word) => bool"
+ PBITBOP :: "('a::type word => 'b::type word => 'c::type word) => bool"
defs
PBITBOP_primdef: "PBITBOP ==
GSPEC
- (%oper.
+ (%oper::'a::type word => 'b::type word => 'c::type word.
(oper,
- ALL n.
+ ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. IN (oper w1 w2) (PWORDLEN n) &
- (ALL m k.
- m + k <= n -->
- oper (WSEG m k w1) (WSEG m k w2) =
- WSEG m k (oper w1 w2))))))"
+ (%w1::'a::type word.
+ RES_FORALL (PWORDLEN n)
+ (%w2::'b::type word.
+ IN (oper w1 w2) (PWORDLEN n) &
+ (ALL (m::nat) k::nat.
+ m + k <= n -->
+ oper (WSEG m k w1) (WSEG m k w2) =
+ WSEG m k (oper w1 w2))))))"
lemma PBITBOP_def: "PBITBOP =
GSPEC
- (%oper.
+ (%oper::'a::type word => 'b::type word => 'c::type word.
(oper,
- ALL n.
+ ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. IN (oper w1 w2) (PWORDLEN n) &
- (ALL m k.
- m + k <= n -->
- oper (WSEG m k w1) (WSEG m k w2) =
- WSEG m k (oper w1 w2))))))"
+ (%w1::'a::type word.
+ RES_FORALL (PWORDLEN n)
+ (%w2::'b::type word.
+ IN (oper w1 w2) (PWORDLEN n) &
+ (ALL (m::nat) k::nat.
+ m + k <= n -->
+ oper (WSEG m k w1) (WSEG m k w2) =
+ WSEG m k (oper w1 w2))))))"
by (import word_bitop PBITBOP_def)
-lemma IN_PBITBOP: "ALL oper.
+lemma IN_PBITBOP: "ALL oper::'a::type word => 'b::type word => 'c::type word.
IN oper PBITBOP =
- (ALL n.
+ (ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. IN (oper w1 w2) (PWORDLEN n) &
- (ALL m k.
- m + k <= n -->
- oper (WSEG m k w1) (WSEG m k w2) =
- WSEG m k (oper w1 w2)))))"
+ (%w1::'a::type word.
+ RES_FORALL (PWORDLEN n)
+ (%w2::'b::type word.
+ IN (oper w1 w2) (PWORDLEN n) &
+ (ALL (m::nat) k::nat.
+ m + k <= n -->
+ oper (WSEG m k w1) (WSEG m k w2) =
+ WSEG m k (oper w1 w2)))))"
by (import word_bitop IN_PBITBOP)
lemma PBITBOP_PWORDLEN: "RES_FORALL PBITBOP
- (%oper.
- ALL n.
+ (%oper::'a::type word => 'b::type word => 'c::type word.
+ ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n) (%w2. IN (oper w1 w2) (PWORDLEN n))))"
+ (%w1::'a::type word.
+ RES_FORALL (PWORDLEN n)
+ (%w2::'b::type word. IN (oper w1 w2) (PWORDLEN n))))"
by (import word_bitop PBITBOP_PWORDLEN)
lemma PBITBOP_WSEG: "RES_FORALL PBITBOP
- (%oper.
- ALL n.
+ (%oper::'a::type word => 'b::type word => 'c::type word.
+ ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. ALL m k.
- m + k <= n -->
- oper (WSEG m k w1) (WSEG m k w2) =
- WSEG m k (oper w1 w2))))"
+ (%w1::'a::type word.
+ RES_FORALL (PWORDLEN n)
+ (%w2::'b::type word.
+ ALL (m::nat) k::nat.
+ m + k <= n -->
+ oper (WSEG m k w1) (WSEG m k w2) =
+ WSEG m k (oper w1 w2))))"
by (import word_bitop PBITBOP_WSEG)
-lemma PBITBOP_EXISTS: "ALL f. EX x. ALL l1 l2. x (WORD l1) (WORD l2) = WORD (map2 f l1 l2)"
+lemma PBITBOP_EXISTS: "ALL f::'a::type => 'b::type => 'c::type.
+ EX x::'a::type word => 'b::type word => 'c::type word.
+ ALL (l1::'a::type list) l2::'b::type list.
+ x (WORD l1) (WORD l2) = WORD (map2 f l1 l2)"
by (import word_bitop PBITBOP_EXISTS)
consts
- WMAP :: "('a => 'b) => 'a word => 'b word"
+ WMAP :: "('a::type => 'b::type) => 'a::type word => 'b::type word"
-specification (WMAP) WMAP_DEF: "ALL f l. WMAP f (WORD l) = WORD (map f l)"
+specification (WMAP) WMAP_DEF: "ALL (f::'a::type => 'b::type) l::'a::type list.
+ WMAP f (WORD l) = WORD (map f l)"
by (import word_bitop WMAP_DEF)
-lemma WMAP_PWORDLEN: "RES_FORALL (PWORDLEN n) (%w. ALL f. IN (WMAP f w) (PWORDLEN n))"
+lemma WMAP_PWORDLEN: "RES_FORALL (PWORDLEN (n::nat))
+ (%w::'a::type word.
+ ALL f::'a::type => 'b::type. IN (WMAP f w) (PWORDLEN n))"
by (import word_bitop WMAP_PWORDLEN)
-lemma WMAP_0: "ALL x. WMAP x (WORD []) = WORD []"
+lemma WMAP_0: "ALL x::'a::type => 'b::type. WMAP x (WORD []) = WORD []"
by (import word_bitop WMAP_0)
lemma WMAP_BIT: "(All::(nat => bool) => bool)
(%n::nat.
- (RES_FORALL::('a word => bool) => ('a word => bool) => bool)
- ((PWORDLEN::nat => 'a word => bool) n)
- (%w::'a word.
+ (RES_FORALL::('a::type word => bool)
+ => ('a::type word => bool) => bool)
+ ((PWORDLEN::nat => 'a::type word => bool) n)
+ (%w::'a::type word.
(All::(nat => bool) => bool)
(%k::nat.
(op -->::bool => bool => bool)
((op <::nat => nat => bool) k n)
- ((All::(('a => 'b) => bool) => bool)
- (%f::'a => 'b.
- (op =::'b => 'b => bool)
- ((bit::nat => 'b word => 'b) k
- ((WMAP::('a => 'b) => 'a word => 'b word) f w))
- (f ((bit::nat => 'a word => 'a) k w)))))))"
+ ((All::(('a::type => 'b::type) => bool) => bool)
+ (%f::'a::type => 'b::type.
+ (op =::'b::type => 'b::type => bool)
+ ((bit::nat => 'b::type word => 'b::type) k
+ ((WMAP::('a::type => 'b::type)
+ => 'a::type word => 'b::type word)
+ f w))
+ (f ((bit::nat => 'a::type word => 'a::type) k
+ w)))))))"
by (import word_bitop WMAP_BIT)
-lemma WMAP_WSEG: "ALL n.
+lemma WMAP_WSEG: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL m k.
- m + k <= n -->
- (ALL f. WMAP f (WSEG m k w) = WSEG m k (WMAP f w)))"
+ (%w::'a::type word.
+ ALL (m::nat) k::nat.
+ m + k <= n -->
+ (ALL f::'a::type => 'b::type.
+ WMAP f (WSEG m k w) = WSEG m k (WMAP f w)))"
by (import word_bitop WMAP_WSEG)
-lemma WMAP_PBITOP: "ALL f. IN (WMAP f) PBITOP"
+lemma WMAP_PBITOP: "ALL f::'a::type => 'b::type. IN (WMAP f) PBITOP"
by (import word_bitop WMAP_PBITOP)
-lemma WMAP_WCAT: "ALL w1 w2 f. WMAP f (WCAT (w1, w2)) = WCAT (WMAP f w1, WMAP f w2)"
+lemma WMAP_WCAT: "ALL (w1::'a::type word) (w2::'a::type word) f::'a::type => 'b::type.
+ WMAP f (WCAT (w1, w2)) = WCAT (WMAP f w1, WMAP f w2)"
by (import word_bitop WMAP_WCAT)
-lemma WMAP_o: "ALL w f g. WMAP g (WMAP f w) = WMAP (g o f) w"
+lemma WMAP_o: "ALL (w::'a::type word) (f::'a::type => 'b::type) g::'b::type => 'c::type.
+ WMAP g (WMAP f w) = WMAP (g o f) w"
by (import word_bitop WMAP_o)
consts
- FORALLBITS :: "('a => bool) => 'a word => bool"
+ FORALLBITS :: "('a::type => bool) => 'a::type word => bool"
-specification (FORALLBITS) FORALLBITS_DEF: "ALL P l. FORALLBITS P (WORD l) = list_all P l"
+specification (FORALLBITS) FORALLBITS_DEF: "ALL (P::'a::type => bool) l::'a::type list.
+ FORALLBITS P (WORD l) = list_all P l"
by (import word_bitop FORALLBITS_DEF)
lemma FORALLBITS: "(All::(nat => bool) => bool)
(%n::nat.
- (RES_FORALL::('a word => bool) => ('a word => bool) => bool)
- ((PWORDLEN::nat => 'a word => bool) n)
- (%w::'a word.
- (All::(('a => bool) => bool) => bool)
- (%P::'a => bool.
+ (RES_FORALL::('a::type word => bool)
+ => ('a::type word => bool) => bool)
+ ((PWORDLEN::nat => 'a::type word => bool) n)
+ (%w::'a::type word.
+ (All::(('a::type => bool) => bool) => bool)
+ (%P::'a::type => bool.
(op =::bool => bool => bool)
- ((FORALLBITS::('a => bool) => 'a word => bool) P w)
+ ((FORALLBITS::('a::type => bool) => 'a::type word => bool) P
+ w)
((All::(nat => bool) => bool)
(%k::nat.
(op -->::bool => bool => bool)
((op <::nat => nat => bool) k n)
- (P ((bit::nat => 'a word => 'a) k w)))))))"
+ (P ((bit::nat => 'a::type word => 'a::type) k
+ w)))))))"
by (import word_bitop FORALLBITS)
-lemma FORALLBITS_WSEG: "ALL n.
+lemma FORALLBITS_WSEG: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL P.
- FORALLBITS P w -->
- (ALL m k. m + k <= n --> FORALLBITS P (WSEG m k w)))"
+ (%w::'a::type word.
+ ALL P::'a::type => bool.
+ FORALLBITS P w -->
+ (ALL (m::nat) k::nat. m + k <= n --> FORALLBITS P (WSEG m k w)))"
by (import word_bitop FORALLBITS_WSEG)
-lemma FORALLBITS_WCAT: "ALL w1 w2 P.
+lemma FORALLBITS_WCAT: "ALL (w1::'a::type word) (w2::'a::type word) P::'a::type => bool.
FORALLBITS P (WCAT (w1, w2)) = (FORALLBITS P w1 & FORALLBITS P w2)"
by (import word_bitop FORALLBITS_WCAT)
consts
- EXISTSABIT :: "('a => bool) => 'a word => bool"
+ EXISTSABIT :: "('a::type => bool) => 'a::type word => bool"
-specification (EXISTSABIT) EXISTSABIT_DEF: "ALL P l. EXISTSABIT P (WORD l) = list_exists P l"
+specification (EXISTSABIT) EXISTSABIT_DEF: "ALL (P::'a::type => bool) l::'a::type list.
+ EXISTSABIT P (WORD l) = list_exists P l"
by (import word_bitop EXISTSABIT_DEF)
-lemma NOT_EXISTSABIT: "ALL P w. (~ EXISTSABIT P w) = FORALLBITS (Not o P) w"
+lemma NOT_EXISTSABIT: "ALL (P::'a::type => bool) w::'a::type word.
+ (~ EXISTSABIT P w) = FORALLBITS (Not o P) w"
by (import word_bitop NOT_EXISTSABIT)
-lemma NOT_FORALLBITS: "ALL P w. (~ FORALLBITS P w) = EXISTSABIT (Not o P) w"
+lemma NOT_FORALLBITS: "ALL (P::'a::type => bool) w::'a::type word.
+ (~ FORALLBITS P w) = EXISTSABIT (Not o P) w"
by (import word_bitop NOT_FORALLBITS)
lemma EXISTSABIT: "(All::(nat => bool) => bool)
(%n::nat.
- (RES_FORALL::('a word => bool) => ('a word => bool) => bool)
- ((PWORDLEN::nat => 'a word => bool) n)
- (%w::'a word.
- (All::(('a => bool) => bool) => bool)
- (%P::'a => bool.
+ (RES_FORALL::('a::type word => bool)
+ => ('a::type word => bool) => bool)
+ ((PWORDLEN::nat => 'a::type word => bool) n)
+ (%w::'a::type word.
+ (All::(('a::type => bool) => bool) => bool)
+ (%P::'a::type => bool.
(op =::bool => bool => bool)
- ((EXISTSABIT::('a => bool) => 'a word => bool) P w)
+ ((EXISTSABIT::('a::type => bool) => 'a::type word => bool) P
+ w)
((Ex::(nat => bool) => bool)
(%k::nat.
(op &::bool => bool => bool)
((op <::nat => nat => bool) k n)
- (P ((bit::nat => 'a word => 'a) k w)))))))"
+ (P ((bit::nat => 'a::type word => 'a::type) k
+ w)))))))"
by (import word_bitop EXISTSABIT)
-lemma EXISTSABIT_WSEG: "ALL n.
+lemma EXISTSABIT_WSEG: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL m k.
- m + k <= n -->
- (ALL P. EXISTSABIT P (WSEG m k w) --> EXISTSABIT P w))"
+ (%w::'a::type word.
+ ALL (m::nat) k::nat.
+ m + k <= n -->
+ (ALL P::'a::type => bool.
+ EXISTSABIT P (WSEG m k w) --> EXISTSABIT P w))"
by (import word_bitop EXISTSABIT_WSEG)
-lemma EXISTSABIT_WCAT: "ALL w1 w2 P.
+lemma EXISTSABIT_WCAT: "ALL (w1::'a::type word) (w2::'a::type word) P::'a::type => bool.
EXISTSABIT P (WCAT (w1, w2)) = (EXISTSABIT P w1 | EXISTSABIT P w2)"
by (import word_bitop EXISTSABIT_WCAT)
constdefs
- SHR :: "bool => 'a => 'a word => 'a word * 'a"
+ SHR :: "bool => 'a::type => 'a::type word => 'a::type word * 'a::type"
"SHR ==
-%f b w.
+%(f::bool) (b::'a::type) w::'a::type word.
(WCAT
- (if f then WSEG 1 (PRE (WORDLEN w)) w else WORD [b],
- WSEG (PRE (WORDLEN w)) 1 w),
- bit 0 w)"
+ (if f then WSEG (1::nat) (PRE (WORDLEN w)) w else WORD [b],
+ WSEG (PRE (WORDLEN w)) (1::nat) w),
+ bit (0::nat) w)"
-lemma SHR_DEF: "ALL f b w.
+lemma SHR_DEF: "ALL (f::bool) (b::'a::type) w::'a::type word.
SHR f b w =
(WCAT
- (if f then WSEG 1 (PRE (WORDLEN w)) w else WORD [b],
- WSEG (PRE (WORDLEN w)) 1 w),
- bit 0 w)"
+ (if f then WSEG (1::nat) (PRE (WORDLEN w)) w else WORD [b],
+ WSEG (PRE (WORDLEN w)) (1::nat) w),
+ bit (0::nat) w)"
by (import word_bitop SHR_DEF)
constdefs
- SHL :: "bool => 'a word => 'a => 'a * 'a word"
+ SHL :: "bool => 'a::type word => 'a::type => 'a::type * 'a::type word"
"SHL ==
-%f w b.
+%(f::bool) (w::'a::type word) b::'a::type.
(bit (PRE (WORDLEN w)) w,
- WCAT (WSEG (PRE (WORDLEN w)) 0 w, if f then WSEG 1 0 w else WORD [b]))"
+ WCAT
+ (WSEG (PRE (WORDLEN w)) (0::nat) w,
+ if f then WSEG (1::nat) (0::nat) w else WORD [b]))"
-lemma SHL_DEF: "ALL f w b.
+lemma SHL_DEF: "ALL (f::bool) (w::'a::type word) b::'a::type.
SHL f w b =
(bit (PRE (WORDLEN w)) w,
- WCAT (WSEG (PRE (WORDLEN w)) 0 w, if f then WSEG 1 0 w else WORD [b]))"
+ WCAT
+ (WSEG (PRE (WORDLEN w)) (0::nat) w,
+ if f then WSEG (1::nat) (0::nat) w else WORD [b]))"
by (import word_bitop SHL_DEF)
-lemma SHR_WSEG: "ALL n.
+lemma SHR_WSEG: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL m k.
- m + k <= n -->
- 0 < m -->
- (ALL f b.
- SHR f b (WSEG m k w) =
- (if f
- then WCAT (WSEG 1 (k + (m - 1)) w, WSEG (m - 1) (k + 1) w)
- else WCAT (WORD [b], WSEG (m - 1) (k + 1) w),
- bit k w)))"
+ (%w::'a::type word.
+ ALL (m::nat) k::nat.
+ m + k <= n -->
+ (0::nat) < m -->
+ (ALL (f::bool) b::'a::type.
+ SHR f b (WSEG m k w) =
+ (if f
+ then WCAT
+ (WSEG (1::nat) (k + (m - (1::nat))) w,
+ WSEG (m - (1::nat)) (k + (1::nat)) w)
+ else WCAT (WORD [b], WSEG (m - (1::nat)) (k + (1::nat)) w),
+ bit k w)))"
by (import word_bitop SHR_WSEG)
-lemma SHR_WSEG_1F: "ALL n.
+lemma SHR_WSEG_1F: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL b m k.
- m + k <= n -->
- 0 < m -->
- SHR False b (WSEG m k w) =
- (WCAT (WORD [b], WSEG (m - 1) (k + 1) w), bit k w))"
+ (%w::'a::type word.
+ ALL (b::'a::type) (m::nat) k::nat.
+ m + k <= n -->
+ (0::nat) < m -->
+ SHR False b (WSEG m k w) =
+ (WCAT (WORD [b], WSEG (m - (1::nat)) (k + (1::nat)) w), bit k w))"
by (import word_bitop SHR_WSEG_1F)
-lemma SHR_WSEG_NF: "ALL n.
+lemma SHR_WSEG_NF: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL m k.
- m + k < n -->
- 0 < m -->
- SHR False (bit (m + k) w) (WSEG m k w) =
- (WSEG m (k + 1) w, bit k w))"
+ (%w::'a::type word.
+ ALL (m::nat) k::nat.
+ m + k < n -->
+ (0::nat) < m -->
+ SHR False (bit (m + k) w) (WSEG m k w) =
+ (WSEG m (k + (1::nat)) w, bit k w))"
by (import word_bitop SHR_WSEG_NF)
-lemma SHL_WSEG: "ALL n.
+lemma SHL_WSEG: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL m k.
- m + k <= n -->
- 0 < m -->
- (ALL f b.
- SHL f (WSEG m k w) b =
- (bit (k + (m - 1)) w,
- if f then WCAT (WSEG (m - 1) k w, WSEG 1 k w)
- else WCAT (WSEG (m - 1) k w, WORD [b]))))"
+ (%w::'a::type word.
+ ALL (m::nat) k::nat.
+ m + k <= n -->
+ (0::nat) < m -->
+ (ALL (f::bool) b::'a::type.
+ SHL f (WSEG m k w) b =
+ (bit (k + (m - (1::nat))) w,
+ if f then WCAT (WSEG (m - (1::nat)) k w, WSEG (1::nat) k w)
+ else WCAT (WSEG (m - (1::nat)) k w, WORD [b]))))"
by (import word_bitop SHL_WSEG)
-lemma SHL_WSEG_1F: "ALL n.
+lemma SHL_WSEG_1F: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL b m k.
- m + k <= n -->
- 0 < m -->
- SHL False (WSEG m k w) b =
- (bit (k + (m - 1)) w, WCAT (WSEG (m - 1) k w, WORD [b])))"
+ (%w::'a::type word.
+ ALL (b::'a::type) (m::nat) k::nat.
+ m + k <= n -->
+ (0::nat) < m -->
+ SHL False (WSEG m k w) b =
+ (bit (k + (m - (1::nat))) w,
+ WCAT (WSEG (m - (1::nat)) k w, WORD [b])))"
by (import word_bitop SHL_WSEG_1F)
-lemma SHL_WSEG_NF: "ALL n.
+lemma SHL_WSEG_NF: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL m k.
- m + k <= n -->
- 0 < m -->
- 0 < k -->
- SHL False (WSEG m k w) (bit (k - 1) w) =
- (bit (k + (m - 1)) w, WSEG m (k - 1) w))"
+ (%w::'a::type word.
+ ALL (m::nat) k::nat.
+ m + k <= n -->
+ (0::nat) < m -->
+ (0::nat) < k -->
+ SHL False (WSEG m k w) (bit (k - (1::nat)) w) =
+ (bit (k + (m - (1::nat))) w, WSEG m (k - (1::nat)) w))"
by (import word_bitop SHL_WSEG_NF)
-lemma WSEG_SHL: "ALL n.
+lemma WSEG_SHL: "ALL n::nat.
RES_FORALL (PWORDLEN (Suc n))
- (%w. ALL m k.
- 0 < k & m + k <= Suc n -->
- (ALL b. WSEG m k (snd (SHL f w b)) = WSEG m (k - 1) w))"
+ (%w::'a::type word.
+ ALL (m::nat) k::nat.
+ (0::nat) < k & m + k <= Suc n -->
+ (ALL b::'a::type.
+ WSEG m k (snd (SHL (f::bool) w b)) =
+ WSEG m (k - (1::nat)) w))"
by (import word_bitop WSEG_SHL)
-lemma WSEG_SHL_0: "ALL n.
+lemma WSEG_SHL_0: "ALL n::nat.
RES_FORALL (PWORDLEN (Suc n))
- (%w. ALL m b.
- 0 < m & m <= Suc n -->
- WSEG m 0 (snd (SHL f w b)) =
- WCAT (WSEG (m - 1) 0 w, if f then WSEG 1 0 w else WORD [b]))"
+ (%w::'a::type word.
+ ALL (m::nat) b::'a::type.
+ (0::nat) < m & m <= Suc n -->
+ WSEG m (0::nat) (snd (SHL (f::bool) w b)) =
+ WCAT
+ (WSEG (m - (1::nat)) (0::nat) w,
+ if f then WSEG (1::nat) (0::nat) w else WORD [b]))"
by (import word_bitop WSEG_SHL_0)
;end_setup
@@ -1013,78 +1216,86 @@
constdefs
BV :: "bool => nat"
- "BV == %b. if b then Suc 0 else 0"
+ "(BV == (%(b::bool). (if b then (Suc (0::nat)) else (0::nat))))"
-lemma BV_DEF: "ALL b. BV b = (if b then Suc 0 else 0)"
+lemma BV_DEF: "(ALL (b::bool). ((BV b) = (if b then (Suc (0::nat)) else (0::nat))))"
by (import bword_num BV_DEF)
consts
BNVAL :: "bool word => nat"
-specification (BNVAL) BNVAL_DEF: "ALL l. BNVAL (WORD l) = LVAL BV 2 l"
+specification (BNVAL) BNVAL_DEF: "ALL l::bool list. BNVAL (WORD l) = LVAL BV (2::nat) l"
by (import bword_num BNVAL_DEF)
-lemma BV_LESS_2: "ALL x. BV x < 2"
+lemma BV_LESS_2: "ALL x::bool. BV x < (2::nat)"
by (import bword_num BV_LESS_2)
-lemma BNVAL_NVAL: "ALL w. BNVAL w = NVAL BV 2 w"
+lemma BNVAL_NVAL: "ALL w::bool word. BNVAL w = NVAL BV (2::nat) w"
by (import bword_num BNVAL_NVAL)
-lemma BNVAL0: "BNVAL (WORD []) = 0"
+lemma BNVAL0: "BNVAL (WORD []) = (0::nat)"
by (import bword_num BNVAL0)
-lemma BNVAL_11: "ALL w1 w2. WORDLEN w1 = WORDLEN w2 --> BNVAL w1 = BNVAL w2 --> w1 = w2"
+lemma BNVAL_11: "ALL (w1::bool word) w2::bool word.
+ WORDLEN w1 = WORDLEN w2 --> BNVAL w1 = BNVAL w2 --> w1 = w2"
by (import bword_num BNVAL_11)
-lemma BNVAL_ONTO: "ALL w. Ex (op = (BNVAL w))"
+lemma BNVAL_ONTO: "ALL w::bool word. Ex (op = (BNVAL w))"
by (import bword_num BNVAL_ONTO)
-lemma BNVAL_MAX: "ALL n. RES_FORALL (PWORDLEN n) (%w. BNVAL w < 2 ^ n)"
+lemma BNVAL_MAX: "ALL n::nat. RES_FORALL (PWORDLEN n) (%w::bool word. BNVAL w < (2::nat) ^ n)"
by (import bword_num BNVAL_MAX)
-lemma BNVAL_WCAT1: "ALL n.
+lemma BNVAL_WCAT1: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL x. BNVAL (WCAT (w, WORD [x])) = BNVAL w * 2 + BV x)"
+ (%w::bool word.
+ ALL x::bool. BNVAL (WCAT (w, WORD [x])) = BNVAL w * (2::nat) + BV x)"
by (import bword_num BNVAL_WCAT1)
-lemma BNVAL_WCAT2: "ALL n.
+lemma BNVAL_WCAT2: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w. ALL x. BNVAL (WCAT (WORD [x], w)) = BV x * 2 ^ n + BNVAL w)"
+ (%w::bool word.
+ ALL x::bool.
+ BNVAL (WCAT (WORD [x], w)) = BV x * (2::nat) ^ n + BNVAL w)"
by (import bword_num BNVAL_WCAT2)
-lemma BNVAL_WCAT: "ALL n m.
+lemma BNVAL_WCAT: "ALL (n::nat) m::nat.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN m)
- (%w2. BNVAL (WCAT (w1, w2)) = BNVAL w1 * 2 ^ m + BNVAL w2))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN m)
+ (%w2::bool word.
+ BNVAL (WCAT (w1, w2)) = BNVAL w1 * (2::nat) ^ m + BNVAL w2))"
by (import bword_num BNVAL_WCAT)
constdefs
VB :: "nat => bool"
- "VB == %n. n mod 2 ~= 0"
+ "VB == %n::nat. n mod (2::nat) ~= (0::nat)"
-lemma VB_DEF: "ALL n. VB n = (n mod 2 ~= 0)"
+lemma VB_DEF: "ALL n::nat. VB n = (n mod (2::nat) ~= (0::nat))"
by (import bword_num VB_DEF)
constdefs
NBWORD :: "nat => nat => bool word"
- "NBWORD == %n m. WORD (NLIST n VB 2 m)"
+ "NBWORD == %(n::nat) m::nat. WORD (NLIST n VB (2::nat) m)"
-lemma NBWORD_DEF: "ALL n m. NBWORD n m = WORD (NLIST n VB 2 m)"
+lemma NBWORD_DEF: "ALL (n::nat) m::nat. NBWORD n m = WORD (NLIST n VB (2::nat) m)"
by (import bword_num NBWORD_DEF)
-lemma NBWORD0: "ALL x. NBWORD 0 x = WORD []"
+lemma NBWORD0: "ALL x::nat. NBWORD (0::nat) x = WORD []"
by (import bword_num NBWORD0)
-lemma WORDLEN_NBWORD: "ALL x xa. WORDLEN (NBWORD x xa) = x"
+lemma WORDLEN_NBWORD: "ALL (x::nat) xa::nat. WORDLEN (NBWORD x xa) = x"
by (import bword_num WORDLEN_NBWORD)
-lemma PWORDLEN_NBWORD: "ALL x xa. IN (NBWORD x xa) (PWORDLEN x)"
+lemma PWORDLEN_NBWORD: "ALL (x::nat) xa::nat. IN (NBWORD x xa) (PWORDLEN x)"
by (import bword_num PWORDLEN_NBWORD)
-lemma NBWORD_SUC: "ALL n m. NBWORD (Suc n) m = WCAT (NBWORD n (m div 2), WORD [VB (m mod 2)])"
+lemma NBWORD_SUC: "ALL (n::nat) m::nat.
+ NBWORD (Suc n) m =
+ WCAT (NBWORD n (m div (2::nat)), WORD [VB (m mod (2::nat))])"
by (import bword_num NBWORD_SUC)
-lemma VB_BV: "ALL x. VB (BV x) = x"
+lemma VB_BV: "ALL x::bool. VB (BV x) = x"
by (import bword_num VB_BV)
lemma BV_VB: "(All::(nat => bool) => bool)
@@ -1099,19 +1310,24 @@
x))"
by (import bword_num BV_VB)
-lemma NBWORD_BNVAL: "ALL n. RES_FORALL (PWORDLEN n) (%w. NBWORD n (BNVAL w) = w)"
+lemma NBWORD_BNVAL: "ALL n::nat. RES_FORALL (PWORDLEN n) (%w::bool word. NBWORD n (BNVAL w) = w)"
by (import bword_num NBWORD_BNVAL)
-lemma BNVAL_NBWORD: "ALL n m. m < 2 ^ n --> BNVAL (NBWORD n m) = m"
+lemma BNVAL_NBWORD: "ALL (n::nat) m::nat. m < (2::nat) ^ n --> BNVAL (NBWORD n m) = m"
by (import bword_num BNVAL_NBWORD)
-lemma ZERO_WORD_VAL: "RES_FORALL (PWORDLEN n) (%w. (w = NBWORD n 0) = (BNVAL w = 0))"
+lemma ZERO_WORD_VAL: "RES_FORALL (PWORDLEN (n::nat))
+ (%w::bool word. (w = NBWORD n (0::nat)) = (BNVAL w = (0::nat)))"
by (import bword_num ZERO_WORD_VAL)
-lemma WCAT_NBWORD_0: "ALL n1 n2. WCAT (NBWORD n1 0, NBWORD n2 0) = NBWORD (n1 + n2) 0"
+lemma WCAT_NBWORD_0: "ALL (n1::nat) n2::nat.
+ WCAT (NBWORD n1 (0::nat), NBWORD n2 (0::nat)) = NBWORD (n1 + n2) (0::nat)"
by (import bword_num WCAT_NBWORD_0)
-lemma WSPLIT_NBWORD_0: "ALL n m. m <= n --> WSPLIT m (NBWORD n 0) = (NBWORD (n - m) 0, NBWORD m 0)"
+lemma WSPLIT_NBWORD_0: "ALL (n::nat) m::nat.
+ m <= n -->
+ WSPLIT m (NBWORD n (0::nat)) =
+ (NBWORD (n - m) (0::nat), NBWORD m (0::nat))"
by (import bword_num WSPLIT_NBWORD_0)
lemma EQ_NBWORD0_SPLIT: "(All::(nat => bool) => bool)
@@ -1138,60 +1354,75 @@
((NBWORD::nat => nat => bool word) m (0::nat))))))))"
by (import bword_num EQ_NBWORD0_SPLIT)
-lemma NBWORD_MOD: "ALL n m. NBWORD n (m mod 2 ^ n) = NBWORD n m"
+lemma NBWORD_MOD: "ALL (n::nat) m::nat. NBWORD n (m mod (2::nat) ^ n) = NBWORD n m"
by (import bword_num NBWORD_MOD)
-lemma WSEG_NBWORD_SUC: "ALL n m. WSEG n 0 (NBWORD (Suc n) m) = NBWORD n m"
+lemma WSEG_NBWORD_SUC: "ALL (n::nat) m::nat. WSEG n (0::nat) (NBWORD (Suc n) m) = NBWORD n m"
by (import bword_num WSEG_NBWORD_SUC)
-lemma NBWORD_SUC_WSEG: "ALL n. RES_FORALL (PWORDLEN (Suc n)) (%w. NBWORD n (BNVAL w) = WSEG n 0 w)"
+lemma NBWORD_SUC_WSEG: "ALL n::nat.
+ RES_FORALL (PWORDLEN (Suc n))
+ (%w::bool word. NBWORD n (BNVAL w) = WSEG n (0::nat) w)"
by (import bword_num NBWORD_SUC_WSEG)
-lemma DOUBL_EQ_SHL: "ALL x>0.
+lemma DOUBL_EQ_SHL: "ALL x>0::nat.
RES_FORALL (PWORDLEN x)
- (%xa. ALL xb.
- NBWORD x (BNVAL xa + BNVAL xa + BV xb) = snd (SHL False xa xb))"
+ (%xa::bool word.
+ ALL xb::bool.
+ NBWORD x (BNVAL xa + BNVAL xa + BV xb) = snd (SHL False xa xb))"
by (import bword_num DOUBL_EQ_SHL)
-lemma MSB_NBWORD: "ALL n m. bit n (NBWORD (Suc n) m) = VB (m div 2 ^ n mod 2)"
+lemma MSB_NBWORD: "ALL (n::nat) m::nat.
+ bit n (NBWORD (Suc n) m) = VB (m div (2::nat) ^ n mod (2::nat))"
by (import bword_num MSB_NBWORD)
-lemma NBWORD_SPLIT: "ALL n1 n2 m.
- NBWORD (n1 + n2) m = WCAT (NBWORD n1 (m div 2 ^ n2), NBWORD n2 m)"
+lemma NBWORD_SPLIT: "ALL (n1::nat) (n2::nat) m::nat.
+ NBWORD (n1 + n2) m = WCAT (NBWORD n1 (m div (2::nat) ^ n2), NBWORD n2 m)"
by (import bword_num NBWORD_SPLIT)
-lemma WSEG_NBWORD: "ALL m k n.
- m + k <= n --> (ALL l. WSEG m k (NBWORD n l) = NBWORD m (l div 2 ^ k))"
+lemma WSEG_NBWORD: "ALL (m::nat) (k::nat) n::nat.
+ m + k <= n -->
+ (ALL l::nat. WSEG m k (NBWORD n l) = NBWORD m (l div (2::nat) ^ k))"
by (import bword_num WSEG_NBWORD)
-lemma NBWORD_SUC_FST: "ALL n x. NBWORD (Suc n) x = WCAT (WORD [VB (x div 2 ^ n mod 2)], NBWORD n x)"
+lemma NBWORD_SUC_FST: "ALL (n::nat) x::nat.
+ NBWORD (Suc n) x =
+ WCAT (WORD [VB (x div (2::nat) ^ n mod (2::nat))], NBWORD n x)"
by (import bword_num NBWORD_SUC_FST)
-lemma BIT_NBWORD0: "ALL k n. k < n --> bit k (NBWORD n 0) = False"
+lemma BIT_NBWORD0: "ALL (k::nat) n::nat. k < n --> bit k (NBWORD n (0::nat)) = False"
by (import bword_num BIT_NBWORD0)
-lemma ADD_BNVAL_LEFT: "ALL n.
+lemma ADD_BNVAL_LEFT: "ALL n::nat.
RES_FORALL (PWORDLEN (Suc n))
- (%w1. RES_FORALL (PWORDLEN (Suc n))
- (%w2. BNVAL w1 + BNVAL w2 =
- (BV (bit n w1) + BV (bit n w2)) * 2 ^ n +
- (BNVAL (WSEG n 0 w1) + BNVAL (WSEG n 0 w2))))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN (Suc n))
+ (%w2::bool word.
+ BNVAL w1 + BNVAL w2 =
+ (BV (bit n w1) + BV (bit n w2)) * (2::nat) ^ n +
+ (BNVAL (WSEG n (0::nat) w1) + BNVAL (WSEG n (0::nat) w2))))"
by (import bword_num ADD_BNVAL_LEFT)
-lemma ADD_BNVAL_RIGHT: "ALL n.
+lemma ADD_BNVAL_RIGHT: "ALL n::nat.
RES_FORALL (PWORDLEN (Suc n))
- (%w1. RES_FORALL (PWORDLEN (Suc n))
- (%w2. BNVAL w1 + BNVAL w2 =
- (BNVAL (WSEG n 1 w1) + BNVAL (WSEG n 1 w2)) * 2 +
- (BV (bit 0 w1) + BV (bit 0 w2))))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN (Suc n))
+ (%w2::bool word.
+ BNVAL w1 + BNVAL w2 =
+ (BNVAL (WSEG n (1::nat) w1) + BNVAL (WSEG n (1::nat) w2)) *
+ (2::nat) +
+ (BV (bit (0::nat) w1) + BV (bit (0::nat) w2))))"
by (import bword_num ADD_BNVAL_RIGHT)
-lemma ADD_BNVAL_SPLIT: "ALL n1 n2.
+lemma ADD_BNVAL_SPLIT: "ALL (n1::nat) n2::nat.
RES_FORALL (PWORDLEN (n1 + n2))
- (%w1. RES_FORALL (PWORDLEN (n1 + n2))
- (%w2. BNVAL w1 + BNVAL w2 =
- (BNVAL (WSEG n1 n2 w1) + BNVAL (WSEG n1 n2 w2)) * 2 ^ n2 +
- (BNVAL (WSEG n2 0 w1) + BNVAL (WSEG n2 0 w2))))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN (n1 + n2))
+ (%w2::bool word.
+ BNVAL w1 + BNVAL w2 =
+ (BNVAL (WSEG n1 n2 w1) + BNVAL (WSEG n1 n2 w2)) *
+ (2::nat) ^ n2 +
+ (BNVAL (WSEG n2 (0::nat) w1) + BNVAL (WSEG n2 (0::nat) w2))))"
by (import bword_num ADD_BNVAL_SPLIT)
;end_setup
@@ -1201,59 +1432,75 @@
consts
ACARRY :: "nat => bool word => bool word => bool => bool"
-specification (ACARRY) ACARRY_DEF: "(ALL w1 w2 cin. ACARRY 0 w1 w2 cin = cin) &
-(ALL n w1 w2 cin.
+specification (ACARRY) ACARRY_DEF: "(ALL (w1::bool word) (w2::bool word) cin::bool.
+ ACARRY (0::nat) w1 w2 cin = cin) &
+(ALL (n::nat) (w1::bool word) (w2::bool word) cin::bool.
ACARRY (Suc n) w1 w2 cin =
- VB ((BV (bit n w1) + BV (bit n w2) + BV (ACARRY n w1 w2 cin)) div 2))"
+ VB ((BV (bit n w1) + BV (bit n w2) + BV (ACARRY n w1 w2 cin)) div
+ (2::nat)))"
by (import bword_arith ACARRY_DEF)
consts
ICARRY :: "nat => bool word => bool word => bool => bool"
-specification (ICARRY) ICARRY_DEF: "(ALL w1 w2 cin. ICARRY 0 w1 w2 cin = cin) &
-(ALL n w1 w2 cin.
+specification (ICARRY) ICARRY_DEF: "(ALL (w1::bool word) (w2::bool word) cin::bool.
+ ICARRY (0::nat) w1 w2 cin = cin) &
+(ALL (n::nat) (w1::bool word) (w2::bool word) cin::bool.
ICARRY (Suc n) w1 w2 cin =
(bit n w1 & bit n w2 | (bit n w1 | bit n w2) & ICARRY n w1 w2 cin))"
by (import bword_arith ICARRY_DEF)
-lemma ACARRY_EQ_ICARRY: "ALL n.
+lemma ACARRY_EQ_ICARRY: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. ALL cin k.
- k <= n --> ACARRY k w1 w2 cin = ICARRY k w1 w2 cin))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN n)
+ (%w2::bool word.
+ ALL (cin::bool) k::nat.
+ k <= n --> ACARRY k w1 w2 cin = ICARRY k w1 w2 cin))"
by (import bword_arith ACARRY_EQ_ICARRY)
-lemma BNVAL_LESS_EQ: "ALL n. RES_FORALL (PWORDLEN n) (%w. BNVAL w <= 2 ^ n - 1)"
+lemma BNVAL_LESS_EQ: "ALL n::nat.
+ RES_FORALL (PWORDLEN n)
+ (%w::bool word. BNVAL w <= (2::nat) ^ n - (1::nat))"
by (import bword_arith BNVAL_LESS_EQ)
-lemma ADD_BNVAL_LESS_EQ1: "ALL n cin.
+lemma ADD_BNVAL_LESS_EQ1: "ALL (n::nat) cin::bool.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. (BNVAL w1 + (BNVAL w2 + BV cin)) div 2 ^ n <= Suc 0))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN n)
+ (%w2::bool word.
+ (BNVAL w1 + (BNVAL w2 + BV cin)) div (2::nat) ^ n
+ <= Suc (0::nat)))"
by (import bword_arith ADD_BNVAL_LESS_EQ1)
-lemma ADD_BV_BNVAL_DIV_LESS_EQ1: "ALL n x1 x2 cin.
+lemma ADD_BV_BNVAL_DIV_LESS_EQ1: "ALL (n::nat) (x1::bool) (x2::bool) cin::bool.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. (BV x1 + BV x2 +
- (BNVAL w1 + (BNVAL w2 + BV cin)) div 2 ^ n) div
- 2
- <= 1))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN n)
+ (%w2::bool word.
+ (BV x1 + BV x2 +
+ (BNVAL w1 + (BNVAL w2 + BV cin)) div (2::nat) ^ n) div
+ (2::nat)
+ <= (1::nat)))"
by (import bword_arith ADD_BV_BNVAL_DIV_LESS_EQ1)
-lemma ADD_BV_BNVAL_LESS_EQ: "ALL n x1 x2 cin.
+lemma ADD_BV_BNVAL_LESS_EQ: "ALL (n::nat) (x1::bool) (x2::bool) cin::bool.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. BV x1 + BV x2 + (BNVAL w1 + (BNVAL w2 + BV cin))
- <= Suc (2 ^ Suc n)))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN n)
+ (%w2::bool word.
+ BV x1 + BV x2 + (BNVAL w1 + (BNVAL w2 + BV cin))
+ <= Suc ((2::nat) ^ Suc n)))"
by (import bword_arith ADD_BV_BNVAL_LESS_EQ)
-lemma ADD_BV_BNVAL_LESS_EQ1: "ALL n x1 x2 cin.
+lemma ADD_BV_BNVAL_LESS_EQ1: "ALL (n::nat) (x1::bool) (x2::bool) cin::bool.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. (BV x1 + BV x2 + (BNVAL w1 + (BNVAL w2 + BV cin))) div
- 2 ^ Suc n
- <= 1))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN n)
+ (%w2::bool word.
+ (BV x1 + BV x2 + (BNVAL w1 + (BNVAL w2 + BV cin))) div
+ (2::nat) ^ Suc n
+ <= (1::nat)))"
by (import bword_arith ADD_BV_BNVAL_LESS_EQ1)
lemma ACARRY_EQ_ADD_DIV: "(All::(nat => bool) => bool)
@@ -1293,81 +1540,97 @@
k)))))))"
by (import bword_arith ACARRY_EQ_ADD_DIV)
-lemma ADD_WORD_SPLIT: "ALL n1 n2.
+lemma ADD_WORD_SPLIT: "ALL (n1::nat) n2::nat.
RES_FORALL (PWORDLEN (n1 + n2))
- (%w1. RES_FORALL (PWORDLEN (n1 + n2))
- (%w2. ALL cin.
- NBWORD (n1 + n2) (BNVAL w1 + BNVAL w2 + BV cin) =
- WCAT
- (NBWORD n1
- (BNVAL (WSEG n1 n2 w1) + BNVAL (WSEG n1 n2 w2) +
- BV (ACARRY n2 w1 w2 cin)),
- NBWORD n2
- (BNVAL (WSEG n2 0 w1) + BNVAL (WSEG n2 0 w2) +
- BV cin))))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN (n1 + n2))
+ (%w2::bool word.
+ ALL cin::bool.
+ NBWORD (n1 + n2) (BNVAL w1 + BNVAL w2 + BV cin) =
+ WCAT
+ (NBWORD n1
+ (BNVAL (WSEG n1 n2 w1) + BNVAL (WSEG n1 n2 w2) +
+ BV (ACARRY n2 w1 w2 cin)),
+ NBWORD n2
+ (BNVAL (WSEG n2 (0::nat) w1) +
+ BNVAL (WSEG n2 (0::nat) w2) +
+ BV cin))))"
by (import bword_arith ADD_WORD_SPLIT)
-lemma WSEG_NBWORD_ADD: "ALL n.
+lemma WSEG_NBWORD_ADD: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. ALL m k cin.
- m + k <= n -->
- WSEG m k (NBWORD n (BNVAL w1 + BNVAL w2 + BV cin)) =
- NBWORD m
- (BNVAL (WSEG m k w1) + BNVAL (WSEG m k w2) +
- BV (ACARRY k w1 w2 cin))))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN n)
+ (%w2::bool word.
+ ALL (m::nat) (k::nat) cin::bool.
+ m + k <= n -->
+ WSEG m k (NBWORD n (BNVAL w1 + BNVAL w2 + BV cin)) =
+ NBWORD m
+ (BNVAL (WSEG m k w1) + BNVAL (WSEG m k w2) +
+ BV (ACARRY k w1 w2 cin))))"
by (import bword_arith WSEG_NBWORD_ADD)
-lemma ADD_NBWORD_EQ0_SPLIT: "ALL n1 n2.
+lemma ADD_NBWORD_EQ0_SPLIT: "ALL (n1::nat) n2::nat.
RES_FORALL (PWORDLEN (n1 + n2))
- (%w1. RES_FORALL (PWORDLEN (n1 + n2))
- (%w2. ALL cin.
- (NBWORD (n1 + n2) (BNVAL w1 + BNVAL w2 + BV cin) =
- NBWORD (n1 + n2) 0) =
- (NBWORD n1
- (BNVAL (WSEG n1 n2 w1) + BNVAL (WSEG n1 n2 w2) +
- BV (ACARRY n2 w1 w2 cin)) =
- NBWORD n1 0 &
- NBWORD n2
- (BNVAL (WSEG n2 0 w1) + BNVAL (WSEG n2 0 w2) +
- BV cin) =
- NBWORD n2 0)))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN (n1 + n2))
+ (%w2::bool word.
+ ALL cin::bool.
+ (NBWORD (n1 + n2) (BNVAL w1 + BNVAL w2 + BV cin) =
+ NBWORD (n1 + n2) (0::nat)) =
+ (NBWORD n1
+ (BNVAL (WSEG n1 n2 w1) + BNVAL (WSEG n1 n2 w2) +
+ BV (ACARRY n2 w1 w2 cin)) =
+ NBWORD n1 (0::nat) &
+ NBWORD n2
+ (BNVAL (WSEG n2 (0::nat) w1) +
+ BNVAL (WSEG n2 (0::nat) w2) +
+ BV cin) =
+ NBWORD n2 (0::nat))))"
by (import bword_arith ADD_NBWORD_EQ0_SPLIT)
-lemma ACARRY_MSB: "ALL n.
+lemma ACARRY_MSB: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. ALL cin.
- ACARRY n w1 w2 cin =
- bit n (NBWORD (Suc n) (BNVAL w1 + BNVAL w2 + BV cin))))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN n)
+ (%w2::bool word.
+ ALL cin::bool.
+ ACARRY n w1 w2 cin =
+ bit n (NBWORD (Suc n) (BNVAL w1 + BNVAL w2 + BV cin))))"
by (import bword_arith ACARRY_MSB)
-lemma ACARRY_WSEG: "ALL n.
+lemma ACARRY_WSEG: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. ALL cin k m.
- k < m & m <= n -->
- ACARRY k (WSEG m 0 w1) (WSEG m 0 w2) cin =
- ACARRY k w1 w2 cin))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN n)
+ (%w2::bool word.
+ ALL (cin::bool) (k::nat) m::nat.
+ k < m & m <= n -->
+ ACARRY k (WSEG m (0::nat) w1) (WSEG m (0::nat) w2) cin =
+ ACARRY k w1 w2 cin))"
by (import bword_arith ACARRY_WSEG)
-lemma ICARRY_WSEG: "ALL n.
+lemma ICARRY_WSEG: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. ALL cin k m.
- k < m & m <= n -->
- ICARRY k (WSEG m 0 w1) (WSEG m 0 w2) cin =
- ICARRY k w1 w2 cin))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN n)
+ (%w2::bool word.
+ ALL (cin::bool) (k::nat) m::nat.
+ k < m & m <= n -->
+ ICARRY k (WSEG m (0::nat) w1) (WSEG m (0::nat) w2) cin =
+ ICARRY k w1 w2 cin))"
by (import bword_arith ICARRY_WSEG)
-lemma ACARRY_ACARRY_WSEG: "ALL n.
+lemma ACARRY_ACARRY_WSEG: "ALL n::nat.
RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. ALL cin m k1 k2.
- k1 < m & k2 < n & m + k2 <= n -->
- ACARRY k1 (WSEG m k2 w1) (WSEG m k2 w2)
- (ACARRY k2 w1 w2 cin) =
- ACARRY (k1 + k2) w1 w2 cin))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN n)
+ (%w2::bool word.
+ ALL (cin::bool) (m::nat) (k1::nat) k2::nat.
+ k1 < m & k2 < n & m + k2 <= n -->
+ ACARRY k1 (WSEG m k2 w1) (WSEG m k2 w2)
+ (ACARRY k2 w1 w2 cin) =
+ ACARRY (k1 + k2) w1 w2 cin))"
by (import bword_arith ACARRY_ACARRY_WSEG)
;end_setup
@@ -1377,25 +1640,27 @@
consts
WNOT :: "bool word => bool word"
-specification (WNOT) WNOT_DEF: "ALL l. WNOT (WORD l) = WORD (map Not l)"
+specification (WNOT) WNOT_DEF: "ALL l::bool list. WNOT (WORD l) = WORD (map Not l)"
by (import bword_bitop WNOT_DEF)
lemma PBITOP_WNOT: "IN WNOT PBITOP"
by (import bword_bitop PBITOP_WNOT)
-lemma WNOT_WNOT: "ALL w. WNOT (WNOT w) = w"
+lemma WNOT_WNOT: "ALL w::bool word. WNOT (WNOT w) = w"
by (import bword_bitop WNOT_WNOT)
-lemma WCAT_WNOT: "ALL n1 n2.
+lemma WCAT_WNOT: "ALL (n1::nat) n2::nat.
RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2)
- (%w2. WCAT (WNOT w1, WNOT w2) = WNOT (WCAT (w1, w2))))"
+ (%w1::bool word.
+ RES_FORALL (PWORDLEN n2)
+ (%w2::bool word. WCAT (WNOT w1, WNOT w2) = WNOT (WCAT (w1, w2))))"
by (import bword_bitop WCAT_WNOT)
consts
WAND :: "bool word => bool word => bool word"
-specification (WAND) WAND_DEF: "ALL l1 l2. WAND (WORD l1) (WORD l2) = WORD (map2 op & l1 l2)"
+specification (WAND) WAND_DEF: "ALL (l1::bool list) l2::bool list.
+ WAND (WORD l1) (WORD l2) = WORD (map2 op & l1 l2)"
by (import bword_bitop WAND_DEF)
lemma PBITBOP_WAND: "IN WAND PBITBOP"
@@ -1404,7 +1669,8 @@
consts
WOR :: "bool word => bool word => bool word"
-specification (WOR) WOR_DEF: "ALL l1 l2. WOR (WORD l1) (WORD l2) = WORD (map2 op | l1 l2)"
+specification (WOR) WOR_DEF: "ALL (l1::bool list) l2::bool list.
+ WOR (WORD l1) (WORD l2) = WORD (map2 op | l1 l2)"
by (import bword_bitop WOR_DEF)
lemma PBITBOP_WOR: "IN WOR PBITBOP"
@@ -1413,7 +1679,8 @@
consts
WXOR :: "bool word => bool word => bool word"
-specification (WXOR) WXOR_DEF: "ALL l1 l2. WXOR (WORD l1) (WORD l2) = WORD (map2 (%x y. x ~= y) l1 l2)"
+specification (WXOR) WXOR_DEF: "ALL (l1::bool list) l2::bool list.
+ WXOR (WORD l1) (WORD l2) = WORD (map2 (%(x::bool) y::bool. x ~= y) l1 l2)"
by (import bword_bitop WXOR_DEF)
lemma PBITBOP_WXOR: "IN WXOR PBITBOP"
--- a/src/HOL/Import/HOL/HOL4Word32.thy Mon Sep 26 02:06:44 2005 +0200
+++ b/src/HOL/Import/HOL/HOL4Word32.thy Mon Sep 26 02:27:14 2005 +0200
@@ -8,95 +8,122 @@
DIV2 :: "nat => nat"
defs
- DIV2_primdef: "DIV2 == %n. n div 2"
+ DIV2_primdef: "DIV2 == %n::nat. n div (2::nat)"
-lemma DIV2_def: "ALL n. DIV2 n = n div 2"
+lemma DIV2_def: "ALL n::nat. DIV2 n = n div (2::nat)"
by (import bits DIV2_def)
consts
TIMES_2EXP :: "nat => nat => nat"
defs
- TIMES_2EXP_primdef: "TIMES_2EXP == %x n. n * 2 ^ x"
+ TIMES_2EXP_primdef: "TIMES_2EXP == %(x::nat) n::nat. n * (2::nat) ^ x"
-lemma TIMES_2EXP_def: "ALL x n. TIMES_2EXP x n = n * 2 ^ x"
+lemma TIMES_2EXP_def: "ALL (x::nat) n::nat. TIMES_2EXP x n = n * (2::nat) ^ x"
by (import bits TIMES_2EXP_def)
consts
DIV_2EXP :: "nat => nat => nat"
defs
- DIV_2EXP_primdef: "DIV_2EXP == %x n. n div 2 ^ x"
+ DIV_2EXP_primdef: "DIV_2EXP == %(x::nat) n::nat. n div (2::nat) ^ x"
-lemma DIV_2EXP_def: "ALL x n. DIV_2EXP x n = n div 2 ^ x"
+lemma DIV_2EXP_def: "ALL (x::nat) n::nat. DIV_2EXP x n = n div (2::nat) ^ x"
by (import bits DIV_2EXP_def)
consts
MOD_2EXP :: "nat => nat => nat"
defs
- MOD_2EXP_primdef: "MOD_2EXP == %x n. n mod 2 ^ x"
+ MOD_2EXP_primdef: "MOD_2EXP == %(x::nat) n::nat. n mod (2::nat) ^ x"
-lemma MOD_2EXP_def: "ALL x n. MOD_2EXP x n = n mod 2 ^ x"
+lemma MOD_2EXP_def: "ALL (x::nat) n::nat. MOD_2EXP x n = n mod (2::nat) ^ x"
by (import bits MOD_2EXP_def)
consts
DIVMOD_2EXP :: "nat => nat => nat * nat"
defs
- DIVMOD_2EXP_primdef: "DIVMOD_2EXP == %x n. (n div 2 ^ x, n mod 2 ^ x)"
+ DIVMOD_2EXP_primdef: "DIVMOD_2EXP == %(x::nat) n::nat. (n div (2::nat) ^ x, n mod (2::nat) ^ x)"
-lemma DIVMOD_2EXP_def: "ALL x n. DIVMOD_2EXP x n = (n div 2 ^ x, n mod 2 ^ x)"
+lemma DIVMOD_2EXP_def: "ALL (x::nat) n::nat.
+ DIVMOD_2EXP x n = (n div (2::nat) ^ x, n mod (2::nat) ^ x)"
by (import bits DIVMOD_2EXP_def)
consts
SBIT :: "bool => nat => nat"
defs
- SBIT_primdef: "SBIT == %b n. if b then 2 ^ n else 0"
+ SBIT_primdef: "(op ==::(bool => nat => nat) => (bool => nat => nat) => prop)
+ (SBIT::bool => nat => nat)
+ (%(b::bool) n::nat.
+ (If::bool => nat => nat => nat) b
+ ((op ^::nat => nat => nat)
+ ((number_of::bin => nat)
+ ((op BIT::bin => bit => bin)
+ ((op BIT::bin => bit => bin) (Numeral.Pls::bin) (bit.B1::bit))
+ (bit.B0::bit)))
+ n)
+ (0::nat))"
-lemma SBIT_def: "ALL b n. SBIT b n = (if b then 2 ^ n else 0)"
+lemma SBIT_def: "(All::(bool => bool) => bool)
+ (%b::bool.
+ (All::(nat => bool) => bool)
+ (%n::nat.
+ (op =::nat => nat => bool) ((SBIT::bool => nat => nat) b n)
+ ((If::bool => nat => nat => nat) b
+ ((op ^::nat => nat => nat)
+ ((number_of::bin => nat)
+ ((op BIT::bin => bit => bin)
+ ((op BIT::bin => bit => bin) (Numeral.Pls::bin)
+ (bit.B1::bit))
+ (bit.B0::bit)))
+ n)
+ (0::nat))))"
by (import bits SBIT_def)
consts
BITS :: "nat => nat => nat => nat"
defs
- BITS_primdef: "BITS == %h l n. MOD_2EXP (Suc h - l) (DIV_2EXP l n)"
+ BITS_primdef: "BITS == %(h::nat) (l::nat) n::nat. MOD_2EXP (Suc h - l) (DIV_2EXP l n)"
-lemma BITS_def: "ALL h l n. BITS h l n = MOD_2EXP (Suc h - l) (DIV_2EXP l n)"
+lemma BITS_def: "ALL (h::nat) (l::nat) n::nat.
+ BITS h l n = MOD_2EXP (Suc h - l) (DIV_2EXP l n)"
by (import bits BITS_def)
constdefs
bit :: "nat => nat => bool"
- "bit == %b n. BITS b b n = 1"
+ "bit == %(b::nat) n::nat. BITS b b n = (1::nat)"
-lemma BIT_def: "ALL b n. bit b n = (BITS b b n = 1)"
+lemma BIT_def: "ALL (b::nat) n::nat. bit b n = (BITS b b n = (1::nat))"
by (import bits BIT_def)
consts
SLICE :: "nat => nat => nat => nat"
defs
- SLICE_primdef: "SLICE == %h l n. MOD_2EXP (Suc h) n - MOD_2EXP l n"
+ SLICE_primdef: "SLICE == %(h::nat) (l::nat) n::nat. MOD_2EXP (Suc h) n - MOD_2EXP l n"
-lemma SLICE_def: "ALL h l n. SLICE h l n = MOD_2EXP (Suc h) n - MOD_2EXP l n"
+lemma SLICE_def: "ALL (h::nat) (l::nat) n::nat.
+ SLICE h l n = MOD_2EXP (Suc h) n - MOD_2EXP l n"
by (import bits SLICE_def)
consts
LSBn :: "nat => bool"
defs
- LSBn_primdef: "LSBn == bit 0"
+ LSBn_primdef: "LSBn == bit (0::nat)"
-lemma LSBn_def: "LSBn = bit 0"
+lemma LSBn_def: "LSBn = bit (0::nat)"
by (import bits LSBn_def)
consts
BITWISE :: "nat => (bool => bool => bool) => nat => nat => nat"
-specification (BITWISE_primdef: BITWISE) BITWISE_def: "(ALL oper x y. BITWISE 0 oper x y = 0) &
-(ALL n oper x y.
+specification (BITWISE_primdef: BITWISE) BITWISE_def: "(ALL (oper::bool => bool => bool) (x::nat) y::nat.
+ BITWISE (0::nat) oper x y = (0::nat)) &
+(ALL (n::nat) (oper::bool => bool => bool) (x::nat) y::nat.
BITWISE (Suc n) oper x y =
BITWISE n oper x y + SBIT (oper (bit n x) (bit n y)) n)"
by (import bits BITWISE_def)
@@ -104,7 +131,7 @@
lemma DIV1: "ALL x::nat. x div (1::nat) = x"
by (import bits DIV1)
-lemma SUC_SUB: "Suc a - a = 1"
+lemma SUC_SUB: "Suc (a::nat) - a = (1::nat)"
by (import bits SUC_SUB)
lemma DIV_MULT_1: "ALL (r::nat) n::nat. r < n --> (n + r) div n = (1::nat)"
@@ -129,10 +156,11 @@
lemma EXP_SUB_LESS_EQ: "ALL (a::nat) b::nat. (2::nat) ^ (a - b) <= (2::nat) ^ a"
by (import bits EXP_SUB_LESS_EQ)
-lemma BITS_THM: "ALL x xa xb. BITS x xa xb = xb div 2 ^ xa mod 2 ^ (Suc x - xa)"
+lemma BITS_THM: "ALL (x::nat) (xa::nat) xb::nat.
+ BITS x xa xb = xb div (2::nat) ^ xa mod (2::nat) ^ (Suc x - xa)"
by (import bits BITS_THM)
-lemma BITSLT_THM: "ALL h l n. BITS h l n < 2 ^ (Suc h - l)"
+lemma BITSLT_THM: "ALL (h::nat) (l::nat) n::nat. BITS h l n < (2::nat) ^ (Suc h - l)"
by (import bits BITSLT_THM)
lemma DIV_MULT_LEM: "ALL (m::nat) n::nat. (0::nat) < n --> m div n * n <= m"
@@ -142,43 +170,46 @@
n mod (2::nat) ^ x = n - n div (2::nat) ^ x * (2::nat) ^ x"
by (import bits MOD_2EXP_LEM)
-lemma BITS2_THM: "ALL h l n. BITS h l n = n mod 2 ^ Suc h div 2 ^ l"
+lemma BITS2_THM: "ALL (h::nat) (l::nat) n::nat.
+ BITS h l n = n mod (2::nat) ^ Suc h div (2::nat) ^ l"
by (import bits BITS2_THM)
-lemma BITS_COMP_THM: "ALL h1 l1 h2 l2 n.
+lemma BITS_COMP_THM: "ALL (h1::nat) (l1::nat) (h2::nat) (l2::nat) n::nat.
h2 + l1 <= h1 --> BITS h2 l2 (BITS h1 l1 n) = BITS (h2 + l1) (l2 + l1) n"
by (import bits BITS_COMP_THM)
-lemma BITS_DIV_THM: "ALL h l x n. BITS h l x div 2 ^ n = BITS h (l + n) x"
+lemma BITS_DIV_THM: "ALL (h::nat) (l::nat) (x::nat) n::nat.
+ BITS h l x div (2::nat) ^ n = BITS h (l + n) x"
by (import bits BITS_DIV_THM)
-lemma BITS_LT_HIGH: "ALL h l n. n < 2 ^ Suc h --> BITS h l n = n div 2 ^ l"
+lemma BITS_LT_HIGH: "ALL (h::nat) (l::nat) n::nat.
+ n < (2::nat) ^ Suc h --> BITS h l n = n div (2::nat) ^ l"
by (import bits BITS_LT_HIGH)
-lemma BITS_ZERO: "ALL h l n. h < l --> BITS h l n = 0"
+lemma BITS_ZERO: "ALL (h::nat) (l::nat) n::nat. h < l --> BITS h l n = (0::nat)"
by (import bits BITS_ZERO)
-lemma BITS_ZERO2: "ALL h l. BITS h l 0 = 0"
+lemma BITS_ZERO2: "ALL (h::nat) l::nat. BITS h l (0::nat) = (0::nat)"
by (import bits BITS_ZERO2)
-lemma BITS_ZERO3: "ALL h x. BITS h 0 x = x mod 2 ^ Suc h"
+lemma BITS_ZERO3: "ALL (h::nat) x::nat. BITS h (0::nat) x = x mod (2::nat) ^ Suc h"
by (import bits BITS_ZERO3)
-lemma BITS_COMP_THM2: "ALL h1 l1 h2 l2 n.
+lemma BITS_COMP_THM2: "ALL (h1::nat) (l1::nat) (h2::nat) (l2::nat) n::nat.
BITS h2 l2 (BITS h1 l1 n) = BITS (min h1 (h2 + l1)) (l2 + l1) n"
by (import bits BITS_COMP_THM2)
lemma NOT_MOD2_LEM: "ALL n::nat. (n mod (2::nat) ~= (0::nat)) = (n mod (2::nat) = (1::nat))"
by (import bits NOT_MOD2_LEM)
-lemma NOT_MOD2_LEM2: "ALL (n::nat) a::'a.
+lemma NOT_MOD2_LEM2: "ALL (n::nat) a::'a::type.
(n mod (2::nat) ~= (1::nat)) = (n mod (2::nat) = (0::nat))"
by (import bits NOT_MOD2_LEM2)
-lemma EVEN_MOD2_LEM: "ALL n. EVEN n = (n mod 2 = 0)"
+lemma EVEN_MOD2_LEM: "ALL n::nat. EVEN n = (n mod (2::nat) = (0::nat))"
by (import bits EVEN_MOD2_LEM)
-lemma ODD_MOD2_LEM: "ALL n. ODD n = (n mod 2 = 1)"
+lemma ODD_MOD2_LEM: "ALL n::nat. ODD n = (n mod (2::nat) = (1::nat))"
by (import bits ODD_MOD2_LEM)
lemma LSB_ODD: "LSBn = ODD"
@@ -200,7 +231,7 @@
a div (2::nat) ^ x mod (2::nat) ^ y * (2::nat) ^ x"
by (import bits SLICE_LEM1)
-lemma SLICE_LEM2: "ALL (a::'a) (x::nat) y::nat.
+lemma SLICE_LEM2: "ALL (a::'a::type) (x::nat) y::nat.
(n::nat) mod (2::nat) ^ (x + y) =
n mod (2::nat) ^ x + n div (2::nat) ^ x mod (2::nat) ^ y * (2::nat) ^ x"
by (import bits SLICE_LEM2)
@@ -209,71 +240,77 @@
l < h --> n mod (2::nat) ^ Suc l <= n mod (2::nat) ^ h"
by (import bits SLICE_LEM3)
-lemma SLICE_THM: "ALL n h l. SLICE h l n = BITS h l n * 2 ^ l"
+lemma SLICE_THM: "ALL (n::nat) (h::nat) l::nat. SLICE h l n = BITS h l n * (2::nat) ^ l"
by (import bits SLICE_THM)
-lemma SLICELT_THM: "ALL h l n. SLICE h l n < 2 ^ Suc h"
+lemma SLICELT_THM: "ALL (h::nat) (l::nat) n::nat. SLICE h l n < (2::nat) ^ Suc h"
by (import bits SLICELT_THM)
-lemma BITS_SLICE_THM: "ALL h l n. BITS h l (SLICE h l n) = BITS h l n"
+lemma BITS_SLICE_THM: "ALL (h::nat) (l::nat) n::nat. BITS h l (SLICE h l n) = BITS h l n"
by (import bits BITS_SLICE_THM)
-lemma BITS_SLICE_THM2: "ALL h l n. h <= h2 --> BITS h2 l (SLICE h l n) = BITS h l n"
+lemma BITS_SLICE_THM2: "ALL (h::nat) (l::nat) n::nat.
+ h <= (h2::nat) --> BITS h2 l (SLICE h l n) = BITS h l n"
by (import bits BITS_SLICE_THM2)
lemma MOD_2EXP_MONO: "ALL (n::nat) (h::nat) l::nat.
l <= h --> n mod (2::nat) ^ l <= n mod (2::nat) ^ Suc h"
by (import bits MOD_2EXP_MONO)
-lemma SLICE_COMP_THM: "ALL h m l n.
+lemma SLICE_COMP_THM: "ALL (h::nat) (m::nat) (l::nat) n::nat.
Suc m <= h & l <= m --> SLICE h (Suc m) n + SLICE m l n = SLICE h l n"
by (import bits SLICE_COMP_THM)
-lemma SLICE_ZERO: "ALL h l n. h < l --> SLICE h l n = 0"
+lemma SLICE_ZERO: "ALL (h::nat) (l::nat) n::nat. h < l --> SLICE h l n = (0::nat)"
by (import bits SLICE_ZERO)
-lemma BIT_COMP_THM3: "ALL h m l n.
+lemma BIT_COMP_THM3: "ALL (h::nat) (m::nat) (l::nat) n::nat.
Suc m <= h & l <= m -->
- BITS h (Suc m) n * 2 ^ (Suc m - l) + BITS m l n = BITS h l n"
+ BITS h (Suc m) n * (2::nat) ^ (Suc m - l) + BITS m l n = BITS h l n"
by (import bits BIT_COMP_THM3)
-lemma NOT_BIT: "ALL n a. (~ bit n a) = (BITS n n a = 0)"
+lemma NOT_BIT: "ALL (n::nat) a::nat. (~ bit n a) = (BITS n n a = (0::nat))"
by (import bits NOT_BIT)
-lemma NOT_BITS: "ALL n a. (BITS n n a ~= 0) = (BITS n n a = 1)"
+lemma NOT_BITS: "ALL (n::nat) a::nat. (BITS n n a ~= (0::nat)) = (BITS n n a = (1::nat))"
by (import bits NOT_BITS)
-lemma NOT_BITS2: "ALL n a. (BITS n n a ~= 1) = (BITS n n a = 0)"
+lemma NOT_BITS2: "ALL (n::nat) a::nat. (BITS n n a ~= (1::nat)) = (BITS n n a = (0::nat))"
by (import bits NOT_BITS2)
-lemma BIT_SLICE: "ALL n a b. (bit n a = bit n b) = (SLICE n n a = SLICE n n b)"
+lemma BIT_SLICE: "ALL (n::nat) (a::nat) b::nat.
+ (bit n a = bit n b) = (SLICE n n a = SLICE n n b)"
by (import bits BIT_SLICE)
-lemma BIT_SLICE_LEM: "ALL y x n. SBIT (bit x n) (x + y) = SLICE x x n * 2 ^ y"
+lemma BIT_SLICE_LEM: "ALL (y::nat) (x::nat) n::nat.
+ SBIT (bit x n) (x + y) = SLICE x x n * (2::nat) ^ y"
by (import bits BIT_SLICE_LEM)
-lemma BIT_SLICE_THM: "ALL x xa. SBIT (bit x xa) x = SLICE x x xa"
+lemma BIT_SLICE_THM: "ALL (x::nat) xa::nat. SBIT (bit x xa) x = SLICE x x xa"
by (import bits BIT_SLICE_THM)
-lemma SBIT_DIV: "ALL b m n. n < m --> SBIT b (m - n) = SBIT b m div 2 ^ n"
+lemma SBIT_DIV: "ALL (b::bool) (m::nat) n::nat.
+ n < m --> SBIT b (m - n) = SBIT b m div (2::nat) ^ n"
by (import bits SBIT_DIV)
-lemma BITS_SUC: "ALL h l n.
+lemma BITS_SUC: "ALL (h::nat) (l::nat) n::nat.
l <= Suc h -->
SBIT (bit (Suc h) n) (Suc h - l) + BITS h l n = BITS (Suc h) l n"
by (import bits BITS_SUC)
-lemma BITS_SUC_THM: "ALL h l n.
+lemma BITS_SUC_THM: "ALL (h::nat) (l::nat) n::nat.
BITS (Suc h) l n =
- (if Suc h < l then 0 else SBIT (bit (Suc h) n) (Suc h - l) + BITS h l n)"
+ (if Suc h < l then 0::nat
+ else SBIT (bit (Suc h) n) (Suc h - l) + BITS h l n)"
by (import bits BITS_SUC_THM)
-lemma BIT_BITS_THM: "ALL h l a b.
- (ALL x. l <= x & x <= h --> bit x a = bit x b) =
+lemma BIT_BITS_THM: "ALL (h::nat) (l::nat) (a::nat) b::nat.
+ (ALL x::nat. l <= x & x <= h --> bit x a = bit x b) =
(BITS h l a = BITS h l b)"
by (import bits BIT_BITS_THM)
-lemma BITWISE_LT_2EXP: "ALL n oper a b. BITWISE n oper a b < 2 ^ n"
+lemma BITWISE_LT_2EXP: "ALL (n::nat) (oper::bool => bool => bool) (a::nat) b::nat.
+ BITWISE n oper a b < (2::nat) ^ n"
by (import bits BITWISE_LT_2EXP)
lemma LESS_EXP_MULT2: "ALL (a::nat) b::nat.
@@ -281,18 +318,20 @@
(EX x::nat. (2::nat) ^ b = (2::nat) ^ (x + (1::nat)) * (2::nat) ^ a)"
by (import bits LESS_EXP_MULT2)
-lemma BITWISE_THM: "ALL x n oper a b.
+lemma BITWISE_THM: "ALL (x::nat) (n::nat) (oper::bool => bool => bool) (a::nat) b::nat.
x < n --> bit x (BITWISE n oper a b) = oper (bit x a) (bit x b)"
by (import bits BITWISE_THM)
-lemma BITWISE_COR: "ALL x n oper a b.
+lemma BITWISE_COR: "ALL (x::nat) (n::nat) (oper::bool => bool => bool) (a::nat) b::nat.
x < n -->
- oper (bit x a) (bit x b) --> BITWISE n oper a b div 2 ^ x mod 2 = 1"
+ oper (bit x a) (bit x b) -->
+ BITWISE n oper a b div (2::nat) ^ x mod (2::nat) = (1::nat)"
by (import bits BITWISE_COR)
-lemma BITWISE_NOT_COR: "ALL x n oper a b.
+lemma BITWISE_NOT_COR: "ALL (x::nat) (n::nat) (oper::bool => bool => bool) (a::nat) b::nat.
x < n -->
- ~ oper (bit x a) (bit x b) --> BITWISE n oper a b div 2 ^ x mod 2 = 0"
+ ~ oper (bit x a) (bit x b) -->
+ BITWISE n oper a b div (2::nat) ^ x mod (2::nat) = (0::nat)"
by (import bits BITWISE_NOT_COR)
lemma MOD_PLUS_RIGHT: "ALL n>0::nat. ALL (j::nat) k::nat. (j + k mod n) mod n = (j + k) mod n"
@@ -340,125 +379,131 @@
MODw :: "nat => nat"
defs
- MODw_primdef: "MODw == %n. n mod 2 ^ WL"
+ MODw_primdef: "MODw == %n::nat. n mod (2::nat) ^ WL"
-lemma MODw_def: "ALL n. MODw n = n mod 2 ^ WL"
+lemma MODw_def: "ALL n::nat. MODw n = n mod (2::nat) ^ WL"
by (import word32 MODw_def)
consts
INw :: "nat => bool"
defs
- INw_primdef: "INw == %n. n < 2 ^ WL"
+ INw_primdef: "INw == %n::nat. n < (2::nat) ^ WL"
-lemma INw_def: "ALL n. INw n = (n < 2 ^ WL)"
+lemma INw_def: "ALL n::nat. INw n = (n < (2::nat) ^ WL)"
by (import word32 INw_def)
consts
EQUIV :: "nat => nat => bool"
defs
- EQUIV_primdef: "EQUIV == %x y. MODw x = MODw y"
+ EQUIV_primdef: "EQUIV == %(x::nat) y::nat. MODw x = MODw y"
-lemma EQUIV_def: "ALL x y. EQUIV x y = (MODw x = MODw y)"
+lemma EQUIV_def: "ALL (x::nat) y::nat. EQUIV x y = (MODw x = MODw y)"
by (import word32 EQUIV_def)
-lemma EQUIV_QT: "ALL x y. EQUIV x y = (EQUIV x = EQUIV y)"
+lemma EQUIV_QT: "ALL (x::nat) y::nat. EQUIV x y = (EQUIV x = EQUIV y)"
by (import word32 EQUIV_QT)
-lemma FUNPOW_THM: "ALL f n x. (f ^ n) (f x) = f ((f ^ n) x)"
+lemma FUNPOW_THM: "ALL (f::'a::type => 'a::type) (n::nat) x::'a::type.
+ (f ^ n) (f x) = f ((f ^ n) x)"
by (import word32 FUNPOW_THM)
-lemma FUNPOW_THM2: "ALL f n x. (f ^ Suc n) x = f ((f ^ n) x)"
+lemma FUNPOW_THM2: "ALL (f::'a::type => 'a::type) (n::nat) x::'a::type.
+ (f ^ Suc n) x = f ((f ^ n) x)"
by (import word32 FUNPOW_THM2)
-lemma FUNPOW_COMP: "ALL f m n a. (f ^ m) ((f ^ n) a) = (f ^ (m + n)) a"
+lemma FUNPOW_COMP: "ALL (f::'a::type => 'a::type) (m::nat) (n::nat) a::'a::type.
+ (f ^ m) ((f ^ n) a) = (f ^ (m + n)) a"
by (import word32 FUNPOW_COMP)
-lemma INw_MODw: "ALL n. INw (MODw n)"
+lemma INw_MODw: "ALL n::nat. INw (MODw n)"
by (import word32 INw_MODw)
-lemma TOw_IDEM: "ALL a. INw a --> MODw a = a"
+lemma TOw_IDEM: "ALL a::nat. INw a --> MODw a = a"
by (import word32 TOw_IDEM)
-lemma MODw_IDEM2: "ALL a. MODw (MODw a) = MODw a"
+lemma MODw_IDEM2: "ALL a::nat. MODw (MODw a) = MODw a"
by (import word32 MODw_IDEM2)
-lemma TOw_QT: "ALL a. EQUIV (MODw a) a"
+lemma TOw_QT: "ALL a::nat. EQUIV (MODw a) a"
by (import word32 TOw_QT)
-lemma MODw_THM: "MODw = BITS HB 0"
+lemma MODw_THM: "MODw = BITS HB (0::nat)"
by (import word32 MODw_THM)
-lemma MOD_ADD: "ALL a b. MODw (a + b) = MODw (MODw a + MODw b)"
+lemma MOD_ADD: "ALL (a::nat) b::nat. MODw (a + b) = MODw (MODw a + MODw b)"
by (import word32 MOD_ADD)
-lemma MODw_MULT: "ALL a b. MODw (a * b) = MODw (MODw a * MODw b)"
+lemma MODw_MULT: "ALL (a::nat) b::nat. MODw (a * b) = MODw (MODw a * MODw b)"
by (import word32 MODw_MULT)
consts
AONE :: "nat"
defs
- AONE_primdef: "AONE == 1"
+ AONE_primdef: "AONE == 1::nat"
-lemma AONE_def: "AONE = 1"
+lemma AONE_def: "AONE = (1::nat)"
by (import word32 AONE_def)
-lemma ADD_QT: "(ALL n. EQUIV (0 + n) n) & (ALL m n. EQUIV (Suc m + n) (Suc (m + n)))"
+lemma ADD_QT: "(ALL n::nat. EQUIV ((0::nat) + n) n) &
+(ALL (m::nat) n::nat. EQUIV (Suc m + n) (Suc (m + n)))"
by (import word32 ADD_QT)
-lemma ADD_0_QT: "ALL a. EQUIV (a + 0) a"
+lemma ADD_0_QT: "ALL a::nat. EQUIV (a + (0::nat)) a"
by (import word32 ADD_0_QT)
-lemma ADD_COMM_QT: "ALL a b. EQUIV (a + b) (b + a)"
+lemma ADD_COMM_QT: "ALL (a::nat) b::nat. EQUIV (a + b) (b + a)"
by (import word32 ADD_COMM_QT)
-lemma ADD_ASSOC_QT: "ALL a b c. EQUIV (a + (b + c)) (a + b + c)"
+lemma ADD_ASSOC_QT: "ALL (a::nat) (b::nat) c::nat. EQUIV (a + (b + c)) (a + b + c)"
by (import word32 ADD_ASSOC_QT)
-lemma MULT_QT: "(ALL n. EQUIV (0 * n) 0) & (ALL m n. EQUIV (Suc m * n) (m * n + n))"
+lemma MULT_QT: "(ALL n::nat. EQUIV ((0::nat) * n) (0::nat)) &
+(ALL (m::nat) n::nat. EQUIV (Suc m * n) (m * n + n))"
by (import word32 MULT_QT)
-lemma ADD1_QT: "ALL m. EQUIV (Suc m) (m + AONE)"
+lemma ADD1_QT: "ALL m::nat. EQUIV (Suc m) (m + AONE)"
by (import word32 ADD1_QT)
-lemma ADD_CLAUSES_QT: "(ALL m. EQUIV (0 + m) m) &
-(ALL m. EQUIV (m + 0) m) &
-(ALL m n. EQUIV (Suc m + n) (Suc (m + n))) &
-(ALL m n. EQUIV (m + Suc n) (Suc (m + n)))"
+lemma ADD_CLAUSES_QT: "(ALL m::nat. EQUIV ((0::nat) + m) m) &
+(ALL m::nat. EQUIV (m + (0::nat)) m) &
+(ALL (m::nat) n::nat. EQUIV (Suc m + n) (Suc (m + n))) &
+(ALL (m::nat) n::nat. EQUIV (m + Suc n) (Suc (m + n)))"
by (import word32 ADD_CLAUSES_QT)
-lemma SUC_EQUIV_COMP: "ALL a b. EQUIV (Suc a) b --> EQUIV a (b + (2 ^ WL - 1))"
+lemma SUC_EQUIV_COMP: "ALL (a::nat) b::nat.
+ EQUIV (Suc a) b --> EQUIV a (b + ((2::nat) ^ WL - (1::nat)))"
by (import word32 SUC_EQUIV_COMP)
-lemma INV_SUC_EQ_QT: "ALL m n. EQUIV (Suc m) (Suc n) = EQUIV m n"
+lemma INV_SUC_EQ_QT: "ALL (m::nat) n::nat. EQUIV (Suc m) (Suc n) = EQUIV m n"
by (import word32 INV_SUC_EQ_QT)
-lemma ADD_INV_0_QT: "ALL m n. EQUIV (m + n) m --> EQUIV n 0"
+lemma ADD_INV_0_QT: "ALL (m::nat) n::nat. EQUIV (m + n) m --> EQUIV n (0::nat)"
by (import word32 ADD_INV_0_QT)
-lemma ADD_INV_0_EQ_QT: "ALL m n. EQUIV (m + n) m = EQUIV n 0"
+lemma ADD_INV_0_EQ_QT: "ALL (m::nat) n::nat. EQUIV (m + n) m = EQUIV n (0::nat)"
by (import word32 ADD_INV_0_EQ_QT)
-lemma EQ_ADD_LCANCEL_QT: "ALL m n p. EQUIV (m + n) (m + p) = EQUIV n p"
+lemma EQ_ADD_LCANCEL_QT: "ALL (m::nat) (n::nat) p::nat. EQUIV (m + n) (m + p) = EQUIV n p"
by (import word32 EQ_ADD_LCANCEL_QT)
-lemma EQ_ADD_RCANCEL_QT: "ALL x xa xb. EQUIV (x + xb) (xa + xb) = EQUIV x xa"
+lemma EQ_ADD_RCANCEL_QT: "ALL (x::nat) (xa::nat) xb::nat. EQUIV (x + xb) (xa + xb) = EQUIV x xa"
by (import word32 EQ_ADD_RCANCEL_QT)
-lemma LEFT_ADD_DISTRIB_QT: "ALL m n p. EQUIV (p * (m + n)) (p * m + p * n)"
+lemma LEFT_ADD_DISTRIB_QT: "ALL (m::nat) (n::nat) p::nat. EQUIV (p * (m + n)) (p * m + p * n)"
by (import word32 LEFT_ADD_DISTRIB_QT)
-lemma MULT_ASSOC_QT: "ALL m n p. EQUIV (m * (n * p)) (m * n * p)"
+lemma MULT_ASSOC_QT: "ALL (m::nat) (n::nat) p::nat. EQUIV (m * (n * p)) (m * n * p)"
by (import word32 MULT_ASSOC_QT)
-lemma MULT_COMM_QT: "ALL m n. EQUIV (m * n) (n * m)"
+lemma MULT_COMM_QT: "ALL (m::nat) n::nat. EQUIV (m * n) (n * m)"
by (import word32 MULT_COMM_QT)
-lemma MULT_CLAUSES_QT: "ALL m n.
- EQUIV (0 * m) 0 &
- EQUIV (m * 0) 0 &
+lemma MULT_CLAUSES_QT: "ALL (m::nat) n::nat.
+ EQUIV ((0::nat) * m) (0::nat) &
+ EQUIV (m * (0::nat)) (0::nat) &
EQUIV (AONE * m) m &
EQUIV (m * AONE) m &
EQUIV (Suc m * n) (m * n + n) & EQUIV (m * Suc n) (m + m * n)"
@@ -477,24 +522,24 @@
ONE_COMP :: "nat => nat"
defs
- ONE_COMP_primdef: "ONE_COMP == %x. 2 ^ WL - 1 - MODw x"
+ ONE_COMP_primdef: "ONE_COMP == %x::nat. (2::nat) ^ WL - (1::nat) - MODw x"
-lemma ONE_COMP_def: "ALL x. ONE_COMP x = 2 ^ WL - 1 - MODw x"
+lemma ONE_COMP_def: "ALL x::nat. ONE_COMP x = (2::nat) ^ WL - (1::nat) - MODw x"
by (import word32 ONE_COMP_def)
consts
TWO_COMP :: "nat => nat"
defs
- TWO_COMP_primdef: "TWO_COMP == %x. 2 ^ WL - MODw x"
+ TWO_COMP_primdef: "TWO_COMP == %x::nat. (2::nat) ^ WL - MODw x"
-lemma TWO_COMP_def: "ALL x. TWO_COMP x = 2 ^ WL - MODw x"
+lemma TWO_COMP_def: "ALL x::nat. TWO_COMP x = (2::nat) ^ WL - MODw x"
by (import word32 TWO_COMP_def)
-lemma ADD_TWO_COMP_QT: "ALL a. EQUIV (MODw a + TWO_COMP a) 0"
+lemma ADD_TWO_COMP_QT: "ALL a::nat. EQUIV (MODw a + TWO_COMP a) (0::nat)"
by (import word32 ADD_TWO_COMP_QT)
-lemma TWO_COMP_ONE_COMP_QT: "ALL a. EQUIV (TWO_COMP a) (ONE_COMP a + AONE)"
+lemma TWO_COMP_ONE_COMP_QT: "ALL a::nat. EQUIV (TWO_COMP a) (ONE_COMP a + AONE)"
by (import word32 TWO_COMP_ONE_COMP_QT)
lemma BIT_EQUIV_THM: "(All::(nat => bool) => bool)
@@ -512,13 +557,14 @@
((EQUIV::nat => nat => bool) x xa)))"
by (import word32 BIT_EQUIV_THM)
-lemma BITS_SUC2: "ALL n a. BITS (Suc n) 0 a = SLICE (Suc n) (Suc n) a + BITS n 0 a"
+lemma BITS_SUC2: "ALL (n::nat) a::nat.
+ BITS (Suc n) (0::nat) a = SLICE (Suc n) (Suc n) a + BITS n (0::nat) a"
by (import word32 BITS_SUC2)
-lemma BITWISE_ONE_COMP_THM: "ALL a b. BITWISE WL (%x y. ~ x) a b = ONE_COMP a"
+lemma BITWISE_ONE_COMP_THM: "ALL (a::nat) b::nat. BITWISE WL (%(x::bool) y::bool. ~ x) a b = ONE_COMP a"
by (import word32 BITWISE_ONE_COMP_THM)
-lemma ONE_COMP_THM: "ALL x xa. xa < WL --> bit xa (ONE_COMP x) = (~ bit xa x)"
+lemma ONE_COMP_THM: "ALL (x::nat) xa::nat. xa < WL --> bit xa (ONE_COMP x) = (~ bit xa x)"
by (import word32 ONE_COMP_THM)
consts
@@ -543,18 +589,18 @@
EOR :: "nat => nat => nat"
defs
- EOR_primdef: "EOR == BITWISE WL (%x y. x ~= y)"
+ EOR_primdef: "EOR == BITWISE WL (%(x::bool) y::bool. x ~= y)"
-lemma EOR_def: "EOR = BITWISE WL (%x y. x ~= y)"
+lemma EOR_def: "EOR = BITWISE WL (%(x::bool) y::bool. x ~= y)"
by (import word32 EOR_def)
consts
COMP0 :: "nat"
defs
- COMP0_primdef: "COMP0 == ONE_COMP 0"
+ COMP0_primdef: "COMP0 == ONE_COMP (0::nat)"
-lemma COMP0_def: "COMP0 = ONE_COMP 0"
+lemma COMP0_def: "COMP0 = ONE_COMP (0::nat)"
by (import word32 COMP0_def)
lemma BITWISE_THM2: "(All::(nat => bool) => bool)
@@ -582,149 +628,154 @@
y)))))"
by (import word32 BITWISE_THM2)
-lemma OR_ASSOC_QT: "ALL a b c. EQUIV (OR a (OR b c)) (OR (OR a b) c)"
+lemma OR_ASSOC_QT: "ALL (a::nat) (b::nat) c::nat. EQUIV (OR a (OR b c)) (OR (OR a b) c)"
by (import word32 OR_ASSOC_QT)
-lemma OR_COMM_QT: "ALL a b. EQUIV (OR a b) (OR b a)"
+lemma OR_COMM_QT: "ALL (a::nat) b::nat. EQUIV (OR a b) (OR b a)"
by (import word32 OR_COMM_QT)
-lemma OR_ABSORB_QT: "ALL a b. EQUIV (AND a (OR a b)) a"
+lemma OR_ABSORB_QT: "ALL (a::nat) b::nat. EQUIV (AND a (OR a b)) a"
by (import word32 OR_ABSORB_QT)
-lemma OR_IDEM_QT: "ALL a. EQUIV (OR a a) a"
+lemma OR_IDEM_QT: "ALL a::nat. EQUIV (OR a a) a"
by (import word32 OR_IDEM_QT)
-lemma AND_ASSOC_QT: "ALL a b c. EQUIV (AND a (AND b c)) (AND (AND a b) c)"
+lemma AND_ASSOC_QT: "ALL (a::nat) (b::nat) c::nat. EQUIV (AND a (AND b c)) (AND (AND a b) c)"
by (import word32 AND_ASSOC_QT)
-lemma AND_COMM_QT: "ALL a b. EQUIV (AND a b) (AND b a)"
+lemma AND_COMM_QT: "ALL (a::nat) b::nat. EQUIV (AND a b) (AND b a)"
by (import word32 AND_COMM_QT)
-lemma AND_ABSORB_QT: "ALL a b. EQUIV (OR a (AND a b)) a"
+lemma AND_ABSORB_QT: "ALL (a::nat) b::nat. EQUIV (OR a (AND a b)) a"
by (import word32 AND_ABSORB_QT)
-lemma AND_IDEM_QT: "ALL a. EQUIV (AND a a) a"
+lemma AND_IDEM_QT: "ALL a::nat. EQUIV (AND a a) a"
by (import word32 AND_IDEM_QT)
-lemma OR_COMP_QT: "ALL a. EQUIV (OR a (ONE_COMP a)) COMP0"
+lemma OR_COMP_QT: "ALL a::nat. EQUIV (OR a (ONE_COMP a)) COMP0"
by (import word32 OR_COMP_QT)
-lemma AND_COMP_QT: "ALL a. EQUIV (AND a (ONE_COMP a)) 0"
+lemma AND_COMP_QT: "ALL a::nat. EQUIV (AND a (ONE_COMP a)) (0::nat)"
by (import word32 AND_COMP_QT)
-lemma ONE_COMP_QT: "ALL a. EQUIV (ONE_COMP (ONE_COMP a)) a"
+lemma ONE_COMP_QT: "ALL a::nat. EQUIV (ONE_COMP (ONE_COMP a)) a"
by (import word32 ONE_COMP_QT)
-lemma RIGHT_AND_OVER_OR_QT: "ALL a b c. EQUIV (AND (OR a b) c) (OR (AND a c) (AND b c))"
+lemma RIGHT_AND_OVER_OR_QT: "ALL (a::nat) (b::nat) c::nat.
+ EQUIV (AND (OR a b) c) (OR (AND a c) (AND b c))"
by (import word32 RIGHT_AND_OVER_OR_QT)
-lemma RIGHT_OR_OVER_AND_QT: "ALL a b c. EQUIV (OR (AND a b) c) (AND (OR a c) (OR b c))"
+lemma RIGHT_OR_OVER_AND_QT: "ALL (a::nat) (b::nat) c::nat. EQUIV (OR (AND a b) c) (AND (OR a c) (OR b c))"
by (import word32 RIGHT_OR_OVER_AND_QT)
-lemma DE_MORGAN_THM_QT: "ALL a b.
+lemma DE_MORGAN_THM_QT: "ALL (a::nat) b::nat.
EQUIV (ONE_COMP (AND a b)) (OR (ONE_COMP a) (ONE_COMP b)) &
EQUIV (ONE_COMP (OR a b)) (AND (ONE_COMP a) (ONE_COMP b))"
by (import word32 DE_MORGAN_THM_QT)
-lemma BIT_EQUIV: "ALL n a b. n < WL --> EQUIV a b --> bit n a = bit n b"
+lemma BIT_EQUIV: "ALL (n::nat) (a::nat) b::nat. n < WL --> EQUIV a b --> bit n a = bit n b"
by (import word32 BIT_EQUIV)
-lemma LSB_WELLDEF: "ALL a b. EQUIV a b --> LSBn a = LSBn b"
+lemma LSB_WELLDEF: "ALL (a::nat) b::nat. EQUIV a b --> LSBn a = LSBn b"
by (import word32 LSB_WELLDEF)
-lemma MSB_WELLDEF: "ALL a b. EQUIV a b --> MSBn a = MSBn b"
+lemma MSB_WELLDEF: "ALL (a::nat) b::nat. EQUIV a b --> MSBn a = MSBn b"
by (import word32 MSB_WELLDEF)
-lemma BITWISE_ISTEP: "ALL n oper a b.
- 0 < n -->
- BITWISE n oper (a div 2) (b div 2) =
- BITWISE n oper a b div 2 + SBIT (oper (bit n a) (bit n b)) (n - 1)"
+lemma BITWISE_ISTEP: "ALL (n::nat) (oper::bool => bool => bool) (a::nat) b::nat.
+ (0::nat) < n -->
+ BITWISE n oper (a div (2::nat)) (b div (2::nat)) =
+ BITWISE n oper a b div (2::nat) +
+ SBIT (oper (bit n a) (bit n b)) (n - (1::nat))"
by (import word32 BITWISE_ISTEP)
-lemma BITWISE_EVAL: "ALL n oper a b.
+lemma BITWISE_EVAL: "ALL (n::nat) (oper::bool => bool => bool) (a::nat) b::nat.
BITWISE (Suc n) oper a b =
- 2 * BITWISE n oper (a div 2) (b div 2) + SBIT (oper (LSBn a) (LSBn b)) 0"
+ (2::nat) * BITWISE n oper (a div (2::nat)) (b div (2::nat)) +
+ SBIT (oper (LSBn a) (LSBn b)) (0::nat)"
by (import word32 BITWISE_EVAL)
-lemma BITWISE_WELLDEF: "ALL n oper a b c d.
+lemma BITWISE_WELLDEF: "ALL (n::nat) (oper::bool => bool => bool) (a::nat) (b::nat) (c::nat) d::nat.
EQUIV a b & EQUIV c d --> EQUIV (BITWISE n oper a c) (BITWISE n oper b d)"
by (import word32 BITWISE_WELLDEF)
-lemma BITWISEw_WELLDEF: "ALL oper a b c d.
+lemma BITWISEw_WELLDEF: "ALL (oper::bool => bool => bool) (a::nat) (b::nat) (c::nat) d::nat.
EQUIV a b & EQUIV c d -->
EQUIV (BITWISE WL oper a c) (BITWISE WL oper b d)"
by (import word32 BITWISEw_WELLDEF)
-lemma SUC_WELLDEF: "ALL a b. EQUIV a b --> EQUIV (Suc a) (Suc b)"
+lemma SUC_WELLDEF: "ALL (a::nat) b::nat. EQUIV a b --> EQUIV (Suc a) (Suc b)"
by (import word32 SUC_WELLDEF)
-lemma ADD_WELLDEF: "ALL a b c d. EQUIV a b & EQUIV c d --> EQUIV (a + c) (b + d)"
+lemma ADD_WELLDEF: "ALL (a::nat) (b::nat) (c::nat) d::nat.
+ EQUIV a b & EQUIV c d --> EQUIV (a + c) (b + d)"
by (import word32 ADD_WELLDEF)
-lemma MUL_WELLDEF: "ALL a b c d. EQUIV a b & EQUIV c d --> EQUIV (a * c) (b * d)"
+lemma MUL_WELLDEF: "ALL (a::nat) (b::nat) (c::nat) d::nat.
+ EQUIV a b & EQUIV c d --> EQUIV (a * c) (b * d)"
by (import word32 MUL_WELLDEF)
-lemma ONE_COMP_WELLDEF: "ALL a b. EQUIV a b --> EQUIV (ONE_COMP a) (ONE_COMP b)"
+lemma ONE_COMP_WELLDEF: "ALL (a::nat) b::nat. EQUIV a b --> EQUIV (ONE_COMP a) (ONE_COMP b)"
by (import word32 ONE_COMP_WELLDEF)
-lemma TWO_COMP_WELLDEF: "ALL a b. EQUIV a b --> EQUIV (TWO_COMP a) (TWO_COMP b)"
+lemma TWO_COMP_WELLDEF: "ALL (a::nat) b::nat. EQUIV a b --> EQUIV (TWO_COMP a) (TWO_COMP b)"
by (import word32 TWO_COMP_WELLDEF)
-lemma TOw_WELLDEF: "ALL a b. EQUIV a b --> EQUIV (MODw a) (MODw b)"
+lemma TOw_WELLDEF: "ALL (a::nat) b::nat. EQUIV a b --> EQUIV (MODw a) (MODw b)"
by (import word32 TOw_WELLDEF)
consts
LSR_ONE :: "nat => nat"
defs
- LSR_ONE_primdef: "LSR_ONE == %a. MODw a div 2"
+ LSR_ONE_primdef: "LSR_ONE == %a::nat. MODw a div (2::nat)"
-lemma LSR_ONE_def: "ALL a. LSR_ONE a = MODw a div 2"
+lemma LSR_ONE_def: "ALL a::nat. LSR_ONE a = MODw a div (2::nat)"
by (import word32 LSR_ONE_def)
consts
ASR_ONE :: "nat => nat"
defs
- ASR_ONE_primdef: "ASR_ONE == %a. LSR_ONE a + SBIT (MSBn a) HB"
+ ASR_ONE_primdef: "ASR_ONE == %a::nat. LSR_ONE a + SBIT (MSBn a) HB"
-lemma ASR_ONE_def: "ALL a. ASR_ONE a = LSR_ONE a + SBIT (MSBn a) HB"
+lemma ASR_ONE_def: "ALL a::nat. ASR_ONE a = LSR_ONE a + SBIT (MSBn a) HB"
by (import word32 ASR_ONE_def)
consts
ROR_ONE :: "nat => nat"
defs
- ROR_ONE_primdef: "ROR_ONE == %a. LSR_ONE a + SBIT (LSBn a) HB"
+ ROR_ONE_primdef: "ROR_ONE == %a::nat. LSR_ONE a + SBIT (LSBn a) HB"
-lemma ROR_ONE_def: "ALL a. ROR_ONE a = LSR_ONE a + SBIT (LSBn a) HB"
+lemma ROR_ONE_def: "ALL a::nat. ROR_ONE a = LSR_ONE a + SBIT (LSBn a) HB"
by (import word32 ROR_ONE_def)
consts
RRXn :: "bool => nat => nat"
defs
- RRXn_primdef: "RRXn == %c a. LSR_ONE a + SBIT c HB"
+ RRXn_primdef: "RRXn == %(c::bool) a::nat. LSR_ONE a + SBIT c HB"
-lemma RRXn_def: "ALL c a. RRXn c a = LSR_ONE a + SBIT c HB"
+lemma RRXn_def: "ALL (c::bool) a::nat. RRXn c a = LSR_ONE a + SBIT c HB"
by (import word32 RRXn_def)
-lemma LSR_ONE_WELLDEF: "ALL a b. EQUIV a b --> EQUIV (LSR_ONE a) (LSR_ONE b)"
+lemma LSR_ONE_WELLDEF: "ALL (a::nat) b::nat. EQUIV a b --> EQUIV (LSR_ONE a) (LSR_ONE b)"
by (import word32 LSR_ONE_WELLDEF)
-lemma ASR_ONE_WELLDEF: "ALL a b. EQUIV a b --> EQUIV (ASR_ONE a) (ASR_ONE b)"
+lemma ASR_ONE_WELLDEF: "ALL (a::nat) b::nat. EQUIV a b --> EQUIV (ASR_ONE a) (ASR_ONE b)"
by (import word32 ASR_ONE_WELLDEF)
-lemma ROR_ONE_WELLDEF: "ALL a b. EQUIV a b --> EQUIV (ROR_ONE a) (ROR_ONE b)"
+lemma ROR_ONE_WELLDEF: "ALL (a::nat) b::nat. EQUIV a b --> EQUIV (ROR_ONE a) (ROR_ONE b)"
by (import word32 ROR_ONE_WELLDEF)
-lemma RRX_WELLDEF: "ALL a b c. EQUIV a b --> EQUIV (RRXn c a) (RRXn c b)"
+lemma RRX_WELLDEF: "ALL (a::nat) (b::nat) c::bool. EQUIV a b --> EQUIV (RRXn c a) (RRXn c b)"
by (import word32 RRX_WELLDEF)
-lemma LSR_ONE: "LSR_ONE = BITS HB 1"
+lemma LSR_ONE: "LSR_ONE = BITS HB (1::nat)"
by (import word32 LSR_ONE)
-typedef (open) word32 = "{x. EX xa. x = EQUIV xa}"
+typedef (open) word32 = "{x::nat => bool. EX xa::nat. x = EQUIV xa}"
by (rule typedef_helper,import word32 word32_TY_DEF)
lemmas word32_TY_DEF = typedef_hol2hol4 [OF type_definition_word32]
@@ -733,17 +784,18 @@
mk_word32 :: "(nat => bool) => word32"
dest_word32 :: "word32 => nat => bool"
-specification (dest_word32 mk_word32) word32_tybij: "(ALL a. mk_word32 (dest_word32 a) = a) &
-(ALL r. (EX x. r = EQUIV x) = (dest_word32 (mk_word32 r) = r))"
+specification (dest_word32 mk_word32) word32_tybij: "(ALL a::word32. mk_word32 (dest_word32 a) = a) &
+(ALL r::nat => bool.
+ (EX x::nat. r = EQUIV x) = (dest_word32 (mk_word32 r) = r))"
by (import word32 word32_tybij)
consts
w_0 :: "word32"
defs
- w_0_primdef: "w_0 == mk_word32 (EQUIV 0)"
+ w_0_primdef: "w_0 == mk_word32 (EQUIV (0::nat))"
-lemma w_0_def: "w_0 = mk_word32 (EQUIV 0)"
+lemma w_0_def: "w_0 = mk_word32 (EQUIV (0::nat))"
by (import word32 w_0_def)
consts
@@ -766,17 +818,18 @@
constdefs
word_suc :: "word32 => word32"
- "word_suc == %T1. mk_word32 (EQUIV (Suc (Eps (dest_word32 T1))))"
+ "word_suc == %T1::word32. mk_word32 (EQUIV (Suc (Eps (dest_word32 T1))))"
-lemma word_suc: "ALL T1. word_suc T1 = mk_word32 (EQUIV (Suc (Eps (dest_word32 T1))))"
+lemma word_suc: "ALL T1::word32. word_suc T1 = mk_word32 (EQUIV (Suc (Eps (dest_word32 T1))))"
by (import word32 word_suc)
constdefs
word_add :: "word32 => word32 => word32"
"word_add ==
-%T1 T2. mk_word32 (EQUIV (Eps (dest_word32 T1) + Eps (dest_word32 T2)))"
+%(T1::word32) T2::word32.
+ mk_word32 (EQUIV (Eps (dest_word32 T1) + Eps (dest_word32 T2)))"
-lemma word_add: "ALL T1 T2.
+lemma word_add: "ALL (T1::word32) T2::word32.
word_add T1 T2 =
mk_word32 (EQUIV (Eps (dest_word32 T1) + Eps (dest_word32 T2)))"
by (import word32 word_add)
@@ -784,81 +837,92 @@
constdefs
word_mul :: "word32 => word32 => word32"
"word_mul ==
-%T1 T2. mk_word32 (EQUIV (Eps (dest_word32 T1) * Eps (dest_word32 T2)))"
+%(T1::word32) T2::word32.
+ mk_word32 (EQUIV (Eps (dest_word32 T1) * Eps (dest_word32 T2)))"
-lemma word_mul: "ALL T1 T2.
+lemma word_mul: "ALL (T1::word32) T2::word32.
word_mul T1 T2 =
mk_word32 (EQUIV (Eps (dest_word32 T1) * Eps (dest_word32 T2)))"
by (import word32 word_mul)
constdefs
word_1comp :: "word32 => word32"
- "word_1comp == %T1. mk_word32 (EQUIV (ONE_COMP (Eps (dest_word32 T1))))"
+ "word_1comp ==
+%T1::word32. mk_word32 (EQUIV (ONE_COMP (Eps (dest_word32 T1))))"
-lemma word_1comp: "ALL T1. word_1comp T1 = mk_word32 (EQUIV (ONE_COMP (Eps (dest_word32 T1))))"
+lemma word_1comp: "ALL T1::word32.
+ word_1comp T1 = mk_word32 (EQUIV (ONE_COMP (Eps (dest_word32 T1))))"
by (import word32 word_1comp)
constdefs
word_2comp :: "word32 => word32"
- "word_2comp == %T1. mk_word32 (EQUIV (TWO_COMP (Eps (dest_word32 T1))))"
+ "word_2comp ==
+%T1::word32. mk_word32 (EQUIV (TWO_COMP (Eps (dest_word32 T1))))"
-lemma word_2comp: "ALL T1. word_2comp T1 = mk_word32 (EQUIV (TWO_COMP (Eps (dest_word32 T1))))"
+lemma word_2comp: "ALL T1::word32.
+ word_2comp T1 = mk_word32 (EQUIV (TWO_COMP (Eps (dest_word32 T1))))"
by (import word32 word_2comp)
constdefs
word_lsr1 :: "word32 => word32"
- "word_lsr1 == %T1. mk_word32 (EQUIV (LSR_ONE (Eps (dest_word32 T1))))"
+ "word_lsr1 == %T1::word32. mk_word32 (EQUIV (LSR_ONE (Eps (dest_word32 T1))))"
-lemma word_lsr1: "ALL T1. word_lsr1 T1 = mk_word32 (EQUIV (LSR_ONE (Eps (dest_word32 T1))))"
+lemma word_lsr1: "ALL T1::word32.
+ word_lsr1 T1 = mk_word32 (EQUIV (LSR_ONE (Eps (dest_word32 T1))))"
by (import word32 word_lsr1)
constdefs
word_asr1 :: "word32 => word32"
- "word_asr1 == %T1. mk_word32 (EQUIV (ASR_ONE (Eps (dest_word32 T1))))"
+ "word_asr1 == %T1::word32. mk_word32 (EQUIV (ASR_ONE (Eps (dest_word32 T1))))"
-lemma word_asr1: "ALL T1. word_asr1 T1 = mk_word32 (EQUIV (ASR_ONE (Eps (dest_word32 T1))))"
+lemma word_asr1: "ALL T1::word32.
+ word_asr1 T1 = mk_word32 (EQUIV (ASR_ONE (Eps (dest_word32 T1))))"
by (import word32 word_asr1)
constdefs
word_ror1 :: "word32 => word32"
- "word_ror1 == %T1. mk_word32 (EQUIV (ROR_ONE (Eps (dest_word32 T1))))"
+ "word_ror1 == %T1::word32. mk_word32 (EQUIV (ROR_ONE (Eps (dest_word32 T1))))"
-lemma word_ror1: "ALL T1. word_ror1 T1 = mk_word32 (EQUIV (ROR_ONE (Eps (dest_word32 T1))))"
+lemma word_ror1: "ALL T1::word32.
+ word_ror1 T1 = mk_word32 (EQUIV (ROR_ONE (Eps (dest_word32 T1))))"
by (import word32 word_ror1)
consts
RRX :: "bool => word32 => word32"
defs
- RRX_primdef: "RRX == %T1 T2. mk_word32 (EQUIV (RRXn T1 (Eps (dest_word32 T2))))"
+ RRX_primdef: "RRX ==
+%(T1::bool) T2::word32. mk_word32 (EQUIV (RRXn T1 (Eps (dest_word32 T2))))"
-lemma RRX_def: "ALL T1 T2. RRX T1 T2 = mk_word32 (EQUIV (RRXn T1 (Eps (dest_word32 T2))))"
+lemma RRX_def: "ALL (T1::bool) T2::word32.
+ RRX T1 T2 = mk_word32 (EQUIV (RRXn T1 (Eps (dest_word32 T2))))"
by (import word32 RRX_def)
consts
LSB :: "word32 => bool"
defs
- LSB_primdef: "LSB == %T1. LSBn (Eps (dest_word32 T1))"
+ LSB_primdef: "LSB == %T1::word32. LSBn (Eps (dest_word32 T1))"
-lemma LSB_def: "ALL T1. LSB T1 = LSBn (Eps (dest_word32 T1))"
+lemma LSB_def: "ALL T1::word32. LSB T1 = LSBn (Eps (dest_word32 T1))"
by (import word32 LSB_def)
consts
MSB :: "word32 => bool"
defs
- MSB_primdef: "MSB == %T1. MSBn (Eps (dest_word32 T1))"
+ MSB_primdef: "MSB == %T1::word32. MSBn (Eps (dest_word32 T1))"
-lemma MSB_def: "ALL T1. MSB T1 = MSBn (Eps (dest_word32 T1))"
+lemma MSB_def: "ALL T1::word32. MSB T1 = MSBn (Eps (dest_word32 T1))"
by (import word32 MSB_def)
constdefs
bitwise_or :: "word32 => word32 => word32"
"bitwise_or ==
-%T1 T2. mk_word32 (EQUIV (OR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
+%(T1::word32) T2::word32.
+ mk_word32 (EQUIV (OR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
-lemma bitwise_or: "ALL T1 T2.
+lemma bitwise_or: "ALL (T1::word32) T2::word32.
bitwise_or T1 T2 =
mk_word32 (EQUIV (OR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
by (import word32 bitwise_or)
@@ -866,10 +930,10 @@
constdefs
bitwise_eor :: "word32 => word32 => word32"
"bitwise_eor ==
-%T1 T2.
+%(T1::word32) T2::word32.
mk_word32 (EQUIV (EOR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
-lemma bitwise_eor: "ALL T1 T2.
+lemma bitwise_eor: "ALL (T1::word32) T2::word32.
bitwise_eor T1 T2 =
mk_word32 (EQUIV (EOR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
by (import word32 bitwise_eor)
@@ -877,10 +941,10 @@
constdefs
bitwise_and :: "word32 => word32 => word32"
"bitwise_and ==
-%T1 T2.
+%(T1::word32) T2::word32.
mk_word32 (EQUIV (AND (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
-lemma bitwise_and: "ALL T1 T2.
+lemma bitwise_and: "ALL (T1::word32) T2::word32.
bitwise_and T1 T2 =
mk_word32 (EQUIV (AND (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
by (import word32 bitwise_and)
@@ -889,71 +953,78 @@
TOw :: "word32 => word32"
defs
- TOw_primdef: "TOw == %T1. mk_word32 (EQUIV (MODw (Eps (dest_word32 T1))))"
+ TOw_primdef: "TOw == %T1::word32. mk_word32 (EQUIV (MODw (Eps (dest_word32 T1))))"
-lemma TOw_def: "ALL T1. TOw T1 = mk_word32 (EQUIV (MODw (Eps (dest_word32 T1))))"
+lemma TOw_def: "ALL T1::word32. TOw T1 = mk_word32 (EQUIV (MODw (Eps (dest_word32 T1))))"
by (import word32 TOw_def)
consts
n2w :: "nat => word32"
defs
- n2w_primdef: "n2w == %n. mk_word32 (EQUIV n)"
+ n2w_primdef: "n2w == %n::nat. mk_word32 (EQUIV n)"
-lemma n2w_def: "ALL n. n2w n = mk_word32 (EQUIV n)"
+lemma n2w_def: "ALL n::nat. n2w n = mk_word32 (EQUIV n)"
by (import word32 n2w_def)
consts
w2n :: "word32 => nat"
defs
- w2n_primdef: "w2n == %w. MODw (Eps (dest_word32 w))"
+ w2n_primdef: "w2n == %w::word32. MODw (Eps (dest_word32 w))"
-lemma w2n_def: "ALL w. w2n w = MODw (Eps (dest_word32 w))"
+lemma w2n_def: "ALL w::word32. w2n w = MODw (Eps (dest_word32 w))"
by (import word32 w2n_def)
-lemma ADDw: "(ALL x. word_add w_0 x = x) &
-(ALL x xa. word_add (word_suc x) xa = word_suc (word_add x xa))"
+lemma ADDw: "(ALL x::word32. word_add w_0 x = x) &
+(ALL (x::word32) xa::word32.
+ word_add (word_suc x) xa = word_suc (word_add x xa))"
by (import word32 ADDw)
-lemma ADD_0w: "ALL x. word_add x w_0 = x"
+lemma ADD_0w: "ALL x::word32. word_add x w_0 = x"
by (import word32 ADD_0w)
-lemma ADD1w: "ALL x. word_suc x = word_add x w_1"
+lemma ADD1w: "ALL x::word32. word_suc x = word_add x w_1"
by (import word32 ADD1w)
-lemma ADD_ASSOCw: "ALL x xa xb. word_add x (word_add xa xb) = word_add (word_add x xa) xb"
+lemma ADD_ASSOCw: "ALL (x::word32) (xa::word32) xb::word32.
+ word_add x (word_add xa xb) = word_add (word_add x xa) xb"
by (import word32 ADD_ASSOCw)
-lemma ADD_CLAUSESw: "(ALL x. word_add w_0 x = x) &
-(ALL x. word_add x w_0 = x) &
-(ALL x xa. word_add (word_suc x) xa = word_suc (word_add x xa)) &
-(ALL x xa. word_add x (word_suc xa) = word_suc (word_add x xa))"
+lemma ADD_CLAUSESw: "(ALL x::word32. word_add w_0 x = x) &
+(ALL x::word32. word_add x w_0 = x) &
+(ALL (x::word32) xa::word32.
+ word_add (word_suc x) xa = word_suc (word_add x xa)) &
+(ALL (x::word32) xa::word32.
+ word_add x (word_suc xa) = word_suc (word_add x xa))"
by (import word32 ADD_CLAUSESw)
-lemma ADD_COMMw: "ALL x xa. word_add x xa = word_add xa x"
+lemma ADD_COMMw: "ALL (x::word32) xa::word32. word_add x xa = word_add xa x"
by (import word32 ADD_COMMw)
-lemma ADD_INV_0_EQw: "ALL x xa. (word_add x xa = x) = (xa = w_0)"
+lemma ADD_INV_0_EQw: "ALL (x::word32) xa::word32. (word_add x xa = x) = (xa = w_0)"
by (import word32 ADD_INV_0_EQw)
-lemma EQ_ADD_LCANCELw: "ALL x xa xb. (word_add x xa = word_add x xb) = (xa = xb)"
+lemma EQ_ADD_LCANCELw: "ALL (x::word32) (xa::word32) xb::word32.
+ (word_add x xa = word_add x xb) = (xa = xb)"
by (import word32 EQ_ADD_LCANCELw)
-lemma EQ_ADD_RCANCELw: "ALL x xa xb. (word_add x xb = word_add xa xb) = (x = xa)"
+lemma EQ_ADD_RCANCELw: "ALL (x::word32) (xa::word32) xb::word32.
+ (word_add x xb = word_add xa xb) = (x = xa)"
by (import word32 EQ_ADD_RCANCELw)
-lemma LEFT_ADD_DISTRIBw: "ALL x xa xb.
+lemma LEFT_ADD_DISTRIBw: "ALL (x::word32) (xa::word32) xb::word32.
word_mul xb (word_add x xa) = word_add (word_mul xb x) (word_mul xb xa)"
by (import word32 LEFT_ADD_DISTRIBw)
-lemma MULT_ASSOCw: "ALL x xa xb. word_mul x (word_mul xa xb) = word_mul (word_mul x xa) xb"
+lemma MULT_ASSOCw: "ALL (x::word32) (xa::word32) xb::word32.
+ word_mul x (word_mul xa xb) = word_mul (word_mul x xa) xb"
by (import word32 MULT_ASSOCw)
-lemma MULT_COMMw: "ALL x xa. word_mul x xa = word_mul xa x"
+lemma MULT_COMMw: "ALL (x::word32) xa::word32. word_mul x xa = word_mul xa x"
by (import word32 MULT_COMMw)
-lemma MULT_CLAUSESw: "ALL x xa.
+lemma MULT_CLAUSESw: "ALL (x::word32) xa::word32.
word_mul w_0 x = w_0 &
word_mul x w_0 = w_0 &
word_mul w_1 x = x &
@@ -962,58 +1033,58 @@
word_mul x (word_suc xa) = word_add x (word_mul x xa)"
by (import word32 MULT_CLAUSESw)
-lemma TWO_COMP_ONE_COMP: "ALL x. word_2comp x = word_add (word_1comp x) w_1"
+lemma TWO_COMP_ONE_COMP: "ALL x::word32. word_2comp x = word_add (word_1comp x) w_1"
by (import word32 TWO_COMP_ONE_COMP)
-lemma OR_ASSOCw: "ALL x xa xb.
+lemma OR_ASSOCw: "ALL (x::word32) (xa::word32) xb::word32.
bitwise_or x (bitwise_or xa xb) = bitwise_or (bitwise_or x xa) xb"
by (import word32 OR_ASSOCw)
-lemma OR_COMMw: "ALL x xa. bitwise_or x xa = bitwise_or xa x"
+lemma OR_COMMw: "ALL (x::word32) xa::word32. bitwise_or x xa = bitwise_or xa x"
by (import word32 OR_COMMw)
-lemma OR_IDEMw: "ALL x. bitwise_or x x = x"
+lemma OR_IDEMw: "ALL x::word32. bitwise_or x x = x"
by (import word32 OR_IDEMw)
-lemma OR_ABSORBw: "ALL x xa. bitwise_and x (bitwise_or x xa) = x"
+lemma OR_ABSORBw: "ALL (x::word32) xa::word32. bitwise_and x (bitwise_or x xa) = x"
by (import word32 OR_ABSORBw)
-lemma AND_ASSOCw: "ALL x xa xb.
+lemma AND_ASSOCw: "ALL (x::word32) (xa::word32) xb::word32.
bitwise_and x (bitwise_and xa xb) = bitwise_and (bitwise_and x xa) xb"
by (import word32 AND_ASSOCw)
-lemma AND_COMMw: "ALL x xa. bitwise_and x xa = bitwise_and xa x"
+lemma AND_COMMw: "ALL (x::word32) xa::word32. bitwise_and x xa = bitwise_and xa x"
by (import word32 AND_COMMw)
-lemma AND_IDEMw: "ALL x. bitwise_and x x = x"
+lemma AND_IDEMw: "ALL x::word32. bitwise_and x x = x"
by (import word32 AND_IDEMw)
-lemma AND_ABSORBw: "ALL x xa. bitwise_or x (bitwise_and x xa) = x"
+lemma AND_ABSORBw: "ALL (x::word32) xa::word32. bitwise_or x (bitwise_and x xa) = x"
by (import word32 AND_ABSORBw)
-lemma ONE_COMPw: "ALL x. word_1comp (word_1comp x) = x"
+lemma ONE_COMPw: "ALL x::word32. word_1comp (word_1comp x) = x"
by (import word32 ONE_COMPw)
-lemma RIGHT_AND_OVER_ORw: "ALL x xa xb.
+lemma RIGHT_AND_OVER_ORw: "ALL (x::word32) (xa::word32) xb::word32.
bitwise_and (bitwise_or x xa) xb =
bitwise_or (bitwise_and x xb) (bitwise_and xa xb)"
by (import word32 RIGHT_AND_OVER_ORw)
-lemma RIGHT_OR_OVER_ANDw: "ALL x xa xb.
+lemma RIGHT_OR_OVER_ANDw: "ALL (x::word32) (xa::word32) xb::word32.
bitwise_or (bitwise_and x xa) xb =
bitwise_and (bitwise_or x xb) (bitwise_or xa xb)"
by (import word32 RIGHT_OR_OVER_ANDw)
-lemma DE_MORGAN_THMw: "ALL x xa.
+lemma DE_MORGAN_THMw: "ALL (x::word32) xa::word32.
word_1comp (bitwise_and x xa) =
bitwise_or (word_1comp x) (word_1comp xa) &
word_1comp (bitwise_or x xa) = bitwise_and (word_1comp x) (word_1comp xa)"
by (import word32 DE_MORGAN_THMw)
-lemma w_0: "w_0 = n2w 0"
+lemma w_0: "w_0 = n2w (0::nat)"
by (import word32 w_0)
-lemma w_1: "w_1 = n2w 1"
+lemma w_1: "w_1 = n2w (1::nat)"
by (import word32 w_1)
lemma w_T: "w_T =
@@ -1053,204 +1124,216 @@
ALT_ZERO)))))))))))))))))))))))))))))))))"
by (import word32 w_T)
-lemma ADD_TWO_COMP: "ALL x. word_add x (word_2comp x) = w_0"
+lemma ADD_TWO_COMP: "ALL x::word32. word_add x (word_2comp x) = w_0"
by (import word32 ADD_TWO_COMP)
-lemma ADD_TWO_COMP2: "ALL x. word_add (word_2comp x) x = w_0"
+lemma ADD_TWO_COMP2: "ALL x::word32. word_add (word_2comp x) x = w_0"
by (import word32 ADD_TWO_COMP2)
constdefs
word_sub :: "word32 => word32 => word32"
- "word_sub == %a b. word_add a (word_2comp b)"
+ "word_sub == %(a::word32) b::word32. word_add a (word_2comp b)"
-lemma word_sub: "ALL a b. word_sub a b = word_add a (word_2comp b)"
+lemma word_sub: "ALL (a::word32) b::word32. word_sub a b = word_add a (word_2comp b)"
by (import word32 word_sub)
constdefs
word_lsl :: "word32 => nat => word32"
- "word_lsl == %a n. word_mul a (n2w (2 ^ n))"
+ "word_lsl == %(a::word32) n::nat. word_mul a (n2w ((2::nat) ^ n))"
-lemma word_lsl: "ALL a n. word_lsl a n = word_mul a (n2w (2 ^ n))"
+lemma word_lsl: "ALL (a::word32) n::nat. word_lsl a n = word_mul a (n2w ((2::nat) ^ n))"
by (import word32 word_lsl)
constdefs
word_lsr :: "word32 => nat => word32"
- "word_lsr == %a n. (word_lsr1 ^ n) a"
+ "word_lsr == %(a::word32) n::nat. (word_lsr1 ^ n) a"
-lemma word_lsr: "ALL a n. word_lsr a n = (word_lsr1 ^ n) a"
+lemma word_lsr: "ALL (a::word32) n::nat. word_lsr a n = (word_lsr1 ^ n) a"
by (import word32 word_lsr)
constdefs
word_asr :: "word32 => nat => word32"
- "word_asr == %a n. (word_asr1 ^ n) a"
+ "word_asr == %(a::word32) n::nat. (word_asr1 ^ n) a"
-lemma word_asr: "ALL a n. word_asr a n = (word_asr1 ^ n) a"
+lemma word_asr: "ALL (a::word32) n::nat. word_asr a n = (word_asr1 ^ n) a"
by (import word32 word_asr)
constdefs
word_ror :: "word32 => nat => word32"
- "word_ror == %a n. (word_ror1 ^ n) a"
+ "word_ror == %(a::word32) n::nat. (word_ror1 ^ n) a"
-lemma word_ror: "ALL a n. word_ror a n = (word_ror1 ^ n) a"
+lemma word_ror: "ALL (a::word32) n::nat. word_ror a n = (word_ror1 ^ n) a"
by (import word32 word_ror)
consts
BITw :: "nat => word32 => bool"
defs
- BITw_primdef: "BITw == %b n. bit b (w2n n)"
+ BITw_primdef: "BITw == %(b::nat) n::word32. bit b (w2n n)"
-lemma BITw_def: "ALL b n. BITw b n = bit b (w2n n)"
+lemma BITw_def: "ALL (b::nat) n::word32. BITw b n = bit b (w2n n)"
by (import word32 BITw_def)
consts
BITSw :: "nat => nat => word32 => nat"
defs
- BITSw_primdef: "BITSw == %h l n. BITS h l (w2n n)"
+ BITSw_primdef: "BITSw == %(h::nat) (l::nat) n::word32. BITS h l (w2n n)"
-lemma BITSw_def: "ALL h l n. BITSw h l n = BITS h l (w2n n)"
+lemma BITSw_def: "ALL (h::nat) (l::nat) n::word32. BITSw h l n = BITS h l (w2n n)"
by (import word32 BITSw_def)
consts
SLICEw :: "nat => nat => word32 => nat"
defs
- SLICEw_primdef: "SLICEw == %h l n. SLICE h l (w2n n)"
+ SLICEw_primdef: "SLICEw == %(h::nat) (l::nat) n::word32. SLICE h l (w2n n)"
-lemma SLICEw_def: "ALL h l n. SLICEw h l n = SLICE h l (w2n n)"
+lemma SLICEw_def: "ALL (h::nat) (l::nat) n::word32. SLICEw h l n = SLICE h l (w2n n)"
by (import word32 SLICEw_def)
-lemma TWO_COMP_ADD: "ALL a b. word_2comp (word_add a b) = word_add (word_2comp a) (word_2comp b)"
+lemma TWO_COMP_ADD: "ALL (a::word32) b::word32.
+ word_2comp (word_add a b) = word_add (word_2comp a) (word_2comp b)"
by (import word32 TWO_COMP_ADD)
-lemma TWO_COMP_ELIM: "ALL a. word_2comp (word_2comp a) = a"
+lemma TWO_COMP_ELIM: "ALL a::word32. word_2comp (word_2comp a) = a"
by (import word32 TWO_COMP_ELIM)
-lemma ADD_SUB_ASSOC: "ALL a b c. word_sub (word_add a b) c = word_add a (word_sub b c)"
+lemma ADD_SUB_ASSOC: "ALL (a::word32) (b::word32) c::word32.
+ word_sub (word_add a b) c = word_add a (word_sub b c)"
by (import word32 ADD_SUB_ASSOC)
-lemma ADD_SUB_SYM: "ALL a b c. word_sub (word_add a b) c = word_add (word_sub a c) b"
+lemma ADD_SUB_SYM: "ALL (a::word32) (b::word32) c::word32.
+ word_sub (word_add a b) c = word_add (word_sub a c) b"
by (import word32 ADD_SUB_SYM)
-lemma SUB_EQUALw: "ALL a. word_sub a a = w_0"
+lemma SUB_EQUALw: "ALL a::word32. word_sub a a = w_0"
by (import word32 SUB_EQUALw)
-lemma ADD_SUBw: "ALL a b. word_sub (word_add a b) b = a"
+lemma ADD_SUBw: "ALL (a::word32) b::word32. word_sub (word_add a b) b = a"
by (import word32 ADD_SUBw)
-lemma SUB_SUBw: "ALL a b c. word_sub a (word_sub b c) = word_sub (word_add a c) b"
+lemma SUB_SUBw: "ALL (a::word32) (b::word32) c::word32.
+ word_sub a (word_sub b c) = word_sub (word_add a c) b"
by (import word32 SUB_SUBw)
-lemma ONE_COMP_TWO_COMP: "ALL a. word_1comp a = word_sub (word_2comp a) w_1"
+lemma ONE_COMP_TWO_COMP: "ALL a::word32. word_1comp a = word_sub (word_2comp a) w_1"
by (import word32 ONE_COMP_TWO_COMP)
-lemma SUBw: "ALL m n. word_sub (word_suc m) n = word_suc (word_sub m n)"
+lemma SUBw: "ALL (m::word32) n::word32. word_sub (word_suc m) n = word_suc (word_sub m n)"
by (import word32 SUBw)
-lemma ADD_EQ_SUBw: "ALL m n p. (word_add m n = p) = (m = word_sub p n)"
+lemma ADD_EQ_SUBw: "ALL (m::word32) (n::word32) p::word32.
+ (word_add m n = p) = (m = word_sub p n)"
by (import word32 ADD_EQ_SUBw)
-lemma CANCEL_SUBw: "ALL m n p. (word_sub n p = word_sub m p) = (n = m)"
+lemma CANCEL_SUBw: "ALL (m::word32) (n::word32) p::word32.
+ (word_sub n p = word_sub m p) = (n = m)"
by (import word32 CANCEL_SUBw)
-lemma SUB_PLUSw: "ALL a b c. word_sub a (word_add b c) = word_sub (word_sub a b) c"
+lemma SUB_PLUSw: "ALL (a::word32) (b::word32) c::word32.
+ word_sub a (word_add b c) = word_sub (word_sub a b) c"
by (import word32 SUB_PLUSw)
-lemma word_nchotomy: "ALL w. EX n. w = n2w n"
+lemma word_nchotomy: "ALL w::word32. EX n::nat. w = n2w n"
by (import word32 word_nchotomy)
-lemma dest_word_mk_word_eq3: "ALL a. dest_word32 (mk_word32 (EQUIV a)) = EQUIV a"
+lemma dest_word_mk_word_eq3: "ALL a::nat. dest_word32 (mk_word32 (EQUIV a)) = EQUIV a"
by (import word32 dest_word_mk_word_eq3)
-lemma MODw_ELIM: "ALL n. n2w (MODw n) = n2w n"
+lemma MODw_ELIM: "ALL n::nat. n2w (MODw n) = n2w n"
by (import word32 MODw_ELIM)
-lemma w2n_EVAL: "ALL n. w2n (n2w n) = MODw n"
+lemma w2n_EVAL: "ALL n::nat. w2n (n2w n) = MODw n"
by (import word32 w2n_EVAL)
-lemma w2n_ELIM: "ALL a. n2w (w2n a) = a"
+lemma w2n_ELIM: "ALL a::word32. n2w (w2n a) = a"
by (import word32 w2n_ELIM)
-lemma n2w_11: "ALL a b. (n2w a = n2w b) = (MODw a = MODw b)"
+lemma n2w_11: "ALL (a::nat) b::nat. (n2w a = n2w b) = (MODw a = MODw b)"
by (import word32 n2w_11)
-lemma ADD_EVAL: "word_add (n2w a) (n2w b) = n2w (a + b)"
+lemma ADD_EVAL: "word_add (n2w (a::nat)) (n2w (b::nat)) = n2w (a + b)"
by (import word32 ADD_EVAL)
-lemma MUL_EVAL: "word_mul (n2w a) (n2w b) = n2w (a * b)"
+lemma MUL_EVAL: "word_mul (n2w (a::nat)) (n2w (b::nat)) = n2w (a * b)"
by (import word32 MUL_EVAL)
-lemma ONE_COMP_EVAL: "word_1comp (n2w a) = n2w (ONE_COMP a)"
+lemma ONE_COMP_EVAL: "word_1comp (n2w (a::nat)) = n2w (ONE_COMP a)"
by (import word32 ONE_COMP_EVAL)
-lemma TWO_COMP_EVAL: "word_2comp (n2w a) = n2w (TWO_COMP a)"
+lemma TWO_COMP_EVAL: "word_2comp (n2w (a::nat)) = n2w (TWO_COMP a)"
by (import word32 TWO_COMP_EVAL)
-lemma LSR_ONE_EVAL: "word_lsr1 (n2w a) = n2w (LSR_ONE a)"
+lemma LSR_ONE_EVAL: "word_lsr1 (n2w (a::nat)) = n2w (LSR_ONE a)"
by (import word32 LSR_ONE_EVAL)
-lemma ASR_ONE_EVAL: "word_asr1 (n2w a) = n2w (ASR_ONE a)"
+lemma ASR_ONE_EVAL: "word_asr1 (n2w (a::nat)) = n2w (ASR_ONE a)"
by (import word32 ASR_ONE_EVAL)
-lemma ROR_ONE_EVAL: "word_ror1 (n2w a) = n2w (ROR_ONE a)"
+lemma ROR_ONE_EVAL: "word_ror1 (n2w (a::nat)) = n2w (ROR_ONE a)"
by (import word32 ROR_ONE_EVAL)
-lemma RRX_EVAL: "RRX c (n2w a) = n2w (RRXn c a)"
+lemma RRX_EVAL: "RRX (c::bool) (n2w (a::nat)) = n2w (RRXn c a)"
by (import word32 RRX_EVAL)
-lemma LSB_EVAL: "LSB (n2w a) = LSBn a"
+lemma LSB_EVAL: "LSB (n2w (a::nat)) = LSBn a"
by (import word32 LSB_EVAL)
-lemma MSB_EVAL: "MSB (n2w a) = MSBn a"
+lemma MSB_EVAL: "MSB (n2w (a::nat)) = MSBn a"
by (import word32 MSB_EVAL)
-lemma OR_EVAL: "bitwise_or (n2w a) (n2w b) = n2w (OR a b)"
+lemma OR_EVAL: "bitwise_or (n2w (a::nat)) (n2w (b::nat)) = n2w (OR a b)"
by (import word32 OR_EVAL)
-lemma EOR_EVAL: "bitwise_eor (n2w a) (n2w b) = n2w (EOR a b)"
+lemma EOR_EVAL: "bitwise_eor (n2w (a::nat)) (n2w (b::nat)) = n2w (EOR a b)"
by (import word32 EOR_EVAL)
-lemma AND_EVAL: "bitwise_and (n2w a) (n2w b) = n2w (AND a b)"
+lemma AND_EVAL: "bitwise_and (n2w (a::nat)) (n2w (b::nat)) = n2w (AND a b)"
by (import word32 AND_EVAL)
-lemma BITS_EVAL: "ALL h l a. BITSw h l (n2w a) = BITS h l (MODw a)"
+lemma BITS_EVAL: "ALL (h::nat) (l::nat) a::nat. BITSw h l (n2w a) = BITS h l (MODw a)"
by (import word32 BITS_EVAL)
-lemma BIT_EVAL: "ALL b a. BITw b (n2w a) = bit b (MODw a)"
+lemma BIT_EVAL: "ALL (b::nat) a::nat. BITw b (n2w a) = bit b (MODw a)"
by (import word32 BIT_EVAL)
-lemma SLICE_EVAL: "ALL h l a. SLICEw h l (n2w a) = SLICE h l (MODw a)"
+lemma SLICE_EVAL: "ALL (h::nat) (l::nat) a::nat. SLICEw h l (n2w a) = SLICE h l (MODw a)"
by (import word32 SLICE_EVAL)
-lemma LSL_ADD: "ALL a m n. word_lsl (word_lsl a m) n = word_lsl a (m + n)"
+lemma LSL_ADD: "ALL (a::word32) (m::nat) n::nat.
+ word_lsl (word_lsl a m) n = word_lsl a (m + n)"
by (import word32 LSL_ADD)
-lemma LSR_ADD: "ALL x xa xb. word_lsr (word_lsr x xa) xb = word_lsr x (xa + xb)"
+lemma LSR_ADD: "ALL (x::word32) (xa::nat) xb::nat.
+ word_lsr (word_lsr x xa) xb = word_lsr x (xa + xb)"
by (import word32 LSR_ADD)
-lemma ASR_ADD: "ALL x xa xb. word_asr (word_asr x xa) xb = word_asr x (xa + xb)"
+lemma ASR_ADD: "ALL (x::word32) (xa::nat) xb::nat.
+ word_asr (word_asr x xa) xb = word_asr x (xa + xb)"
by (import word32 ASR_ADD)
-lemma ROR_ADD: "ALL x xa xb. word_ror (word_ror x xa) xb = word_ror x (xa + xb)"
+lemma ROR_ADD: "ALL (x::word32) (xa::nat) xb::nat.
+ word_ror (word_ror x xa) xb = word_ror x (xa + xb)"
by (import word32 ROR_ADD)
-lemma LSL_LIMIT: "ALL w n. HB < n --> word_lsl w n = w_0"
+lemma LSL_LIMIT: "ALL (w::word32) n::nat. HB < n --> word_lsl w n = w_0"
by (import word32 LSL_LIMIT)
-lemma MOD_MOD_DIV: "ALL a b. INw (MODw a div 2 ^ b)"
+lemma MOD_MOD_DIV: "ALL (a::nat) b::nat. INw (MODw a div (2::nat) ^ b)"
by (import word32 MOD_MOD_DIV)
-lemma MOD_MOD_DIV_2EXP: "ALL a n. MODw (MODw a div 2 ^ n) div 2 = MODw a div 2 ^ Suc n"
+lemma MOD_MOD_DIV_2EXP: "ALL (a::nat) n::nat.
+ MODw (MODw a div (2::nat) ^ n) div (2::nat) = MODw a div (2::nat) ^ Suc n"
by (import word32 MOD_MOD_DIV_2EXP)
-lemma LSR_EVAL: "ALL n. word_lsr (n2w a) n = n2w (MODw a div 2 ^ n)"
+lemma LSR_EVAL: "ALL n::nat. word_lsr (n2w (a::nat)) n = n2w (MODw a div (2::nat) ^ n)"
by (import word32 LSR_EVAL)
-lemma LSR_THM: "ALL x n. word_lsr (n2w n) x = n2w (BITS HB (min WL x) n)"
+lemma LSR_THM: "ALL (x::nat) n::nat. word_lsr (n2w n) x = n2w (BITS HB (min WL x) n)"
by (import word32 LSR_THM)
-lemma LSR_LIMIT: "ALL x w. HB < x --> word_lsr w x = w_0"
+lemma LSR_LIMIT: "ALL (x::nat) w::word32. HB < x --> word_lsr w x = w_0"
by (import word32 LSR_LIMIT)
lemma LEFT_SHIFT_LESS: "ALL (n::nat) (m::nat) a::nat.
@@ -1258,41 +1341,44 @@
(2::nat) ^ n + a * (2::nat) ^ n <= (2::nat) ^ (m + n)"
by (import word32 LEFT_SHIFT_LESS)
-lemma ROR_THM: "ALL x n.
+lemma ROR_THM: "ALL (x::nat) n::nat.
word_ror (n2w n) x =
- (let x' = x mod WL
- in n2w (BITS HB x' n + BITS (x' - 1) 0 n * 2 ^ (WL - x')))"
+ (let x'::nat = x mod WL
+ in n2w (BITS HB x' n +
+ BITS (x' - (1::nat)) (0::nat) n * (2::nat) ^ (WL - x')))"
by (import word32 ROR_THM)
-lemma ROR_CYCLE: "ALL x w. word_ror w (x * WL) = w"
+lemma ROR_CYCLE: "ALL (x::nat) w::word32. word_ror w (x * WL) = w"
by (import word32 ROR_CYCLE)
-lemma ASR_THM: "ALL x n.
+lemma ASR_THM: "ALL (x::nat) n::nat.
word_asr (n2w n) x =
- (let x' = min HB x; s = BITS HB x' n
- in n2w (if MSBn n then 2 ^ WL - 2 ^ (WL - x') + s else s))"
+ (let x'::nat = min HB x; s::nat = BITS HB x' n
+ in n2w (if MSBn n then (2::nat) ^ WL - (2::nat) ^ (WL - x') + s else s))"
by (import word32 ASR_THM)
-lemma ASR_LIMIT: "ALL x w. HB <= x --> word_asr w x = (if MSB w then w_T else w_0)"
+lemma ASR_LIMIT: "ALL (x::nat) w::word32.
+ HB <= x --> word_asr w x = (if MSB w then w_T else w_0)"
by (import word32 ASR_LIMIT)
-lemma ZERO_SHIFT: "(ALL n. word_lsl w_0 n = w_0) &
-(ALL n. word_asr w_0 n = w_0) &
-(ALL n. word_lsr w_0 n = w_0) & (ALL n. word_ror w_0 n = w_0)"
+lemma ZERO_SHIFT: "(ALL n::nat. word_lsl w_0 n = w_0) &
+(ALL n::nat. word_asr w_0 n = w_0) &
+(ALL n::nat. word_lsr w_0 n = w_0) & (ALL n::nat. word_ror w_0 n = w_0)"
by (import word32 ZERO_SHIFT)
-lemma ZERO_SHIFT2: "(ALL a. word_lsl a 0 = a) &
-(ALL a. word_asr a 0 = a) &
-(ALL a. word_lsr a 0 = a) & (ALL a. word_ror a 0 = a)"
+lemma ZERO_SHIFT2: "(ALL a::word32. word_lsl a (0::nat) = a) &
+(ALL a::word32. word_asr a (0::nat) = a) &
+(ALL a::word32. word_lsr a (0::nat) = a) &
+(ALL a::word32. word_ror a (0::nat) = a)"
by (import word32 ZERO_SHIFT2)
-lemma ASR_w_T: "ALL n. word_asr w_T n = w_T"
+lemma ASR_w_T: "ALL n::nat. word_asr w_T n = w_T"
by (import word32 ASR_w_T)
-lemma ROR_w_T: "ALL n. word_ror w_T n = w_T"
+lemma ROR_w_T: "ALL n::nat. word_ror w_T n = w_T"
by (import word32 ROR_w_T)
-lemma MODw_EVAL: "ALL x.
+lemma MODw_EVAL: "ALL x::nat.
MODw x =
x mod
NUMERAL
@@ -1331,27 +1417,27 @@
ALT_ZERO))))))))))))))))))))))))))))))))"
by (import word32 MODw_EVAL)
-lemma ADD_EVAL2: "ALL b a. word_add (n2w a) (n2w b) = n2w (MODw (a + b))"
+lemma ADD_EVAL2: "ALL (b::nat) a::nat. word_add (n2w a) (n2w b) = n2w (MODw (a + b))"
by (import word32 ADD_EVAL2)
-lemma MUL_EVAL2: "ALL b a. word_mul (n2w a) (n2w b) = n2w (MODw (a * b))"
+lemma MUL_EVAL2: "ALL (b::nat) a::nat. word_mul (n2w a) (n2w b) = n2w (MODw (a * b))"
by (import word32 MUL_EVAL2)
-lemma ONE_COMP_EVAL2: "ALL a.
+lemma ONE_COMP_EVAL2: "ALL a::nat.
word_1comp (n2w a) =
- n2w (2 ^
+ n2w ((2::nat) ^
NUMERAL
(NUMERAL_BIT2
(NUMERAL_BIT1
(NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))) -
- 1 -
+ (1::nat) -
MODw a)"
by (import word32 ONE_COMP_EVAL2)
-lemma TWO_COMP_EVAL2: "ALL a.
+lemma TWO_COMP_EVAL2: "ALL a::nat.
word_2comp (n2w a) =
n2w (MODw
- (2 ^
+ ((2::nat) ^
NUMERAL
(NUMERAL_BIT2
(NUMERAL_BIT1
@@ -1359,12 +1445,12 @@
MODw a))"
by (import word32 TWO_COMP_EVAL2)
-lemma LSR_ONE_EVAL2: "ALL a. word_lsr1 (n2w a) = n2w (MODw a div 2)"
+lemma LSR_ONE_EVAL2: "ALL a::nat. word_lsr1 (n2w a) = n2w (MODw a div (2::nat))"
by (import word32 LSR_ONE_EVAL2)
-lemma ASR_ONE_EVAL2: "ALL a.
+lemma ASR_ONE_EVAL2: "ALL a::nat.
word_asr1 (n2w a) =
- n2w (MODw a div 2 +
+ n2w (MODw a div (2::nat) +
SBIT (MSBn a)
(NUMERAL
(NUMERAL_BIT1
@@ -1372,9 +1458,9 @@
(NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))))"
by (import word32 ASR_ONE_EVAL2)
-lemma ROR_ONE_EVAL2: "ALL a.
+lemma ROR_ONE_EVAL2: "ALL a::nat.
word_ror1 (n2w a) =
- n2w (MODw a div 2 +
+ n2w (MODw a div (2::nat) +
SBIT (LSBn a)
(NUMERAL
(NUMERAL_BIT1
@@ -1382,9 +1468,9 @@
(NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))))"
by (import word32 ROR_ONE_EVAL2)
-lemma RRX_EVAL2: "ALL c a.
+lemma RRX_EVAL2: "ALL (c::bool) a::nat.
RRX c (n2w a) =
- n2w (MODw a div 2 +
+ n2w (MODw a div (2::nat) +
SBIT c
(NUMERAL
(NUMERAL_BIT1
@@ -1392,10 +1478,10 @@
(NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))))"
by (import word32 RRX_EVAL2)
-lemma LSB_EVAL2: "ALL a. LSB (n2w a) = ODD a"
+lemma LSB_EVAL2: "ALL a::nat. LSB (n2w a) = ODD a"
by (import word32 LSB_EVAL2)
-lemma MSB_EVAL2: "ALL a.
+lemma MSB_EVAL2: "ALL a::nat.
MSB (n2w a) =
bit (NUMERAL
(NUMERAL_BIT1
@@ -1404,7 +1490,7 @@
a"
by (import word32 MSB_EVAL2)
-lemma OR_EVAL2: "ALL b a.
+lemma OR_EVAL2: "ALL (b::nat) a::nat.
bitwise_or (n2w a) (n2w b) =
n2w (BITWISE
(NUMERAL
@@ -1414,7 +1500,7 @@
op | a b)"
by (import word32 OR_EVAL2)
-lemma AND_EVAL2: "ALL b a.
+lemma AND_EVAL2: "ALL (b::nat) a::nat.
bitwise_and (n2w a) (n2w b) =
n2w (BITWISE
(NUMERAL
@@ -1424,54 +1510,91 @@
op & a b)"
by (import word32 AND_EVAL2)
-lemma EOR_EVAL2: "ALL b a.
+lemma EOR_EVAL2: "ALL (b::nat) a::nat.
bitwise_eor (n2w a) (n2w b) =
n2w (BITWISE
(NUMERAL
(NUMERAL_BIT2
(NUMERAL_BIT1
(NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))))
- (%x y. x ~= y) a b)"
+ (%(x::bool) y::bool. x ~= y) a b)"
by (import word32 EOR_EVAL2)
-lemma BITWISE_EVAL2: "ALL n oper x y.
- BITWISE n oper x y =
- (if n = 0 then 0
- else 2 * BITWISE (n - 1) oper (x div 2) (y div 2) +
- (if oper (ODD x) (ODD y) then 1 else 0))"
+lemma BITWISE_EVAL2: "(All::(nat => bool) => bool)
+ (%n::nat.
+ (All::((bool => bool => bool) => bool) => bool)
+ (%oper::bool => bool => bool.
+ (All::(nat => bool) => bool)
+ (%x::nat.
+ (All::(nat => bool) => bool)
+ (%y::nat.
+ (op =::nat => nat => bool)
+ ((BITWISE::nat
+ => (bool => bool => bool)
+ => nat => nat => nat)
+ n oper x y)
+ ((If::bool => nat => nat => nat)
+ ((op =::nat => nat => bool) n (0::nat)) (0::nat)
+ ((op +::nat => nat => nat)
+ ((op *::nat => nat => nat)
+ ((number_of::bin => nat)
+ ((op BIT::bin => bit => bin)
+ ((op BIT::bin => bit => bin)
+ (Numeral.Pls::bin) (bit.B1::bit))
+ (bit.B0::bit)))
+ ((BITWISE::nat
+=> (bool => bool => bool) => nat => nat => nat)
+ ((op -::nat => nat => nat) n (1::nat)) oper
+ ((op div::nat => nat => nat) x
+ ((number_of::bin => nat)
+ ((op BIT::bin => bit => bin)
+ ((op BIT::bin => bit => bin)
+ (Numeral.Pls::bin) (bit.B1::bit))
+ (bit.B0::bit))))
+ ((op div::nat => nat => nat) y
+ ((number_of::bin => nat)
+ ((op BIT::bin => bit => bin)
+ ((op BIT::bin => bit => bin)
+ (Numeral.Pls::bin) (bit.B1::bit))
+ (bit.B0::bit))))))
+ ((If::bool => nat => nat => nat)
+ (oper ((ODD::nat => bool) x)
+ ((ODD::nat => bool) y))
+ (1::nat) (0::nat))))))))"
by (import word32 BITWISE_EVAL2)
-lemma BITSwLT_THM: "ALL h l n. BITSw h l n < 2 ^ (Suc h - l)"
+lemma BITSwLT_THM: "ALL (h::nat) (l::nat) n::word32. BITSw h l n < (2::nat) ^ (Suc h - l)"
by (import word32 BITSwLT_THM)
-lemma BITSw_COMP_THM: "ALL h1 l1 h2 l2 n.
+lemma BITSw_COMP_THM: "ALL (h1::nat) (l1::nat) (h2::nat) (l2::nat) n::word32.
h2 + l1 <= h1 -->
BITS h2 l2 (BITSw h1 l1 n) = BITSw (h2 + l1) (l2 + l1) n"
by (import word32 BITSw_COMP_THM)
-lemma BITSw_DIV_THM: "ALL h l n x. BITSw h l x div 2 ^ n = BITSw h (l + n) x"
+lemma BITSw_DIV_THM: "ALL (h::nat) (l::nat) (n::nat) x::word32.
+ BITSw h l x div (2::nat) ^ n = BITSw h (l + n) x"
by (import word32 BITSw_DIV_THM)
-lemma BITw_THM: "ALL b n. BITw b n = (BITSw b b n = 1)"
+lemma BITw_THM: "ALL (b::nat) n::word32. BITw b n = (BITSw b b n = (1::nat))"
by (import word32 BITw_THM)
-lemma SLICEw_THM: "ALL n h l. SLICEw h l n = BITSw h l n * 2 ^ l"
+lemma SLICEw_THM: "ALL (n::word32) (h::nat) l::nat. SLICEw h l n = BITSw h l n * (2::nat) ^ l"
by (import word32 SLICEw_THM)
-lemma BITS_SLICEw_THM: "ALL h l n. BITS h l (SLICEw h l n) = BITSw h l n"
+lemma BITS_SLICEw_THM: "ALL (h::nat) (l::nat) n::word32. BITS h l (SLICEw h l n) = BITSw h l n"
by (import word32 BITS_SLICEw_THM)
-lemma SLICEw_ZERO_THM: "ALL n h. SLICEw h 0 n = BITSw h 0 n"
+lemma SLICEw_ZERO_THM: "ALL (n::word32) h::nat. SLICEw h (0::nat) n = BITSw h (0::nat) n"
by (import word32 SLICEw_ZERO_THM)
-lemma SLICEw_COMP_THM: "ALL h m l a.
+lemma SLICEw_COMP_THM: "ALL (h::nat) (m::nat) (l::nat) a::word32.
Suc m <= h & l <= m --> SLICEw h (Suc m) a + SLICEw m l a = SLICEw h l a"
by (import word32 SLICEw_COMP_THM)
-lemma BITSw_ZERO: "ALL h l n. h < l --> BITSw h l n = 0"
+lemma BITSw_ZERO: "ALL (h::nat) (l::nat) n::word32. h < l --> BITSw h l n = (0::nat)"
by (import word32 BITSw_ZERO)
-lemma SLICEw_ZERO: "ALL h l n. h < l --> SLICEw h l n = 0"
+lemma SLICEw_ZERO: "ALL (h::nat) (l::nat) n::word32. h < l --> SLICEw h l n = (0::nat)"
by (import word32 SLICEw_ZERO)
;end_setup
--- a/src/HOL/Import/HOL/ROOT.ML Mon Sep 26 02:06:44 2005 +0200
+++ b/src/HOL/Import/HOL/ROOT.ML Mon Sep 26 02:27:14 2005 +0200
@@ -3,5 +3,6 @@
Author: Sebastian Skalberg (TU Muenchen)
*)
-setmp quick_and_dirty true use_thy "HOL4Prob";
-setmp quick_and_dirty true use_thy "HOL4";
+set show_types; set show_sorts;
+use_thy "HOL4Prob";
+use_thy "HOL4";
--- a/src/HOL/Import/HOL/bool.imp Mon Sep 26 02:06:44 2005 +0200
+++ b/src/HOL/Import/HOL/bool.imp Mon Sep 26 02:27:14 2005 +0200
@@ -21,7 +21,7 @@
"RES_FORALL" > "HOL4Base.bool.RES_FORALL"
"RES_EXISTS_UNIQUE" > "HOL4Base.bool.RES_EXISTS_UNIQUE"
"RES_EXISTS" > "HOL4Base.bool.RES_EXISTS"
- "ONTO" > "HOL4Setup.ONTO"
+ "ONTO" > "Fun.surj"
"ONE_ONE" > "HOL4Setup.ONE_ONE"
"LET" > "HOL4Compat.LET"
"IN" > "HOL4Base.bool.IN"
@@ -37,11 +37,11 @@
"bool_case_thm" > "HOL4Base.bool.bool_case_thm"
"bool_case_ID" > "HOL4Base.bool.bool_case_ID"
"bool_case_DEF" > "HOL4Compat.bool_case_DEF"
- "bool_INDUCT" > "Datatype.bool.induct_correctness"
+ "bool_INDUCT" > "Datatype.bool.induct"
"boolAxiom" > "HOL4Base.bool.boolAxiom"
"UNWIND_THM2" > "HOL.simp_thms_39"
"UNWIND_THM1" > "HOL.simp_thms_40"
- "UNWIND_FORALL_THM2" > "HOL.simp_thms_41"
+ "UNWIND_FORALL_THM2" > "HOL4Base.bool.UNWIND_FORALL_THM2"
"UNWIND_FORALL_THM1" > "HOL.simp_thms_42"
"UEXISTS_SIMP" > "HOL4Base.bool.UEXISTS_SIMP"
"UEXISTS_OR_THM" > "HOL4Base.bool.UEXISTS_OR_THM"
@@ -82,8 +82,8 @@
"OR_DEF" > "HOL.or_def"
"OR_CONG" > "HOL4Base.bool.OR_CONG"
"OR_CLAUSES" > "HOL4Base.bool.OR_CLAUSES"
- "ONTO_THM" > "HOL4Setup.ONTO_DEF"
- "ONTO_DEF" > "HOL4Setup.ONTO_DEF"
+ "ONTO_THM" > "Fun.surj_def"
+ "ONTO_DEF" > "Fun.surj_def"
"ONE_ONE_THM" > "HOL4Base.bool.ONE_ONE_THM"
"ONE_ONE_DEF" > "HOL4Setup.ONE_ONE_DEF"
"NOT_IMP" > "HOL.not_imp"
@@ -95,7 +95,7 @@
"NOT_AND" > "HOL4Base.bool.NOT_AND"
"MONO_OR" > "Inductive.basic_monos_3"
"MONO_NOT" > "HOL.rev_contrapos"
- "MONO_IMP" > "Set.imp_mono"
+ "MONO_IMP" > "HOL4Base.bool.MONO_IMP"
"MONO_EXISTS" > "Inductive.basic_monos_5"
"MONO_COND" > "HOL4Base.bool.MONO_COND"
"MONO_AND" > "Inductive.basic_monos_4"
@@ -108,11 +108,11 @@
"LEFT_OR_OVER_AND" > "HOL.disj_conj_distribL"
"LEFT_OR_EXISTS_THM" > "HOL.ex_simps_3"
"LEFT_FORALL_OR_THM" > "HOL.all_simps_3"
- "LEFT_FORALL_IMP_THM" > "HOL.imp_ex"
+ "LEFT_FORALL_IMP_THM" > "HOL4Base.bool.LEFT_FORALL_IMP_THM"
"LEFT_EXISTS_IMP_THM" > "HOL.imp_all"
"LEFT_EXISTS_AND_THM" > "HOL.ex_simps_1"
"LEFT_AND_OVER_OR" > "HOL.conj_disj_distribL"
- "LEFT_AND_FORALL_THM" > "HOL.all_simps_1"
+ "LEFT_AND_FORALL_THM" > "HOL4Base.bool.LEFT_AND_FORALL_THM"
"IN_def" > "HOL4Base.bool.IN_def"
"IN_DEF" > "HOL4Base.bool.IN_DEF"
"INFINITY_AX" > "HOL4Setup.INFINITY_AX"
@@ -146,7 +146,7 @@
"EQ_SYM" > "HOL.meta_eq_to_obj_eq"
"EQ_REFL" > "Presburger.fm_modd_pinf"
"EQ_IMP_THM" > "HOL.iff_conv_conj_imp"
- "EQ_EXT" > "HOL.meta_eq_to_obj_eq"
+ "EQ_EXT" > "HOL4Base.bool.EQ_EXT"
"EQ_EXPAND" > "HOL4Base.bool.EQ_EXPAND"
"EQ_CLAUSES" > "HOL4Base.bool.EQ_CLAUSES"
"DISJ_SYM" > "HOL.disj_comms_1"
--- a/src/HOL/Import/HOL/pair.imp Mon Sep 26 02:06:44 2005 +0200
+++ b/src/HOL/Import/HOL/pair.imp Mon Sep 26 02:27:14 2005 +0200
@@ -21,7 +21,7 @@
"##" > "prod_fun"
thm_maps
- "pair_induction" > "Datatype.prod.induct_correctness"
+ "pair_induction" > "Datatype.prod.induct"
"pair_case_thm" > "Product_Type.split"
"pair_case_def" > "HOL4Compat.pair_case_def"
"pair_case_cong" > "HOL4Base.pair.pair_case_cong"
--- a/src/HOL/Import/HOL/real.imp Mon Sep 26 02:06:44 2005 +0200
+++ b/src/HOL/Import/HOL/real.imp Mon Sep 26 02:27:14 2005 +0200
@@ -31,7 +31,7 @@
"real_lt" > "Orderings.linorder_not_le"
"real_gt" > "HOL4Compat.real_gt"
"real_ge" > "HOL4Compat.real_ge"
- "real_div" > "Ring_and_Field.field.divide_inverse"
+ "real_div" > "Ring_and_Field.field_class.divide_inverse"
"pow" > "HOL4Compat.pow"
"abs" > "HOL4Compat.abs"
"SUP_LEMMA3" > "HOL4Real.real.SUP_LEMMA3"
@@ -147,7 +147,7 @@
"REAL_LT_TOTAL" > "HOL4Compat.REAL_LT_TOTAL"
"REAL_LT_SUB_RADD" > "OrderedGroup.compare_rls_6"
"REAL_LT_SUB_LADD" > "OrderedGroup.compare_rls_7"
- "REAL_LT_RMUL_IMP" > "Ring_and_Field.ordered_semiring_strict.mult_strict_right_mono"
+ "REAL_LT_RMUL_IMP" > "Ring_and_Field.ordered_semiring_strict_class.mult_strict_right_mono"
"REAL_LT_RMUL_0" > "HOL4Real.real.REAL_LT_RMUL_0"
"REAL_LT_RMUL" > "RealDef.real_mult_less_iff1"
"REAL_LT_REFL" > "Orderings.order_less_irrefl"
@@ -161,10 +161,10 @@
"REAL_LT_MULTIPLE" > "HOL4Real.real.REAL_LT_MULTIPLE"
"REAL_LT_MUL2" > "Ring_and_Field.mult_strict_mono'"
"REAL_LT_MUL" > "Ring_and_Field.mult_pos_pos"
- "REAL_LT_LMUL_IMP" > "Ring_and_Field.ordered_comm_semiring_strict.mult_strict_mono"
+ "REAL_LT_LMUL_IMP" > "Ring_and_Field.ordered_comm_semiring_strict_class.mult_strict_mono"
"REAL_LT_LMUL_0" > "HOL4Real.real.REAL_LT_LMUL_0"
"REAL_LT_LMUL" > "HOL4Real.real.REAL_LT_LMUL"
- "REAL_LT_LE" > "Orderings.order.order_less_le"
+ "REAL_LT_LE" > "Orderings.order_class.order_less_le"
"REAL_LT_LDIV_EQ" > "Ring_and_Field.pos_divide_less_eq"
"REAL_LT_LADD" > "OrderedGroup.add_less_cancel_left"
"REAL_LT_INV_EQ" > "Ring_and_Field.inverse_positive_iff_positive"
@@ -188,7 +188,7 @@
"REAL_LT_ADD1" > "HOL4Real.real.REAL_LT_ADD1"
"REAL_LT_ADD" > "OrderedGroup.add_pos_pos"
"REAL_LT_1" > "HOL4Real.real.REAL_LT_1"
- "REAL_LT_01" > "Ring_and_Field.ordered_semidom.zero_less_one"
+ "REAL_LT_01" > "Ring_and_Field.ordered_semidom_class.zero_less_one"
"REAL_LTE_TRANS" > "Set.basic_trans_rules_24"
"REAL_LTE_TOTAL" > "HOL4Real.real.REAL_LTE_TOTAL"
"REAL_LTE_ANTSYM" > "HOL4Real.real.REAL_LTE_ANTSYM"
@@ -199,12 +199,12 @@
"REAL_LNEG_UNIQ" > "HOL4Real.real.REAL_LNEG_UNIQ"
"REAL_LINV_UNIQ" > "HOL4Real.real.REAL_LINV_UNIQ"
"REAL_LE_TRANS" > "Set.basic_trans_rules_25"
- "REAL_LE_TOTAL" > "Orderings.linorder.linorder_linear"
+ "REAL_LE_TOTAL" > "Orderings.linorder_class.linorder_linear"
"REAL_LE_SUB_RADD" > "OrderedGroup.compare_rls_8"
"REAL_LE_SUB_LADD" > "OrderedGroup.compare_rls_9"
"REAL_LE_SQUARE" > "Ring_and_Field.zero_le_square"
"REAL_LE_RNEG" > "OrderedGroup.le_eq_neg"
- "REAL_LE_RMUL_IMP" > "Ring_and_Field.pordered_semiring.mult_right_mono"
+ "REAL_LE_RMUL_IMP" > "Ring_and_Field.pordered_semiring_class.mult_right_mono"
"REAL_LE_RMUL" > "RealDef.real_mult_le_cancel_iff1"
"REAL_LE_REFL" > "Finite_Set.max.f_below.below_refl"
"REAL_LE_RDIV_EQ" > "Ring_and_Field.pos_le_divide_eq"
@@ -220,11 +220,11 @@
"REAL_LE_MUL" > "Ring_and_Field.mult_nonneg_nonneg"
"REAL_LE_LT" > "Orderings.order_le_less"
"REAL_LE_LNEG" > "RealDef.real_0_le_add_iff"
- "REAL_LE_LMUL_IMP" > "Ring_and_Field.pordered_comm_semiring.mult_mono"
+ "REAL_LE_LMUL_IMP" > "Ring_and_Field.pordered_comm_semiring_class.mult_mono"
"REAL_LE_LMUL" > "RealDef.real_mult_le_cancel_iff2"
"REAL_LE_LDIV_EQ" > "Ring_and_Field.pos_divide_le_eq"
"REAL_LE_LDIV" > "Ring_and_Field.mult_imp_div_pos_le"
- "REAL_LE_LADD_IMP" > "OrderedGroup.pordered_ab_semigroup_add.add_left_mono"
+ "REAL_LE_LADD_IMP" > "OrderedGroup.pordered_ab_semigroup_add_class.add_left_mono"
"REAL_LE_LADD" > "OrderedGroup.add_le_cancel_left"
"REAL_LE_INV_EQ" > "Ring_and_Field.inverse_nonnegative_iff_nonnegative"
"REAL_LE_INV" > "HOL4Real.real.REAL_LE_INV"
@@ -251,7 +251,7 @@
"REAL_INV_INV" > "Ring_and_Field.inverse_inverse_eq"
"REAL_INV_EQ_0" > "Ring_and_Field.inverse_nonzero_iff_nonzero"
"REAL_INV_1OVER" > "Ring_and_Field.inverse_eq_divide"
- "REAL_INV_0" > "Ring_and_Field.division_by_zero.inverse_zero"
+ "REAL_INV_0" > "Ring_and_Field.division_by_zero_class.inverse_zero"
"REAL_INVINV" > "Ring_and_Field.nonzero_inverse_inverse_eq"
"REAL_INV1" > "Ring_and_Field.inverse_1"
"REAL_INJ" > "RealDef.real_of_nat_inject"
--- a/src/HOL/Import/HOL/realax.imp Mon Sep 26 02:06:44 2005 +0200
+++ b/src/HOL/Import/HOL/realax.imp Mon Sep 26 02:27:14 2005 +0200
@@ -101,7 +101,7 @@
"REAL_LT_MUL" > "Ring_and_Field.mult_pos_pos"
"REAL_LT_IADD" > "OrderedGroup.add_strict_left_mono"
"REAL_LDISTRIB" > "Ring_and_Field.ring_eq_simps_2"
- "REAL_INV_0" > "Ring_and_Field.division_by_zero.inverse_zero"
+ "REAL_INV_0" > "Ring_and_Field.division_by_zero_class.inverse_zero"
"REAL_ADD_SYM" > "Finite_Set.AC_add.f.AC_2"
"REAL_ADD_LINV" > "HOL4Compat.REAL_ADD_LINV"
"REAL_ADD_LID" > "Finite_Set.AC_add.f_e.left_ident"
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOLLight/HOLLight.thy Mon Sep 26 02:27:14 2005 +0200
@@ -0,0 +1,13857 @@
+(* AUTOMATICALLY GENERATED, DO NOT EDIT! *)
+
+theory HOLLight = "../HOLLightCompat" + "../HOL4Syntax":
+
+;setup_theory hollight
+
+consts
+ "_FALSITY_" :: "bool" ("'_FALSITY'_")
+
+defs
+ "_FALSITY__def": "_FALSITY_ == False"
+
+lemma DEF__FALSITY_: "_FALSITY_ = False"
+ by (import hollight DEF__FALSITY_)
+
+lemma CONJ_ACI: "((p::bool) & (q::bool)) = (q & p) &
+((p & q) & (r::bool)) = (p & q & r) &
+(p & q & r) = (q & p & r) & (p & p) = p & (p & p & q) = (p & q)"
+ by (import hollight CONJ_ACI)
+
+lemma DISJ_ACI: "((p::bool) | (q::bool)) = (q | p) &
+((p | q) | (r::bool)) = (p | q | r) &
+(p | q | r) = (q | p | r) & (p | p) = p & (p | p | q) = (p | q)"
+ by (import hollight DISJ_ACI)
+
+lemma EQ_CLAUSES: "ALL t::bool.
+ (True = t) = t &
+ (t = True) = t & (False = t) = (~ t) & (t = False) = (~ t)"
+ by (import hollight EQ_CLAUSES)
+
+lemma NOT_CLAUSES_WEAK: "(~ True) = False & (~ False) = True"
+ by (import hollight NOT_CLAUSES_WEAK)
+
+lemma AND_CLAUSES: "ALL t::bool.
+ (True & t) = t &
+ (t & True) = t & (False & t) = False & (t & False) = False & (t & t) = t"
+ by (import hollight AND_CLAUSES)
+
+lemma OR_CLAUSES: "ALL t::bool.
+ (True | t) = True &
+ (t | True) = True & (False | t) = t & (t | False) = t & (t | t) = t"
+ by (import hollight OR_CLAUSES)
+
+lemma IMP_CLAUSES: "ALL t::bool.
+ (True --> t) = t &
+ (t --> True) = True &
+ (False --> t) = True & (t --> t) = True & (t --> False) = (~ t)"
+ by (import hollight IMP_CLAUSES)
+
+lemma IMP_EQ_CLAUSE: "((x::'q_864::type) = x --> (p::bool)) = p"
+ by (import hollight IMP_EQ_CLAUSE)
+
+lemma SWAP_FORALL_THM: "ALL P::'A::type => 'B::type => bool.
+ (ALL x::'A::type. All (P x)) = (ALL (y::'B::type) x::'A::type. P x y)"
+ by (import hollight SWAP_FORALL_THM)
+
+lemma SWAP_EXISTS_THM: "ALL P::'A::type => 'B::type => bool.
+ (EX x::'A::type. Ex (P x)) = (EX (x::'B::type) xa::'A::type. P xa x)"
+ by (import hollight SWAP_EXISTS_THM)
+
+lemma TRIV_EXISTS_AND_THM: "ALL (P::bool) Q::bool.
+ (EX x::'A::type. P & Q) = ((EX x::'A::type. P) & (EX x::'A::type. Q))"
+ by (import hollight TRIV_EXISTS_AND_THM)
+
+lemma TRIV_AND_EXISTS_THM: "ALL (P::bool) Q::bool.
+ ((EX x::'A::type. P) & (EX x::'A::type. Q)) = (EX x::'A::type. P & Q)"
+ by (import hollight TRIV_AND_EXISTS_THM)
+
+lemma TRIV_FORALL_OR_THM: "ALL (P::bool) Q::bool.
+ (ALL x::'A::type. P | Q) = ((ALL x::'A::type. P) | (ALL x::'A::type. Q))"
+ by (import hollight TRIV_FORALL_OR_THM)
+
+lemma TRIV_OR_FORALL_THM: "ALL (P::bool) Q::bool.
+ ((ALL x::'A::type. P) | (ALL x::'A::type. Q)) = (ALL x::'A::type. P | Q)"
+ by (import hollight TRIV_OR_FORALL_THM)
+
+lemma TRIV_FORALL_IMP_THM: "ALL (P::bool) Q::bool.
+ (ALL x::'A::type. P --> Q) =
+ ((EX x::'A::type. P) --> (ALL x::'A::type. Q))"
+ by (import hollight TRIV_FORALL_IMP_THM)
+
+lemma TRIV_EXISTS_IMP_THM: "ALL (P::bool) Q::bool.
+ (EX x::'A::type. P --> Q) =
+ ((ALL x::'A::type. P) --> (EX x::'A::type. Q))"
+ by (import hollight TRIV_EXISTS_IMP_THM)
+
+lemma EXISTS_UNIQUE_ALT: "ALL P::'A::type => bool.
+ Ex1 P = (EX x::'A::type. ALL y::'A::type. P y = (x = y))"
+ by (import hollight EXISTS_UNIQUE_ALT)
+
+lemma SELECT_UNIQUE: "ALL (P::'A::type => bool) x::'A::type.
+ (ALL y::'A::type. P y = (y = x)) --> Eps P = x"
+ by (import hollight SELECT_UNIQUE)
+
+lemma EXCLUDED_MIDDLE: "ALL t::bool. t | ~ t"
+ by (import hollight EXCLUDED_MIDDLE)
+
+constdefs
+ COND :: "bool => 'A::type => 'A::type => 'A::type"
+ "COND ==
+%(t::bool) (t1::'A::type) t2::'A::type.
+ SOME x::'A::type. (t = True --> x = t1) & (t = False --> x = t2)"
+
+lemma DEF_COND: "COND =
+(%(t::bool) (t1::'A::type) t2::'A::type.
+ SOME x::'A::type. (t = True --> x = t1) & (t = False --> x = t2))"
+ by (import hollight DEF_COND)
+
+lemma COND_CLAUSES: "ALL (x::'A::type) xa::'A::type. COND True x xa = x & COND False x xa = xa"
+ by (import hollight COND_CLAUSES)
+
+lemma COND_EXPAND: "ALL (b::bool) (t1::bool) t2::bool. COND b t1 t2 = ((~ b | t1) & (b | t2))"
+ by (import hollight COND_EXPAND)
+
+lemma COND_ID: "ALL (b::bool) t::'A::type. COND b t t = t"
+ by (import hollight COND_ID)
+
+lemma COND_RAND: "ALL (b::bool) (f::'A::type => 'B::type) (x::'A::type) y::'A::type.
+ f (COND b x y) = COND b (f x) (f y)"
+ by (import hollight COND_RAND)
+
+lemma COND_RATOR: "ALL (b::bool) (f::'A::type => 'B::type) (g::'A::type => 'B::type)
+ x::'A::type. COND b f g x = COND b (f x) (g x)"
+ by (import hollight COND_RATOR)
+
+lemma COND_ABS: "ALL (b::bool) (f::'A::type => 'B::type) g::'A::type => 'B::type.
+ (%x::'A::type. COND b (f x) (g x)) = COND b f g"
+ by (import hollight COND_ABS)
+
+lemma MONO_COND: "((A::bool) --> (B::bool)) & ((C::bool) --> (D::bool)) -->
+COND (b::bool) A C --> COND b B D"
+ by (import hollight MONO_COND)
+
+lemma COND_ELIM_THM: "(P::'A::type => bool) (COND (c::bool) (x::'A::type) (y::'A::type)) =
+((c --> P x) & (~ c --> P y))"
+ by (import hollight COND_ELIM_THM)
+
+lemma SKOLEM_THM: "ALL P::'A::type => 'B::type => bool.
+ (ALL x::'A::type. Ex (P x)) =
+ (EX x::'A::type => 'B::type. ALL xa::'A::type. P xa (x xa))"
+ by (import hollight SKOLEM_THM)
+
+lemma UNIQUE_SKOLEM_ALT: "ALL P::'A::type => 'B::type => bool.
+ (ALL x::'A::type. Ex1 (P x)) =
+ (EX f::'A::type => 'B::type.
+ ALL (x::'A::type) y::'B::type. P x y = (f x = y))"
+ by (import hollight UNIQUE_SKOLEM_ALT)
+
+lemma COND_EQ_CLAUSE: "COND ((x::'q_3000::type) = x) (y::'q_2993::type) (z::'q_2993::type) = y"
+ by (import hollight COND_EQ_CLAUSE)
+
+lemma o_ASSOC: "ALL (f::'C::type => 'D::type) (g::'B::type => 'C::type)
+ h::'A::type => 'B::type. f o (g o h) = f o g o h"
+ by (import hollight o_ASSOC)
+
+lemma I_O_ID: "ALL f::'A::type => 'B::type. id o f = f & f o id = f"
+ by (import hollight I_O_ID)
+
+lemma EXISTS_ONE_REP: "EX x::bool. x"
+ by (import hollight EXISTS_ONE_REP)
+
+lemma one_axiom: "ALL f::'A::type => unit. All (op = f)"
+ by (import hollight one_axiom)
+
+lemma one_RECURSION: "ALL e::'A::type. EX x::unit => 'A::type. x () = e"
+ by (import hollight one_RECURSION)
+
+lemma one_Axiom: "ALL e::'A::type. EX! fn::unit => 'A::type. fn () = e"
+ by (import hollight one_Axiom)
+
+lemma th_cond: "(P::'A::type => bool => bool) (COND (b::bool) (x::'A::type) (y::'A::type))
+ b =
+(b & P x True | ~ b & P y False)"
+ by (import hollight th_cond)
+
+constdefs
+ LET_END :: "'A::type => 'A::type"
+ "LET_END == %t::'A::type. t"
+
+lemma DEF_LET_END: "LET_END = (%t::'A::type. t)"
+ by (import hollight DEF_LET_END)
+
+constdefs
+ GABS :: "('A::type => bool) => 'A::type"
+ "(op ==::(('A::type => bool) => 'A::type)
+ => (('A::type => bool) => 'A::type) => prop)
+ (GABS::('A::type => bool) => 'A::type)
+ (Eps::('A::type => bool) => 'A::type)"
+
+lemma DEF_GABS: "(op =::(('A::type => bool) => 'A::type)
+ => (('A::type => bool) => 'A::type) => bool)
+ (GABS::('A::type => bool) => 'A::type)
+ (Eps::('A::type => bool) => 'A::type)"
+ by (import hollight DEF_GABS)
+
+constdefs
+ GEQ :: "'A::type => 'A::type => bool"
+ "(op ==::('A::type => 'A::type => bool)
+ => ('A::type => 'A::type => bool) => prop)
+ (GEQ::'A::type => 'A::type => bool) (op =::'A::type => 'A::type => bool)"
+
+lemma DEF_GEQ: "(op =::('A::type => 'A::type => bool)
+ => ('A::type => 'A::type => bool) => bool)
+ (GEQ::'A::type => 'A::type => bool) (op =::'A::type => 'A::type => bool)"
+ by (import hollight DEF_GEQ)
+
+lemma PAIR_EXISTS_THM: "EX (x::'A::type => 'B::type => bool) (a::'A::type) b::'B::type.
+ x = Pair_Rep a b"
+ by (import hollight PAIR_EXISTS_THM)
+
+constdefs
+ CURRY :: "('A::type * 'B::type => 'C::type) => 'A::type => 'B::type => 'C::type"
+ "CURRY ==
+%(u::'A::type * 'B::type => 'C::type) (ua::'A::type) ub::'B::type.
+ u (ua, ub)"
+
+lemma DEF_CURRY: "CURRY =
+(%(u::'A::type * 'B::type => 'C::type) (ua::'A::type) ub::'B::type.
+ u (ua, ub))"
+ by (import hollight DEF_CURRY)
+
+constdefs
+ UNCURRY :: "('A::type => 'B::type => 'C::type) => 'A::type * 'B::type => 'C::type"
+ "UNCURRY ==
+%(u::'A::type => 'B::type => 'C::type) ua::'A::type * 'B::type.
+ u (fst ua) (snd ua)"
+
+lemma DEF_UNCURRY: "UNCURRY =
+(%(u::'A::type => 'B::type => 'C::type) ua::'A::type * 'B::type.
+ u (fst ua) (snd ua))"
+ by (import hollight DEF_UNCURRY)
+
+constdefs
+ PASSOC :: "(('A::type * 'B::type) * 'C::type => 'D::type)
+=> 'A::type * 'B::type * 'C::type => 'D::type"
+ "PASSOC ==
+%(u::('A::type * 'B::type) * 'C::type => 'D::type)
+ ua::'A::type * 'B::type * 'C::type.
+ u ((fst ua, fst (snd ua)), snd (snd ua))"
+
+lemma DEF_PASSOC: "PASSOC =
+(%(u::('A::type * 'B::type) * 'C::type => 'D::type)
+ ua::'A::type * 'B::type * 'C::type.
+ u ((fst ua, fst (snd ua)), snd (snd ua)))"
+ by (import hollight DEF_PASSOC)
+
+lemma num_Axiom: "ALL (e::'A::type) f::'A::type => nat => 'A::type.
+ EX! fn::nat => 'A::type.
+ fn (0::nat) = e & (ALL n::nat. fn (Suc n) = f (fn n) n)"
+ by (import hollight num_Axiom)
+
+lemma ADD_CLAUSES: "(ALL x::nat. (0::nat) + x = x) &
+(ALL x::nat. x + (0::nat) = x) &
+(ALL (x::nat) xa::nat. Suc x + xa = Suc (x + xa)) &
+(ALL (x::nat) xa::nat. x + Suc xa = Suc (x + xa))"
+ by (import hollight ADD_CLAUSES)
+
+lemma ADD_AC: "(m::nat) + (n::nat) = n + m &
+m + n + (p::nat) = m + (n + p) & m + (n + p) = n + (m + p)"
+ by (import hollight ADD_AC)
+
+lemma EQ_ADD_LCANCEL_0: "ALL (m::nat) n::nat. (m + n = m) = (n = (0::nat))"
+ by (import hollight EQ_ADD_LCANCEL_0)
+
+lemma EQ_ADD_RCANCEL_0: "ALL (x::nat) xa::nat. (x + xa = xa) = (x = (0::nat))"
+ by (import hollight EQ_ADD_RCANCEL_0)
+
+lemma ONE: "NUMERAL_BIT1 (0::nat) = Suc (0::nat)"
+ by (import hollight ONE)
+
+lemma TWO: "NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) = Suc (NUMERAL_BIT1 (0::nat))"
+ by (import hollight TWO)
+
+lemma ADD1: "ALL x::nat. Suc x = x + NUMERAL_BIT1 (0::nat)"
+ by (import hollight ADD1)
+
+lemma MULT_CLAUSES: "(ALL x::nat. (0::nat) * x = (0::nat)) &
+(ALL x::nat. x * (0::nat) = (0::nat)) &
+(ALL x::nat. NUMERAL_BIT1 (0::nat) * x = x) &
+(ALL x::nat. x * NUMERAL_BIT1 (0::nat) = x) &
+(ALL (x::nat) xa::nat. Suc x * xa = x * xa + xa) &
+(ALL (x::nat) xa::nat. x * Suc xa = x + x * xa)"
+ by (import hollight MULT_CLAUSES)
+
+lemma MULT_AC: "(m::nat) * (n::nat) = n * m &
+m * n * (p::nat) = m * (n * p) & m * (n * p) = n * (m * p)"
+ by (import hollight MULT_AC)
+
+lemma MULT_2: "ALL n::nat. NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * n = n + n"
+ by (import hollight MULT_2)
+
+lemma MULT_EQ_1: "ALL (m::nat) n::nat.
+ (m * n = NUMERAL_BIT1 (0::nat)) =
+ (m = NUMERAL_BIT1 (0::nat) & n = NUMERAL_BIT1 (0::nat))"
+ by (import hollight MULT_EQ_1)
+
+constdefs
+ EXP :: "nat => nat => nat"
+ "EXP ==
+SOME EXP::nat => nat => nat.
+ (ALL m::nat. EXP m (0::nat) = NUMERAL_BIT1 (0::nat)) &
+ (ALL (m::nat) n::nat. EXP m (Suc n) = m * EXP m n)"
+
+lemma DEF_EXP: "EXP =
+(SOME EXP::nat => nat => nat.
+ (ALL m::nat. EXP m (0::nat) = NUMERAL_BIT1 (0::nat)) &
+ (ALL (m::nat) n::nat. EXP m (Suc n) = m * EXP m n))"
+ by (import hollight DEF_EXP)
+
+lemma EXP_EQ_0: "ALL (m::nat) n::nat. (EXP m n = (0::nat)) = (m = (0::nat) & n ~= (0::nat))"
+ by (import hollight EXP_EQ_0)
+
+lemma EXP_ADD: "ALL (m::nat) (n::nat) p::nat. EXP m (n + p) = EXP m n * EXP m p"
+ by (import hollight EXP_ADD)
+
+lemma EXP_ONE: "ALL n::nat. EXP (NUMERAL_BIT1 (0::nat)) n = NUMERAL_BIT1 (0::nat)"
+ by (import hollight EXP_ONE)
+
+lemma EXP_1: "ALL x::nat. EXP x (NUMERAL_BIT1 (0::nat)) = x"
+ by (import hollight EXP_1)
+
+lemma EXP_2: "ALL x::nat. EXP x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) = x * x"
+ by (import hollight EXP_2)
+
+lemma MULT_EXP: "ALL (p::nat) (m::nat) n::nat. EXP (m * n) p = EXP m p * EXP n p"
+ by (import hollight MULT_EXP)
+
+lemma EXP_MULT: "ALL (m::nat) (n::nat) p::nat. EXP m (n * p) = EXP (EXP m n) p"
+ by (import hollight EXP_MULT)
+
+consts
+ "<=" :: "nat => nat => bool" ("<=")
+
+defs
+ "<=_def": "<= ==
+SOME u::nat => nat => bool.
+ (ALL m::nat. u m (0::nat) = (m = (0::nat))) &
+ (ALL (m::nat) n::nat. u m (Suc n) = (m = Suc n | u m n))"
+
+lemma DEF__lessthan__equal_: "<= =
+(SOME u::nat => nat => bool.
+ (ALL m::nat. u m (0::nat) = (m = (0::nat))) &
+ (ALL (m::nat) n::nat. u m (Suc n) = (m = Suc n | u m n)))"
+ by (import hollight DEF__lessthan__equal_)
+
+consts
+ "<" :: "nat => nat => bool" ("<")
+
+defs
+ "<_def": "< ==
+SOME u::nat => nat => bool.
+ (ALL m::nat. u m (0::nat) = False) &
+ (ALL (m::nat) n::nat. u m (Suc n) = (m = n | u m n))"
+
+lemma DEF__lessthan_: "< =
+(SOME u::nat => nat => bool.
+ (ALL m::nat. u m (0::nat) = False) &
+ (ALL (m::nat) n::nat. u m (Suc n) = (m = n | u m n)))"
+ by (import hollight DEF__lessthan_)
+
+consts
+ ">=" :: "nat => nat => bool" (">=")
+
+defs
+ ">=_def": ">= == %(u::nat) ua::nat. <= ua u"
+
+lemma DEF__greaterthan__equal_: ">= = (%(u::nat) ua::nat. <= ua u)"
+ by (import hollight DEF__greaterthan__equal_)
+
+consts
+ ">" :: "nat => nat => bool" (">")
+
+defs
+ ">_def": "> == %(u::nat) ua::nat. < ua u"
+
+lemma DEF__greaterthan_: "> = (%(u::nat) ua::nat. < ua u)"
+ by (import hollight DEF__greaterthan_)
+
+lemma LE_SUC_LT: "ALL (m::nat) n::nat. <= (Suc m) n = < m n"
+ by (import hollight LE_SUC_LT)
+
+lemma LT_SUC_LE: "ALL (m::nat) n::nat. < m (Suc n) = <= m n"
+ by (import hollight LT_SUC_LE)
+
+lemma LE_SUC: "ALL (x::nat) xa::nat. <= (Suc x) (Suc xa) = <= x xa"
+ by (import hollight LE_SUC)
+
+lemma LT_SUC: "ALL (x::nat) xa::nat. < (Suc x) (Suc xa) = < x xa"
+ by (import hollight LT_SUC)
+
+lemma LE_0: "All (<= (0::nat))"
+ by (import hollight LE_0)
+
+lemma LT_0: "ALL x::nat. < (0::nat) (Suc x)"
+ by (import hollight LT_0)
+
+lemma LE_REFL: "ALL n::nat. <= n n"
+ by (import hollight LE_REFL)
+
+lemma LT_REFL: "ALL n::nat. ~ < n n"
+ by (import hollight LT_REFL)
+
+lemma LE_ANTISYM: "ALL (m::nat) n::nat. (<= m n & <= n m) = (m = n)"
+ by (import hollight LE_ANTISYM)
+
+lemma LT_ANTISYM: "ALL (m::nat) n::nat. ~ (< m n & < n m)"
+ by (import hollight LT_ANTISYM)
+
+lemma LET_ANTISYM: "ALL (m::nat) n::nat. ~ (<= m n & < n m)"
+ by (import hollight LET_ANTISYM)
+
+lemma LTE_ANTISYM: "ALL (x::nat) xa::nat. ~ (< x xa & <= xa x)"
+ by (import hollight LTE_ANTISYM)
+
+lemma LE_TRANS: "ALL (m::nat) (n::nat) p::nat. <= m n & <= n p --> <= m p"
+ by (import hollight LE_TRANS)
+
+lemma LT_TRANS: "ALL (m::nat) (n::nat) p::nat. < m n & < n p --> < m p"
+ by (import hollight LT_TRANS)
+
+lemma LET_TRANS: "ALL (m::nat) (n::nat) p::nat. <= m n & < n p --> < m p"
+ by (import hollight LET_TRANS)
+
+lemma LTE_TRANS: "ALL (m::nat) (n::nat) p::nat. < m n & <= n p --> < m p"
+ by (import hollight LTE_TRANS)
+
+lemma LE_CASES: "ALL (m::nat) n::nat. <= m n | <= n m"
+ by (import hollight LE_CASES)
+
+lemma LT_CASES: "ALL (m::nat) n::nat. < m n | < n m | m = n"
+ by (import hollight LT_CASES)
+
+lemma LET_CASES: "ALL (m::nat) n::nat. <= m n | < n m"
+ by (import hollight LET_CASES)
+
+lemma LTE_CASES: "ALL (x::nat) xa::nat. < x xa | <= xa x"
+ by (import hollight LTE_CASES)
+
+lemma LT_NZ: "ALL n::nat. < (0::nat) n = (n ~= (0::nat))"
+ by (import hollight LT_NZ)
+
+lemma LE_LT: "ALL (m::nat) n::nat. <= m n = (< m n | m = n)"
+ by (import hollight LE_LT)
+
+lemma LT_LE: "ALL (x::nat) xa::nat. < x xa = (<= x xa & x ~= xa)"
+ by (import hollight LT_LE)
+
+lemma NOT_LE: "ALL (m::nat) n::nat. (~ <= m n) = < n m"
+ by (import hollight NOT_LE)
+
+lemma NOT_LT: "ALL (m::nat) n::nat. (~ < m n) = <= n m"
+ by (import hollight NOT_LT)
+
+lemma LT_IMP_LE: "ALL (x::nat) xa::nat. < x xa --> <= x xa"
+ by (import hollight LT_IMP_LE)
+
+lemma EQ_IMP_LE: "ALL (m::nat) n::nat. m = n --> <= m n"
+ by (import hollight EQ_IMP_LE)
+
+lemma LE_EXISTS: "ALL (m::nat) n::nat. <= m n = (EX d::nat. n = m + d)"
+ by (import hollight LE_EXISTS)
+
+lemma LT_EXISTS: "ALL (m::nat) n::nat. < m n = (EX d::nat. n = m + Suc d)"
+ by (import hollight LT_EXISTS)
+
+lemma LE_ADD: "ALL (m::nat) n::nat. <= m (m + n)"
+ by (import hollight LE_ADD)
+
+lemma LE_ADDR: "ALL (x::nat) xa::nat. <= xa (x + xa)"
+ by (import hollight LE_ADDR)
+
+lemma LT_ADD: "ALL (m::nat) n::nat. < m (m + n) = < (0::nat) n"
+ by (import hollight LT_ADD)
+
+lemma LT_ADDR: "ALL (x::nat) xa::nat. < xa (x + xa) = < (0::nat) x"
+ by (import hollight LT_ADDR)
+
+lemma LE_ADD_LCANCEL: "ALL (x::nat) (xa::nat) xb::nat. <= (x + xa) (x + xb) = <= xa xb"
+ by (import hollight LE_ADD_LCANCEL)
+
+lemma LE_ADD_RCANCEL: "ALL (x::nat) (xa::nat) xb::nat. <= (x + xb) (xa + xb) = <= x xa"
+ by (import hollight LE_ADD_RCANCEL)
+
+lemma LT_ADD_LCANCEL: "ALL (x::nat) (xa::nat) xb::nat. < (x + xa) (x + xb) = < xa xb"
+ by (import hollight LT_ADD_LCANCEL)
+
+lemma LT_ADD_RCANCEL: "ALL (x::nat) (xa::nat) xb::nat. < (x + xb) (xa + xb) = < x xa"
+ by (import hollight LT_ADD_RCANCEL)
+
+lemma LE_ADD2: "ALL (m::nat) (n::nat) (p::nat) q::nat.
+ <= m p & <= n q --> <= (m + n) (p + q)"
+ by (import hollight LE_ADD2)
+
+lemma LET_ADD2: "ALL (m::nat) (n::nat) (p::nat) q::nat. <= m p & < n q --> < (m + n) (p + q)"
+ by (import hollight LET_ADD2)
+
+lemma LTE_ADD2: "ALL (x::nat) (xa::nat) (xb::nat) xc::nat.
+ < x xb & <= xa xc --> < (x + xa) (xb + xc)"
+ by (import hollight LTE_ADD2)
+
+lemma LT_ADD2: "ALL (m::nat) (n::nat) (p::nat) q::nat. < m p & < n q --> < (m + n) (p + q)"
+ by (import hollight LT_ADD2)
+
+lemma LT_MULT: "ALL (m::nat) n::nat. < (0::nat) (m * n) = (< (0::nat) m & < (0::nat) n)"
+ by (import hollight LT_MULT)
+
+lemma LE_MULT2: "ALL (m::nat) (n::nat) (p::nat) q::nat.
+ <= m n & <= p q --> <= (m * p) (n * q)"
+ by (import hollight LE_MULT2)
+
+lemma LT_LMULT: "ALL (m::nat) (n::nat) p::nat. m ~= (0::nat) & < n p --> < (m * n) (m * p)"
+ by (import hollight LT_LMULT)
+
+lemma LE_MULT_LCANCEL: "ALL (m::nat) (n::nat) p::nat. <= (m * n) (m * p) = (m = (0::nat) | <= n p)"
+ by (import hollight LE_MULT_LCANCEL)
+
+lemma LE_MULT_RCANCEL: "ALL (x::nat) (xa::nat) xb::nat.
+ <= (x * xb) (xa * xb) = (<= x xa | xb = (0::nat))"
+ by (import hollight LE_MULT_RCANCEL)
+
+lemma LT_MULT_LCANCEL: "ALL (m::nat) (n::nat) p::nat. < (m * n) (m * p) = (m ~= (0::nat) & < n p)"
+ by (import hollight LT_MULT_LCANCEL)
+
+lemma LT_MULT_RCANCEL: "ALL (x::nat) (xa::nat) xb::nat.
+ < (x * xb) (xa * xb) = (< x xa & xb ~= (0::nat))"
+ by (import hollight LT_MULT_RCANCEL)
+
+lemma LT_MULT2: "ALL (m::nat) (n::nat) (p::nat) q::nat. < m n & < p q --> < (m * p) (n * q)"
+ by (import hollight LT_MULT2)
+
+lemma LE_SQUARE_REFL: "ALL n::nat. <= n (n * n)"
+ by (import hollight LE_SQUARE_REFL)
+
+lemma WLOG_LE: "(ALL (m::nat) n::nat. (P::nat => nat => bool) m n = P n m) &
+(ALL (m::nat) n::nat. <= m n --> P m n) -->
+(ALL m::nat. All (P m))"
+ by (import hollight WLOG_LE)
+
+lemma WLOG_LT: "(ALL m::nat. (P::nat => nat => bool) m m) &
+(ALL (m::nat) n::nat. P m n = P n m) &
+(ALL (m::nat) n::nat. < m n --> P m n) -->
+(ALL m::nat. All (P m))"
+ by (import hollight WLOG_LT)
+
+lemma num_WF: "ALL P::nat => bool.
+ (ALL n::nat. (ALL m::nat. < m n --> P m) --> P n) --> All P"
+ by (import hollight num_WF)
+
+lemma num_WOP: "ALL P::nat => bool. Ex P = (EX n::nat. P n & (ALL m::nat. < m n --> ~ P m))"
+ by (import hollight num_WOP)
+
+lemma num_MAX: "ALL P::nat => bool.
+ (Ex P & (EX M::nat. ALL x::nat. P x --> <= x M)) =
+ (EX m::nat. P m & (ALL x::nat. P x --> <= x m))"
+ by (import hollight num_MAX)
+
+constdefs
+ EVEN :: "nat => bool"
+ "EVEN ==
+SOME EVEN::nat => bool.
+ EVEN (0::nat) = True & (ALL n::nat. EVEN (Suc n) = (~ EVEN n))"
+
+lemma DEF_EVEN: "EVEN =
+(SOME EVEN::nat => bool.
+ EVEN (0::nat) = True & (ALL n::nat. EVEN (Suc n) = (~ EVEN n)))"
+ by (import hollight DEF_EVEN)
+
+constdefs
+ ODD :: "nat => bool"
+ "ODD ==
+SOME ODD::nat => bool.
+ ODD (0::nat) = False & (ALL n::nat. ODD (Suc n) = (~ ODD n))"
+
+lemma DEF_ODD: "ODD =
+(SOME ODD::nat => bool.
+ ODD (0::nat) = False & (ALL n::nat. ODD (Suc n) = (~ ODD n)))"
+ by (import hollight DEF_ODD)
+
+lemma NOT_EVEN: "ALL n::nat. (~ EVEN n) = ODD n"
+ by (import hollight NOT_EVEN)
+
+lemma NOT_ODD: "ALL n::nat. (~ ODD n) = EVEN n"
+ by (import hollight NOT_ODD)
+
+lemma EVEN_OR_ODD: "ALL n::nat. EVEN n | ODD n"
+ by (import hollight EVEN_OR_ODD)
+
+lemma EVEN_AND_ODD: "ALL x::nat. ~ (EVEN x & ODD x)"
+ by (import hollight EVEN_AND_ODD)
+
+lemma EVEN_ADD: "ALL (m::nat) n::nat. EVEN (m + n) = (EVEN m = EVEN n)"
+ by (import hollight EVEN_ADD)
+
+lemma EVEN_MULT: "ALL (m::nat) n::nat. EVEN (m * n) = (EVEN m | EVEN n)"
+ by (import hollight EVEN_MULT)
+
+lemma EVEN_EXP: "ALL (m::nat) n::nat. EVEN (EXP m n) = (EVEN m & n ~= (0::nat))"
+ by (import hollight EVEN_EXP)
+
+lemma ODD_ADD: "ALL (m::nat) n::nat. ODD (m + n) = (ODD m ~= ODD n)"
+ by (import hollight ODD_ADD)
+
+lemma ODD_MULT: "ALL (m::nat) n::nat. ODD (m * n) = (ODD m & ODD n)"
+ by (import hollight ODD_MULT)
+
+lemma ODD_EXP: "ALL (m::nat) n::nat. ODD (EXP m n) = (ODD m | n = (0::nat))"
+ by (import hollight ODD_EXP)
+
+lemma EVEN_DOUBLE: "ALL n::nat. EVEN (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * n)"
+ by (import hollight EVEN_DOUBLE)
+
+lemma ODD_DOUBLE: "ALL x::nat. ODD (Suc (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * x))"
+ by (import hollight ODD_DOUBLE)
+
+lemma EVEN_EXISTS_LEMMA: "ALL n::nat.
+ (EVEN n --> (EX m::nat. n = NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * m)) &
+ (~ EVEN n -->
+ (EX m::nat. n = Suc (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * m)))"
+ by (import hollight EVEN_EXISTS_LEMMA)
+
+lemma EVEN_EXISTS: "ALL n::nat.
+ EVEN n = (EX m::nat. n = NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * m)"
+ by (import hollight EVEN_EXISTS)
+
+lemma ODD_EXISTS: "ALL n::nat.
+ ODD n = (EX m::nat. n = Suc (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * m))"
+ by (import hollight ODD_EXISTS)
+
+lemma EVEN_ODD_DECOMPOSITION: "ALL n::nat.
+ (EX (k::nat) m::nat.
+ ODD m & n = EXP (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) k * m) =
+ (n ~= (0::nat))"
+ by (import hollight EVEN_ODD_DECOMPOSITION)
+
+lemma SUB_0: "ALL x::nat. (0::nat) - x = (0::nat) & x - (0::nat) = x"
+ by (import hollight SUB_0)
+
+lemma SUB_PRESUC: "ALL (m::nat) n::nat. Pred (Suc m - n) = m - n"
+ by (import hollight SUB_PRESUC)
+
+lemma SUB_EQ_0: "ALL (m::nat) n::nat. (m - n = (0::nat)) = <= m n"
+ by (import hollight SUB_EQ_0)
+
+lemma ADD_SUBR: "ALL (x::nat) xa::nat. xa - (x + xa) = (0::nat)"
+ by (import hollight ADD_SUBR)
+
+lemma SUB_ADD: "ALL (x::nat) xa::nat. <= xa x --> x - xa + xa = x"
+ by (import hollight SUB_ADD)
+
+lemma SUC_SUB1: "ALL x::nat. Suc x - NUMERAL_BIT1 (0::nat) = x"
+ by (import hollight SUC_SUB1)
+
+constdefs
+ FACT :: "nat => nat"
+ "FACT ==
+SOME FACT::nat => nat.
+ FACT (0::nat) = NUMERAL_BIT1 (0::nat) &
+ (ALL n::nat. FACT (Suc n) = Suc n * FACT n)"
+
+lemma DEF_FACT: "FACT =
+(SOME FACT::nat => nat.
+ FACT (0::nat) = NUMERAL_BIT1 (0::nat) &
+ (ALL n::nat. FACT (Suc n) = Suc n * FACT n))"
+ by (import hollight DEF_FACT)
+
+lemma FACT_LT: "ALL n::nat. < (0::nat) (FACT n)"
+ by (import hollight FACT_LT)
+
+lemma FACT_LE: "ALL x::nat. <= (NUMERAL_BIT1 (0::nat)) (FACT x)"
+ by (import hollight FACT_LE)
+
+lemma FACT_MONO: "ALL (m::nat) n::nat. <= m n --> <= (FACT m) (FACT n)"
+ by (import hollight FACT_MONO)
+
+lemma DIVMOD_EXIST: "ALL (m::nat) n::nat.
+ n ~= (0::nat) --> (EX (q::nat) r::nat. m = q * n + r & < r n)"
+ by (import hollight DIVMOD_EXIST)
+
+lemma DIVMOD_EXIST_0: "ALL (m::nat) n::nat.
+ EX (x::nat) xa::nat.
+ COND (n = (0::nat)) (x = (0::nat) & xa = (0::nat))
+ (m = x * n + xa & < xa n)"
+ by (import hollight DIVMOD_EXIST_0)
+
+constdefs
+ DIV :: "nat => nat => nat"
+ "DIV ==
+SOME q::nat => nat => nat.
+ EX r::nat => nat => nat.
+ ALL (m::nat) n::nat.
+ COND (n = (0::nat)) (q m n = (0::nat) & r m n = (0::nat))
+ (m = q m n * n + r m n & < (r m n) n)"
+
+lemma DEF_DIV: "DIV =
+(SOME q::nat => nat => nat.
+ EX r::nat => nat => nat.
+ ALL (m::nat) n::nat.
+ COND (n = (0::nat)) (q m n = (0::nat) & r m n = (0::nat))
+ (m = q m n * n + r m n & < (r m n) n))"
+ by (import hollight DEF_DIV)
+
+constdefs
+ MOD :: "nat => nat => nat"
+ "MOD ==
+SOME r::nat => nat => nat.
+ ALL (m::nat) n::nat.
+ COND (n = (0::nat)) (DIV m n = (0::nat) & r m n = (0::nat))
+ (m = DIV m n * n + r m n & < (r m n) n)"
+
+lemma DEF_MOD: "MOD =
+(SOME r::nat => nat => nat.
+ ALL (m::nat) n::nat.
+ COND (n = (0::nat)) (DIV m n = (0::nat) & r m n = (0::nat))
+ (m = DIV m n * n + r m n & < (r m n) n))"
+ by (import hollight DEF_MOD)
+
+lemma DIVISION: "ALL (m::nat) n::nat.
+ n ~= (0::nat) --> m = DIV m n * n + MOD m n & < (MOD m n) n"
+ by (import hollight DIVISION)
+
+lemma DIVMOD_UNIQ_LEMMA: "ALL (m::nat) (n::nat) (q1::nat) (r1::nat) (q2::nat) r2::nat.
+ (m = q1 * n + r1 & < r1 n) & m = q2 * n + r2 & < r2 n -->
+ q1 = q2 & r1 = r2"
+ by (import hollight DIVMOD_UNIQ_LEMMA)
+
+lemma DIVMOD_UNIQ: "ALL (m::nat) (n::nat) (q::nat) r::nat.
+ m = q * n + r & < r n --> DIV m n = q & MOD m n = r"
+ by (import hollight DIVMOD_UNIQ)
+
+lemma MOD_UNIQ: "ALL (m::nat) (n::nat) (q::nat) r::nat. m = q * n + r & < r n --> MOD m n = r"
+ by (import hollight MOD_UNIQ)
+
+lemma DIV_UNIQ: "ALL (m::nat) (n::nat) (q::nat) r::nat. m = q * n + r & < r n --> DIV m n = q"
+ by (import hollight DIV_UNIQ)
+
+lemma MOD_MULT: "ALL (x::nat) xa::nat. x ~= (0::nat) --> MOD (x * xa) x = (0::nat)"
+ by (import hollight MOD_MULT)
+
+lemma DIV_MULT: "ALL (x::nat) xa::nat. x ~= (0::nat) --> DIV (x * xa) x = xa"
+ by (import hollight DIV_MULT)
+
+lemma DIV_DIV: "ALL (m::nat) (n::nat) p::nat.
+ n * p ~= (0::nat) --> DIV (DIV m n) p = DIV m (n * p)"
+ by (import hollight DIV_DIV)
+
+lemma MOD_LT: "ALL (m::nat) n::nat. < m n --> MOD m n = m"
+ by (import hollight MOD_LT)
+
+lemma MOD_EQ: "ALL (m::nat) (n::nat) (p::nat) q::nat. m = n + q * p --> MOD m p = MOD n p"
+ by (import hollight MOD_EQ)
+
+lemma DIV_MOD: "ALL (m::nat) (n::nat) p::nat.
+ n * p ~= (0::nat) --> MOD (DIV m n) p = DIV (MOD m (n * p)) n"
+ by (import hollight DIV_MOD)
+
+lemma DIV_1: "ALL n::nat. DIV n (NUMERAL_BIT1 (0::nat)) = n"
+ by (import hollight DIV_1)
+
+lemma EXP_LT_0: "ALL (x::nat) xa::nat.
+ < (0::nat) (EXP xa x) = (xa ~= (0::nat) | x = (0::nat))"
+ by (import hollight EXP_LT_0)
+
+lemma DIV_LE: "ALL (m::nat) n::nat. n ~= (0::nat) --> <= (DIV m n) m"
+ by (import hollight DIV_LE)
+
+lemma DIV_MUL_LE: "ALL (m::nat) n::nat. <= (n * DIV m n) m"
+ by (import hollight DIV_MUL_LE)
+
+lemma DIV_0: "ALL n::nat. n ~= (0::nat) --> DIV (0::nat) n = (0::nat)"
+ by (import hollight DIV_0)
+
+lemma MOD_0: "ALL n::nat. n ~= (0::nat) --> MOD (0::nat) n = (0::nat)"
+ by (import hollight MOD_0)
+
+lemma DIV_LT: "ALL (m::nat) n::nat. < m n --> DIV m n = (0::nat)"
+ by (import hollight DIV_LT)
+
+lemma MOD_MOD: "ALL (m::nat) (n::nat) p::nat.
+ n * p ~= (0::nat) --> MOD (MOD m (n * p)) n = MOD m n"
+ by (import hollight MOD_MOD)
+
+lemma MOD_MOD_REFL: "ALL (m::nat) n::nat. n ~= (0::nat) --> MOD (MOD m n) n = MOD m n"
+ by (import hollight MOD_MOD_REFL)
+
+lemma DIV_MULT2: "ALL (x::nat) (xa::nat) xb::nat.
+ x * xb ~= (0::nat) --> DIV (x * xa) (x * xb) = DIV xa xb"
+ by (import hollight DIV_MULT2)
+
+lemma MOD_MULT2: "ALL (x::nat) (xa::nat) xb::nat.
+ x * xb ~= (0::nat) --> MOD (x * xa) (x * xb) = x * MOD xa xb"
+ by (import hollight MOD_MULT2)
+
+lemma MOD_1: "ALL n::nat. MOD n (NUMERAL_BIT1 (0::nat)) = (0::nat)"
+ by (import hollight MOD_1)
+
+lemma MOD_EXISTS: "ALL (m::nat) n::nat.
+ (EX q::nat. m = n * q) =
+ COND (n = (0::nat)) (m = (0::nat)) (MOD m n = (0::nat))"
+ by (import hollight MOD_EXISTS)
+
+lemma LT_EXP: "ALL (x::nat) (m::nat) n::nat.
+ < (EXP x m) (EXP x n) =
+ (<= (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) x & < m n |
+ x = (0::nat) & m ~= (0::nat) & n = (0::nat))"
+ by (import hollight LT_EXP)
+
+lemma LE_EXP: "ALL (x::nat) (m::nat) n::nat.
+ <= (EXP x m) (EXP x n) =
+ COND (x = (0::nat)) (m = (0::nat) --> n = (0::nat))
+ (x = NUMERAL_BIT1 (0::nat) | <= m n)"
+ by (import hollight LE_EXP)
+
+lemma DIV_MONO: "ALL (m::nat) (n::nat) p::nat.
+ p ~= (0::nat) & <= m n --> <= (DIV m p) (DIV n p)"
+ by (import hollight DIV_MONO)
+
+lemma DIV_MONO_LT: "ALL (m::nat) (n::nat) p::nat.
+ p ~= (0::nat) & <= (m + p) n --> < (DIV m p) (DIV n p)"
+ by (import hollight DIV_MONO_LT)
+
+lemma LE_LDIV: "ALL (a::nat) (b::nat) n::nat.
+ a ~= (0::nat) & <= b (a * n) --> <= (DIV b a) n"
+ by (import hollight LE_LDIV)
+
+lemma LE_RDIV_EQ: "ALL (a::nat) (b::nat) n::nat.
+ a ~= (0::nat) --> <= n (DIV b a) = <= (a * n) b"
+ by (import hollight LE_RDIV_EQ)
+
+lemma LE_LDIV_EQ: "ALL (a::nat) (b::nat) n::nat.
+ a ~= (0::nat) --> <= (DIV b a) n = < b (a * (n + NUMERAL_BIT1 (0::nat)))"
+ by (import hollight LE_LDIV_EQ)
+
+lemma DIV_EQ_0: "ALL (m::nat) n::nat. n ~= (0::nat) --> (DIV m n = (0::nat)) = < m n"
+ by (import hollight DIV_EQ_0)
+
+lemma MOD_EQ_0: "ALL (m::nat) n::nat.
+ n ~= (0::nat) --> (MOD m n = (0::nat)) = (EX q::nat. m = q * n)"
+ by (import hollight MOD_EQ_0)
+
+lemma EVEN_MOD: "ALL n::nat.
+ EVEN n = (MOD n (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) = (0::nat))"
+ by (import hollight EVEN_MOD)
+
+lemma ODD_MOD: "ALL n::nat.
+ ODD n =
+ (MOD n (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) = NUMERAL_BIT1 (0::nat))"
+ by (import hollight ODD_MOD)
+
+lemma MOD_MULT_RMOD: "ALL (m::nat) (n::nat) p::nat.
+ n ~= (0::nat) --> MOD (m * MOD p n) n = MOD (m * p) n"
+ by (import hollight MOD_MULT_RMOD)
+
+lemma MOD_MULT_LMOD: "ALL (x::nat) (xa::nat) xb::nat.
+ xa ~= (0::nat) --> MOD (MOD x xa * xb) xa = MOD (x * xb) xa"
+ by (import hollight MOD_MULT_LMOD)
+
+lemma MOD_MULT_MOD2: "ALL (x::nat) (xa::nat) xb::nat.
+ xa ~= (0::nat) --> MOD (MOD x xa * MOD xb xa) xa = MOD (x * xb) xa"
+ by (import hollight MOD_MULT_MOD2)
+
+lemma MOD_EXP_MOD: "ALL (m::nat) (n::nat) p::nat.
+ n ~= (0::nat) --> MOD (EXP (MOD m n) p) n = MOD (EXP m p) n"
+ by (import hollight MOD_EXP_MOD)
+
+lemma MOD_MULT_ADD: "ALL (m::nat) (n::nat) p::nat. MOD (m * n + p) n = MOD p n"
+ by (import hollight MOD_MULT_ADD)
+
+lemma MOD_ADD_MOD: "ALL (a::nat) (b::nat) n::nat.
+ n ~= (0::nat) --> MOD (MOD a n + MOD b n) n = MOD (a + b) n"
+ by (import hollight MOD_ADD_MOD)
+
+lemma DIV_ADD_MOD: "ALL (a::nat) (b::nat) n::nat.
+ n ~= (0::nat) -->
+ (MOD (a + b) n = MOD a n + MOD b n) = (DIV (a + b) n = DIV a n + DIV b n)"
+ by (import hollight DIV_ADD_MOD)
+
+lemma DIV_REFL: "ALL n::nat. n ~= (0::nat) --> DIV n n = NUMERAL_BIT1 (0::nat)"
+ by (import hollight DIV_REFL)
+
+lemma MOD_LE: "ALL (m::nat) n::nat. n ~= (0::nat) --> <= (MOD m n) m"
+ by (import hollight MOD_LE)
+
+lemma DIV_MONO2: "ALL (m::nat) (n::nat) p::nat.
+ p ~= (0::nat) & <= p m --> <= (DIV n m) (DIV n p)"
+ by (import hollight DIV_MONO2)
+
+lemma DIV_LE_EXCLUSION: "ALL (a::nat) (b::nat) (c::nat) d::nat.
+ b ~= (0::nat) & < (b * c) ((a + NUMERAL_BIT1 (0::nat)) * d) -->
+ <= (DIV c d) (DIV a b)"
+ by (import hollight DIV_LE_EXCLUSION)
+
+lemma DIV_EQ_EXCLUSION: "< ((b::nat) * (c::nat)) (((a::nat) + NUMERAL_BIT1 (0::nat)) * (d::nat)) &
+< (a * d) ((c + NUMERAL_BIT1 (0::nat)) * b) -->
+DIV a b = DIV c d"
+ by (import hollight DIV_EQ_EXCLUSION)
+
+lemma SUB_ELIM_THM: "(P::nat => bool) ((a::nat) - (b::nat)) =
+(ALL x::nat. (b = a + x --> P (0::nat)) & (a = b + x --> P x))"
+ by (import hollight SUB_ELIM_THM)
+
+lemma PRE_ELIM_THM: "(P::nat => bool) (Pred (n::nat)) =
+(ALL m::nat. (n = (0::nat) --> P (0::nat)) & (n = Suc m --> P m))"
+ by (import hollight PRE_ELIM_THM)
+
+lemma DIVMOD_ELIM_THM: "(P::nat => nat => bool) (DIV (m::nat) (n::nat)) (MOD m n) =
+(n = (0::nat) & P (0::nat) (0::nat) |
+ n ~= (0::nat) & (ALL (q::nat) r::nat. m = q * n + r & < r n --> P q r))"
+ by (import hollight DIVMOD_ELIM_THM)
+
+constdefs
+ eqeq :: "'q_9910::type
+=> 'q_9909::type => ('q_9910::type => 'q_9909::type => bool) => bool"
+ "eqeq ==
+%(u::'q_9910::type) (ua::'q_9909::type)
+ ub::'q_9910::type => 'q_9909::type => bool. ub u ua"
+
+lemma DEF__equal__equal_: "eqeq =
+(%(u::'q_9910::type) (ua::'q_9909::type)
+ ub::'q_9910::type => 'q_9909::type => bool. ub u ua)"
+ by (import hollight DEF__equal__equal_)
+
+constdefs
+ mod_nat :: "nat => nat => nat => bool"
+ "mod_nat ==
+%(u::nat) (ua::nat) ub::nat. EX (q1::nat) q2::nat. ua + u * q1 = ub + u * q2"
+
+lemma DEF_mod_nat: "mod_nat =
+(%(u::nat) (ua::nat) ub::nat.
+ EX (q1::nat) q2::nat. ua + u * q1 = ub + u * q2)"
+ by (import hollight DEF_mod_nat)
+
+constdefs
+ minimal :: "(nat => bool) => nat"
+ "minimal == %u::nat => bool. SOME n::nat. u n & (ALL m::nat. < m n --> ~ u m)"
+
+lemma DEF_minimal: "minimal =
+(%u::nat => bool. SOME n::nat. u n & (ALL m::nat. < m n --> ~ u m))"
+ by (import hollight DEF_minimal)
+
+lemma MINIMAL: "ALL P::nat => bool.
+ Ex P = (P (minimal P) & (ALL x::nat. < x (minimal P) --> ~ P x))"
+ by (import hollight MINIMAL)
+
+constdefs
+ WF :: "('A::type => 'A::type => bool) => bool"
+ "WF ==
+%u::'A::type => 'A::type => bool.
+ ALL P::'A::type => bool.
+ Ex P --> (EX x::'A::type. P x & (ALL y::'A::type. u y x --> ~ P y))"
+
+lemma DEF_WF: "WF =
+(%u::'A::type => 'A::type => bool.
+ ALL P::'A::type => bool.
+ Ex P --> (EX x::'A::type. P x & (ALL y::'A::type. u y x --> ~ P y)))"
+ by (import hollight DEF_WF)
+
+lemma WF_EQ: "WF (u_354::'A::type => 'A::type => bool) =
+(ALL P::'A::type => bool.
+ Ex P = (EX x::'A::type. P x & (ALL y::'A::type. u_354 y x --> ~ P y)))"
+ by (import hollight WF_EQ)
+
+lemma WF_IND: "WF (u_354::'A::type => 'A::type => bool) =
+(ALL P::'A::type => bool.
+ (ALL x::'A::type. (ALL y::'A::type. u_354 y x --> P y) --> P x) -->
+ All P)"
+ by (import hollight WF_IND)
+
+lemma WF_DCHAIN: "WF (u_354::'A::type => 'A::type => bool) =
+(~ (EX s::nat => 'A::type. ALL n::nat. u_354 (s (Suc n)) (s n)))"
+ by (import hollight WF_DCHAIN)
+
+lemma WF_UREC: "WF (u_354::'A::type => 'A::type => bool) -->
+(ALL H::('A::type => 'B::type) => 'A::type => 'B::type.
+ (ALL (f::'A::type => 'B::type) (g::'A::type => 'B::type) x::'A::type.
+ (ALL z::'A::type. u_354 z x --> f z = g z) --> H f x = H g x) -->
+ (ALL (f::'A::type => 'B::type) g::'A::type => 'B::type.
+ (ALL x::'A::type. f x = H f x) & (ALL x::'A::type. g x = H g x) -->
+ f = g))"
+ by (import hollight WF_UREC)
+
+lemma WF_UREC_WF: "(ALL H::('A::type => bool) => 'A::type => bool.
+ (ALL (f::'A::type => bool) (g::'A::type => bool) x::'A::type.
+ (ALL z::'A::type.
+ (u_354::'A::type => 'A::type => bool) z x --> f z = g z) -->
+ H f x = H g x) -->
+ (ALL (f::'A::type => bool) g::'A::type => bool.
+ (ALL x::'A::type. f x = H f x) & (ALL x::'A::type. g x = H g x) -->
+ f = g)) -->
+WF u_354"
+ by (import hollight WF_UREC_WF)
+
+lemma WF_REC_INVARIANT: "WF (u_354::'A::type => 'A::type => bool) -->
+(ALL (H::('A::type => 'B::type) => 'A::type => 'B::type)
+ S::'A::type => 'B::type => bool.
+ (ALL (f::'A::type => 'B::type) (g::'A::type => 'B::type) x::'A::type.
+ (ALL z::'A::type. u_354 z x --> f z = g z & S z (f z)) -->
+ H f x = H g x & S x (H f x)) -->
+ (EX f::'A::type => 'B::type. ALL x::'A::type. f x = H f x))"
+ by (import hollight WF_REC_INVARIANT)
+
+lemma WF_REC: "WF (u_354::'A::type => 'A::type => bool) -->
+(ALL H::('A::type => 'B::type) => 'A::type => 'B::type.
+ (ALL (f::'A::type => 'B::type) (g::'A::type => 'B::type) x::'A::type.
+ (ALL z::'A::type. u_354 z x --> f z = g z) --> H f x = H g x) -->
+ (EX f::'A::type => 'B::type. ALL x::'A::type. f x = H f x))"
+ by (import hollight WF_REC)
+
+lemma WF_REC_WF: "(ALL H::('A::type => nat) => 'A::type => nat.
+ (ALL (f::'A::type => nat) (g::'A::type => nat) x::'A::type.
+ (ALL z::'A::type.
+ (u_354::'A::type => 'A::type => bool) z x --> f z = g z) -->
+ H f x = H g x) -->
+ (EX f::'A::type => nat. ALL x::'A::type. f x = H f x)) -->
+WF u_354"
+ by (import hollight WF_REC_WF)
+
+lemma WF_EREC: "WF (u_354::'A::type => 'A::type => bool) -->
+(ALL H::('A::type => 'B::type) => 'A::type => 'B::type.
+ (ALL (f::'A::type => 'B::type) (g::'A::type => 'B::type) x::'A::type.
+ (ALL z::'A::type. u_354 z x --> f z = g z) --> H f x = H g x) -->
+ (EX! f::'A::type => 'B::type. ALL x::'A::type. f x = H f x))"
+ by (import hollight WF_EREC)
+
+lemma WF_SUBSET: "(ALL (x::'A::type) y::'A::type.
+ (u_354::'A::type => 'A::type => bool) x y -->
+ (u_473::'A::type => 'A::type => bool) x y) &
+WF u_473 -->
+WF u_354"
+ by (import hollight WF_SUBSET)
+
+lemma WF_MEASURE_GEN: "ALL m::'A::type => 'B::type.
+ WF (u_354::'B::type => 'B::type => bool) -->
+ WF (%(x::'A::type) x'::'A::type. u_354 (m x) (m x'))"
+ by (import hollight WF_MEASURE_GEN)
+
+lemma WF_LEX_DEPENDENT: "ALL (R::'A::type => 'A::type => bool)
+ S::'A::type => 'B::type => 'B::type => bool.
+ WF R & (ALL x::'A::type. WF (S x)) -->
+ WF (GABS
+ (%f::'A::type * 'B::type => 'A::type * 'B::type => bool.
+ ALL (r1::'A::type) s1::'B::type.
+ GEQ (f (r1, s1))
+ (GABS
+ (%f::'A::type * 'B::type => bool.
+ ALL (r2::'A::type) s2::'B::type.
+ GEQ (f (r2, s2))
+ (R r1 r2 | r1 = r2 & S r1 s1 s2)))))"
+ by (import hollight WF_LEX_DEPENDENT)
+
+lemma WF_LEX: "ALL (x::'A::type => 'A::type => bool) xa::'B::type => 'B::type => bool.
+ WF x & WF xa -->
+ WF (GABS
+ (%f::'A::type * 'B::type => 'A::type * 'B::type => bool.
+ ALL (r1::'A::type) s1::'B::type.
+ GEQ (f (r1, s1))
+ (GABS
+ (%f::'A::type * 'B::type => bool.
+ ALL (r2::'A::type) s2::'B::type.
+ GEQ (f (r2, s2)) (x r1 r2 | r1 = r2 & xa s1 s2)))))"
+ by (import hollight WF_LEX)
+
+lemma WF_POINTWISE: "WF (u_354::'A::type => 'A::type => bool) &
+WF (u_473::'B::type => 'B::type => bool) -->
+WF (GABS
+ (%f::'A::type * 'B::type => 'A::type * 'B::type => bool.
+ ALL (x1::'A::type) y1::'B::type.
+ GEQ (f (x1, y1))
+ (GABS
+ (%f::'A::type * 'B::type => bool.
+ ALL (x2::'A::type) y2::'B::type.
+ GEQ (f (x2, y2)) (u_354 x1 x2 & u_473 y1 y2)))))"
+ by (import hollight WF_POINTWISE)
+
+lemma WF_num: "WF <"
+ by (import hollight WF_num)
+
+lemma WF_REC_num: "ALL H::(nat => 'A::type) => nat => 'A::type.
+ (ALL (f::nat => 'A::type) (g::nat => 'A::type) x::nat.
+ (ALL z::nat. < z x --> f z = g z) --> H f x = H g x) -->
+ (EX f::nat => 'A::type. ALL x::nat. f x = H f x)"
+ by (import hollight WF_REC_num)
+
+consts
+ measure :: "('q_11107::type => nat) => 'q_11107::type => 'q_11107::type => bool"
+
+defs
+ measure_def: "hollight.measure ==
+%(u::'q_11107::type => nat) (x::'q_11107::type) y::'q_11107::type.
+ < (u x) (u y)"
+
+lemma DEF_measure: "hollight.measure =
+(%(u::'q_11107::type => nat) (x::'q_11107::type) y::'q_11107::type.
+ < (u x) (u y))"
+ by (import hollight DEF_measure)
+
+lemma WF_MEASURE: "ALL m::'A::type => nat. WF (hollight.measure m)"
+ by (import hollight WF_MEASURE)
+
+lemma MEASURE_LE: "(ALL x::'q_11137::type.
+ hollight.measure (m::'q_11137::type => nat) x (a::'q_11137::type) -->
+ hollight.measure m x (b::'q_11137::type)) =
+<= (m a) (m b)"
+ by (import hollight MEASURE_LE)
+
+lemma WF_REFL: "ALL x::'A::type. WF (u_354::'A::type => 'A::type => bool) --> ~ u_354 x x"
+ by (import hollight WF_REFL)
+
+lemma WF_FALSE: "WF (%(x::'A::type) y::'A::type. False)"
+ by (import hollight WF_FALSE)
+
+lemma WF_REC_TAIL: "ALL (P::'A::type => bool) (g::'A::type => 'A::type) h::'A::type => 'B::type.
+ EX f::'A::type => 'B::type.
+ ALL x::'A::type. f x = COND (P x) (f (g x)) (h x)"
+ by (import hollight WF_REC_TAIL)
+
+lemma WF_REC_TAIL_GENERAL: "ALL (P::('A::type => 'B::type) => 'A::type => bool)
+ (G::('A::type => 'B::type) => 'A::type => 'A::type)
+ H::('A::type => 'B::type) => 'A::type => 'B::type.
+ WF (u_354::'A::type => 'A::type => bool) &
+ (ALL (f::'A::type => 'B::type) (g::'A::type => 'B::type) x::'A::type.
+ (ALL z::'A::type. u_354 z x --> f z = g z) -->
+ P f x = P g x & G f x = G g x & H f x = H g x) &
+ (ALL (f::'A::type => 'B::type) (g::'A::type => 'B::type) x::'A::type.
+ (ALL z::'A::type. u_354 z x --> f z = g z) --> H f x = H g x) &
+ (ALL (f::'A::type => 'B::type) (x::'A::type) y::'A::type.
+ P f x & u_354 y (G f x) --> u_354 y x) -->
+ (EX f::'A::type => 'B::type.
+ ALL x::'A::type. f x = COND (P f x) (f (G f x)) (H f x))"
+ by (import hollight WF_REC_TAIL_GENERAL)
+
+lemma ARITH_ZERO: "(0::nat) = (0::nat) & NUMERAL_BIT0 (0::nat) = (0::nat)"
+ by (import hollight ARITH_ZERO)
+
+lemma ARITH_SUC: "(ALL x::nat. Suc x = Suc x) &
+Suc (0::nat) = NUMERAL_BIT1 (0::nat) &
+(ALL x::nat. Suc (NUMERAL_BIT0 x) = NUMERAL_BIT1 x) &
+(ALL x::nat. Suc (NUMERAL_BIT1 x) = NUMERAL_BIT0 (Suc x))"
+ by (import hollight ARITH_SUC)
+
+lemma ARITH_PRE: "(ALL x::nat. Pred x = Pred x) &
+Pred (0::nat) = (0::nat) &
+(ALL x::nat.
+ Pred (NUMERAL_BIT0 x) =
+ COND (x = (0::nat)) (0::nat) (NUMERAL_BIT1 (Pred x))) &
+(ALL x::nat. Pred (NUMERAL_BIT1 x) = NUMERAL_BIT0 x)"
+ by (import hollight ARITH_PRE)
+
+lemma ARITH_ADD: "(ALL (x::nat) xa::nat. x + xa = x + xa) &
+(0::nat) + (0::nat) = (0::nat) &
+(ALL x::nat. (0::nat) + NUMERAL_BIT0 x = NUMERAL_BIT0 x) &
+(ALL x::nat. (0::nat) + NUMERAL_BIT1 x = NUMERAL_BIT1 x) &
+(ALL x::nat. NUMERAL_BIT0 x + (0::nat) = NUMERAL_BIT0 x) &
+(ALL x::nat. NUMERAL_BIT1 x + (0::nat) = NUMERAL_BIT1 x) &
+(ALL (x::nat) xa::nat.
+ NUMERAL_BIT0 x + NUMERAL_BIT0 xa = NUMERAL_BIT0 (x + xa)) &
+(ALL (x::nat) xa::nat.
+ NUMERAL_BIT0 x + NUMERAL_BIT1 xa = NUMERAL_BIT1 (x + xa)) &
+(ALL (x::nat) xa::nat.
+ NUMERAL_BIT1 x + NUMERAL_BIT0 xa = NUMERAL_BIT1 (x + xa)) &
+(ALL (x::nat) xa::nat.
+ NUMERAL_BIT1 x + NUMERAL_BIT1 xa = NUMERAL_BIT0 (Suc (x + xa)))"
+ by (import hollight ARITH_ADD)
+
+lemma ARITH_MULT: "(ALL (x::nat) xa::nat. x * xa = x * xa) &
+(0::nat) * (0::nat) = (0::nat) &
+(ALL x::nat. (0::nat) * NUMERAL_BIT0 x = (0::nat)) &
+(ALL x::nat. (0::nat) * NUMERAL_BIT1 x = (0::nat)) &
+(ALL x::nat. NUMERAL_BIT0 x * (0::nat) = (0::nat)) &
+(ALL x::nat. NUMERAL_BIT1 x * (0::nat) = (0::nat)) &
+(ALL (x::nat) xa::nat.
+ NUMERAL_BIT0 x * NUMERAL_BIT0 xa =
+ NUMERAL_BIT0 (NUMERAL_BIT0 (x * xa))) &
+(ALL (x::nat) xa::nat.
+ NUMERAL_BIT0 x * NUMERAL_BIT1 xa =
+ NUMERAL_BIT0 x + NUMERAL_BIT0 (NUMERAL_BIT0 (x * xa))) &
+(ALL (x::nat) xa::nat.
+ NUMERAL_BIT1 x * NUMERAL_BIT0 xa =
+ NUMERAL_BIT0 xa + NUMERAL_BIT0 (NUMERAL_BIT0 (x * xa))) &
+(ALL (x::nat) xa::nat.
+ NUMERAL_BIT1 x * NUMERAL_BIT1 xa =
+ NUMERAL_BIT1 x +
+ (NUMERAL_BIT0 xa + NUMERAL_BIT0 (NUMERAL_BIT0 (x * xa))))"
+ by (import hollight ARITH_MULT)
+
+lemma ARITH_EXP: "(ALL (x::nat) xa::nat. EXP x xa = EXP x xa) &
+EXP (0::nat) (0::nat) = NUMERAL_BIT1 (0::nat) &
+(ALL m::nat. EXP (NUMERAL_BIT0 m) (0::nat) = NUMERAL_BIT1 (0::nat)) &
+(ALL m::nat. EXP (NUMERAL_BIT1 m) (0::nat) = NUMERAL_BIT1 (0::nat)) &
+(ALL n::nat.
+ EXP (0::nat) (NUMERAL_BIT0 n) = EXP (0::nat) n * EXP (0::nat) n) &
+(ALL (m::nat) n::nat.
+ EXP (NUMERAL_BIT0 m) (NUMERAL_BIT0 n) =
+ EXP (NUMERAL_BIT0 m) n * EXP (NUMERAL_BIT0 m) n) &
+(ALL (m::nat) n::nat.
+ EXP (NUMERAL_BIT1 m) (NUMERAL_BIT0 n) =
+ EXP (NUMERAL_BIT1 m) n * EXP (NUMERAL_BIT1 m) n) &
+(ALL n::nat. EXP (0::nat) (NUMERAL_BIT1 n) = (0::nat)) &
+(ALL (m::nat) n::nat.
+ EXP (NUMERAL_BIT0 m) (NUMERAL_BIT1 n) =
+ NUMERAL_BIT0 m * (EXP (NUMERAL_BIT0 m) n * EXP (NUMERAL_BIT0 m) n)) &
+(ALL (m::nat) n::nat.
+ EXP (NUMERAL_BIT1 m) (NUMERAL_BIT1 n) =
+ NUMERAL_BIT1 m * (EXP (NUMERAL_BIT1 m) n * EXP (NUMERAL_BIT1 m) n))"
+ by (import hollight ARITH_EXP)
+
+lemma ARITH_EVEN: "(ALL x::nat. EVEN x = EVEN x) &
+EVEN (0::nat) = True &
+(ALL x::nat. EVEN (NUMERAL_BIT0 x) = True) &
+(ALL x::nat. EVEN (NUMERAL_BIT1 x) = False)"
+ by (import hollight ARITH_EVEN)
+
+lemma ARITH_ODD: "(ALL x::nat. ODD x = ODD x) &
+ODD (0::nat) = False &
+(ALL x::nat. ODD (NUMERAL_BIT0 x) = False) &
+(ALL x::nat. ODD (NUMERAL_BIT1 x) = True)"
+ by (import hollight ARITH_ODD)
+
+lemma ARITH_LE: "(ALL (x::nat) xa::nat. <= x xa = <= x xa) &
+<= (0::nat) (0::nat) = True &
+(ALL x::nat. <= (NUMERAL_BIT0 x) (0::nat) = (x = (0::nat))) &
+(ALL x::nat. <= (NUMERAL_BIT1 x) (0::nat) = False) &
+(ALL x::nat. <= (0::nat) (NUMERAL_BIT0 x) = True) &
+(ALL x::nat. <= (0::nat) (NUMERAL_BIT1 x) = True) &
+(ALL (x::nat) xa::nat. <= (NUMERAL_BIT0 x) (NUMERAL_BIT0 xa) = <= x xa) &
+(ALL (x::nat) xa::nat. <= (NUMERAL_BIT0 x) (NUMERAL_BIT1 xa) = <= x xa) &
+(ALL (x::nat) xa::nat. <= (NUMERAL_BIT1 x) (NUMERAL_BIT0 xa) = < x xa) &
+(ALL (x::nat) xa::nat. <= (NUMERAL_BIT1 x) (NUMERAL_BIT1 xa) = <= x xa)"
+ by (import hollight ARITH_LE)
+
+lemma ARITH_LT: "(ALL (x::nat) xa::nat. < x xa = < x xa) &
+< (0::nat) (0::nat) = False &
+(ALL x::nat. < (NUMERAL_BIT0 x) (0::nat) = False) &
+(ALL x::nat. < (NUMERAL_BIT1 x) (0::nat) = False) &
+(ALL x::nat. < (0::nat) (NUMERAL_BIT0 x) = < (0::nat) x) &
+(ALL x::nat. < (0::nat) (NUMERAL_BIT1 x) = True) &
+(ALL (x::nat) xa::nat. < (NUMERAL_BIT0 x) (NUMERAL_BIT0 xa) = < x xa) &
+(ALL (x::nat) xa::nat. < (NUMERAL_BIT0 x) (NUMERAL_BIT1 xa) = <= x xa) &
+(ALL (x::nat) xa::nat. < (NUMERAL_BIT1 x) (NUMERAL_BIT0 xa) = < x xa) &
+(ALL (x::nat) xa::nat. < (NUMERAL_BIT1 x) (NUMERAL_BIT1 xa) = < x xa)"
+ by (import hollight ARITH_LT)
+
+lemma ARITH_EQ: "(ALL (x::nat) xa::nat. (x = xa) = (x = xa)) &
+((0::nat) = (0::nat)) = True &
+(ALL x::nat. (NUMERAL_BIT0 x = (0::nat)) = (x = (0::nat))) &
+(ALL x::nat. (NUMERAL_BIT1 x = (0::nat)) = False) &
+(ALL x::nat. ((0::nat) = NUMERAL_BIT0 x) = ((0::nat) = x)) &
+(ALL x::nat. ((0::nat) = NUMERAL_BIT1 x) = False) &
+(ALL (x::nat) xa::nat. (NUMERAL_BIT0 x = NUMERAL_BIT0 xa) = (x = xa)) &
+(ALL (x::nat) xa::nat. (NUMERAL_BIT0 x = NUMERAL_BIT1 xa) = False) &
+(ALL (x::nat) xa::nat. (NUMERAL_BIT1 x = NUMERAL_BIT0 xa) = False) &
+(ALL (x::nat) xa::nat. (NUMERAL_BIT1 x = NUMERAL_BIT1 xa) = (x = xa))"
+ by (import hollight ARITH_EQ)
+
+lemma ARITH_SUB: "(ALL (x::nat) xa::nat. x - xa = x - xa) &
+(0::nat) - (0::nat) = (0::nat) &
+(ALL x::nat. (0::nat) - NUMERAL_BIT0 x = (0::nat)) &
+(ALL x::nat. (0::nat) - NUMERAL_BIT1 x = (0::nat)) &
+(ALL x::nat. NUMERAL_BIT0 x - (0::nat) = NUMERAL_BIT0 x) &
+(ALL x::nat. NUMERAL_BIT1 x - (0::nat) = NUMERAL_BIT1 x) &
+(ALL (m::nat) n::nat.
+ NUMERAL_BIT0 m - NUMERAL_BIT0 n = NUMERAL_BIT0 (m - n)) &
+(ALL (m::nat) n::nat.
+ NUMERAL_BIT0 m - NUMERAL_BIT1 n = Pred (NUMERAL_BIT0 (m - n))) &
+(ALL (m::nat) n::nat.
+ NUMERAL_BIT1 m - NUMERAL_BIT0 n =
+ COND (<= n m) (NUMERAL_BIT1 (m - n)) (0::nat)) &
+(ALL (m::nat) n::nat.
+ NUMERAL_BIT1 m - NUMERAL_BIT1 n = NUMERAL_BIT0 (m - n))"
+ by (import hollight ARITH_SUB)
+
+lemma right_th: "(s::nat) * NUMERAL_BIT1 (x::nat) = s + NUMERAL_BIT0 (s * x)"
+ by (import hollight right_th)
+
+lemma SEMIRING_PTHS: "(ALL (x::'A::type) (y::'A::type) z::'A::type.
+ (add::'A::type => 'A::type => 'A::type) x (add y z) = add (add x y) z) &
+(ALL (x::'A::type) y::'A::type. add x y = add y x) &
+(ALL x::'A::type. add (r0::'A::type) x = x) &
+(ALL (x::'A::type) (y::'A::type) z::'A::type.
+ (mul::'A::type => 'A::type => 'A::type) x (mul y z) = mul (mul x y) z) &
+(ALL (x::'A::type) y::'A::type. mul x y = mul y x) &
+(ALL x::'A::type. mul (r1::'A::type) x = x) &
+(ALL x::'A::type. mul r0 x = r0) &
+(ALL (x::'A::type) (y::'A::type) z::'A::type.
+ mul x (add y z) = add (mul x y) (mul x z)) &
+(ALL x::'A::type. (pwr::'A::type => nat => 'A::type) x (0::nat) = r1) &
+(ALL (x::'A::type) n::nat. pwr x (Suc n) = mul x (pwr x n)) -->
+mul r1 (x::'A::type) = x &
+add (mul (a::'A::type) (m::'A::type)) (mul (b::'A::type) m) =
+mul (add a b) m &
+add (mul a m) m = mul (add a r1) m &
+add m (mul a m) = mul (add a r1) m &
+add m m = mul (add r1 r1) m &
+mul r0 m = r0 &
+add r0 a = a &
+add a r0 = a &
+mul a b = mul b a &
+mul (add a b) (c::'A::type) = add (mul a c) (mul b c) &
+mul r0 a = r0 &
+mul a r0 = r0 &
+mul r1 a = a &
+mul a r1 = a &
+mul (mul (lx::'A::type) (ly::'A::type))
+ (mul (rx::'A::type) (ry::'A::type)) =
+mul (mul lx rx) (mul ly ry) &
+mul (mul lx ly) (mul rx ry) = mul lx (mul ly (mul rx ry)) &
+mul (mul lx ly) (mul rx ry) = mul rx (mul (mul lx ly) ry) &
+mul (mul lx ly) rx = mul (mul lx rx) ly &
+mul (mul lx ly) rx = mul lx (mul ly rx) &
+mul lx rx = mul rx lx &
+mul lx (mul rx ry) = mul (mul lx rx) ry &
+mul lx (mul rx ry) = mul rx (mul lx ry) &
+add (add a b) (add c (d::'A::type)) = add (add a c) (add b d) &
+add (add a b) c = add a (add b c) &
+add a (add c d) = add c (add a d) &
+add (add a b) c = add (add a c) b &
+add a c = add c a &
+add a (add c d) = add (add a c) d &
+mul (pwr x (p::nat)) (pwr x (q::nat)) = pwr x (p + q) &
+mul x (pwr x q) = pwr x (Suc q) &
+mul (pwr x q) x = pwr x (Suc q) &
+mul x x = pwr x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) &
+pwr (mul x (y::'A::type)) q = mul (pwr x q) (pwr y q) &
+pwr (pwr x p) q = pwr x (p * q) &
+pwr x (0::nat) = r1 &
+pwr x (NUMERAL_BIT1 (0::nat)) = x &
+mul x (add y (z::'A::type)) = add (mul x y) (mul x z) &
+pwr x (Suc q) = mul x (pwr x q)"
+ by (import hollight SEMIRING_PTHS)
+
+lemma sth: "(ALL (x::nat) (y::nat) z::nat. x + (y + z) = x + y + z) &
+(ALL (x::nat) y::nat. x + y = y + x) &
+(ALL x::nat. (0::nat) + x = x) &
+(ALL (x::nat) (y::nat) z::nat. x * (y * z) = x * y * z) &
+(ALL (x::nat) y::nat. x * y = y * x) &
+(ALL x::nat. NUMERAL_BIT1 (0::nat) * x = x) &
+(ALL x::nat. (0::nat) * x = (0::nat)) &
+(ALL (x::nat) (xa::nat) xb::nat. x * (xa + xb) = x * xa + x * xb) &
+(ALL x::nat. EXP x (0::nat) = NUMERAL_BIT1 (0::nat)) &
+(ALL (x::nat) xa::nat. EXP x (Suc xa) = x * EXP x xa)"
+ by (import hollight sth)
+
+lemma NUM_INTEGRAL_LEMMA: "(w::nat) = (x::nat) + (d::nat) & (y::nat) = (z::nat) + (e::nat) -->
+(w * y + x * z = w * z + x * y) = (w = x | y = z)"
+ by (import hollight NUM_INTEGRAL_LEMMA)
+
+lemma NUM_INTEGRAL: "(ALL x::nat. (0::nat) * x = (0::nat)) &
+(ALL (x::nat) (xa::nat) xb::nat. (x + xa = x + xb) = (xa = xb)) &
+(ALL (w::nat) (x::nat) (y::nat) z::nat.
+ (w * y + x * z = w * z + x * y) = (w = x | y = z))"
+ by (import hollight NUM_INTEGRAL)
+
+lemma INJ_INVERSE2: "ALL P::'A::type => 'B::type => 'C::type.
+ (ALL (x1::'A::type) (y1::'B::type) (x2::'A::type) y2::'B::type.
+ (P x1 y1 = P x2 y2) = (x1 = x2 & y1 = y2)) -->
+ (EX (x::'C::type => 'A::type) Y::'C::type => 'B::type.
+ ALL (xa::'A::type) y::'B::type. x (P xa y) = xa & Y (P xa y) = y)"
+ by (import hollight INJ_INVERSE2)
+
+constdefs
+ NUMPAIR :: "nat => nat => nat"
+ "NUMPAIR ==
+%(u::nat) ua::nat.
+ EXP (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) u *
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * ua + NUMERAL_BIT1 (0::nat))"
+
+lemma DEF_NUMPAIR: "NUMPAIR =
+(%(u::nat) ua::nat.
+ EXP (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) u *
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * ua + NUMERAL_BIT1 (0::nat)))"
+ by (import hollight DEF_NUMPAIR)
+
+lemma NUMPAIR_INJ_LEMMA: "ALL (x::nat) (xa::nat) (xb::nat) xc::nat.
+ NUMPAIR x xa = NUMPAIR xb xc --> x = xb"
+ by (import hollight NUMPAIR_INJ_LEMMA)
+
+lemma NUMPAIR_INJ: "ALL (x1::nat) (y1::nat) (x2::nat) y2::nat.
+ (NUMPAIR x1 y1 = NUMPAIR x2 y2) = (x1 = x2 & y1 = y2)"
+ by (import hollight NUMPAIR_INJ)
+
+constdefs
+ NUMFST :: "nat => nat"
+ "NUMFST ==
+SOME X::nat => nat.
+ EX Y::nat => nat.
+ ALL (x::nat) y::nat. X (NUMPAIR x y) = x & Y (NUMPAIR x y) = y"
+
+lemma DEF_NUMFST: "NUMFST =
+(SOME X::nat => nat.
+ EX Y::nat => nat.
+ ALL (x::nat) y::nat. X (NUMPAIR x y) = x & Y (NUMPAIR x y) = y)"
+ by (import hollight DEF_NUMFST)
+
+constdefs
+ NUMSND :: "nat => nat"
+ "NUMSND ==
+SOME Y::nat => nat.
+ ALL (x::nat) y::nat. NUMFST (NUMPAIR x y) = x & Y (NUMPAIR x y) = y"
+
+lemma DEF_NUMSND: "NUMSND =
+(SOME Y::nat => nat.
+ ALL (x::nat) y::nat. NUMFST (NUMPAIR x y) = x & Y (NUMPAIR x y) = y)"
+ by (import hollight DEF_NUMSND)
+
+constdefs
+ NUMSUM :: "bool => nat => nat"
+ "NUMSUM ==
+%(u::bool) ua::nat.
+ COND u (Suc (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * ua))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * ua)"
+
+lemma DEF_NUMSUM: "NUMSUM =
+(%(u::bool) ua::nat.
+ COND u (Suc (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * ua))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * ua))"
+ by (import hollight DEF_NUMSUM)
+
+lemma NUMSUM_INJ: "ALL (b1::bool) (x1::nat) (b2::bool) x2::nat.
+ (NUMSUM b1 x1 = NUMSUM b2 x2) = (b1 = b2 & x1 = x2)"
+ by (import hollight NUMSUM_INJ)
+
+constdefs
+ NUMLEFT :: "nat => bool"
+ "NUMLEFT ==
+SOME X::nat => bool.
+ EX Y::nat => nat.
+ ALL (x::bool) y::nat. X (NUMSUM x y) = x & Y (NUMSUM x y) = y"
+
+lemma DEF_NUMLEFT: "NUMLEFT =
+(SOME X::nat => bool.
+ EX Y::nat => nat.
+ ALL (x::bool) y::nat. X (NUMSUM x y) = x & Y (NUMSUM x y) = y)"
+ by (import hollight DEF_NUMLEFT)
+
+constdefs
+ NUMRIGHT :: "nat => nat"
+ "NUMRIGHT ==
+SOME Y::nat => nat.
+ ALL (x::bool) y::nat. NUMLEFT (NUMSUM x y) = x & Y (NUMSUM x y) = y"
+
+lemma DEF_NUMRIGHT: "NUMRIGHT =
+(SOME Y::nat => nat.
+ ALL (x::bool) y::nat. NUMLEFT (NUMSUM x y) = x & Y (NUMSUM x y) = y)"
+ by (import hollight DEF_NUMRIGHT)
+
+constdefs
+ INJN :: "nat => nat => 'A::type => bool"
+ "INJN == %(u::nat) (n::nat) a::'A::type. n = u"
+
+lemma DEF_INJN: "INJN = (%(u::nat) (n::nat) a::'A::type. n = u)"
+ by (import hollight DEF_INJN)
+
+lemma INJN_INJ: "(All::(nat => bool) => bool)
+ (%n1::nat.
+ (All::(nat => bool) => bool)
+ (%n2::nat.
+ (op =::bool => bool => bool)
+ ((op =::(nat => 'A::type => bool)
+ => (nat => 'A::type => bool) => bool)
+ ((INJN::nat => nat => 'A::type => bool) n1)
+ ((INJN::nat => nat => 'A::type => bool) n2))
+ ((op =::nat => nat => bool) n1 n2)))"
+ by (import hollight INJN_INJ)
+
+constdefs
+ INJA :: "'A::type => nat => 'A::type => bool"
+ "INJA == %(u::'A::type) (n::nat) b::'A::type. b = u"
+
+lemma DEF_INJA: "INJA = (%(u::'A::type) (n::nat) b::'A::type. b = u)"
+ by (import hollight DEF_INJA)
+
+lemma INJA_INJ: "ALL (a1::'A::type) a2::'A::type. (INJA a1 = INJA a2) = (a1 = a2)"
+ by (import hollight INJA_INJ)
+
+constdefs
+ INJF :: "(nat => nat => 'A::type => bool) => nat => 'A::type => bool"
+ "INJF == %(u::nat => nat => 'A::type => bool) n::nat. u (NUMFST n) (NUMSND n)"
+
+lemma DEF_INJF: "INJF =
+(%(u::nat => nat => 'A::type => bool) n::nat. u (NUMFST n) (NUMSND n))"
+ by (import hollight DEF_INJF)
+
+lemma INJF_INJ: "ALL (f1::nat => nat => 'A::type => bool) f2::nat => nat => 'A::type => bool.
+ (INJF f1 = INJF f2) = (f1 = f2)"
+ by (import hollight INJF_INJ)
+
+constdefs
+ INJP :: "(nat => 'A::type => bool)
+=> (nat => 'A::type => bool) => nat => 'A::type => bool"
+ "INJP ==
+%(u::nat => 'A::type => bool) (ua::nat => 'A::type => bool) (n::nat)
+ a::'A::type. COND (NUMLEFT n) (u (NUMRIGHT n) a) (ua (NUMRIGHT n) a)"
+
+lemma DEF_INJP: "INJP =
+(%(u::nat => 'A::type => bool) (ua::nat => 'A::type => bool) (n::nat)
+ a::'A::type. COND (NUMLEFT n) (u (NUMRIGHT n) a) (ua (NUMRIGHT n) a))"
+ by (import hollight DEF_INJP)
+
+lemma INJP_INJ: "ALL (f1::nat => 'A::type => bool) (f1'::nat => 'A::type => bool)
+ (f2::nat => 'A::type => bool) f2'::nat => 'A::type => bool.
+ (INJP f1 f2 = INJP f1' f2') = (f1 = f1' & f2 = f2')"
+ by (import hollight INJP_INJ)
+
+constdefs
+ ZCONSTR :: "nat
+=> 'A::type => (nat => nat => 'A::type => bool) => nat => 'A::type => bool"
+ "ZCONSTR ==
+%(u::nat) (ua::'A::type) ub::nat => nat => 'A::type => bool.
+ INJP (INJN (Suc u)) (INJP (INJA ua) (INJF ub))"
+
+lemma DEF_ZCONSTR: "ZCONSTR =
+(%(u::nat) (ua::'A::type) ub::nat => nat => 'A::type => bool.
+ INJP (INJN (Suc u)) (INJP (INJA ua) (INJF ub)))"
+ by (import hollight DEF_ZCONSTR)
+
+constdefs
+ ZBOT :: "nat => 'A::type => bool"
+ "ZBOT == INJP (INJN (0::nat)) (SOME z::nat => 'A::type => bool. True)"
+
+lemma DEF_ZBOT: "ZBOT = INJP (INJN (0::nat)) (SOME z::nat => 'A::type => bool. True)"
+ by (import hollight DEF_ZBOT)
+
+lemma ZCONSTR_ZBOT: "ALL (x::nat) (xa::'A::type) xb::nat => nat => 'A::type => bool.
+ ZCONSTR x xa xb ~= ZBOT"
+ by (import hollight ZCONSTR_ZBOT)
+
+constdefs
+ ZRECSPACE :: "(nat => 'A::type => bool) => bool"
+ "ZRECSPACE ==
+%a::nat => 'A::type => bool.
+ ALL ZRECSPACE'::(nat => 'A::type => bool) => bool.
+ (ALL a::nat => 'A::type => bool.
+ a = ZBOT |
+ (EX (c::nat) (i::'A::type) r::nat => nat => 'A::type => bool.
+ a = ZCONSTR c i r & (ALL n::nat. ZRECSPACE' (r n))) -->
+ ZRECSPACE' a) -->
+ ZRECSPACE' a"
+
+lemma DEF_ZRECSPACE: "ZRECSPACE =
+(%a::nat => 'A::type => bool.
+ ALL ZRECSPACE'::(nat => 'A::type => bool) => bool.
+ (ALL a::nat => 'A::type => bool.
+ a = ZBOT |
+ (EX (c::nat) (i::'A::type) r::nat => nat => 'A::type => bool.
+ a = ZCONSTR c i r & (ALL n::nat. ZRECSPACE' (r n))) -->
+ ZRECSPACE' a) -->
+ ZRECSPACE' a)"
+ by (import hollight DEF_ZRECSPACE)
+
+typedef (open) ('A) recspace = "(Collect::((nat => 'A::type => bool) => bool)
+ => (nat => 'A::type => bool) set)
+ (ZRECSPACE::(nat => 'A::type => bool) => bool)" morphisms "_dest_rec" "_mk_rec"
+ apply (rule light_ex_imp_nonempty[where t="ZBOT::nat => 'A::type => bool"])
+ by (import hollight TYDEF_recspace)
+
+syntax
+ "_dest_rec" :: _ ("'_dest'_rec")
+
+syntax
+ "_mk_rec" :: _ ("'_mk'_rec")
+
+lemmas "TYDEF_recspace_@intern" = typedef_hol2hollight
+ [where a="a :: 'A::type recspace" and r=r ,
+ OF type_definition_recspace]
+
+constdefs
+ BOTTOM :: "'A::type recspace"
+ "BOTTOM == _mk_rec ZBOT"
+
+lemma DEF_BOTTOM: "BOTTOM = _mk_rec ZBOT"
+ by (import hollight DEF_BOTTOM)
+
+constdefs
+ CONSTR :: "nat => 'A::type => (nat => 'A::type recspace) => 'A::type recspace"
+ "CONSTR ==
+%(u::nat) (ua::'A::type) ub::nat => 'A::type recspace.
+ _mk_rec (ZCONSTR u ua (%n::nat. _dest_rec (ub n)))"
+
+lemma DEF_CONSTR: "CONSTR =
+(%(u::nat) (ua::'A::type) ub::nat => 'A::type recspace.
+ _mk_rec (ZCONSTR u ua (%n::nat. _dest_rec (ub n))))"
+ by (import hollight DEF_CONSTR)
+
+lemma MK_REC_INJ: "ALL (x::nat => 'A::type => bool) y::nat => 'A::type => bool.
+ _mk_rec x = _mk_rec y --> ZRECSPACE x & ZRECSPACE y --> x = y"
+ by (import hollight MK_REC_INJ)
+
+lemma CONSTR_BOT: "ALL (c::nat) (i::'A::type) r::nat => 'A::type recspace.
+ CONSTR c i r ~= BOTTOM"
+ by (import hollight CONSTR_BOT)
+
+lemma CONSTR_INJ: "ALL (c1::nat) (i1::'A::type) (r1::nat => 'A::type recspace) (c2::nat)
+ (i2::'A::type) r2::nat => 'A::type recspace.
+ (CONSTR c1 i1 r1 = CONSTR c2 i2 r2) = (c1 = c2 & i1 = i2 & r1 = r2)"
+ by (import hollight CONSTR_INJ)
+
+lemma CONSTR_IND: "ALL P::'A::type recspace => bool.
+ P BOTTOM &
+ (ALL (c::nat) (i::'A::type) r::nat => 'A::type recspace.
+ (ALL n::nat. P (r n)) --> P (CONSTR c i r)) -->
+ All P"
+ by (import hollight CONSTR_IND)
+
+lemma CONSTR_REC: "ALL Fn::nat
+ => 'A::type
+ => (nat => 'A::type recspace) => (nat => 'B::type) => 'B::type.
+ EX f::'A::type recspace => 'B::type.
+ ALL (c::nat) (i::'A::type) r::nat => 'A::type recspace.
+ f (CONSTR c i r) = Fn c i r (%n::nat. f (r n))"
+ by (import hollight CONSTR_REC)
+
+constdefs
+ FCONS :: "'A::type => (nat => 'A::type) => nat => 'A::type"
+ "FCONS ==
+SOME FCONS::'A::type => (nat => 'A::type) => nat => 'A::type.
+ (ALL (a::'A::type) f::nat => 'A::type. FCONS a f (0::nat) = a) &
+ (ALL (a::'A::type) (f::nat => 'A::type) n::nat. FCONS a f (Suc n) = f n)"
+
+lemma DEF_FCONS: "FCONS =
+(SOME FCONS::'A::type => (nat => 'A::type) => nat => 'A::type.
+ (ALL (a::'A::type) f::nat => 'A::type. FCONS a f (0::nat) = a) &
+ (ALL (a::'A::type) (f::nat => 'A::type) n::nat.
+ FCONS a f (Suc n) = f n))"
+ by (import hollight DEF_FCONS)
+
+lemma FCONS_UNDO: "ALL f::nat => 'A::type. f = FCONS (f (0::nat)) (f o Suc)"
+ by (import hollight FCONS_UNDO)
+
+constdefs
+ FNIL :: "nat => 'A::type"
+ "FNIL == %u::nat. SOME x::'A::type. True"
+
+lemma DEF_FNIL: "FNIL = (%u::nat. SOME x::'A::type. True)"
+ by (import hollight DEF_FNIL)
+
+typedef (open) ('A, 'B) sum = "(Collect::(('A::type * 'B::type) recspace => bool)
+ => ('A::type * 'B::type) recspace set)
+ (%a::('A::type * 'B::type) recspace.
+ (All::((('A::type * 'B::type) recspace => bool) => bool) => bool)
+ (%sum'::('A::type * 'B::type) recspace => bool.
+ (op -->::bool => bool => bool)
+ ((All::(('A::type * 'B::type) recspace => bool) => bool)
+ (%a::('A::type * 'B::type) recspace.
+ (op -->::bool => bool => bool)
+ ((op |::bool => bool => bool)
+ ((Ex::('A::type => bool) => bool)
+ (%aa::'A::type.
+ (op =::('A::type * 'B::type) recspace
+ => ('A::type * 'B::type) recspace => bool)
+ a ((CONSTR::nat
+ => 'A::type * 'B::type
+ => (nat => ('A::type * 'B::type) recspace)
+ => ('A::type * 'B::type) recspace)
+ ((NUMERAL::nat => nat) (0::nat))
+ ((Pair::'A::type
+ => 'B::type => 'A::type * 'B::type)
+ aa ((Eps::('B::type => bool) => 'B::type)
+(%v::'B::type. True::bool)))
+ (%n::nat.
+ BOTTOM::('A::type *
+ 'B::type) recspace))))
+ ((Ex::('B::type => bool) => bool)
+ (%aa::'B::type.
+ (op =::('A::type * 'B::type) recspace
+ => ('A::type * 'B::type) recspace => bool)
+ a ((CONSTR::nat
+ => 'A::type * 'B::type
+ => (nat => ('A::type * 'B::type) recspace)
+ => ('A::type * 'B::type) recspace)
+ ((Suc::nat => nat)
+ ((NUMERAL::nat => nat) (0::nat)))
+ ((Pair::'A::type
+ => 'B::type => 'A::type * 'B::type)
+ ((Eps::('A::type => bool) => 'A::type)
+ (%v::'A::type. True::bool))
+ aa)
+ (%n::nat.
+ BOTTOM::('A::type *
+ 'B::type) recspace)))))
+ (sum' a)))
+ (sum' a)))" morphisms "_dest_sum" "_mk_sum"
+ apply (rule light_ex_imp_nonempty[where t="(CONSTR::nat
+ => 'A::type * 'B::type
+ => (nat => ('A::type * 'B::type) recspace)
+ => ('A::type * 'B::type) recspace)
+ ((NUMERAL::nat => nat) (0::nat))
+ ((Pair::'A::type => 'B::type => 'A::type * 'B::type) (a::'A::type)
+ ((Eps::('B::type => bool) => 'B::type) (%v::'B::type. True::bool)))
+ (%n::nat. BOTTOM::('A::type * 'B::type) recspace)"])
+ by (import hollight TYDEF_sum)
+
+syntax
+ "_dest_sum" :: _ ("'_dest'_sum")
+
+syntax
+ "_mk_sum" :: _ ("'_mk'_sum")
+
+lemmas "TYDEF_sum_@intern" = typedef_hol2hollight
+ [where a="a :: ('A::type, 'B::type) sum" and r=r ,
+ OF type_definition_sum]
+
+constdefs
+ INL :: "'A::type => ('A::type, 'B::type) sum"
+ "INL ==
+%a::'A::type.
+ _mk_sum (CONSTR (0::nat) (a, SOME v::'B::type. True) (%n::nat. BOTTOM))"
+
+lemma DEF_INL: "INL =
+(%a::'A::type.
+ _mk_sum (CONSTR (0::nat) (a, SOME v::'B::type. True) (%n::nat. BOTTOM)))"
+ by (import hollight DEF_INL)
+
+constdefs
+ INR :: "'B::type => ('A::type, 'B::type) sum"
+ "INR ==
+%a::'B::type.
+ _mk_sum
+ (CONSTR (Suc (0::nat)) (SOME v::'A::type. True, a) (%n::nat. BOTTOM))"
+
+lemma DEF_INR: "INR =
+(%a::'B::type.
+ _mk_sum
+ (CONSTR (Suc (0::nat)) (SOME v::'A::type. True, a) (%n::nat. BOTTOM)))"
+ by (import hollight DEF_INR)
+
+consts
+ OUTL :: "('A::type, 'B::type) sum => 'A::type"
+
+defs
+ OUTL_def: "hollight.OUTL ==
+SOME OUTL::('A::type, 'B::type) sum => 'A::type.
+ ALL x::'A::type. OUTL (INL x) = x"
+
+lemma DEF_OUTL: "hollight.OUTL =
+(SOME OUTL::('A::type, 'B::type) sum => 'A::type.
+ ALL x::'A::type. OUTL (INL x) = x)"
+ by (import hollight DEF_OUTL)
+
+consts
+ OUTR :: "('A::type, 'B::type) sum => 'B::type"
+
+defs
+ OUTR_def: "hollight.OUTR ==
+SOME OUTR::('A::type, 'B::type) sum => 'B::type.
+ ALL y::'B::type. OUTR (INR y) = y"
+
+lemma DEF_OUTR: "hollight.OUTR =
+(SOME OUTR::('A::type, 'B::type) sum => 'B::type.
+ ALL y::'B::type. OUTR (INR y) = y)"
+ by (import hollight DEF_OUTR)
+
+typedef (open) ('A) option = "(Collect::('A::type recspace => bool) => 'A::type recspace set)
+ (%a::'A::type recspace.
+ (All::(('A::type recspace => bool) => bool) => bool)
+ (%option'::'A::type recspace => bool.
+ (op -->::bool => bool => bool)
+ ((All::('A::type recspace => bool) => bool)
+ (%a::'A::type recspace.
+ (op -->::bool => bool => bool)
+ ((op |::bool => bool => bool)
+ ((op =::'A::type recspace => 'A::type recspace => bool)
+ a ((CONSTR::nat
+ => 'A::type
+ => (nat => 'A::type recspace)
+ => 'A::type recspace)
+ ((NUMERAL::nat => nat) (0::nat))
+ ((Eps::('A::type => bool) => 'A::type)
+ (%v::'A::type. True::bool))
+ (%n::nat. BOTTOM::'A::type recspace)))
+ ((Ex::('A::type => bool) => bool)
+ (%aa::'A::type.
+ (op =::'A::type recspace
+ => 'A::type recspace => bool)
+ a ((CONSTR::nat
+ => 'A::type => (nat => 'A::type recspace) => 'A::type recspace)
+ ((Suc::nat => nat)
+ ((NUMERAL::nat => nat) (0::nat)))
+ aa (%n::nat. BOTTOM::'A::type recspace)))))
+ (option' a)))
+ (option' a)))" morphisms "_dest_option" "_mk_option"
+ apply (rule light_ex_imp_nonempty[where t="(CONSTR::nat => 'A::type => (nat => 'A::type recspace) => 'A::type recspace)
+ ((NUMERAL::nat => nat) (0::nat))
+ ((Eps::('A::type => bool) => 'A::type) (%v::'A::type. True::bool))
+ (%n::nat. BOTTOM::'A::type recspace)"])
+ by (import hollight TYDEF_option)
+
+syntax
+ "_dest_option" :: _ ("'_dest'_option")
+
+syntax
+ "_mk_option" :: _ ("'_mk'_option")
+
+lemmas "TYDEF_option_@intern" = typedef_hol2hollight
+ [where a="a :: 'A::type hollight.option" and r=r ,
+ OF type_definition_option]
+
+constdefs
+ NONE :: "'A::type hollight.option"
+ "NONE ==
+_mk_option (CONSTR (0::nat) (SOME v::'A::type. True) (%n::nat. BOTTOM))"
+
+lemma DEF_NONE: "NONE =
+_mk_option (CONSTR (0::nat) (SOME v::'A::type. True) (%n::nat. BOTTOM))"
+ by (import hollight DEF_NONE)
+
+consts
+ SOME :: "'A::type => 'A::type hollight.option" ("SOME")
+
+defs
+ SOME_def: "SOME == %a::'A::type. _mk_option (CONSTR (Suc (0::nat)) a (%n::nat. BOTTOM))"
+
+lemma DEF_SOME: "SOME =
+(%a::'A::type. _mk_option (CONSTR (Suc (0::nat)) a (%n::nat. BOTTOM)))"
+ by (import hollight DEF_SOME)
+
+typedef (open) ('A) list = "(Collect::('A::type recspace => bool) => 'A::type recspace set)
+ (%a::'A::type recspace.
+ (All::(('A::type recspace => bool) => bool) => bool)
+ (%list'::'A::type recspace => bool.
+ (op -->::bool => bool => bool)
+ ((All::('A::type recspace => bool) => bool)
+ (%a::'A::type recspace.
+ (op -->::bool => bool => bool)
+ ((op |::bool => bool => bool)
+ ((op =::'A::type recspace => 'A::type recspace => bool)
+ a ((CONSTR::nat
+ => 'A::type
+ => (nat => 'A::type recspace)
+ => 'A::type recspace)
+ ((NUMERAL::nat => nat) (0::nat))
+ ((Eps::('A::type => bool) => 'A::type)
+ (%v::'A::type. True::bool))
+ (%n::nat. BOTTOM::'A::type recspace)))
+ ((Ex::('A::type => bool) => bool)
+ (%a0::'A::type.
+ (Ex::('A::type recspace => bool) => bool)
+ (%a1::'A::type recspace.
+ (op &::bool => bool => bool)
+ ((op =::'A::type recspace
+ => 'A::type recspace => bool)
+ a ((CONSTR::nat
+ => 'A::type => (nat => 'A::type recspace) => 'A::type recspace)
+((Suc::nat => nat) ((NUMERAL::nat => nat) (0::nat))) a0
+((FCONS::'A::type recspace
+ => (nat => 'A::type recspace) => nat => 'A::type recspace)
+ a1 (%n::nat. BOTTOM::'A::type recspace))))
+ (list' a1)))))
+ (list' a)))
+ (list' a)))" morphisms "_dest_list" "_mk_list"
+ apply (rule light_ex_imp_nonempty[where t="(CONSTR::nat => 'A::type => (nat => 'A::type recspace) => 'A::type recspace)
+ ((NUMERAL::nat => nat) (0::nat))
+ ((Eps::('A::type => bool) => 'A::type) (%v::'A::type. True::bool))
+ (%n::nat. BOTTOM::'A::type recspace)"])
+ by (import hollight TYDEF_list)
+
+syntax
+ "_dest_list" :: _ ("'_dest'_list")
+
+syntax
+ "_mk_list" :: _ ("'_mk'_list")
+
+lemmas "TYDEF_list_@intern" = typedef_hol2hollight
+ [where a="a :: 'A::type hollight.list" and r=r ,
+ OF type_definition_list]
+
+constdefs
+ NIL :: "'A::type hollight.list"
+ "NIL == _mk_list (CONSTR (0::nat) (SOME v::'A::type. True) (%n::nat. BOTTOM))"
+
+lemma DEF_NIL: "NIL = _mk_list (CONSTR (0::nat) (SOME v::'A::type. True) (%n::nat. BOTTOM))"
+ by (import hollight DEF_NIL)
+
+constdefs
+ CONS :: "'A::type => 'A::type hollight.list => 'A::type hollight.list"
+ "CONS ==
+%(a0::'A::type) a1::'A::type hollight.list.
+ _mk_list
+ (CONSTR (Suc (0::nat)) a0 (FCONS (_dest_list a1) (%n::nat. BOTTOM)))"
+
+lemma DEF_CONS: "CONS =
+(%(a0::'A::type) a1::'A::type hollight.list.
+ _mk_list
+ (CONSTR (Suc (0::nat)) a0 (FCONS (_dest_list a1) (%n::nat. BOTTOM))))"
+ by (import hollight DEF_CONS)
+
+lemma pair_RECURSION: "ALL PAIR'::'A::type => 'B::type => 'C::type.
+ EX x::'A::type * 'B::type => 'C::type.
+ ALL (a0::'A::type) a1::'B::type. x (a0, a1) = PAIR' a0 a1"
+ by (import hollight pair_RECURSION)
+
+lemma num_RECURSION_STD: "ALL (e::'Z::type) f::nat => 'Z::type => 'Z::type.
+ EX fn::nat => 'Z::type.
+ fn (0::nat) = e & (ALL n::nat. fn (Suc n) = f n (fn n))"
+ by (import hollight num_RECURSION_STD)
+
+constdefs
+ ISO :: "('A::type => 'B::type) => ('B::type => 'A::type) => bool"
+ "ISO ==
+%(u::'A::type => 'B::type) ua::'B::type => 'A::type.
+ (ALL x::'B::type. u (ua x) = x) & (ALL y::'A::type. ua (u y) = y)"
+
+lemma DEF_ISO: "ISO =
+(%(u::'A::type => 'B::type) ua::'B::type => 'A::type.
+ (ALL x::'B::type. u (ua x) = x) & (ALL y::'A::type. ua (u y) = y))"
+ by (import hollight DEF_ISO)
+
+lemma ISO_REFL: "ISO (%x::'A::type. x) (%x::'A::type. x)"
+ by (import hollight ISO_REFL)
+
+lemma ISO_FUN: "ISO (f::'A::type => 'A'::type) (f'::'A'::type => 'A::type) &
+ISO (g::'B::type => 'B'::type) (g'::'B'::type => 'B::type) -->
+ISO (%(h::'A::type => 'B::type) a'::'A'::type. g (h (f' a')))
+ (%(h::'A'::type => 'B'::type) a::'A::type. g' (h (f a)))"
+ by (import hollight ISO_FUN)
+
+lemma ISO_USAGE: "ISO (f::'q_16585::type => 'q_16582::type)
+ (g::'q_16582::type => 'q_16585::type) -->
+(ALL P::'q_16585::type => bool. All P = (ALL x::'q_16582::type. P (g x))) &
+(ALL P::'q_16585::type => bool. Ex P = (EX x::'q_16582::type. P (g x))) &
+(ALL (a::'q_16585::type) b::'q_16582::type. (a = g b) = (f a = b))"
+ by (import hollight ISO_USAGE)
+
+typedef (open) N_2 = "{a::bool recspace.
+ ALL u::bool recspace => bool.
+ (ALL a::bool recspace.
+ a =
+ CONSTR (NUMERAL (0::nat)) (SOME x::bool. True) (%n::nat. BOTTOM) |
+ a =
+ CONSTR (Suc (NUMERAL (0::nat))) (SOME x::bool. True)
+ (%n::nat. BOTTOM) -->
+ u a) -->
+ u a}" morphisms "_dest_2" "_mk_2"
+ apply (rule light_ex_imp_nonempty[where t="CONSTR (NUMERAL (0::nat)) (SOME x::bool. True) (%n::nat. BOTTOM)"])
+ by (import hollight TYDEF_2)
+
+syntax
+ "_dest_2" :: _ ("'_dest'_2")
+
+syntax
+ "_mk_2" :: _ ("'_mk'_2")
+
+lemmas "TYDEF_2_@intern" = typedef_hol2hollight
+ [where a="a :: N_2" and r=r ,
+ OF type_definition_N_2]
+
+consts
+ "_10288" :: "N_2" ("'_10288")
+
+defs
+ "_10288_def": "_10288 == _mk_2 (CONSTR (0::nat) (SOME x::bool. True) (%n::nat. BOTTOM))"
+
+lemma DEF__10288: "_10288 = _mk_2 (CONSTR (0::nat) (SOME x::bool. True) (%n::nat. BOTTOM))"
+ by (import hollight DEF__10288)
+
+consts
+ "_10289" :: "N_2" ("'_10289")
+
+defs
+ "_10289_def": "_10289 ==
+_mk_2 (CONSTR (Suc (0::nat)) (SOME x::bool. True) (%n::nat. BOTTOM))"
+
+lemma DEF__10289: "_10289 =
+_mk_2 (CONSTR (Suc (0::nat)) (SOME x::bool. True) (%n::nat. BOTTOM))"
+ by (import hollight DEF__10289)
+
+constdefs
+ two_1 :: "N_2"
+ "two_1 == _10288"
+
+lemma DEF_two_1: "two_1 = _10288"
+ by (import hollight DEF_two_1)
+
+constdefs
+ two_2 :: "N_2"
+ "two_2 == _10289"
+
+lemma DEF_two_2: "two_2 = _10289"
+ by (import hollight DEF_two_2)
+
+typedef (open) N_3 = "{a::bool recspace.
+ ALL u::bool recspace => bool.
+ (ALL a::bool recspace.
+ a =
+ CONSTR (NUMERAL (0::nat)) (SOME x::bool. True) (%n::nat. BOTTOM) |
+ a =
+ CONSTR (Suc (NUMERAL (0::nat))) (SOME x::bool. True)
+ (%n::nat. BOTTOM) |
+ a =
+ CONSTR (Suc (Suc (NUMERAL (0::nat)))) (SOME x::bool. True)
+ (%n::nat. BOTTOM) -->
+ u a) -->
+ u a}" morphisms "_dest_3" "_mk_3"
+ apply (rule light_ex_imp_nonempty[where t="CONSTR (NUMERAL (0::nat)) (SOME x::bool. True) (%n::nat. BOTTOM)"])
+ by (import hollight TYDEF_3)
+
+syntax
+ "_dest_3" :: _ ("'_dest'_3")
+
+syntax
+ "_mk_3" :: _ ("'_mk'_3")
+
+lemmas "TYDEF_3_@intern" = typedef_hol2hollight
+ [where a="a :: N_3" and r=r ,
+ OF type_definition_N_3]
+
+consts
+ "_10312" :: "N_3" ("'_10312")
+
+defs
+ "_10312_def": "_10312 == _mk_3 (CONSTR (0::nat) (SOME x::bool. True) (%n::nat. BOTTOM))"
+
+lemma DEF__10312: "_10312 = _mk_3 (CONSTR (0::nat) (SOME x::bool. True) (%n::nat. BOTTOM))"
+ by (import hollight DEF__10312)
+
+consts
+ "_10313" :: "N_3" ("'_10313")
+
+defs
+ "_10313_def": "_10313 ==
+_mk_3 (CONSTR (Suc (0::nat)) (SOME x::bool. True) (%n::nat. BOTTOM))"
+
+lemma DEF__10313: "_10313 =
+_mk_3 (CONSTR (Suc (0::nat)) (SOME x::bool. True) (%n::nat. BOTTOM))"
+ by (import hollight DEF__10313)
+
+consts
+ "_10314" :: "N_3" ("'_10314")
+
+defs
+ "_10314_def": "_10314 ==
+_mk_3 (CONSTR (Suc (Suc (0::nat))) (SOME x::bool. True) (%n::nat. BOTTOM))"
+
+lemma DEF__10314: "_10314 =
+_mk_3 (CONSTR (Suc (Suc (0::nat))) (SOME x::bool. True) (%n::nat. BOTTOM))"
+ by (import hollight DEF__10314)
+
+constdefs
+ three_1 :: "N_3"
+ "three_1 == _10312"
+
+lemma DEF_three_1: "three_1 = _10312"
+ by (import hollight DEF_three_1)
+
+constdefs
+ three_2 :: "N_3"
+ "three_2 == _10313"
+
+lemma DEF_three_2: "three_2 = _10313"
+ by (import hollight DEF_three_2)
+
+constdefs
+ three_3 :: "N_3"
+ "three_3 == _10314"
+
+lemma DEF_three_3: "three_3 = _10314"
+ by (import hollight DEF_three_3)
+
+lemma list_INDUCT: "ALL P::'A::type hollight.list => bool.
+ P NIL &
+ (ALL (a0::'A::type) a1::'A::type hollight.list.
+ P a1 --> P (CONS a0 a1)) -->
+ All P"
+ by (import hollight list_INDUCT)
+
+constdefs
+ HD :: "'A::type hollight.list => 'A::type"
+ "HD ==
+SOME HD::'A::type hollight.list => 'A::type.
+ ALL (t::'A::type hollight.list) h::'A::type. HD (CONS h t) = h"
+
+lemma DEF_HD: "HD =
+(SOME HD::'A::type hollight.list => 'A::type.
+ ALL (t::'A::type hollight.list) h::'A::type. HD (CONS h t) = h)"
+ by (import hollight DEF_HD)
+
+constdefs
+ TL :: "'A::type hollight.list => 'A::type hollight.list"
+ "TL ==
+SOME TL::'A::type hollight.list => 'A::type hollight.list.
+ ALL (h::'A::type) t::'A::type hollight.list. TL (CONS h t) = t"
+
+lemma DEF_TL: "TL =
+(SOME TL::'A::type hollight.list => 'A::type hollight.list.
+ ALL (h::'A::type) t::'A::type hollight.list. TL (CONS h t) = t)"
+ by (import hollight DEF_TL)
+
+constdefs
+ APPEND :: "'A::type hollight.list => 'A::type hollight.list => 'A::type hollight.list"
+ "APPEND ==
+SOME APPEND::'A::type hollight.list
+ => 'A::type hollight.list => 'A::type hollight.list.
+ (ALL l::'A::type hollight.list. APPEND NIL l = l) &
+ (ALL (h::'A::type) (t::'A::type hollight.list) l::'A::type hollight.list.
+ APPEND (CONS h t) l = CONS h (APPEND t l))"
+
+lemma DEF_APPEND: "APPEND =
+(SOME APPEND::'A::type hollight.list
+ => 'A::type hollight.list => 'A::type hollight.list.
+ (ALL l::'A::type hollight.list. APPEND NIL l = l) &
+ (ALL (h::'A::type) (t::'A::type hollight.list)
+ l::'A::type hollight.list.
+ APPEND (CONS h t) l = CONS h (APPEND t l)))"
+ by (import hollight DEF_APPEND)
+
+constdefs
+ REVERSE :: "'A::type hollight.list => 'A::type hollight.list"
+ "REVERSE ==
+SOME REVERSE::'A::type hollight.list => 'A::type hollight.list.
+ REVERSE NIL = NIL &
+ (ALL (l::'A::type hollight.list) x::'A::type.
+ REVERSE (CONS x l) = APPEND (REVERSE l) (CONS x NIL))"
+
+lemma DEF_REVERSE: "REVERSE =
+(SOME REVERSE::'A::type hollight.list => 'A::type hollight.list.
+ REVERSE NIL = NIL &
+ (ALL (l::'A::type hollight.list) x::'A::type.
+ REVERSE (CONS x l) = APPEND (REVERSE l) (CONS x NIL)))"
+ by (import hollight DEF_REVERSE)
+
+constdefs
+ LENGTH :: "'A::type hollight.list => nat"
+ "LENGTH ==
+SOME LENGTH::'A::type hollight.list => nat.
+ LENGTH NIL = (0::nat) &
+ (ALL (h::'A::type) t::'A::type hollight.list.
+ LENGTH (CONS h t) = Suc (LENGTH t))"
+
+lemma DEF_LENGTH: "LENGTH =
+(SOME LENGTH::'A::type hollight.list => nat.
+ LENGTH NIL = (0::nat) &
+ (ALL (h::'A::type) t::'A::type hollight.list.
+ LENGTH (CONS h t) = Suc (LENGTH t)))"
+ by (import hollight DEF_LENGTH)
+
+constdefs
+ MAP :: "('A::type => 'B::type) => 'A::type hollight.list => 'B::type hollight.list"
+ "MAP ==
+SOME MAP::('A::type => 'B::type)
+ => 'A::type hollight.list => 'B::type hollight.list.
+ (ALL f::'A::type => 'B::type. MAP f NIL = NIL) &
+ (ALL (f::'A::type => 'B::type) (h::'A::type) t::'A::type hollight.list.
+ MAP f (CONS h t) = CONS (f h) (MAP f t))"
+
+lemma DEF_MAP: "MAP =
+(SOME MAP::('A::type => 'B::type)
+ => 'A::type hollight.list => 'B::type hollight.list.
+ (ALL f::'A::type => 'B::type. MAP f NIL = NIL) &
+ (ALL (f::'A::type => 'B::type) (h::'A::type) t::'A::type hollight.list.
+ MAP f (CONS h t) = CONS (f h) (MAP f t)))"
+ by (import hollight DEF_MAP)
+
+constdefs
+ LAST :: "'A::type hollight.list => 'A::type"
+ "LAST ==
+SOME LAST::'A::type hollight.list => 'A::type.
+ ALL (h::'A::type) t::'A::type hollight.list.
+ LAST (CONS h t) = COND (t = NIL) h (LAST t)"
+
+lemma DEF_LAST: "LAST =
+(SOME LAST::'A::type hollight.list => 'A::type.
+ ALL (h::'A::type) t::'A::type hollight.list.
+ LAST (CONS h t) = COND (t = NIL) h (LAST t))"
+ by (import hollight DEF_LAST)
+
+constdefs
+ REPLICATE :: "nat => 'q_16809::type => 'q_16809::type hollight.list"
+ "REPLICATE ==
+SOME REPLICATE::nat => 'q_16809::type => 'q_16809::type hollight.list.
+ (ALL x::'q_16809::type. REPLICATE (0::nat) x = NIL) &
+ (ALL (n::nat) x::'q_16809::type.
+ REPLICATE (Suc n) x = CONS x (REPLICATE n x))"
+
+lemma DEF_REPLICATE: "REPLICATE =
+(SOME REPLICATE::nat => 'q_16809::type => 'q_16809::type hollight.list.
+ (ALL x::'q_16809::type. REPLICATE (0::nat) x = NIL) &
+ (ALL (n::nat) x::'q_16809::type.
+ REPLICATE (Suc n) x = CONS x (REPLICATE n x)))"
+ by (import hollight DEF_REPLICATE)
+
+constdefs
+ NULL :: "'q_16824::type hollight.list => bool"
+ "NULL ==
+SOME NULL::'q_16824::type hollight.list => bool.
+ NULL NIL = True &
+ (ALL (h::'q_16824::type) t::'q_16824::type hollight.list.
+ NULL (CONS h t) = False)"
+
+lemma DEF_NULL: "NULL =
+(SOME NULL::'q_16824::type hollight.list => bool.
+ NULL NIL = True &
+ (ALL (h::'q_16824::type) t::'q_16824::type hollight.list.
+ NULL (CONS h t) = False))"
+ by (import hollight DEF_NULL)
+
+constdefs
+ ALL_list :: "('q_16844::type => bool) => 'q_16844::type hollight.list => bool"
+ "ALL_list ==
+SOME u::('q_16844::type => bool) => 'q_16844::type hollight.list => bool.
+ (ALL P::'q_16844::type => bool. u P NIL = True) &
+ (ALL (h::'q_16844::type) (P::'q_16844::type => bool)
+ t::'q_16844::type hollight.list. u P (CONS h t) = (P h & u P t))"
+
+lemma DEF_ALL: "ALL_list =
+(SOME u::('q_16844::type => bool) => 'q_16844::type hollight.list => bool.
+ (ALL P::'q_16844::type => bool. u P NIL = True) &
+ (ALL (h::'q_16844::type) (P::'q_16844::type => bool)
+ t::'q_16844::type hollight.list. u P (CONS h t) = (P h & u P t)))"
+ by (import hollight DEF_ALL)
+
+consts
+ EX :: "('q_16865::type => bool) => 'q_16865::type hollight.list => bool" ("EX")
+
+defs
+ EX_def: "EX ==
+SOME u::('q_16865::type => bool) => 'q_16865::type hollight.list => bool.
+ (ALL P::'q_16865::type => bool. u P NIL = False) &
+ (ALL (h::'q_16865::type) (P::'q_16865::type => bool)
+ t::'q_16865::type hollight.list. u P (CONS h t) = (P h | u P t))"
+
+lemma DEF_EX: "EX =
+(SOME u::('q_16865::type => bool) => 'q_16865::type hollight.list => bool.
+ (ALL P::'q_16865::type => bool. u P NIL = False) &
+ (ALL (h::'q_16865::type) (P::'q_16865::type => bool)
+ t::'q_16865::type hollight.list. u P (CONS h t) = (P h | u P t)))"
+ by (import hollight DEF_EX)
+
+constdefs
+ ITLIST :: "('q_16888::type => 'q_16887::type => 'q_16887::type)
+=> 'q_16888::type hollight.list => 'q_16887::type => 'q_16887::type"
+ "ITLIST ==
+SOME ITLIST::('q_16888::type => 'q_16887::type => 'q_16887::type)
+ => 'q_16888::type hollight.list
+ => 'q_16887::type => 'q_16887::type.
+ (ALL (f::'q_16888::type => 'q_16887::type => 'q_16887::type)
+ b::'q_16887::type. ITLIST f NIL b = b) &
+ (ALL (h::'q_16888::type)
+ (f::'q_16888::type => 'q_16887::type => 'q_16887::type)
+ (t::'q_16888::type hollight.list) b::'q_16887::type.
+ ITLIST f (CONS h t) b = f h (ITLIST f t b))"
+
+lemma DEF_ITLIST: "ITLIST =
+(SOME ITLIST::('q_16888::type => 'q_16887::type => 'q_16887::type)
+ => 'q_16888::type hollight.list
+ => 'q_16887::type => 'q_16887::type.
+ (ALL (f::'q_16888::type => 'q_16887::type => 'q_16887::type)
+ b::'q_16887::type. ITLIST f NIL b = b) &
+ (ALL (h::'q_16888::type)
+ (f::'q_16888::type => 'q_16887::type => 'q_16887::type)
+ (t::'q_16888::type hollight.list) b::'q_16887::type.
+ ITLIST f (CONS h t) b = f h (ITLIST f t b)))"
+ by (import hollight DEF_ITLIST)
+
+constdefs
+ MEM :: "'q_16913::type => 'q_16913::type hollight.list => bool"
+ "MEM ==
+SOME MEM::'q_16913::type => 'q_16913::type hollight.list => bool.
+ (ALL x::'q_16913::type. MEM x NIL = False) &
+ (ALL (h::'q_16913::type) (x::'q_16913::type)
+ t::'q_16913::type hollight.list.
+ MEM x (CONS h t) = (x = h | MEM x t))"
+
+lemma DEF_MEM: "MEM =
+(SOME MEM::'q_16913::type => 'q_16913::type hollight.list => bool.
+ (ALL x::'q_16913::type. MEM x NIL = False) &
+ (ALL (h::'q_16913::type) (x::'q_16913::type)
+ t::'q_16913::type hollight.list.
+ MEM x (CONS h t) = (x = h | MEM x t)))"
+ by (import hollight DEF_MEM)
+
+constdefs
+ ALL2 :: "('q_16946::type => 'q_16953::type => bool)
+=> 'q_16946::type hollight.list => 'q_16953::type hollight.list => bool"
+ "ALL2 ==
+SOME ALL2::('q_16946::type => 'q_16953::type => bool)
+ => 'q_16946::type hollight.list
+ => 'q_16953::type hollight.list => bool.
+ (ALL (P::'q_16946::type => 'q_16953::type => bool)
+ l2::'q_16953::type hollight.list. ALL2 P NIL l2 = (l2 = NIL)) &
+ (ALL (h1::'q_16946::type) (P::'q_16946::type => 'q_16953::type => bool)
+ (t1::'q_16946::type hollight.list) l2::'q_16953::type hollight.list.
+ ALL2 P (CONS h1 t1) l2 =
+ COND (l2 = NIL) False (P h1 (HD l2) & ALL2 P t1 (TL l2)))"
+
+lemma DEF_ALL2: "ALL2 =
+(SOME ALL2::('q_16946::type => 'q_16953::type => bool)
+ => 'q_16946::type hollight.list
+ => 'q_16953::type hollight.list => bool.
+ (ALL (P::'q_16946::type => 'q_16953::type => bool)
+ l2::'q_16953::type hollight.list. ALL2 P NIL l2 = (l2 = NIL)) &
+ (ALL (h1::'q_16946::type) (P::'q_16946::type => 'q_16953::type => bool)
+ (t1::'q_16946::type hollight.list) l2::'q_16953::type hollight.list.
+ ALL2 P (CONS h1 t1) l2 =
+ COND (l2 = NIL) False (P h1 (HD l2) & ALL2 P t1 (TL l2))))"
+ by (import hollight DEF_ALL2)
+
+lemma ALL2: "ALL2 (P::'q_17008::type => 'q_17007::type => bool) NIL NIL = True &
+ALL2 P (CONS (h1::'q_17008::type) (t1::'q_17008::type hollight.list)) NIL =
+False &
+ALL2 P NIL (CONS (h2::'q_17007::type) (t2::'q_17007::type hollight.list)) =
+False &
+ALL2 P (CONS h1 t1) (CONS h2 t2) = (P h1 h2 & ALL2 P t1 t2)"
+ by (import hollight ALL2)
+
+constdefs
+ MAP2 :: "('q_17038::type => 'q_17045::type => 'q_17035::type)
+=> 'q_17038::type hollight.list
+ => 'q_17045::type hollight.list => 'q_17035::type hollight.list"
+ "MAP2 ==
+SOME MAP2::('q_17038::type => 'q_17045::type => 'q_17035::type)
+ => 'q_17038::type hollight.list
+ => 'q_17045::type hollight.list
+ => 'q_17035::type hollight.list.
+ (ALL (f::'q_17038::type => 'q_17045::type => 'q_17035::type)
+ l::'q_17045::type hollight.list. MAP2 f NIL l = NIL) &
+ (ALL (h1::'q_17038::type)
+ (f::'q_17038::type => 'q_17045::type => 'q_17035::type)
+ (t1::'q_17038::type hollight.list) l::'q_17045::type hollight.list.
+ MAP2 f (CONS h1 t1) l = CONS (f h1 (HD l)) (MAP2 f t1 (TL l)))"
+
+lemma DEF_MAP2: "MAP2 =
+(SOME MAP2::('q_17038::type => 'q_17045::type => 'q_17035::type)
+ => 'q_17038::type hollight.list
+ => 'q_17045::type hollight.list
+ => 'q_17035::type hollight.list.
+ (ALL (f::'q_17038::type => 'q_17045::type => 'q_17035::type)
+ l::'q_17045::type hollight.list. MAP2 f NIL l = NIL) &
+ (ALL (h1::'q_17038::type)
+ (f::'q_17038::type => 'q_17045::type => 'q_17035::type)
+ (t1::'q_17038::type hollight.list) l::'q_17045::type hollight.list.
+ MAP2 f (CONS h1 t1) l = CONS (f h1 (HD l)) (MAP2 f t1 (TL l))))"
+ by (import hollight DEF_MAP2)
+
+lemma MAP2: "MAP2 (f::'q_17080::type => 'q_17079::type => 'q_17086::type) NIL NIL = NIL &
+MAP2 f (CONS (h1::'q_17080::type) (t1::'q_17080::type hollight.list))
+ (CONS (h2::'q_17079::type) (t2::'q_17079::type hollight.list)) =
+CONS (f h1 h2) (MAP2 f t1 t2)"
+ by (import hollight MAP2)
+
+constdefs
+ EL :: "nat => 'q_17106::type hollight.list => 'q_17106::type"
+ "EL ==
+SOME EL::nat => 'q_17106::type hollight.list => 'q_17106::type.
+ (ALL l::'q_17106::type hollight.list. EL (0::nat) l = HD l) &
+ (ALL (n::nat) l::'q_17106::type hollight.list.
+ EL (Suc n) l = EL n (TL l))"
+
+lemma DEF_EL: "EL =
+(SOME EL::nat => 'q_17106::type hollight.list => 'q_17106::type.
+ (ALL l::'q_17106::type hollight.list. EL (0::nat) l = HD l) &
+ (ALL (n::nat) l::'q_17106::type hollight.list.
+ EL (Suc n) l = EL n (TL l)))"
+ by (import hollight DEF_EL)
+
+constdefs
+ FILTER :: "('q_17131::type => bool)
+=> 'q_17131::type hollight.list => 'q_17131::type hollight.list"
+ "FILTER ==
+SOME FILTER::('q_17131::type => bool)
+ => 'q_17131::type hollight.list
+ => 'q_17131::type hollight.list.
+ (ALL P::'q_17131::type => bool. FILTER P NIL = NIL) &
+ (ALL (h::'q_17131::type) (P::'q_17131::type => bool)
+ t::'q_17131::type hollight.list.
+ FILTER P (CONS h t) = COND (P h) (CONS h (FILTER P t)) (FILTER P t))"
+
+lemma DEF_FILTER: "FILTER =
+(SOME FILTER::('q_17131::type => bool)
+ => 'q_17131::type hollight.list
+ => 'q_17131::type hollight.list.
+ (ALL P::'q_17131::type => bool. FILTER P NIL = NIL) &
+ (ALL (h::'q_17131::type) (P::'q_17131::type => bool)
+ t::'q_17131::type hollight.list.
+ FILTER P (CONS h t) =
+ COND (P h) (CONS h (FILTER P t)) (FILTER P t)))"
+ by (import hollight DEF_FILTER)
+
+constdefs
+ ASSOC :: "'q_17160::type
+=> ('q_17160::type * 'q_17154::type) hollight.list => 'q_17154::type"
+ "ASSOC ==
+SOME ASSOC::'q_17160::type
+ => ('q_17160::type * 'q_17154::type) hollight.list
+ => 'q_17154::type.
+ ALL (h::'q_17160::type * 'q_17154::type) (a::'q_17160::type)
+ t::('q_17160::type * 'q_17154::type) hollight.list.
+ ASSOC a (CONS h t) = COND (fst h = a) (snd h) (ASSOC a t)"
+
+lemma DEF_ASSOC: "ASSOC =
+(SOME ASSOC::'q_17160::type
+ => ('q_17160::type * 'q_17154::type) hollight.list
+ => 'q_17154::type.
+ ALL (h::'q_17160::type * 'q_17154::type) (a::'q_17160::type)
+ t::('q_17160::type * 'q_17154::type) hollight.list.
+ ASSOC a (CONS h t) = COND (fst h = a) (snd h) (ASSOC a t))"
+ by (import hollight DEF_ASSOC)
+
+constdefs
+ ITLIST2 :: "('q_17184::type => 'q_17192::type => 'q_17182::type => 'q_17182::type)
+=> 'q_17184::type hollight.list
+ => 'q_17192::type hollight.list => 'q_17182::type => 'q_17182::type"
+ "ITLIST2 ==
+SOME ITLIST2::('q_17184::type
+ => 'q_17192::type => 'q_17182::type => 'q_17182::type)
+ => 'q_17184::type hollight.list
+ => 'q_17192::type hollight.list
+ => 'q_17182::type => 'q_17182::type.
+ (ALL (f::'q_17184::type
+ => 'q_17192::type => 'q_17182::type => 'q_17182::type)
+ (l2::'q_17192::type hollight.list) b::'q_17182::type.
+ ITLIST2 f NIL l2 b = b) &
+ (ALL (h1::'q_17184::type)
+ (f::'q_17184::type
+ => 'q_17192::type => 'q_17182::type => 'q_17182::type)
+ (t1::'q_17184::type hollight.list) (l2::'q_17192::type hollight.list)
+ b::'q_17182::type.
+ ITLIST2 f (CONS h1 t1) l2 b = f h1 (HD l2) (ITLIST2 f t1 (TL l2) b))"
+
+lemma DEF_ITLIST2: "ITLIST2 =
+(SOME ITLIST2::('q_17184::type
+ => 'q_17192::type => 'q_17182::type => 'q_17182::type)
+ => 'q_17184::type hollight.list
+ => 'q_17192::type hollight.list
+ => 'q_17182::type => 'q_17182::type.
+ (ALL (f::'q_17184::type
+ => 'q_17192::type => 'q_17182::type => 'q_17182::type)
+ (l2::'q_17192::type hollight.list) b::'q_17182::type.
+ ITLIST2 f NIL l2 b = b) &
+ (ALL (h1::'q_17184::type)
+ (f::'q_17184::type
+ => 'q_17192::type => 'q_17182::type => 'q_17182::type)
+ (t1::'q_17184::type hollight.list)
+ (l2::'q_17192::type hollight.list) b::'q_17182::type.
+ ITLIST2 f (CONS h1 t1) l2 b =
+ f h1 (HD l2) (ITLIST2 f t1 (TL l2) b)))"
+ by (import hollight DEF_ITLIST2)
+
+lemma ITLIST2: "ITLIST2
+ (f::'q_17226::type => 'q_17225::type => 'q_17224::type => 'q_17224::type)
+ NIL NIL (b::'q_17224::type) =
+b &
+ITLIST2 f (CONS (h1::'q_17226::type) (t1::'q_17226::type hollight.list))
+ (CONS (h2::'q_17225::type) (t2::'q_17225::type hollight.list)) b =
+f h1 h2 (ITLIST2 f t1 t2 b)"
+ by (import hollight ITLIST2)
+
+consts
+ ZIP :: "'q_17256::type hollight.list
+=> 'q_17264::type hollight.list
+ => ('q_17256::type * 'q_17264::type) hollight.list"
+
+defs
+ ZIP_def: "hollight.ZIP ==
+SOME ZIP::'q_17256::type hollight.list
+ => 'q_17264::type hollight.list
+ => ('q_17256::type * 'q_17264::type) hollight.list.
+ (ALL l2::'q_17264::type hollight.list. ZIP NIL l2 = NIL) &
+ (ALL (h1::'q_17256::type) (t1::'q_17256::type hollight.list)
+ l2::'q_17264::type hollight.list.
+ ZIP (CONS h1 t1) l2 = CONS (h1, HD l2) (ZIP t1 (TL l2)))"
+
+lemma DEF_ZIP: "hollight.ZIP =
+(SOME ZIP::'q_17256::type hollight.list
+ => 'q_17264::type hollight.list
+ => ('q_17256::type * 'q_17264::type) hollight.list.
+ (ALL l2::'q_17264::type hollight.list. ZIP NIL l2 = NIL) &
+ (ALL (h1::'q_17256::type) (t1::'q_17256::type hollight.list)
+ l2::'q_17264::type hollight.list.
+ ZIP (CONS h1 t1) l2 = CONS (h1, HD l2) (ZIP t1 (TL l2))))"
+ by (import hollight DEF_ZIP)
+
+lemma ZIP: "(op &::bool => bool => bool)
+ ((op =::('q_17275::type * 'q_17276::type) hollight.list
+ => ('q_17275::type * 'q_17276::type) hollight.list => bool)
+ ((hollight.ZIP::'q_17275::type hollight.list
+ => 'q_17276::type hollight.list
+ => ('q_17275::type * 'q_17276::type) hollight.list)
+ (NIL::'q_17275::type hollight.list)
+ (NIL::'q_17276::type hollight.list))
+ (NIL::('q_17275::type * 'q_17276::type) hollight.list))
+ ((op =::('q_17300::type * 'q_17301::type) hollight.list
+ => ('q_17300::type * 'q_17301::type) hollight.list => bool)
+ ((hollight.ZIP::'q_17300::type hollight.list
+ => 'q_17301::type hollight.list
+ => ('q_17300::type * 'q_17301::type) hollight.list)
+ ((CONS::'q_17300::type
+ => 'q_17300::type hollight.list
+ => 'q_17300::type hollight.list)
+ (h1::'q_17300::type) (t1::'q_17300::type hollight.list))
+ ((CONS::'q_17301::type
+ => 'q_17301::type hollight.list
+ => 'q_17301::type hollight.list)
+ (h2::'q_17301::type) (t2::'q_17301::type hollight.list)))
+ ((CONS::'q_17300::type * 'q_17301::type
+ => ('q_17300::type * 'q_17301::type) hollight.list
+ => ('q_17300::type * 'q_17301::type) hollight.list)
+ ((Pair::'q_17300::type
+ => 'q_17301::type => 'q_17300::type * 'q_17301::type)
+ h1 h2)
+ ((hollight.ZIP::'q_17300::type hollight.list
+ => 'q_17301::type hollight.list
+ => ('q_17300::type * 'q_17301::type) hollight.list)
+ t1 t2)))"
+ by (import hollight ZIP)
+
+lemma NOT_CONS_NIL: "ALL (x::'A::type) xa::'A::type hollight.list. CONS x xa ~= NIL"
+ by (import hollight NOT_CONS_NIL)
+
+lemma LAST_CLAUSES: "LAST (CONS (h::'A::type) NIL) = h &
+LAST (CONS h (CONS (k::'A::type) (t::'A::type hollight.list))) =
+LAST (CONS k t)"
+ by (import hollight LAST_CLAUSES)
+
+lemma APPEND_NIL: "ALL l::'A::type hollight.list. APPEND l NIL = l"
+ by (import hollight APPEND_NIL)
+
+lemma APPEND_ASSOC: "ALL (l::'A::type hollight.list) (m::'A::type hollight.list)
+ n::'A::type hollight.list. APPEND l (APPEND m n) = APPEND (APPEND l m) n"
+ by (import hollight APPEND_ASSOC)
+
+lemma REVERSE_APPEND: "ALL (l::'A::type hollight.list) m::'A::type hollight.list.
+ REVERSE (APPEND l m) = APPEND (REVERSE m) (REVERSE l)"
+ by (import hollight REVERSE_APPEND)
+
+lemma REVERSE_REVERSE: "ALL l::'A::type hollight.list. REVERSE (REVERSE l) = l"
+ by (import hollight REVERSE_REVERSE)
+
+lemma CONS_11: "ALL (x::'A::type) (xa::'A::type) (xb::'A::type hollight.list)
+ xc::'A::type hollight.list. (CONS x xb = CONS xa xc) = (x = xa & xb = xc)"
+ by (import hollight CONS_11)
+
+lemma list_CASES: "ALL l::'A::type hollight.list.
+ l = NIL | (EX (h::'A::type) t::'A::type hollight.list. l = CONS h t)"
+ by (import hollight list_CASES)
+
+lemma LENGTH_APPEND: "ALL (l::'A::type hollight.list) m::'A::type hollight.list.
+ LENGTH (APPEND l m) = LENGTH l + LENGTH m"
+ by (import hollight LENGTH_APPEND)
+
+lemma MAP_APPEND: "ALL (f::'A::type => 'B::type) (l1::'A::type hollight.list)
+ l2::'A::type hollight.list.
+ MAP f (APPEND l1 l2) = APPEND (MAP f l1) (MAP f l2)"
+ by (import hollight MAP_APPEND)
+
+lemma LENGTH_MAP: "ALL (l::'A::type hollight.list) f::'A::type => 'B::type.
+ LENGTH (MAP f l) = LENGTH l"
+ by (import hollight LENGTH_MAP)
+
+lemma LENGTH_EQ_NIL: "ALL l::'A::type hollight.list. (LENGTH l = (0::nat)) = (l = NIL)"
+ by (import hollight LENGTH_EQ_NIL)
+
+lemma LENGTH_EQ_CONS: "ALL (l::'q_17608::type hollight.list) n::nat.
+ (LENGTH l = Suc n) =
+ (EX (h::'q_17608::type) t::'q_17608::type hollight.list.
+ l = CONS h t & LENGTH t = n)"
+ by (import hollight LENGTH_EQ_CONS)
+
+lemma MAP_o: "ALL (f::'A::type => 'B::type) (g::'B::type => 'C::type)
+ l::'A::type hollight.list. MAP (g o f) l = MAP g (MAP f l)"
+ by (import hollight MAP_o)
+
+lemma MAP_EQ: "ALL (f::'q_17672::type => 'q_17683::type)
+ (g::'q_17672::type => 'q_17683::type) l::'q_17672::type hollight.list.
+ ALL_list (%x::'q_17672::type. f x = g x) l --> MAP f l = MAP g l"
+ by (import hollight MAP_EQ)
+
+lemma ALL_IMP: "ALL (P::'q_17713::type => bool) (Q::'q_17713::type => bool)
+ l::'q_17713::type hollight.list.
+ (ALL x::'q_17713::type. MEM x l & P x --> Q x) & ALL_list P l -->
+ ALL_list Q l"
+ by (import hollight ALL_IMP)
+
+lemma NOT_EX: "ALL (P::'q_17741::type => bool) l::'q_17741::type hollight.list.
+ (~ EX P l) = ALL_list (%x::'q_17741::type. ~ P x) l"
+ by (import hollight NOT_EX)
+
+lemma NOT_ALL: "ALL (P::'q_17763::type => bool) l::'q_17763::type hollight.list.
+ (~ ALL_list P l) = EX (%x::'q_17763::type. ~ P x) l"
+ by (import hollight NOT_ALL)
+
+lemma ALL_MAP: "ALL (P::'q_17785::type => bool) (f::'q_17784::type => 'q_17785::type)
+ l::'q_17784::type hollight.list.
+ ALL_list P (MAP f l) = ALL_list (P o f) l"
+ by (import hollight ALL_MAP)
+
+lemma ALL_T: "All (ALL_list (%x::'q_17803::type. True))"
+ by (import hollight ALL_T)
+
+lemma MAP_EQ_ALL2: "ALL (l::'q_17828::type hollight.list) m::'q_17828::type hollight.list.
+ ALL2
+ (%(x::'q_17828::type) y::'q_17828::type.
+ (f::'q_17828::type => 'q_17839::type) x = f y)
+ l m -->
+ MAP f l = MAP f m"
+ by (import hollight MAP_EQ_ALL2)
+
+lemma ALL2_MAP: "ALL (P::'q_17870::type => 'q_17871::type => bool)
+ (f::'q_17871::type => 'q_17870::type) l::'q_17871::type hollight.list.
+ ALL2 P (MAP f l) l = ALL_list (%a::'q_17871::type. P (f a) a) l"
+ by (import hollight ALL2_MAP)
+
+lemma MAP_EQ_DEGEN: "ALL (l::'q_17888::type hollight.list) f::'q_17888::type => 'q_17888::type.
+ ALL_list (%x::'q_17888::type. f x = x) l --> MAP f l = l"
+ by (import hollight MAP_EQ_DEGEN)
+
+lemma ALL2_AND_RIGHT: "ALL (l::'q_17931::type hollight.list) (m::'q_17930::type hollight.list)
+ (P::'q_17931::type => bool) Q::'q_17931::type => 'q_17930::type => bool.
+ ALL2 (%(x::'q_17931::type) y::'q_17930::type. P x & Q x y) l m =
+ (ALL_list P l & ALL2 Q l m)"
+ by (import hollight ALL2_AND_RIGHT)
+
+lemma ITLIST_EXTRA: "ALL l::'q_17968::type hollight.list.
+ ITLIST (f::'q_17968::type => 'q_17967::type => 'q_17967::type)
+ (APPEND l (CONS (a::'q_17968::type) NIL)) (b::'q_17967::type) =
+ ITLIST f l (f a b)"
+ by (import hollight ITLIST_EXTRA)
+
+lemma ALL_MP: "ALL (P::'q_17994::type => bool) (Q::'q_17994::type => bool)
+ l::'q_17994::type hollight.list.
+ ALL_list (%x::'q_17994::type. P x --> Q x) l & ALL_list P l -->
+ ALL_list Q l"
+ by (import hollight ALL_MP)
+
+lemma AND_ALL: "ALL x::'q_18024::type hollight.list.
+ (ALL_list (P::'q_18024::type => bool) x &
+ ALL_list (Q::'q_18024::type => bool) x) =
+ ALL_list (%x::'q_18024::type. P x & Q x) x"
+ by (import hollight AND_ALL)
+
+lemma EX_IMP: "ALL (P::'q_18054::type => bool) (Q::'q_18054::type => bool)
+ l::'q_18054::type hollight.list.
+ (ALL x::'q_18054::type. MEM x l & P x --> Q x) & EX P l --> EX Q l"
+ by (import hollight EX_IMP)
+
+lemma ALL_MEM: "ALL (P::'q_18081::type => bool) l::'q_18081::type hollight.list.
+ (ALL x::'q_18081::type. MEM x l --> P x) = ALL_list P l"
+ by (import hollight ALL_MEM)
+
+lemma LENGTH_REPLICATE: "ALL (n::nat) x::'q_18099::type. LENGTH (REPLICATE n x) = n"
+ by (import hollight LENGTH_REPLICATE)
+
+lemma EX_MAP: "ALL (P::'q_18123::type => bool) (f::'q_18122::type => 'q_18123::type)
+ l::'q_18122::type hollight.list. EX P (MAP f l) = EX (P o f) l"
+ by (import hollight EX_MAP)
+
+lemma EXISTS_EX: "ALL (P::'q_18161::type => 'q_18160::type => bool)
+ l::'q_18160::type hollight.list.
+ (EX x::'q_18161::type. EX (P x) l) =
+ EX (%s::'q_18160::type. EX x::'q_18161::type. P x s) l"
+ by (import hollight EXISTS_EX)
+
+lemma FORALL_ALL: "ALL (P::'q_18191::type => 'q_18190::type => bool)
+ l::'q_18190::type hollight.list.
+ (ALL x::'q_18191::type. ALL_list (P x) l) =
+ ALL_list (%s::'q_18190::type. ALL x::'q_18191::type. P x s) l"
+ by (import hollight FORALL_ALL)
+
+lemma MEM_APPEND: "ALL (x::'q_18219::type) (l1::'q_18219::type hollight.list)
+ l2::'q_18219::type hollight.list.
+ MEM x (APPEND l1 l2) = (MEM x l1 | MEM x l2)"
+ by (import hollight MEM_APPEND)
+
+lemma MEM_MAP: "ALL (f::'q_18255::type => 'q_18252::type) (y::'q_18252::type)
+ l::'q_18255::type hollight.list.
+ MEM y (MAP f l) = (EX x::'q_18255::type. MEM x l & y = f x)"
+ by (import hollight MEM_MAP)
+
+lemma FILTER_APPEND: "ALL (P::'q_18286::type => bool) (l1::'q_18286::type hollight.list)
+ l2::'q_18286::type hollight.list.
+ FILTER P (APPEND l1 l2) = APPEND (FILTER P l1) (FILTER P l2)"
+ by (import hollight FILTER_APPEND)
+
+lemma FILTER_MAP: "ALL (P::'q_18313::type => bool) (f::'q_18320::type => 'q_18313::type)
+ l::'q_18320::type hollight.list.
+ FILTER P (MAP f l) = MAP f (FILTER (P o f) l)"
+ by (import hollight FILTER_MAP)
+
+lemma MEM_FILTER: "ALL (P::'q_18347::type => bool) (l::'q_18347::type hollight.list)
+ x::'q_18347::type. MEM x (FILTER P l) = (P x & MEM x l)"
+ by (import hollight MEM_FILTER)
+
+lemma EX_MEM: "ALL (P::'q_18368::type => bool) l::'q_18368::type hollight.list.
+ (EX x::'q_18368::type. P x & MEM x l) = EX P l"
+ by (import hollight EX_MEM)
+
+lemma MAP_FST_ZIP: "ALL (l1::'q_18388::type hollight.list) l2::'q_18390::type hollight.list.
+ LENGTH l1 = LENGTH l2 --> MAP fst (hollight.ZIP l1 l2) = l1"
+ by (import hollight MAP_FST_ZIP)
+
+lemma MAP_SND_ZIP: "ALL (l1::'q_18419::type hollight.list) l2::'q_18421::type hollight.list.
+ LENGTH l1 = LENGTH l2 --> MAP snd (hollight.ZIP l1 l2) = l2"
+ by (import hollight MAP_SND_ZIP)
+
+lemma MEM_ASSOC: "ALL (l::('q_18465::type * 'q_18449::type) hollight.list) x::'q_18465::type.
+ MEM (x, ASSOC x l) l = MEM x (MAP fst l)"
+ by (import hollight MEM_ASSOC)
+
+lemma ALL_APPEND: "ALL (P::'q_18486::type => bool) (l1::'q_18486::type hollight.list)
+ l2::'q_18486::type hollight.list.
+ ALL_list P (APPEND l1 l2) = (ALL_list P l1 & ALL_list P l2)"
+ by (import hollight ALL_APPEND)
+
+lemma MEM_EL: "ALL (l::'q_18509::type hollight.list) n::nat.
+ < n (LENGTH l) --> MEM (EL n l) l"
+ by (import hollight MEM_EL)
+
+lemma ALL2_MAP2: "ALL (l::'q_18552::type hollight.list) m::'q_18553::type hollight.list.
+ ALL2 (P::'q_18551::type => 'q_18550::type => bool)
+ (MAP (f::'q_18552::type => 'q_18551::type) l)
+ (MAP (g::'q_18553::type => 'q_18550::type) m) =
+ ALL2 (%(x::'q_18552::type) y::'q_18553::type. P (f x) (g y)) l m"
+ by (import hollight ALL2_MAP2)
+
+lemma AND_ALL2: "ALL (P::'q_18599::type => 'q_18598::type => bool)
+ (Q::'q_18599::type => 'q_18598::type => bool)
+ (x::'q_18599::type hollight.list) xa::'q_18598::type hollight.list.
+ (ALL2 P x xa & ALL2 Q x xa) =
+ ALL2 (%(x::'q_18599::type) y::'q_18598::type. P x y & Q x y) x xa"
+ by (import hollight AND_ALL2)
+
+lemma ALL2_ALL: "ALL (P::'q_18621::type => 'q_18621::type => bool)
+ l::'q_18621::type hollight.list.
+ ALL2 P l l = ALL_list (%x::'q_18621::type. P x x) l"
+ by (import hollight ALL2_ALL)
+
+lemma APPEND_EQ_NIL: "ALL (x::'q_18650::type hollight.list) xa::'q_18650::type hollight.list.
+ (APPEND x xa = NIL) = (x = NIL & xa = NIL)"
+ by (import hollight APPEND_EQ_NIL)
+
+lemma LENGTH_MAP2: "ALL (f::'q_18670::type => 'q_18672::type => 'q_18683::type)
+ (l::'q_18670::type hollight.list) m::'q_18672::type hollight.list.
+ LENGTH l = LENGTH m --> LENGTH (MAP2 f l m) = LENGTH m"
+ by (import hollight LENGTH_MAP2)
+
+lemma MONO_ALL: "(ALL x::'A::type. (P::'A::type => bool) x --> (Q::'A::type => bool) x) -->
+ALL_list P (l::'A::type hollight.list) --> ALL_list Q l"
+ by (import hollight MONO_ALL)
+
+lemma MONO_ALL2: "(ALL (x::'A::type) y::'B::type.
+ (P::'A::type => 'B::type => bool) x y -->
+ (Q::'A::type => 'B::type => bool) x y) -->
+ALL2 P (l::'A::type hollight.list) (l'::'B::type hollight.list) -->
+ALL2 Q l l'"
+ by (import hollight MONO_ALL2)
+
+constdefs
+ dist :: "nat * nat => nat"
+ "dist == %u::nat * nat. fst u - snd u + (snd u - fst u)"
+
+lemma DEF_dist: "dist = (%u::nat * nat. fst u - snd u + (snd u - fst u))"
+ by (import hollight DEF_dist)
+
+lemma DIST_REFL: "ALL x::nat. dist (x, x) = (0::nat)"
+ by (import hollight DIST_REFL)
+
+lemma DIST_LZERO: "ALL x::nat. dist (0::nat, x) = x"
+ by (import hollight DIST_LZERO)
+
+lemma DIST_RZERO: "ALL x::nat. dist (x, 0::nat) = x"
+ by (import hollight DIST_RZERO)
+
+lemma DIST_SYM: "ALL (x::nat) xa::nat. dist (x, xa) = dist (xa, x)"
+ by (import hollight DIST_SYM)
+
+lemma DIST_LADD: "ALL (x::nat) (xa::nat) xb::nat. dist (x + xb, x + xa) = dist (xb, xa)"
+ by (import hollight DIST_LADD)
+
+lemma DIST_RADD: "ALL (x::nat) (xa::nat) xb::nat. dist (x + xa, xb + xa) = dist (x, xb)"
+ by (import hollight DIST_RADD)
+
+lemma DIST_LADD_0: "ALL (x::nat) xa::nat. dist (x + xa, x) = xa"
+ by (import hollight DIST_LADD_0)
+
+lemma DIST_RADD_0: "ALL (x::nat) xa::nat. dist (x, x + xa) = xa"
+ by (import hollight DIST_RADD_0)
+
+lemma DIST_LMUL: "ALL (x::nat) (xa::nat) xb::nat. x * dist (xa, xb) = dist (x * xa, x * xb)"
+ by (import hollight DIST_LMUL)
+
+lemma DIST_RMUL: "ALL (x::nat) (xa::nat) xb::nat. dist (x, xa) * xb = dist (x * xb, xa * xb)"
+ by (import hollight DIST_RMUL)
+
+lemma DIST_EQ_0: "ALL (x::nat) xa::nat. (dist (x, xa) = (0::nat)) = (x = xa)"
+ by (import hollight DIST_EQ_0)
+
+lemma DIST_ELIM_THM: "(P::nat => bool) (dist (x::nat, y::nat)) =
+(ALL d::nat. (x = y + d --> P d) & (y = x + d --> P d))"
+ by (import hollight DIST_ELIM_THM)
+
+lemma DIST_LE_CASES: "ALL (m::nat) (n::nat) p::nat.
+ <= (dist (m, n)) p = (<= m (n + p) & <= n (m + p))"
+ by (import hollight DIST_LE_CASES)
+
+lemma DIST_ADDBOUND: "ALL (m::nat) n::nat. <= (dist (m, n)) (m + n)"
+ by (import hollight DIST_ADDBOUND)
+
+lemma DIST_TRIANGLE: "ALL (m::nat) (n::nat) p::nat. <= (dist (m, p)) (dist (m, n) + dist (n, p))"
+ by (import hollight DIST_TRIANGLE)
+
+lemma DIST_ADD2: "ALL (m::nat) (n::nat) (p::nat) q::nat.
+ <= (dist (m + n, p + q)) (dist (m, p) + dist (n, q))"
+ by (import hollight DIST_ADD2)
+
+lemma DIST_ADD2_REV: "ALL (m::nat) (n::nat) (p::nat) q::nat.
+ <= (dist (m, p)) (dist (m + n, p + q) + dist (n, q))"
+ by (import hollight DIST_ADD2_REV)
+
+lemma DIST_TRIANGLE_LE: "ALL (m::nat) (n::nat) (p::nat) q::nat.
+ <= (dist (m, n) + dist (n, p)) q --> <= (dist (m, p)) q"
+ by (import hollight DIST_TRIANGLE_LE)
+
+lemma DIST_TRIANGLES_LE: "ALL (m::nat) (n::nat) (p::nat) (q::nat) (r::nat) s::nat.
+ <= (dist (m, n)) r & <= (dist (p, q)) s -->
+ <= (dist (m, p)) (dist (n, q) + (r + s))"
+ by (import hollight DIST_TRIANGLES_LE)
+
+lemma BOUNDS_LINEAR: "ALL (A::nat) (B::nat) C::nat. (ALL n::nat. <= (A * n) (B * n + C)) = <= A B"
+ by (import hollight BOUNDS_LINEAR)
+
+lemma BOUNDS_LINEAR_0: "ALL (A::nat) B::nat. (ALL n::nat. <= (A * n) B) = (A = (0::nat))"
+ by (import hollight BOUNDS_LINEAR_0)
+
+lemma BOUNDS_DIVIDED: "ALL P::nat => nat.
+ (EX B::nat. ALL n::nat. <= (P n) B) =
+ (EX (x::nat) B::nat. ALL n::nat. <= (n * P n) (x * n + B))"
+ by (import hollight BOUNDS_DIVIDED)
+
+lemma BOUNDS_NOTZERO: "ALL (P::nat => nat => nat) (A::nat) B::nat.
+ P (0::nat) (0::nat) = (0::nat) &
+ (ALL (m::nat) n::nat. <= (P m n) (A * (m + n) + B)) -->
+ (EX x::nat. ALL (m::nat) n::nat. <= (P m n) (x * (m + n)))"
+ by (import hollight BOUNDS_NOTZERO)
+
+lemma BOUNDS_IGNORE: "ALL (P::nat => nat) Q::nat => nat.
+ (EX B::nat. ALL i::nat. <= (P i) (Q i + B)) =
+ (EX (x::nat) N::nat. ALL i::nat. <= N i --> <= (P i) (Q i + x))"
+ by (import hollight BOUNDS_IGNORE)
+
+constdefs
+ is_nadd :: "(nat => nat) => bool"
+ "is_nadd ==
+%u::nat => nat.
+ EX B::nat.
+ ALL (m::nat) n::nat. <= (dist (m * u n, n * u m)) (B * (m + n))"
+
+lemma DEF_is_nadd: "is_nadd =
+(%u::nat => nat.
+ EX B::nat.
+ ALL (m::nat) n::nat. <= (dist (m * u n, n * u m)) (B * (m + n)))"
+ by (import hollight DEF_is_nadd)
+
+lemma is_nadd_0: "is_nadd (%n::nat. 0::nat)"
+ by (import hollight is_nadd_0)
+
+typedef (open) nadd = "Collect is_nadd" morphisms "dest_nadd" "mk_nadd"
+ apply (rule light_ex_imp_nonempty[where t="%n::nat. NUMERAL (0::nat)"])
+ by (import hollight TYDEF_nadd)
+
+syntax
+ dest_nadd :: _
+
+syntax
+ mk_nadd :: _
+
+lemmas "TYDEF_nadd_@intern" = typedef_hol2hollight
+ [where a="a :: nadd" and r=r ,
+ OF type_definition_nadd]
+
+lemma NADD_CAUCHY: "ALL x::nadd.
+ EX xa::nat.
+ ALL (xb::nat) xc::nat.
+ <= (dist (xb * dest_nadd x xc, xc * dest_nadd x xb))
+ (xa * (xb + xc))"
+ by (import hollight NADD_CAUCHY)
+
+lemma NADD_BOUND: "ALL x::nadd.
+ EX (xa::nat) B::nat. ALL n::nat. <= (dest_nadd x n) (xa * n + B)"
+ by (import hollight NADD_BOUND)
+
+lemma NADD_MULTIPLICATIVE: "ALL x::nadd.
+ EX xa::nat.
+ ALL (m::nat) n::nat.
+ <= (dist (dest_nadd x (m * n), m * dest_nadd x n)) (xa * m + xa)"
+ by (import hollight NADD_MULTIPLICATIVE)
+
+lemma NADD_ADDITIVE: "ALL x::nadd.
+ EX xa::nat.
+ ALL (m::nat) n::nat.
+ <= (dist (dest_nadd x (m + n), dest_nadd x m + dest_nadd x n)) xa"
+ by (import hollight NADD_ADDITIVE)
+
+lemma NADD_SUC: "ALL x::nadd.
+ EX xa::nat. ALL n::nat. <= (dist (dest_nadd x (Suc n), dest_nadd x n)) xa"
+ by (import hollight NADD_SUC)
+
+lemma NADD_DIST_LEMMA: "ALL x::nadd.
+ EX xa::nat.
+ ALL (m::nat) n::nat.
+ <= (dist (dest_nadd x (m + n), dest_nadd x m)) (xa * n)"
+ by (import hollight NADD_DIST_LEMMA)
+
+lemma NADD_DIST: "ALL x::nadd.
+ EX xa::nat.
+ ALL (m::nat) n::nat.
+ <= (dist (dest_nadd x m, dest_nadd x n)) (xa * dist (m, n))"
+ by (import hollight NADD_DIST)
+
+lemma NADD_ALTMUL: "ALL (x::nadd) y::nadd.
+ EX (A::nat) B::nat.
+ ALL n::nat.
+ <= (dist
+ (n * dest_nadd x (dest_nadd y n),
+ dest_nadd x n * dest_nadd y n))
+ (A * n + B)"
+ by (import hollight NADD_ALTMUL)
+
+constdefs
+ nadd_eq :: "nadd => nadd => bool"
+ "nadd_eq ==
+%(u::nadd) ua::nadd.
+ EX B::nat. ALL n::nat. <= (dist (dest_nadd u n, dest_nadd ua n)) B"
+
+lemma DEF_nadd_eq: "nadd_eq =
+(%(u::nadd) ua::nadd.
+ EX B::nat. ALL n::nat. <= (dist (dest_nadd u n, dest_nadd ua n)) B)"
+ by (import hollight DEF_nadd_eq)
+
+lemma NADD_EQ_REFL: "ALL x::nadd. nadd_eq x x"
+ by (import hollight NADD_EQ_REFL)
+
+lemma NADD_EQ_SYM: "ALL (x::nadd) y::nadd. nadd_eq x y = nadd_eq y x"
+ by (import hollight NADD_EQ_SYM)
+
+lemma NADD_EQ_TRANS: "ALL (x::nadd) (y::nadd) z::nadd. nadd_eq x y & nadd_eq y z --> nadd_eq x z"
+ by (import hollight NADD_EQ_TRANS)
+
+constdefs
+ nadd_of_num :: "nat => nadd"
+ "nadd_of_num == %u::nat. mk_nadd (op * u)"
+
+lemma DEF_nadd_of_num: "nadd_of_num = (%u::nat. mk_nadd (op * u))"
+ by (import hollight DEF_nadd_of_num)
+
+lemma NADD_OF_NUM: "ALL x::nat. dest_nadd (nadd_of_num x) = op * x"
+ by (import hollight NADD_OF_NUM)
+
+lemma NADD_OF_NUM_WELLDEF: "ALL (m::nat) n::nat. m = n --> nadd_eq (nadd_of_num m) (nadd_of_num n)"
+ by (import hollight NADD_OF_NUM_WELLDEF)
+
+lemma NADD_OF_NUM_EQ: "ALL (m::nat) n::nat. nadd_eq (nadd_of_num m) (nadd_of_num n) = (m = n)"
+ by (import hollight NADD_OF_NUM_EQ)
+
+constdefs
+ nadd_le :: "nadd => nadd => bool"
+ "nadd_le ==
+%(u::nadd) ua::nadd.
+ EX B::nat. ALL n::nat. <= (dest_nadd u n) (dest_nadd ua n + B)"
+
+lemma DEF_nadd_le: "nadd_le =
+(%(u::nadd) ua::nadd.
+ EX B::nat. ALL n::nat. <= (dest_nadd u n) (dest_nadd ua n + B))"
+ by (import hollight DEF_nadd_le)
+
+lemma NADD_LE_WELLDEF_LEMMA: "ALL (x::nadd) (x'::nadd) (y::nadd) y'::nadd.
+ nadd_eq x x' & nadd_eq y y' & nadd_le x y --> nadd_le x' y'"
+ by (import hollight NADD_LE_WELLDEF_LEMMA)
+
+lemma NADD_LE_WELLDEF: "ALL (x::nadd) (x'::nadd) (y::nadd) y'::nadd.
+ nadd_eq x x' & nadd_eq y y' --> nadd_le x y = nadd_le x' y'"
+ by (import hollight NADD_LE_WELLDEF)
+
+lemma NADD_LE_REFL: "ALL x::nadd. nadd_le x x"
+ by (import hollight NADD_LE_REFL)
+
+lemma NADD_LE_TRANS: "ALL (x::nadd) (y::nadd) z::nadd. nadd_le x y & nadd_le y z --> nadd_le x z"
+ by (import hollight NADD_LE_TRANS)
+
+lemma NADD_LE_ANTISYM: "ALL (x::nadd) y::nadd. (nadd_le x y & nadd_le y x) = nadd_eq x y"
+ by (import hollight NADD_LE_ANTISYM)
+
+lemma NADD_LE_TOTAL_LEMMA: "ALL (x::nadd) y::nadd.
+ ~ nadd_le x y -->
+ (ALL B::nat.
+ EX n::nat. n ~= (0::nat) & < (dest_nadd y n + B) (dest_nadd x n))"
+ by (import hollight NADD_LE_TOTAL_LEMMA)
+
+lemma NADD_LE_TOTAL: "ALL (x::nadd) y::nadd. nadd_le x y | nadd_le y x"
+ by (import hollight NADD_LE_TOTAL)
+
+lemma NADD_ARCH: "ALL x::nadd. EX xa::nat. nadd_le x (nadd_of_num xa)"
+ by (import hollight NADD_ARCH)
+
+lemma NADD_OF_NUM_LE: "ALL (m::nat) n::nat. nadd_le (nadd_of_num m) (nadd_of_num n) = <= m n"
+ by (import hollight NADD_OF_NUM_LE)
+
+constdefs
+ nadd_add :: "nadd => nadd => nadd"
+ "nadd_add ==
+%(u::nadd) ua::nadd. mk_nadd (%n::nat. dest_nadd u n + dest_nadd ua n)"
+
+lemma DEF_nadd_add: "nadd_add =
+(%(u::nadd) ua::nadd. mk_nadd (%n::nat. dest_nadd u n + dest_nadd ua n))"
+ by (import hollight DEF_nadd_add)
+
+lemma NADD_ADD: "ALL (x::nadd) y::nadd.
+ dest_nadd (nadd_add x y) = (%n::nat. dest_nadd x n + dest_nadd y n)"
+ by (import hollight NADD_ADD)
+
+lemma NADD_ADD_WELLDEF: "ALL (x::nadd) (x'::nadd) (y::nadd) y'::nadd.
+ nadd_eq x x' & nadd_eq y y' --> nadd_eq (nadd_add x y) (nadd_add x' y')"
+ by (import hollight NADD_ADD_WELLDEF)
+
+lemma NADD_ADD_SYM: "ALL (x::nadd) y::nadd. nadd_eq (nadd_add x y) (nadd_add y x)"
+ by (import hollight NADD_ADD_SYM)
+
+lemma NADD_ADD_ASSOC: "ALL (x::nadd) (y::nadd) z::nadd.
+ nadd_eq (nadd_add x (nadd_add y z)) (nadd_add (nadd_add x y) z)"
+ by (import hollight NADD_ADD_ASSOC)
+
+lemma NADD_ADD_LID: "ALL x::nadd. nadd_eq (nadd_add (nadd_of_num (0::nat)) x) x"
+ by (import hollight NADD_ADD_LID)
+
+lemma NADD_ADD_LCANCEL: "ALL (x::nadd) (y::nadd) z::nadd.
+ nadd_eq (nadd_add x y) (nadd_add x z) --> nadd_eq y z"
+ by (import hollight NADD_ADD_LCANCEL)
+
+lemma NADD_LE_ADD: "ALL (x::nadd) y::nadd. nadd_le x (nadd_add x y)"
+ by (import hollight NADD_LE_ADD)
+
+lemma NADD_LE_EXISTS: "ALL (x::nadd) y::nadd.
+ nadd_le x y --> (EX d::nadd. nadd_eq y (nadd_add x d))"
+ by (import hollight NADD_LE_EXISTS)
+
+lemma NADD_OF_NUM_ADD: "ALL (x::nat) xa::nat.
+ nadd_eq (nadd_add (nadd_of_num x) (nadd_of_num xa))
+ (nadd_of_num (x + xa))"
+ by (import hollight NADD_OF_NUM_ADD)
+
+constdefs
+ nadd_mul :: "nadd => nadd => nadd"
+ "nadd_mul ==
+%(u::nadd) ua::nadd. mk_nadd (%n::nat. dest_nadd u (dest_nadd ua n))"
+
+lemma DEF_nadd_mul: "nadd_mul =
+(%(u::nadd) ua::nadd. mk_nadd (%n::nat. dest_nadd u (dest_nadd ua n)))"
+ by (import hollight DEF_nadd_mul)
+
+lemma NADD_MUL: "ALL (x::nadd) y::nadd.
+ dest_nadd (nadd_mul x y) = (%n::nat. dest_nadd x (dest_nadd y n))"
+ by (import hollight NADD_MUL)
+
+lemma NADD_MUL_SYM: "ALL (x::nadd) y::nadd. nadd_eq (nadd_mul x y) (nadd_mul y x)"
+ by (import hollight NADD_MUL_SYM)
+
+lemma NADD_MUL_ASSOC: "ALL (x::nadd) (y::nadd) z::nadd.
+ nadd_eq (nadd_mul x (nadd_mul y z)) (nadd_mul (nadd_mul x y) z)"
+ by (import hollight NADD_MUL_ASSOC)
+
+lemma NADD_MUL_LID: "ALL x::nadd. nadd_eq (nadd_mul (nadd_of_num (NUMERAL_BIT1 (0::nat))) x) x"
+ by (import hollight NADD_MUL_LID)
+
+lemma NADD_LDISTRIB: "ALL (x::nadd) (y::nadd) z::nadd.
+ nadd_eq (nadd_mul x (nadd_add y z))
+ (nadd_add (nadd_mul x y) (nadd_mul x z))"
+ by (import hollight NADD_LDISTRIB)
+
+lemma NADD_MUL_WELLDEF_LEMMA: "ALL (x::nadd) (y::nadd) y'::nadd.
+ nadd_eq y y' --> nadd_eq (nadd_mul x y) (nadd_mul x y')"
+ by (import hollight NADD_MUL_WELLDEF_LEMMA)
+
+lemma NADD_MUL_WELLDEF: "ALL (x::nadd) (x'::nadd) (y::nadd) y'::nadd.
+ nadd_eq x x' & nadd_eq y y' --> nadd_eq (nadd_mul x y) (nadd_mul x' y')"
+ by (import hollight NADD_MUL_WELLDEF)
+
+lemma NADD_OF_NUM_MUL: "ALL (x::nat) xa::nat.
+ nadd_eq (nadd_mul (nadd_of_num x) (nadd_of_num xa))
+ (nadd_of_num (x * xa))"
+ by (import hollight NADD_OF_NUM_MUL)
+
+lemma NADD_LE_0: "All (nadd_le (nadd_of_num (0::nat)))"
+ by (import hollight NADD_LE_0)
+
+lemma NADD_EQ_IMP_LE: "ALL (x::nadd) y::nadd. nadd_eq x y --> nadd_le x y"
+ by (import hollight NADD_EQ_IMP_LE)
+
+lemma NADD_LE_LMUL: "ALL (x::nadd) (y::nadd) z::nadd.
+ nadd_le y z --> nadd_le (nadd_mul x y) (nadd_mul x z)"
+ by (import hollight NADD_LE_LMUL)
+
+lemma NADD_LE_RMUL: "ALL (x::nadd) (y::nadd) z::nadd.
+ nadd_le x y --> nadd_le (nadd_mul x z) (nadd_mul y z)"
+ by (import hollight NADD_LE_RMUL)
+
+lemma NADD_LE_RADD: "ALL (x::nadd) (y::nadd) z::nadd.
+ nadd_le (nadd_add x z) (nadd_add y z) = nadd_le x y"
+ by (import hollight NADD_LE_RADD)
+
+lemma NADD_LE_LADD: "ALL (x::nadd) (y::nadd) z::nadd.
+ nadd_le (nadd_add x y) (nadd_add x z) = nadd_le y z"
+ by (import hollight NADD_LE_LADD)
+
+lemma NADD_RDISTRIB: "ALL (x::nadd) (y::nadd) z::nadd.
+ nadd_eq (nadd_mul (nadd_add x y) z)
+ (nadd_add (nadd_mul x z) (nadd_mul y z))"
+ by (import hollight NADD_RDISTRIB)
+
+lemma NADD_ARCH_MULT: "ALL (x::nadd) k::nat.
+ ~ nadd_eq x (nadd_of_num (0::nat)) -->
+ (EX xa::nat. nadd_le (nadd_of_num k) (nadd_mul (nadd_of_num xa) x))"
+ by (import hollight NADD_ARCH_MULT)
+
+lemma NADD_ARCH_ZERO: "ALL (x::nadd) k::nadd.
+ (ALL n::nat. nadd_le (nadd_mul (nadd_of_num n) x) k) -->
+ nadd_eq x (nadd_of_num (0::nat))"
+ by (import hollight NADD_ARCH_ZERO)
+
+lemma NADD_ARCH_LEMMA: "ALL (x::nadd) (y::nadd) z::nadd.
+ (ALL n::nat.
+ nadd_le (nadd_mul (nadd_of_num n) x)
+ (nadd_add (nadd_mul (nadd_of_num n) y) z)) -->
+ nadd_le x y"
+ by (import hollight NADD_ARCH_LEMMA)
+
+lemma NADD_COMPLETE: "ALL P::nadd => bool.
+ Ex P & (EX M::nadd. ALL x::nadd. P x --> nadd_le x M) -->
+ (EX M::nadd.
+ (ALL x::nadd. P x --> nadd_le x M) &
+ (ALL M'::nadd. (ALL x::nadd. P x --> nadd_le x M') --> nadd_le M M'))"
+ by (import hollight NADD_COMPLETE)
+
+lemma NADD_UBOUND: "ALL x::nadd.
+ EX (xa::nat) N::nat. ALL n::nat. <= N n --> <= (dest_nadd x n) (xa * n)"
+ by (import hollight NADD_UBOUND)
+
+lemma NADD_NONZERO: "ALL x::nadd.
+ ~ nadd_eq x (nadd_of_num (0::nat)) -->
+ (EX N::nat. ALL n::nat. <= N n --> dest_nadd x n ~= (0::nat))"
+ by (import hollight NADD_NONZERO)
+
+lemma NADD_LBOUND: "ALL x::nadd.
+ ~ nadd_eq x (nadd_of_num (0::nat)) -->
+ (EX (A::nat) N::nat. ALL n::nat. <= N n --> <= n (A * dest_nadd x n))"
+ by (import hollight NADD_LBOUND)
+
+constdefs
+ nadd_rinv :: "nadd => nat => nat"
+ "nadd_rinv == %(u::nadd) n::nat. DIV (n * n) (dest_nadd u n)"
+
+lemma DEF_nadd_rinv: "nadd_rinv = (%(u::nadd) n::nat. DIV (n * n) (dest_nadd u n))"
+ by (import hollight DEF_nadd_rinv)
+
+lemma NADD_MUL_LINV_LEMMA0: "ALL x::nadd.
+ ~ nadd_eq x (nadd_of_num (0::nat)) -->
+ (EX (xa::nat) B::nat. ALL i::nat. <= (nadd_rinv x i) (xa * i + B))"
+ by (import hollight NADD_MUL_LINV_LEMMA0)
+
+lemma NADD_MUL_LINV_LEMMA1: "ALL (x::nadd) n::nat.
+ dest_nadd x n ~= (0::nat) -->
+ <= (dist (dest_nadd x n * nadd_rinv x n, n * n)) (dest_nadd x n)"
+ by (import hollight NADD_MUL_LINV_LEMMA1)
+
+lemma NADD_MUL_LINV_LEMMA2: "ALL x::nadd.
+ ~ nadd_eq x (nadd_of_num (0::nat)) -->
+ (EX N::nat.
+ ALL n::nat.
+ <= N n -->
+ <= (dist (dest_nadd x n * nadd_rinv x n, n * n)) (dest_nadd x n))"
+ by (import hollight NADD_MUL_LINV_LEMMA2)
+
+lemma NADD_MUL_LINV_LEMMA3: "ALL x::nadd.
+ ~ nadd_eq x (nadd_of_num (0::nat)) -->
+ (EX N::nat.
+ ALL (m::nat) n::nat.
+ <= N n -->
+ <= (dist
+ (m * (dest_nadd x m * (dest_nadd x n * nadd_rinv x n)),
+ m * (dest_nadd x m * (n * n))))
+ (m * (dest_nadd x m * dest_nadd x n)))"
+ by (import hollight NADD_MUL_LINV_LEMMA3)
+
+lemma NADD_MUL_LINV_LEMMA4: "ALL x::nadd.
+ ~ nadd_eq x (nadd_of_num (0::nat)) -->
+ (EX N::nat.
+ ALL (m::nat) n::nat.
+ <= N m & <= N n -->
+ <= (dest_nadd x m * dest_nadd x n *
+ dist (m * nadd_rinv x n, n * nadd_rinv x m))
+ (m * n * dist (m * dest_nadd x n, n * dest_nadd x m) +
+ dest_nadd x m * dest_nadd x n * (m + n)))"
+ by (import hollight NADD_MUL_LINV_LEMMA4)
+
+lemma NADD_MUL_LINV_LEMMA5: "ALL x::nadd.
+ ~ nadd_eq x (nadd_of_num (0::nat)) -->
+ (EX (B::nat) N::nat.
+ ALL (m::nat) n::nat.
+ <= N m & <= N n -->
+ <= (dest_nadd x m * dest_nadd x n *
+ dist (m * nadd_rinv x n, n * nadd_rinv x m))
+ (B * (m * n * (m + n))))"
+ by (import hollight NADD_MUL_LINV_LEMMA5)
+
+lemma NADD_MUL_LINV_LEMMA6: "ALL x::nadd.
+ ~ nadd_eq x (nadd_of_num (0::nat)) -->
+ (EX (B::nat) N::nat.
+ ALL (m::nat) n::nat.
+ <= N m & <= N n -->
+ <= (m * n * dist (m * nadd_rinv x n, n * nadd_rinv x m))
+ (B * (m * n * (m + n))))"
+ by (import hollight NADD_MUL_LINV_LEMMA6)
+
+lemma NADD_MUL_LINV_LEMMA7: "ALL x::nadd.
+ ~ nadd_eq x (nadd_of_num (0::nat)) -->
+ (EX (B::nat) N::nat.
+ ALL (m::nat) n::nat.
+ <= N m & <= N n -->
+ <= (dist (m * nadd_rinv x n, n * nadd_rinv x m)) (B * (m + n)))"
+ by (import hollight NADD_MUL_LINV_LEMMA7)
+
+lemma NADD_MUL_LINV_LEMMA7a: "ALL x::nadd.
+ ~ nadd_eq x (nadd_of_num (0::nat)) -->
+ (ALL N::nat.
+ EX (A::nat) B::nat.
+ ALL (m::nat) n::nat.
+ <= m N -->
+ <= (dist (m * nadd_rinv x n, n * nadd_rinv x m)) (A * n + B))"
+ by (import hollight NADD_MUL_LINV_LEMMA7a)
+
+lemma NADD_MUL_LINV_LEMMA8: "ALL x::nadd.
+ ~ nadd_eq x (nadd_of_num (0::nat)) -->
+ (EX B::nat.
+ ALL (m::nat) n::nat.
+ <= (dist (m * nadd_rinv x n, n * nadd_rinv x m)) (B * (m + n)))"
+ by (import hollight NADD_MUL_LINV_LEMMA8)
+
+constdefs
+ nadd_inv :: "nadd => nadd"
+ "nadd_inv ==
+%u::nadd.
+ COND (nadd_eq u (nadd_of_num (0::nat))) (nadd_of_num (0::nat))
+ (mk_nadd (nadd_rinv u))"
+
+lemma DEF_nadd_inv: "nadd_inv =
+(%u::nadd.
+ COND (nadd_eq u (nadd_of_num (0::nat))) (nadd_of_num (0::nat))
+ (mk_nadd (nadd_rinv u)))"
+ by (import hollight DEF_nadd_inv)
+
+lemma NADD_INV: "ALL x::nadd.
+ dest_nadd (nadd_inv x) =
+ COND (nadd_eq x (nadd_of_num (0::nat))) (%n::nat. 0::nat) (nadd_rinv x)"
+ by (import hollight NADD_INV)
+
+lemma NADD_MUL_LINV: "ALL x::nadd.
+ ~ nadd_eq x (nadd_of_num (0::nat)) -->
+ nadd_eq (nadd_mul (nadd_inv x) x) (nadd_of_num (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight NADD_MUL_LINV)
+
+lemma NADD_INV_0: "nadd_eq (nadd_inv (nadd_of_num (0::nat))) (nadd_of_num (0::nat))"
+ by (import hollight NADD_INV_0)
+
+lemma NADD_INV_WELLDEF: "ALL (x::nadd) y::nadd. nadd_eq x y --> nadd_eq (nadd_inv x) (nadd_inv y)"
+ by (import hollight NADD_INV_WELLDEF)
+
+typedef (open) hreal = "{s::nadd => bool. EX x::nadd. s = nadd_eq x}" morphisms "dest_hreal" "mk_hreal"
+ apply (rule light_ex_imp_nonempty[where t="nadd_eq (x::nadd)"])
+ by (import hollight TYDEF_hreal)
+
+syntax
+ dest_hreal :: _
+
+syntax
+ mk_hreal :: _
+
+lemmas "TYDEF_hreal_@intern" = typedef_hol2hollight
+ [where a="a :: hreal" and r=r ,
+ OF type_definition_hreal]
+
+constdefs
+ hreal_of_num :: "nat => hreal"
+ "hreal_of_num == %m::nat. mk_hreal (nadd_eq (nadd_of_num m))"
+
+lemma DEF_hreal_of_num: "hreal_of_num = (%m::nat. mk_hreal (nadd_eq (nadd_of_num m)))"
+ by (import hollight DEF_hreal_of_num)
+
+constdefs
+ hreal_add :: "hreal => hreal => hreal"
+ "hreal_add ==
+%(x::hreal) y::hreal.
+ mk_hreal
+ (%u::nadd.
+ EX (xa::nadd) ya::nadd.
+ nadd_eq (nadd_add xa ya) u & dest_hreal x xa & dest_hreal y ya)"
+
+lemma DEF_hreal_add: "hreal_add =
+(%(x::hreal) y::hreal.
+ mk_hreal
+ (%u::nadd.
+ EX (xa::nadd) ya::nadd.
+ nadd_eq (nadd_add xa ya) u & dest_hreal x xa & dest_hreal y ya))"
+ by (import hollight DEF_hreal_add)
+
+constdefs
+ hreal_mul :: "hreal => hreal => hreal"
+ "hreal_mul ==
+%(x::hreal) y::hreal.
+ mk_hreal
+ (%u::nadd.
+ EX (xa::nadd) ya::nadd.
+ nadd_eq (nadd_mul xa ya) u & dest_hreal x xa & dest_hreal y ya)"
+
+lemma DEF_hreal_mul: "hreal_mul =
+(%(x::hreal) y::hreal.
+ mk_hreal
+ (%u::nadd.
+ EX (xa::nadd) ya::nadd.
+ nadd_eq (nadd_mul xa ya) u & dest_hreal x xa & dest_hreal y ya))"
+ by (import hollight DEF_hreal_mul)
+
+constdefs
+ hreal_le :: "hreal => hreal => bool"
+ "hreal_le ==
+%(x::hreal) y::hreal.
+ SOME u::bool.
+ EX (xa::nadd) ya::nadd.
+ nadd_le xa ya = u & dest_hreal x xa & dest_hreal y ya"
+
+lemma DEF_hreal_le: "hreal_le =
+(%(x::hreal) y::hreal.
+ SOME u::bool.
+ EX (xa::nadd) ya::nadd.
+ nadd_le xa ya = u & dest_hreal x xa & dest_hreal y ya)"
+ by (import hollight DEF_hreal_le)
+
+constdefs
+ hreal_inv :: "hreal => hreal"
+ "hreal_inv ==
+%x::hreal.
+ mk_hreal
+ (%u::nadd. EX xa::nadd. nadd_eq (nadd_inv xa) u & dest_hreal x xa)"
+
+lemma DEF_hreal_inv: "hreal_inv =
+(%x::hreal.
+ mk_hreal
+ (%u::nadd. EX xa::nadd. nadd_eq (nadd_inv xa) u & dest_hreal x xa))"
+ by (import hollight DEF_hreal_inv)
+
+lemma HREAL_LE_EXISTS_DEF: "ALL (m::hreal) n::hreal. hreal_le m n = (EX d::hreal. n = hreal_add m d)"
+ by (import hollight HREAL_LE_EXISTS_DEF)
+
+lemma HREAL_EQ_ADD_LCANCEL: "ALL (m::hreal) (n::hreal) p::hreal.
+ (hreal_add m n = hreal_add m p) = (n = p)"
+ by (import hollight HREAL_EQ_ADD_LCANCEL)
+
+lemma HREAL_EQ_ADD_RCANCEL: "ALL (x::hreal) (xa::hreal) xb::hreal.
+ (hreal_add x xb = hreal_add xa xb) = (x = xa)"
+ by (import hollight HREAL_EQ_ADD_RCANCEL)
+
+lemma HREAL_LE_ADD_LCANCEL: "ALL (x::hreal) (xa::hreal) xb::hreal.
+ hreal_le (hreal_add x xa) (hreal_add x xb) = hreal_le xa xb"
+ by (import hollight HREAL_LE_ADD_LCANCEL)
+
+lemma HREAL_LE_ADD_RCANCEL: "ALL (x::hreal) (xa::hreal) xb::hreal.
+ hreal_le (hreal_add x xb) (hreal_add xa xb) = hreal_le x xa"
+ by (import hollight HREAL_LE_ADD_RCANCEL)
+
+lemma HREAL_ADD_RID: "ALL x::hreal. hreal_add x (hreal_of_num (0::nat)) = x"
+ by (import hollight HREAL_ADD_RID)
+
+lemma HREAL_ADD_RDISTRIB: "ALL (x::hreal) (xa::hreal) xb::hreal.
+ hreal_mul (hreal_add x xa) xb =
+ hreal_add (hreal_mul x xb) (hreal_mul xa xb)"
+ by (import hollight HREAL_ADD_RDISTRIB)
+
+lemma HREAL_MUL_LZERO: "ALL m::hreal. hreal_mul (hreal_of_num (0::nat)) m = hreal_of_num (0::nat)"
+ by (import hollight HREAL_MUL_LZERO)
+
+lemma HREAL_MUL_RZERO: "ALL x::hreal. hreal_mul x (hreal_of_num (0::nat)) = hreal_of_num (0::nat)"
+ by (import hollight HREAL_MUL_RZERO)
+
+lemma HREAL_ADD_AC: "hreal_add (m::hreal) (n::hreal) = hreal_add n m &
+hreal_add (hreal_add m n) (p::hreal) = hreal_add m (hreal_add n p) &
+hreal_add m (hreal_add n p) = hreal_add n (hreal_add m p)"
+ by (import hollight HREAL_ADD_AC)
+
+lemma HREAL_LE_ADD2: "ALL (a::hreal) (b::hreal) (c::hreal) d::hreal.
+ hreal_le a b & hreal_le c d --> hreal_le (hreal_add a c) (hreal_add b d)"
+ by (import hollight HREAL_LE_ADD2)
+
+lemma HREAL_LE_MUL_RCANCEL_IMP: "ALL (a::hreal) (b::hreal) c::hreal.
+ hreal_le a b --> hreal_le (hreal_mul a c) (hreal_mul b c)"
+ by (import hollight HREAL_LE_MUL_RCANCEL_IMP)
+
+constdefs
+ treal_of_num :: "nat => hreal * hreal"
+ "treal_of_num == %u::nat. (hreal_of_num u, hreal_of_num (0::nat))"
+
+lemma DEF_treal_of_num: "treal_of_num = (%u::nat. (hreal_of_num u, hreal_of_num (0::nat)))"
+ by (import hollight DEF_treal_of_num)
+
+constdefs
+ treal_neg :: "hreal * hreal => hreal * hreal"
+ "treal_neg == %u::hreal * hreal. (snd u, fst u)"
+
+lemma DEF_treal_neg: "treal_neg = (%u::hreal * hreal. (snd u, fst u))"
+ by (import hollight DEF_treal_neg)
+
+constdefs
+ treal_add :: "hreal * hreal => hreal * hreal => hreal * hreal"
+ "treal_add ==
+%(u::hreal * hreal) ua::hreal * hreal.
+ (hreal_add (fst u) (fst ua), hreal_add (snd u) (snd ua))"
+
+lemma DEF_treal_add: "treal_add =
+(%(u::hreal * hreal) ua::hreal * hreal.
+ (hreal_add (fst u) (fst ua), hreal_add (snd u) (snd ua)))"
+ by (import hollight DEF_treal_add)
+
+constdefs
+ treal_mul :: "hreal * hreal => hreal * hreal => hreal * hreal"
+ "treal_mul ==
+%(u::hreal * hreal) ua::hreal * hreal.
+ (hreal_add (hreal_mul (fst u) (fst ua)) (hreal_mul (snd u) (snd ua)),
+ hreal_add (hreal_mul (fst u) (snd ua)) (hreal_mul (snd u) (fst ua)))"
+
+lemma DEF_treal_mul: "treal_mul =
+(%(u::hreal * hreal) ua::hreal * hreal.
+ (hreal_add (hreal_mul (fst u) (fst ua)) (hreal_mul (snd u) (snd ua)),
+ hreal_add (hreal_mul (fst u) (snd ua)) (hreal_mul (snd u) (fst ua))))"
+ by (import hollight DEF_treal_mul)
+
+constdefs
+ treal_le :: "hreal * hreal => hreal * hreal => bool"
+ "treal_le ==
+%(u::hreal * hreal) ua::hreal * hreal.
+ hreal_le (hreal_add (fst u) (snd ua)) (hreal_add (fst ua) (snd u))"
+
+lemma DEF_treal_le: "treal_le =
+(%(u::hreal * hreal) ua::hreal * hreal.
+ hreal_le (hreal_add (fst u) (snd ua)) (hreal_add (fst ua) (snd u)))"
+ by (import hollight DEF_treal_le)
+
+constdefs
+ treal_inv :: "hreal * hreal => hreal * hreal"
+ "treal_inv ==
+%u::hreal * hreal.
+ COND (fst u = snd u) (hreal_of_num (0::nat), hreal_of_num (0::nat))
+ (COND (hreal_le (snd u) (fst u))
+ (hreal_inv (SOME d::hreal. fst u = hreal_add (snd u) d),
+ hreal_of_num (0::nat))
+ (hreal_of_num (0::nat),
+ hreal_inv (SOME d::hreal. snd u = hreal_add (fst u) d)))"
+
+lemma DEF_treal_inv: "treal_inv =
+(%u::hreal * hreal.
+ COND (fst u = snd u) (hreal_of_num (0::nat), hreal_of_num (0::nat))
+ (COND (hreal_le (snd u) (fst u))
+ (hreal_inv (SOME d::hreal. fst u = hreal_add (snd u) d),
+ hreal_of_num (0::nat))
+ (hreal_of_num (0::nat),
+ hreal_inv (SOME d::hreal. snd u = hreal_add (fst u) d))))"
+ by (import hollight DEF_treal_inv)
+
+constdefs
+ treal_eq :: "hreal * hreal => hreal * hreal => bool"
+ "treal_eq ==
+%(u::hreal * hreal) ua::hreal * hreal.
+ hreal_add (fst u) (snd ua) = hreal_add (fst ua) (snd u)"
+
+lemma DEF_treal_eq: "treal_eq =
+(%(u::hreal * hreal) ua::hreal * hreal.
+ hreal_add (fst u) (snd ua) = hreal_add (fst ua) (snd u))"
+ by (import hollight DEF_treal_eq)
+
+lemma TREAL_EQ_REFL: "ALL x::hreal * hreal. treal_eq x x"
+ by (import hollight TREAL_EQ_REFL)
+
+lemma TREAL_EQ_SYM: "ALL (x::hreal * hreal) y::hreal * hreal. treal_eq x y = treal_eq y x"
+ by (import hollight TREAL_EQ_SYM)
+
+lemma TREAL_EQ_TRANS: "ALL (x::hreal * hreal) (y::hreal * hreal) z::hreal * hreal.
+ treal_eq x y & treal_eq y z --> treal_eq x z"
+ by (import hollight TREAL_EQ_TRANS)
+
+lemma TREAL_EQ_AP: "ALL (x::hreal * hreal) y::hreal * hreal. x = y --> treal_eq x y"
+ by (import hollight TREAL_EQ_AP)
+
+lemma TREAL_OF_NUM_EQ: "ALL (x::nat) xa::nat. treal_eq (treal_of_num x) (treal_of_num xa) = (x = xa)"
+ by (import hollight TREAL_OF_NUM_EQ)
+
+lemma TREAL_OF_NUM_LE: "ALL (x::nat) xa::nat. treal_le (treal_of_num x) (treal_of_num xa) = <= x xa"
+ by (import hollight TREAL_OF_NUM_LE)
+
+lemma TREAL_OF_NUM_ADD: "ALL (x::nat) xa::nat.
+ treal_eq (treal_add (treal_of_num x) (treal_of_num xa))
+ (treal_of_num (x + xa))"
+ by (import hollight TREAL_OF_NUM_ADD)
+
+lemma TREAL_OF_NUM_MUL: "ALL (x::nat) xa::nat.
+ treal_eq (treal_mul (treal_of_num x) (treal_of_num xa))
+ (treal_of_num (x * xa))"
+ by (import hollight TREAL_OF_NUM_MUL)
+
+lemma TREAL_ADD_SYM_EQ: "ALL (x::hreal * hreal) y::hreal * hreal. treal_add x y = treal_add y x"
+ by (import hollight TREAL_ADD_SYM_EQ)
+
+lemma TREAL_MUL_SYM_EQ: "ALL (x::hreal * hreal) y::hreal * hreal. treal_mul x y = treal_mul y x"
+ by (import hollight TREAL_MUL_SYM_EQ)
+
+lemma TREAL_ADD_SYM: "ALL (x::hreal * hreal) y::hreal * hreal.
+ treal_eq (treal_add x y) (treal_add y x)"
+ by (import hollight TREAL_ADD_SYM)
+
+lemma TREAL_ADD_ASSOC: "ALL (x::hreal * hreal) (y::hreal * hreal) z::hreal * hreal.
+ treal_eq (treal_add x (treal_add y z)) (treal_add (treal_add x y) z)"
+ by (import hollight TREAL_ADD_ASSOC)
+
+lemma TREAL_ADD_LID: "ALL x::hreal * hreal. treal_eq (treal_add (treal_of_num (0::nat)) x) x"
+ by (import hollight TREAL_ADD_LID)
+
+lemma TREAL_ADD_LINV: "ALL x::hreal * hreal.
+ treal_eq (treal_add (treal_neg x) x) (treal_of_num (0::nat))"
+ by (import hollight TREAL_ADD_LINV)
+
+lemma TREAL_MUL_SYM: "ALL (x::hreal * hreal) y::hreal * hreal.
+ treal_eq (treal_mul x y) (treal_mul y x)"
+ by (import hollight TREAL_MUL_SYM)
+
+lemma TREAL_MUL_ASSOC: "ALL (x::hreal * hreal) (y::hreal * hreal) z::hreal * hreal.
+ treal_eq (treal_mul x (treal_mul y z)) (treal_mul (treal_mul x y) z)"
+ by (import hollight TREAL_MUL_ASSOC)
+
+lemma TREAL_MUL_LID: "ALL x::hreal * hreal.
+ treal_eq (treal_mul (treal_of_num (NUMERAL_BIT1 (0::nat))) x) x"
+ by (import hollight TREAL_MUL_LID)
+
+lemma TREAL_ADD_LDISTRIB: "ALL (x::hreal * hreal) (y::hreal * hreal) z::hreal * hreal.
+ treal_eq (treal_mul x (treal_add y z))
+ (treal_add (treal_mul x y) (treal_mul x z))"
+ by (import hollight TREAL_ADD_LDISTRIB)
+
+lemma TREAL_LE_REFL: "ALL x::hreal * hreal. treal_le x x"
+ by (import hollight TREAL_LE_REFL)
+
+lemma TREAL_LE_ANTISYM: "ALL (x::hreal * hreal) y::hreal * hreal.
+ (treal_le x y & treal_le y x) = treal_eq x y"
+ by (import hollight TREAL_LE_ANTISYM)
+
+lemma TREAL_LE_TRANS: "ALL (x::hreal * hreal) (y::hreal * hreal) z::hreal * hreal.
+ treal_le x y & treal_le y z --> treal_le x z"
+ by (import hollight TREAL_LE_TRANS)
+
+lemma TREAL_LE_TOTAL: "ALL (x::hreal * hreal) y::hreal * hreal. treal_le x y | treal_le y x"
+ by (import hollight TREAL_LE_TOTAL)
+
+lemma TREAL_LE_LADD_IMP: "ALL (x::hreal * hreal) (y::hreal * hreal) z::hreal * hreal.
+ treal_le y z --> treal_le (treal_add x y) (treal_add x z)"
+ by (import hollight TREAL_LE_LADD_IMP)
+
+lemma TREAL_LE_MUL: "ALL (x::hreal * hreal) y::hreal * hreal.
+ treal_le (treal_of_num (0::nat)) x &
+ treal_le (treal_of_num (0::nat)) y -->
+ treal_le (treal_of_num (0::nat)) (treal_mul x y)"
+ by (import hollight TREAL_LE_MUL)
+
+lemma TREAL_INV_0: "treal_eq (treal_inv (treal_of_num (0::nat))) (treal_of_num (0::nat))"
+ by (import hollight TREAL_INV_0)
+
+lemma TREAL_MUL_LINV: "ALL x::hreal * hreal.
+ ~ treal_eq x (treal_of_num (0::nat)) -->
+ treal_eq (treal_mul (treal_inv x) x)
+ (treal_of_num (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight TREAL_MUL_LINV)
+
+lemma TREAL_OF_NUM_WELLDEF: "ALL (m::nat) n::nat. m = n --> treal_eq (treal_of_num m) (treal_of_num n)"
+ by (import hollight TREAL_OF_NUM_WELLDEF)
+
+lemma TREAL_NEG_WELLDEF: "ALL (x1::hreal * hreal) x2::hreal * hreal.
+ treal_eq x1 x2 --> treal_eq (treal_neg x1) (treal_neg x2)"
+ by (import hollight TREAL_NEG_WELLDEF)
+
+lemma TREAL_ADD_WELLDEFR: "ALL (x1::hreal * hreal) (x2::hreal * hreal) y::hreal * hreal.
+ treal_eq x1 x2 --> treal_eq (treal_add x1 y) (treal_add x2 y)"
+ by (import hollight TREAL_ADD_WELLDEFR)
+
+lemma TREAL_ADD_WELLDEF: "ALL (x1::hreal * hreal) (x2::hreal * hreal) (y1::hreal * hreal)
+ y2::hreal * hreal.
+ treal_eq x1 x2 & treal_eq y1 y2 -->
+ treal_eq (treal_add x1 y1) (treal_add x2 y2)"
+ by (import hollight TREAL_ADD_WELLDEF)
+
+lemma TREAL_MUL_WELLDEFR: "ALL (x1::hreal * hreal) (x2::hreal * hreal) y::hreal * hreal.
+ treal_eq x1 x2 --> treal_eq (treal_mul x1 y) (treal_mul x2 y)"
+ by (import hollight TREAL_MUL_WELLDEFR)
+
+lemma TREAL_MUL_WELLDEF: "ALL (x1::hreal * hreal) (x2::hreal * hreal) (y1::hreal * hreal)
+ y2::hreal * hreal.
+ treal_eq x1 x2 & treal_eq y1 y2 -->
+ treal_eq (treal_mul x1 y1) (treal_mul x2 y2)"
+ by (import hollight TREAL_MUL_WELLDEF)
+
+lemma TREAL_EQ_IMP_LE: "ALL (x::hreal * hreal) y::hreal * hreal. treal_eq x y --> treal_le x y"
+ by (import hollight TREAL_EQ_IMP_LE)
+
+lemma TREAL_LE_WELLDEF: "ALL (x1::hreal * hreal) (x2::hreal * hreal) (y1::hreal * hreal)
+ y2::hreal * hreal.
+ treal_eq x1 x2 & treal_eq y1 y2 --> treal_le x1 y1 = treal_le x2 y2"
+ by (import hollight TREAL_LE_WELLDEF)
+
+lemma TREAL_INV_WELLDEF: "ALL (x::hreal * hreal) y::hreal * hreal.
+ treal_eq x y --> treal_eq (treal_inv x) (treal_inv y)"
+ by (import hollight TREAL_INV_WELLDEF)
+
+typedef (open) real = "{s::hreal * hreal => bool. EX x::hreal * hreal. s = treal_eq x}" morphisms "dest_real" "mk_real"
+ apply (rule light_ex_imp_nonempty[where t="treal_eq (x::hreal * hreal)"])
+ by (import hollight TYDEF_real)
+
+syntax
+ dest_real :: _
+
+syntax
+ mk_real :: _
+
+lemmas "TYDEF_real_@intern" = typedef_hol2hollight
+ [where a="a :: hollight.real" and r=r ,
+ OF type_definition_real]
+
+constdefs
+ real_of_num :: "nat => hollight.real"
+ "real_of_num == %m::nat. mk_real (treal_eq (treal_of_num m))"
+
+lemma DEF_real_of_num: "real_of_num = (%m::nat. mk_real (treal_eq (treal_of_num m)))"
+ by (import hollight DEF_real_of_num)
+
+constdefs
+ real_neg :: "hollight.real => hollight.real"
+ "real_neg ==
+%x1::hollight.real.
+ mk_real
+ (%u::hreal * hreal.
+ EX x1a::hreal * hreal.
+ treal_eq (treal_neg x1a) u & dest_real x1 x1a)"
+
+lemma DEF_real_neg: "real_neg =
+(%x1::hollight.real.
+ mk_real
+ (%u::hreal * hreal.
+ EX x1a::hreal * hreal.
+ treal_eq (treal_neg x1a) u & dest_real x1 x1a))"
+ by (import hollight DEF_real_neg)
+
+constdefs
+ real_add :: "hollight.real => hollight.real => hollight.real"
+ "real_add ==
+%(x1::hollight.real) y1::hollight.real.
+ mk_real
+ (%u::hreal * hreal.
+ EX (x1a::hreal * hreal) y1a::hreal * hreal.
+ treal_eq (treal_add x1a y1a) u &
+ dest_real x1 x1a & dest_real y1 y1a)"
+
+lemma DEF_real_add: "real_add =
+(%(x1::hollight.real) y1::hollight.real.
+ mk_real
+ (%u::hreal * hreal.
+ EX (x1a::hreal * hreal) y1a::hreal * hreal.
+ treal_eq (treal_add x1a y1a) u &
+ dest_real x1 x1a & dest_real y1 y1a))"
+ by (import hollight DEF_real_add)
+
+constdefs
+ real_mul :: "hollight.real => hollight.real => hollight.real"
+ "real_mul ==
+%(x1::hollight.real) y1::hollight.real.
+ mk_real
+ (%u::hreal * hreal.
+ EX (x1a::hreal * hreal) y1a::hreal * hreal.
+ treal_eq (treal_mul x1a y1a) u &
+ dest_real x1 x1a & dest_real y1 y1a)"
+
+lemma DEF_real_mul: "real_mul =
+(%(x1::hollight.real) y1::hollight.real.
+ mk_real
+ (%u::hreal * hreal.
+ EX (x1a::hreal * hreal) y1a::hreal * hreal.
+ treal_eq (treal_mul x1a y1a) u &
+ dest_real x1 x1a & dest_real y1 y1a))"
+ by (import hollight DEF_real_mul)
+
+constdefs
+ real_le :: "hollight.real => hollight.real => bool"
+ "real_le ==
+%(x1::hollight.real) y1::hollight.real.
+ SOME u::bool.
+ EX (x1a::hreal * hreal) y1a::hreal * hreal.
+ treal_le x1a y1a = u & dest_real x1 x1a & dest_real y1 y1a"
+
+lemma DEF_real_le: "real_le =
+(%(x1::hollight.real) y1::hollight.real.
+ SOME u::bool.
+ EX (x1a::hreal * hreal) y1a::hreal * hreal.
+ treal_le x1a y1a = u & dest_real x1 x1a & dest_real y1 y1a)"
+ by (import hollight DEF_real_le)
+
+constdefs
+ real_inv :: "hollight.real => hollight.real"
+ "real_inv ==
+%x::hollight.real.
+ mk_real
+ (%u::hreal * hreal.
+ EX xa::hreal * hreal. treal_eq (treal_inv xa) u & dest_real x xa)"
+
+lemma DEF_real_inv: "real_inv =
+(%x::hollight.real.
+ mk_real
+ (%u::hreal * hreal.
+ EX xa::hreal * hreal. treal_eq (treal_inv xa) u & dest_real x xa))"
+ by (import hollight DEF_real_inv)
+
+constdefs
+ real_sub :: "hollight.real => hollight.real => hollight.real"
+ "real_sub == %(u::hollight.real) ua::hollight.real. real_add u (real_neg ua)"
+
+lemma DEF_real_sub: "real_sub = (%(u::hollight.real) ua::hollight.real. real_add u (real_neg ua))"
+ by (import hollight DEF_real_sub)
+
+constdefs
+ real_lt :: "hollight.real => hollight.real => bool"
+ "real_lt == %(u::hollight.real) ua::hollight.real. ~ real_le ua u"
+
+lemma DEF_real_lt: "real_lt = (%(u::hollight.real) ua::hollight.real. ~ real_le ua u)"
+ by (import hollight DEF_real_lt)
+
+consts
+ real_ge :: "hollight.real => hollight.real => bool"
+
+defs
+ real_ge_def: "hollight.real_ge == %(u::hollight.real) ua::hollight.real. real_le ua u"
+
+lemma DEF_real_ge: "hollight.real_ge = (%(u::hollight.real) ua::hollight.real. real_le ua u)"
+ by (import hollight DEF_real_ge)
+
+consts
+ real_gt :: "hollight.real => hollight.real => bool"
+
+defs
+ real_gt_def: "hollight.real_gt == %(u::hollight.real) ua::hollight.real. real_lt ua u"
+
+lemma DEF_real_gt: "hollight.real_gt = (%(u::hollight.real) ua::hollight.real. real_lt ua u)"
+ by (import hollight DEF_real_gt)
+
+constdefs
+ real_abs :: "hollight.real => hollight.real"
+ "real_abs ==
+%u::hollight.real. COND (real_le (real_of_num (0::nat)) u) u (real_neg u)"
+
+lemma DEF_real_abs: "real_abs =
+(%u::hollight.real. COND (real_le (real_of_num (0::nat)) u) u (real_neg u))"
+ by (import hollight DEF_real_abs)
+
+constdefs
+ real_pow :: "hollight.real => nat => hollight.real"
+ "real_pow ==
+SOME real_pow::hollight.real => nat => hollight.real.
+ (ALL x::hollight.real.
+ real_pow x (0::nat) = real_of_num (NUMERAL_BIT1 (0::nat))) &
+ (ALL (x::hollight.real) n::nat.
+ real_pow x (Suc n) = real_mul x (real_pow x n))"
+
+lemma DEF_real_pow: "real_pow =
+(SOME real_pow::hollight.real => nat => hollight.real.
+ (ALL x::hollight.real.
+ real_pow x (0::nat) = real_of_num (NUMERAL_BIT1 (0::nat))) &
+ (ALL (x::hollight.real) n::nat.
+ real_pow x (Suc n) = real_mul x (real_pow x n)))"
+ by (import hollight DEF_real_pow)
+
+constdefs
+ real_div :: "hollight.real => hollight.real => hollight.real"
+ "real_div == %(u::hollight.real) ua::hollight.real. real_mul u (real_inv ua)"
+
+lemma DEF_real_div: "real_div = (%(u::hollight.real) ua::hollight.real. real_mul u (real_inv ua))"
+ by (import hollight DEF_real_div)
+
+constdefs
+ real_max :: "hollight.real => hollight.real => hollight.real"
+ "real_max == %(u::hollight.real) ua::hollight.real. COND (real_le u ua) ua u"
+
+lemma DEF_real_max: "real_max = (%(u::hollight.real) ua::hollight.real. COND (real_le u ua) ua u)"
+ by (import hollight DEF_real_max)
+
+constdefs
+ real_min :: "hollight.real => hollight.real => hollight.real"
+ "real_min == %(u::hollight.real) ua::hollight.real. COND (real_le u ua) u ua"
+
+lemma DEF_real_min: "real_min = (%(u::hollight.real) ua::hollight.real. COND (real_le u ua) u ua)"
+ by (import hollight DEF_real_min)
+
+lemma REAL_HREAL_LEMMA1: "EX x::hreal => hollight.real.
+ (ALL xa::hollight.real.
+ real_le (real_of_num (0::nat)) xa = (EX y::hreal. xa = x y)) &
+ (ALL (y::hreal) z::hreal. hreal_le y z = real_le (x y) (x z))"
+ by (import hollight REAL_HREAL_LEMMA1)
+
+lemma REAL_HREAL_LEMMA2: "EX (x::hollight.real => hreal) r::hreal => hollight.real.
+ (ALL xa::hreal. x (r xa) = xa) &
+ (ALL xa::hollight.real.
+ real_le (real_of_num (0::nat)) xa --> r (x xa) = xa) &
+ (ALL x::hreal. real_le (real_of_num (0::nat)) (r x)) &
+ (ALL (x::hreal) y::hreal. hreal_le x y = real_le (r x) (r y))"
+ by (import hollight REAL_HREAL_LEMMA2)
+
+lemma REAL_COMPLETE_SOMEPOS: "ALL P::hollight.real => bool.
+ (EX x::hollight.real. P x & real_le (real_of_num (0::nat)) x) &
+ (EX M::hollight.real. ALL x::hollight.real. P x --> real_le x M) -->
+ (EX M::hollight.real.
+ (ALL x::hollight.real. P x --> real_le x M) &
+ (ALL M'::hollight.real.
+ (ALL x::hollight.real. P x --> real_le x M') --> real_le M M'))"
+ by (import hollight REAL_COMPLETE_SOMEPOS)
+
+lemma REAL_COMPLETE: "ALL P::hollight.real => bool.
+ Ex P &
+ (EX M::hollight.real. ALL x::hollight.real. P x --> real_le x M) -->
+ (EX M::hollight.real.
+ (ALL x::hollight.real. P x --> real_le x M) &
+ (ALL M'::hollight.real.
+ (ALL x::hollight.real. P x --> real_le x M') --> real_le M M'))"
+ by (import hollight REAL_COMPLETE)
+
+lemma REAL_ADD_AC: "real_add (m::hollight.real) (n::hollight.real) = real_add n m &
+real_add (real_add m n) (p::hollight.real) = real_add m (real_add n p) &
+real_add m (real_add n p) = real_add n (real_add m p)"
+ by (import hollight REAL_ADD_AC)
+
+lemma REAL_ADD_RINV: "ALL x::hollight.real. real_add x (real_neg x) = real_of_num (0::nat)"
+ by (import hollight REAL_ADD_RINV)
+
+lemma REAL_EQ_ADD_LCANCEL: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ (real_add x y = real_add x z) = (y = z)"
+ by (import hollight REAL_EQ_ADD_LCANCEL)
+
+lemma REAL_EQ_ADD_RCANCEL: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ (real_add x z = real_add y z) = (x = y)"
+ by (import hollight REAL_EQ_ADD_RCANCEL)
+
+lemma REAL_NEG_NEG: "ALL x::hollight.real. real_neg (real_neg x) = x"
+ by (import hollight REAL_NEG_NEG)
+
+lemma REAL_MUL_RNEG: "ALL (x::hollight.real) y::hollight.real.
+ real_mul x (real_neg y) = real_neg (real_mul x y)"
+ by (import hollight REAL_MUL_RNEG)
+
+lemma REAL_MUL_LNEG: "ALL (x::hollight.real) y::hollight.real.
+ real_mul (real_neg x) y = real_neg (real_mul x y)"
+ by (import hollight REAL_MUL_LNEG)
+
+lemma REAL_ADD_RID: "ALL x::hollight.real. real_add x (real_of_num (0::nat)) = x"
+ by (import hollight REAL_ADD_RID)
+
+lemma REAL_LE_LNEG: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_neg x) y = real_le (real_of_num (0::nat)) (real_add x y)"
+ by (import hollight REAL_LE_LNEG)
+
+lemma REAL_LE_NEG2: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_neg x) (real_neg y) = real_le y x"
+ by (import hollight REAL_LE_NEG2)
+
+lemma REAL_LE_RNEG: "ALL (x::hollight.real) y::hollight.real.
+ real_le x (real_neg y) = real_le (real_add x y) (real_of_num (0::nat))"
+ by (import hollight REAL_LE_RNEG)
+
+lemma REAL_OF_NUM_POW: "ALL (x::nat) n::nat. real_pow (real_of_num x) n = real_of_num (EXP x n)"
+ by (import hollight REAL_OF_NUM_POW)
+
+lemma REAL_POW_NEG: "ALL (x::hollight.real) n::nat.
+ real_pow (real_neg x) n =
+ COND (EVEN n) (real_pow x n) (real_neg (real_pow x n))"
+ by (import hollight REAL_POW_NEG)
+
+lemma REAL_ABS_NUM: "ALL x::nat. real_abs (real_of_num x) = real_of_num x"
+ by (import hollight REAL_ABS_NUM)
+
+lemma REAL_ABS_NEG: "ALL x::hollight.real. real_abs (real_neg x) = real_abs x"
+ by (import hollight REAL_ABS_NEG)
+
+lemma REAL_LTE_TOTAL: "ALL (x::hollight.real) xa::hollight.real. real_lt x xa | real_le xa x"
+ by (import hollight REAL_LTE_TOTAL)
+
+lemma REAL_LET_TOTAL: "ALL (x::hollight.real) xa::hollight.real. real_le x xa | real_lt xa x"
+ by (import hollight REAL_LET_TOTAL)
+
+lemma REAL_LET_TRANS: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_le x y & real_lt y z --> real_lt x z"
+ by (import hollight REAL_LET_TRANS)
+
+lemma REAL_LT_TRANS: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt x y & real_lt y z --> real_lt x z"
+ by (import hollight REAL_LT_TRANS)
+
+lemma REAL_LE_ADD: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le (real_of_num (0::nat)) y -->
+ real_le (real_of_num (0::nat)) (real_add x y)"
+ by (import hollight REAL_LE_ADD)
+
+lemma REAL_LTE_ANTISYM: "ALL (x::hollight.real) y::hollight.real. ~ (real_lt x y & real_le y x)"
+ by (import hollight REAL_LTE_ANTISYM)
+
+lemma REAL_LT_REFL: "ALL x::hollight.real. ~ real_lt x x"
+ by (import hollight REAL_LT_REFL)
+
+lemma REAL_LET_ADD: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_lt (real_of_num (0::nat)) y -->
+ real_lt (real_of_num (0::nat)) (real_add x y)"
+ by (import hollight REAL_LET_ADD)
+
+lemma REAL_ENTIRE: "ALL (x::hollight.real) y::hollight.real.
+ (real_mul x y = real_of_num (0::nat)) =
+ (x = real_of_num (0::nat) | y = real_of_num (0::nat))"
+ by (import hollight REAL_ENTIRE)
+
+lemma REAL_POW_2: "ALL x::hollight.real.
+ real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) = real_mul x x"
+ by (import hollight REAL_POW_2)
+
+lemma REAL_POLY_CLAUSES: "(ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_add x (real_add y z) = real_add (real_add x y) z) &
+(ALL (x::hollight.real) y::hollight.real. real_add x y = real_add y x) &
+(ALL x::hollight.real. real_add (real_of_num (0::nat)) x = x) &
+(ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_mul x (real_mul y z) = real_mul (real_mul x y) z) &
+(ALL (x::hollight.real) y::hollight.real. real_mul x y = real_mul y x) &
+(ALL x::hollight.real.
+ real_mul (real_of_num (NUMERAL_BIT1 (0::nat))) x = x) &
+(ALL x::hollight.real.
+ real_mul (real_of_num (0::nat)) x = real_of_num (0::nat)) &
+(ALL (x::hollight.real) (xa::hollight.real) xb::hollight.real.
+ real_mul x (real_add xa xb) =
+ real_add (real_mul x xa) (real_mul x xb)) &
+(ALL x::hollight.real.
+ real_pow x (0::nat) = real_of_num (NUMERAL_BIT1 (0::nat))) &
+(ALL (x::hollight.real) xa::nat.
+ real_pow x (Suc xa) = real_mul x (real_pow x xa))"
+ by (import hollight REAL_POLY_CLAUSES)
+
+lemma REAL_POLY_NEG_CLAUSES: "(ALL x::hollight.real.
+ real_neg x =
+ real_mul (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) x) &
+(ALL (x::hollight.real) xa::hollight.real.
+ real_sub x xa =
+ real_add x
+ (real_mul (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) xa))"
+ by (import hollight REAL_POLY_NEG_CLAUSES)
+
+lemma REAL_OF_NUM_LT: "ALL (x::nat) xa::nat. real_lt (real_of_num x) (real_of_num xa) = < x xa"
+ by (import hollight REAL_OF_NUM_LT)
+
+lemma REAL_OF_NUM_GE: "ALL (x::nat) xa::nat.
+ hollight.real_ge (real_of_num x) (real_of_num xa) = >= x xa"
+ by (import hollight REAL_OF_NUM_GE)
+
+lemma REAL_OF_NUM_GT: "ALL (x::nat) xa::nat.
+ hollight.real_gt (real_of_num x) (real_of_num xa) = > x xa"
+ by (import hollight REAL_OF_NUM_GT)
+
+lemma REAL_OF_NUM_SUC: "ALL x::nat.
+ real_add (real_of_num x) (real_of_num (NUMERAL_BIT1 (0::nat))) =
+ real_of_num (Suc x)"
+ by (import hollight REAL_OF_NUM_SUC)
+
+lemma REAL_OF_NUM_SUB: "ALL (m::nat) n::nat.
+ <= m n --> real_sub (real_of_num n) (real_of_num m) = real_of_num (n - m)"
+ by (import hollight REAL_OF_NUM_SUB)
+
+lemma REAL_MUL_AC: "real_mul (m::hollight.real) (n::hollight.real) = real_mul n m &
+real_mul (real_mul m n) (p::hollight.real) = real_mul m (real_mul n p) &
+real_mul m (real_mul n p) = real_mul n (real_mul m p)"
+ by (import hollight REAL_MUL_AC)
+
+lemma REAL_ADD_RDISTRIB: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_mul (real_add x y) z = real_add (real_mul x z) (real_mul y z)"
+ by (import hollight REAL_ADD_RDISTRIB)
+
+lemma REAL_LT_LADD_IMP: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt y z --> real_lt (real_add x y) (real_add x z)"
+ by (import hollight REAL_LT_LADD_IMP)
+
+lemma REAL_LT_MUL: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_of_num (0::nat)) x & real_lt (real_of_num (0::nat)) y -->
+ real_lt (real_of_num (0::nat)) (real_mul x y)"
+ by (import hollight REAL_LT_MUL)
+
+lemma REAL_EQ_ADD_LCANCEL_0: "ALL (x::hollight.real) y::hollight.real.
+ (real_add x y = x) = (y = real_of_num (0::nat))"
+ by (import hollight REAL_EQ_ADD_LCANCEL_0)
+
+lemma REAL_EQ_ADD_RCANCEL_0: "ALL (x::hollight.real) y::hollight.real.
+ (real_add x y = y) = (x = real_of_num (0::nat))"
+ by (import hollight REAL_EQ_ADD_RCANCEL_0)
+
+lemma REAL_NOT_EQ: "ALL (x::hollight.real) y::hollight.real.
+ (x ~= y) = (real_lt x y | real_lt y x)"
+ by (import hollight REAL_NOT_EQ)
+
+lemma REAL_LE_ANTISYM: "ALL (x::hollight.real) y::hollight.real.
+ (real_le x y & real_le y x) = (x = y)"
+ by (import hollight REAL_LE_ANTISYM)
+
+lemma REAL_LET_ANTISYM: "ALL (x::hollight.real) y::hollight.real. ~ (real_le x y & real_lt y x)"
+ by (import hollight REAL_LET_ANTISYM)
+
+lemma REAL_LT_TOTAL: "ALL (x::hollight.real) y::hollight.real. x = y | real_lt x y | real_lt y x"
+ by (import hollight REAL_LT_TOTAL)
+
+lemma REAL_LE_01: "real_le (real_of_num (0::nat)) (real_of_num (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight REAL_LE_01)
+
+lemma REAL_LE_ADD2: "ALL (w::hollight.real) (x::hollight.real) (y::hollight.real)
+ z::hollight.real.
+ real_le w x & real_le y z --> real_le (real_add w y) (real_add x z)"
+ by (import hollight REAL_LE_ADD2)
+
+lemma REAL_LT_LNEG: "ALL (x::hollight.real) xa::hollight.real.
+ real_lt (real_neg x) xa = real_lt (real_of_num (0::nat)) (real_add x xa)"
+ by (import hollight REAL_LT_LNEG)
+
+lemma REAL_LT_RNEG: "ALL (x::hollight.real) xa::hollight.real.
+ real_lt x (real_neg xa) = real_lt (real_add x xa) (real_of_num (0::nat))"
+ by (import hollight REAL_LT_RNEG)
+
+lemma REAL_NEG_EQ_0: "ALL x::hollight.real.
+ (real_neg x = real_of_num (0::nat)) = (x = real_of_num (0::nat))"
+ by (import hollight REAL_NEG_EQ_0)
+
+lemma REAL_ADD_SUB: "ALL (x::hollight.real) y::hollight.real. real_sub (real_add x y) x = y"
+ by (import hollight REAL_ADD_SUB)
+
+lemma REAL_LE_ADDR: "ALL (x::hollight.real) y::hollight.real.
+ real_le x (real_add x y) = real_le (real_of_num (0::nat)) y"
+ by (import hollight REAL_LE_ADDR)
+
+lemma REAL_LE_ADDL: "ALL (x::hollight.real) y::hollight.real.
+ real_le y (real_add x y) = real_le (real_of_num (0::nat)) x"
+ by (import hollight REAL_LE_ADDL)
+
+lemma REAL_LT_ADDR: "ALL (x::hollight.real) y::hollight.real.
+ real_lt x (real_add x y) = real_lt (real_of_num (0::nat)) y"
+ by (import hollight REAL_LT_ADDR)
+
+lemma REAL_LT_ADDL: "ALL (x::hollight.real) y::hollight.real.
+ real_lt y (real_add x y) = real_lt (real_of_num (0::nat)) x"
+ by (import hollight REAL_LT_ADDL)
+
+lemma REAL_ADD2_SUB2: "ALL (a::hollight.real) (b::hollight.real) (c::hollight.real)
+ d::hollight.real.
+ real_sub (real_add a b) (real_add c d) =
+ real_add (real_sub a c) (real_sub b d)"
+ by (import hollight REAL_ADD2_SUB2)
+
+lemma REAL_LET_ADD2: "ALL (w::hollight.real) (x::hollight.real) (y::hollight.real)
+ z::hollight.real.
+ real_le w x & real_lt y z --> real_lt (real_add w y) (real_add x z)"
+ by (import hollight REAL_LET_ADD2)
+
+lemma REAL_EQ_SUB_LADD: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ (x = real_sub y z) = (real_add x z = y)"
+ by (import hollight REAL_EQ_SUB_LADD)
+
+lemma REAL_EQ_SUB_RADD: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ (real_sub x y = z) = (x = real_add z y)"
+ by (import hollight REAL_EQ_SUB_RADD)
+
+lemma REAL_ADD_SUB2: "ALL (x::hollight.real) y::hollight.real.
+ real_sub x (real_add x y) = real_neg y"
+ by (import hollight REAL_ADD_SUB2)
+
+lemma REAL_EQ_IMP_LE: "ALL (x::hollight.real) y::hollight.real. x = y --> real_le x y"
+ by (import hollight REAL_EQ_IMP_LE)
+
+lemma REAL_DIFFSQ: "ALL (x::hollight.real) y::hollight.real.
+ real_mul (real_add x y) (real_sub x y) =
+ real_sub (real_mul x x) (real_mul y y)"
+ by (import hollight REAL_DIFFSQ)
+
+lemma REAL_EQ_NEG2: "ALL (x::hollight.real) y::hollight.real. (real_neg x = real_neg y) = (x = y)"
+ by (import hollight REAL_EQ_NEG2)
+
+lemma REAL_LT_NEG2: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_neg x) (real_neg y) = real_lt y x"
+ by (import hollight REAL_LT_NEG2)
+
+lemma REAL_ABS_ZERO: "ALL x::hollight.real.
+ (real_abs x = real_of_num (0::nat)) = (x = real_of_num (0::nat))"
+ by (import hollight REAL_ABS_ZERO)
+
+lemma REAL_ABS_0: "real_abs (real_of_num (0::nat)) = real_of_num (0::nat)"
+ by (import hollight REAL_ABS_0)
+
+lemma REAL_ABS_1: "real_abs (real_of_num (NUMERAL_BIT1 (0::nat))) =
+real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight REAL_ABS_1)
+
+lemma REAL_ABS_TRIANGLE: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_abs (real_add x y)) (real_add (real_abs x) (real_abs y))"
+ by (import hollight REAL_ABS_TRIANGLE)
+
+lemma REAL_ABS_TRIANGLE_LE: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_le (real_add (real_abs x) (real_abs (real_sub y x))) z -->
+ real_le (real_abs y) z"
+ by (import hollight REAL_ABS_TRIANGLE_LE)
+
+lemma REAL_ABS_TRIANGLE_LT: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_add (real_abs x) (real_abs (real_sub y x))) z -->
+ real_lt (real_abs y) z"
+ by (import hollight REAL_ABS_TRIANGLE_LT)
+
+lemma REAL_ABS_POS: "ALL x::hollight.real. real_le (real_of_num (0::nat)) (real_abs x)"
+ by (import hollight REAL_ABS_POS)
+
+lemma REAL_ABS_SUB: "ALL (x::hollight.real) y::hollight.real.
+ real_abs (real_sub x y) = real_abs (real_sub y x)"
+ by (import hollight REAL_ABS_SUB)
+
+lemma REAL_ABS_NZ: "ALL x::hollight.real.
+ (x ~= real_of_num (0::nat)) = real_lt (real_of_num (0::nat)) (real_abs x)"
+ by (import hollight REAL_ABS_NZ)
+
+lemma REAL_ABS_ABS: "ALL x::hollight.real. real_abs (real_abs x) = real_abs x"
+ by (import hollight REAL_ABS_ABS)
+
+lemma REAL_ABS_LE: "ALL x::hollight.real. real_le x (real_abs x)"
+ by (import hollight REAL_ABS_LE)
+
+lemma REAL_ABS_REFL: "ALL x::hollight.real. (real_abs x = x) = real_le (real_of_num (0::nat)) x"
+ by (import hollight REAL_ABS_REFL)
+
+lemma REAL_ABS_BETWEEN: "ALL (x::hollight.real) (y::hollight.real) d::hollight.real.
+ (real_lt (real_of_num (0::nat)) d &
+ real_lt (real_sub x d) y & real_lt y (real_add x d)) =
+ real_lt (real_abs (real_sub y x)) d"
+ by (import hollight REAL_ABS_BETWEEN)
+
+lemma REAL_ABS_BOUND: "ALL (x::hollight.real) (y::hollight.real) d::hollight.real.
+ real_lt (real_abs (real_sub x y)) d --> real_lt y (real_add x d)"
+ by (import hollight REAL_ABS_BOUND)
+
+lemma REAL_ABS_STILLNZ: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_abs (real_sub x y)) (real_abs y) -->
+ x ~= real_of_num (0::nat)"
+ by (import hollight REAL_ABS_STILLNZ)
+
+lemma REAL_ABS_CASES: "ALL x::hollight.real.
+ x = real_of_num (0::nat) | real_lt (real_of_num (0::nat)) (real_abs x)"
+ by (import hollight REAL_ABS_CASES)
+
+lemma REAL_ABS_BETWEEN1: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt x z & real_lt (real_abs (real_sub y x)) (real_sub z x) -->
+ real_lt y z"
+ by (import hollight REAL_ABS_BETWEEN1)
+
+lemma REAL_ABS_SIGN: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_abs (real_sub x y)) y --> real_lt (real_of_num (0::nat)) x"
+ by (import hollight REAL_ABS_SIGN)
+
+lemma REAL_ABS_SIGN2: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_abs (real_sub x y)) (real_neg y) -->
+ real_lt x (real_of_num (0::nat))"
+ by (import hollight REAL_ABS_SIGN2)
+
+lemma REAL_ABS_CIRCLE: "ALL (x::hollight.real) (y::hollight.real) h::hollight.real.
+ real_lt (real_abs h) (real_sub (real_abs y) (real_abs x)) -->
+ real_lt (real_abs (real_add x h)) (real_abs y)"
+ by (import hollight REAL_ABS_CIRCLE)
+
+lemma REAL_ABS_SUB_ABS: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_abs (real_sub (real_abs x) (real_abs y)))
+ (real_abs (real_sub x y))"
+ by (import hollight REAL_ABS_SUB_ABS)
+
+lemma REAL_ABS_BETWEEN2: "ALL (x0::hollight.real) (x::hollight.real) (y0::hollight.real)
+ y::hollight.real.
+ real_lt x0 y0 &
+ real_lt
+ (real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ (real_abs (real_sub x x0)))
+ (real_sub y0 x0) &
+ real_lt
+ (real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ (real_abs (real_sub y y0)))
+ (real_sub y0 x0) -->
+ real_lt x y"
+ by (import hollight REAL_ABS_BETWEEN2)
+
+lemma REAL_ABS_BOUNDS: "ALL (x::hollight.real) k::hollight.real.
+ real_le (real_abs x) k = (real_le (real_neg k) x & real_le x k)"
+ by (import hollight REAL_ABS_BOUNDS)
+
+lemma REAL_MIN_MAX: "ALL (x::hollight.real) y::hollight.real.
+ real_min x y = real_neg (real_max (real_neg x) (real_neg y))"
+ by (import hollight REAL_MIN_MAX)
+
+lemma REAL_MAX_MIN: "ALL (x::hollight.real) y::hollight.real.
+ real_max x y = real_neg (real_min (real_neg x) (real_neg y))"
+ by (import hollight REAL_MAX_MIN)
+
+lemma REAL_MAX_MAX: "ALL (x::hollight.real) y::hollight.real.
+ real_le x (real_max x y) & real_le y (real_max x y)"
+ by (import hollight REAL_MAX_MAX)
+
+lemma REAL_MIN_MIN: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_min x y) x & real_le (real_min x y) y"
+ by (import hollight REAL_MIN_MIN)
+
+lemma REAL_MAX_SYM: "ALL (x::hollight.real) y::hollight.real. real_max x y = real_max y x"
+ by (import hollight REAL_MAX_SYM)
+
+lemma REAL_MIN_SYM: "ALL (x::hollight.real) y::hollight.real. real_min x y = real_min y x"
+ by (import hollight REAL_MIN_SYM)
+
+lemma REAL_LE_MAX: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_le z (real_max x y) = (real_le z x | real_le z y)"
+ by (import hollight REAL_LE_MAX)
+
+lemma REAL_LE_MIN: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_le z (real_min x y) = (real_le z x & real_le z y)"
+ by (import hollight REAL_LE_MIN)
+
+lemma REAL_LT_MAX: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt z (real_max x y) = (real_lt z x | real_lt z y)"
+ by (import hollight REAL_LT_MAX)
+
+lemma REAL_LT_MIN: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt z (real_min x y) = (real_lt z x & real_lt z y)"
+ by (import hollight REAL_LT_MIN)
+
+lemma REAL_MAX_LE: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_le (real_max x y) z = (real_le x z & real_le y z)"
+ by (import hollight REAL_MAX_LE)
+
+lemma REAL_MIN_LE: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_le (real_min x y) z = (real_le x z | real_le y z)"
+ by (import hollight REAL_MIN_LE)
+
+lemma REAL_MAX_LT: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_max x y) z = (real_lt x z & real_lt y z)"
+ by (import hollight REAL_MAX_LT)
+
+lemma REAL_MIN_LT: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_min x y) z = (real_lt x z | real_lt y z)"
+ by (import hollight REAL_MIN_LT)
+
+lemma REAL_MAX_ASSOC: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_max x (real_max y z) = real_max (real_max x y) z"
+ by (import hollight REAL_MAX_ASSOC)
+
+lemma REAL_MIN_ASSOC: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_min x (real_min y z) = real_min (real_min x y) z"
+ by (import hollight REAL_MIN_ASSOC)
+
+lemma REAL_MAX_ACI: "real_max (x::hollight.real) (y::hollight.real) = real_max y x &
+real_max (real_max x y) (z::hollight.real) = real_max x (real_max y z) &
+real_max x (real_max y z) = real_max y (real_max x z) &
+real_max x x = x & real_max x (real_max x y) = real_max x y"
+ by (import hollight REAL_MAX_ACI)
+
+lemma REAL_MIN_ACI: "real_min (x::hollight.real) (y::hollight.real) = real_min y x &
+real_min (real_min x y) (z::hollight.real) = real_min x (real_min y z) &
+real_min x (real_min y z) = real_min y (real_min x z) &
+real_min x x = x & real_min x (real_min x y) = real_min x y"
+ by (import hollight REAL_MIN_ACI)
+
+lemma REAL_ABS_MUL: "ALL (x::hollight.real) y::hollight.real.
+ real_abs (real_mul x y) = real_mul (real_abs x) (real_abs y)"
+ by (import hollight REAL_ABS_MUL)
+
+lemma REAL_POW_LE: "ALL (x::hollight.real) n::nat.
+ real_le (real_of_num (0::nat)) x -->
+ real_le (real_of_num (0::nat)) (real_pow x n)"
+ by (import hollight REAL_POW_LE)
+
+lemma REAL_POW_LT: "ALL (x::hollight.real) n::nat.
+ real_lt (real_of_num (0::nat)) x -->
+ real_lt (real_of_num (0::nat)) (real_pow x n)"
+ by (import hollight REAL_POW_LT)
+
+lemma REAL_ABS_POW: "ALL (x::hollight.real) n::nat.
+ real_abs (real_pow x n) = real_pow (real_abs x) n"
+ by (import hollight REAL_ABS_POW)
+
+lemma REAL_LE_LMUL: "ALL (x::hollight.real) (xa::hollight.real) xb::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le xa xb -->
+ real_le (real_mul x xa) (real_mul x xb)"
+ by (import hollight REAL_LE_LMUL)
+
+lemma REAL_LE_RMUL: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_le x y & real_le (real_of_num (0::nat)) z -->
+ real_le (real_mul x z) (real_mul y z)"
+ by (import hollight REAL_LE_RMUL)
+
+lemma REAL_LT_LMUL: "ALL (x::hollight.real) (xa::hollight.real) xb::hollight.real.
+ real_lt (real_of_num (0::nat)) x & real_lt xa xb -->
+ real_lt (real_mul x xa) (real_mul x xb)"
+ by (import hollight REAL_LT_LMUL)
+
+lemma REAL_LT_RMUL: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt x y & real_lt (real_of_num (0::nat)) z -->
+ real_lt (real_mul x z) (real_mul y z)"
+ by (import hollight REAL_LT_RMUL)
+
+lemma REAL_EQ_MUL_LCANCEL: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ (real_mul x y = real_mul x z) = (x = real_of_num (0::nat) | y = z)"
+ by (import hollight REAL_EQ_MUL_LCANCEL)
+
+lemma REAL_EQ_MUL_RCANCEL: "ALL (x::hollight.real) (xa::hollight.real) xb::hollight.real.
+ (real_mul x xb = real_mul xa xb) = (x = xa | xb = real_of_num (0::nat))"
+ by (import hollight REAL_EQ_MUL_RCANCEL)
+
+lemma REAL_MUL_LINV_UNIQ: "ALL (x::hollight.real) y::hollight.real.
+ real_mul x y = real_of_num (NUMERAL_BIT1 (0::nat)) --> real_inv y = x"
+ by (import hollight REAL_MUL_LINV_UNIQ)
+
+lemma REAL_MUL_RINV_UNIQ: "ALL (x::hollight.real) xa::hollight.real.
+ real_mul x xa = real_of_num (NUMERAL_BIT1 (0::nat)) --> real_inv x = xa"
+ by (import hollight REAL_MUL_RINV_UNIQ)
+
+lemma REAL_INV_INV: "ALL x::hollight.real. real_inv (real_inv x) = x"
+ by (import hollight REAL_INV_INV)
+
+lemma REAL_INV_EQ_0: "ALL x::hollight.real.
+ (real_inv x = real_of_num (0::nat)) = (x = real_of_num (0::nat))"
+ by (import hollight REAL_INV_EQ_0)
+
+lemma REAL_LT_INV: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x -->
+ real_lt (real_of_num (0::nat)) (real_inv x)"
+ by (import hollight REAL_LT_INV)
+
+lemma REAL_LT_INV_EQ: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) (real_inv x) =
+ real_lt (real_of_num (0::nat)) x"
+ by (import hollight REAL_LT_INV_EQ)
+
+lemma REAL_INV_NEG: "ALL x::hollight.real. real_inv (real_neg x) = real_neg (real_inv x)"
+ by (import hollight REAL_INV_NEG)
+
+lemma REAL_LE_INV_EQ: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) (real_inv x) =
+ real_le (real_of_num (0::nat)) x"
+ by (import hollight REAL_LE_INV_EQ)
+
+lemma REAL_LE_INV: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) x -->
+ real_le (real_of_num (0::nat)) (real_inv x)"
+ by (import hollight REAL_LE_INV)
+
+lemma REAL_INV_1: "real_inv (real_of_num (NUMERAL_BIT1 (0::nat))) =
+real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight REAL_INV_1)
+
+lemma REAL_DIV_1: "ALL x::hollight.real. real_div x (real_of_num (NUMERAL_BIT1 (0::nat))) = x"
+ by (import hollight REAL_DIV_1)
+
+lemma REAL_DIV_REFL: "ALL x::hollight.real.
+ x ~= real_of_num (0::nat) -->
+ real_div x x = real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight REAL_DIV_REFL)
+
+lemma REAL_DIV_RMUL: "ALL (x::hollight.real) xa::hollight.real.
+ xa ~= real_of_num (0::nat) --> real_mul (real_div x xa) xa = x"
+ by (import hollight REAL_DIV_RMUL)
+
+lemma REAL_DIV_LMUL: "ALL (x::hollight.real) xa::hollight.real.
+ xa ~= real_of_num (0::nat) --> real_mul xa (real_div x xa) = x"
+ by (import hollight REAL_DIV_LMUL)
+
+lemma REAL_ABS_INV: "ALL x::hollight.real. real_abs (real_inv x) = real_inv (real_abs x)"
+ by (import hollight REAL_ABS_INV)
+
+lemma REAL_ABS_DIV: "ALL (x::hollight.real) xa::hollight.real.
+ real_abs (real_div x xa) = real_div (real_abs x) (real_abs xa)"
+ by (import hollight REAL_ABS_DIV)
+
+lemma REAL_INV_MUL: "ALL (x::hollight.real) y::hollight.real.
+ real_inv (real_mul x y) = real_mul (real_inv x) (real_inv y)"
+ by (import hollight REAL_INV_MUL)
+
+lemma REAL_INV_DIV: "ALL (x::hollight.real) xa::hollight.real.
+ real_inv (real_div x xa) = real_div xa x"
+ by (import hollight REAL_INV_DIV)
+
+lemma REAL_POW_MUL: "ALL (x::hollight.real) (y::hollight.real) n::nat.
+ real_pow (real_mul x y) n = real_mul (real_pow x n) (real_pow y n)"
+ by (import hollight REAL_POW_MUL)
+
+lemma REAL_POW_INV: "ALL (x::hollight.real) n::nat.
+ real_pow (real_inv x) n = real_inv (real_pow x n)"
+ by (import hollight REAL_POW_INV)
+
+lemma REAL_POW_DIV: "ALL (x::hollight.real) (xa::hollight.real) xb::nat.
+ real_pow (real_div x xa) xb = real_div (real_pow x xb) (real_pow xa xb)"
+ by (import hollight REAL_POW_DIV)
+
+lemma REAL_POW_ADD: "ALL (x::hollight.real) (m::nat) n::nat.
+ real_pow x (m + n) = real_mul (real_pow x m) (real_pow x n)"
+ by (import hollight REAL_POW_ADD)
+
+lemma REAL_POW_NZ: "ALL (x::hollight.real) n::nat.
+ x ~= real_of_num (0::nat) --> real_pow x n ~= real_of_num (0::nat)"
+ by (import hollight REAL_POW_NZ)
+
+lemma REAL_POW_SUB: "ALL (x::hollight.real) (m::nat) n::nat.
+ x ~= real_of_num (0::nat) & <= m n -->
+ real_pow x (n - m) = real_div (real_pow x n) (real_pow x m)"
+ by (import hollight REAL_POW_SUB)
+
+lemma REAL_LT_IMP_NZ: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x --> x ~= real_of_num (0::nat)"
+ by (import hollight REAL_LT_IMP_NZ)
+
+lemma REAL_LT_LCANCEL_IMP: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_of_num (0::nat)) x &
+ real_lt (real_mul x y) (real_mul x z) -->
+ real_lt y z"
+ by (import hollight REAL_LT_LCANCEL_IMP)
+
+lemma REAL_LT_RCANCEL_IMP: "ALL (x::hollight.real) (xa::hollight.real) xb::hollight.real.
+ real_lt (real_of_num (0::nat)) xb &
+ real_lt (real_mul x xb) (real_mul xa xb) -->
+ real_lt x xa"
+ by (import hollight REAL_LT_RCANCEL_IMP)
+
+lemma REAL_LE_LCANCEL_IMP: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_of_num (0::nat)) x &
+ real_le (real_mul x y) (real_mul x z) -->
+ real_le y z"
+ by (import hollight REAL_LE_LCANCEL_IMP)
+
+lemma REAL_LE_RCANCEL_IMP: "ALL (x::hollight.real) (xa::hollight.real) xb::hollight.real.
+ real_lt (real_of_num (0::nat)) xb &
+ real_le (real_mul x xb) (real_mul xa xb) -->
+ real_le x xa"
+ by (import hollight REAL_LE_RCANCEL_IMP)
+
+lemma REAL_LE_LMUL_EQ: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_of_num (0::nat)) z -->
+ real_le (real_mul z x) (real_mul z y) = real_le x y"
+ by (import hollight REAL_LE_LMUL_EQ)
+
+lemma REAL_LE_RDIV_EQ: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_of_num (0::nat)) z -->
+ real_le x (real_div y z) = real_le (real_mul x z) y"
+ by (import hollight REAL_LE_RDIV_EQ)
+
+lemma REAL_LE_LDIV_EQ: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_of_num (0::nat)) z -->
+ real_le (real_div x z) y = real_le x (real_mul y z)"
+ by (import hollight REAL_LE_LDIV_EQ)
+
+lemma REAL_LT_RDIV_EQ: "ALL (x::hollight.real) (xa::hollight.real) xb::hollight.real.
+ real_lt (real_of_num (0::nat)) xb -->
+ real_lt x (real_div xa xb) = real_lt (real_mul x xb) xa"
+ by (import hollight REAL_LT_RDIV_EQ)
+
+lemma REAL_LT_LDIV_EQ: "ALL (x::hollight.real) (xa::hollight.real) xb::hollight.real.
+ real_lt (real_of_num (0::nat)) xb -->
+ real_lt (real_div x xb) xa = real_lt x (real_mul xa xb)"
+ by (import hollight REAL_LT_LDIV_EQ)
+
+lemma REAL_EQ_RDIV_EQ: "ALL (x::hollight.real) (xa::hollight.real) xb::hollight.real.
+ real_lt (real_of_num (0::nat)) xb -->
+ (x = real_div xa xb) = (real_mul x xb = xa)"
+ by (import hollight REAL_EQ_RDIV_EQ)
+
+lemma REAL_EQ_LDIV_EQ: "ALL (x::hollight.real) (xa::hollight.real) xb::hollight.real.
+ real_lt (real_of_num (0::nat)) xb -->
+ (real_div x xb = xa) = (x = real_mul xa xb)"
+ by (import hollight REAL_EQ_LDIV_EQ)
+
+lemma REAL_LT_DIV2_EQ: "ALL (x::hollight.real) (xa::hollight.real) xb::hollight.real.
+ real_lt (real_of_num (0::nat)) xb -->
+ real_lt (real_div x xb) (real_div xa xb) = real_lt x xa"
+ by (import hollight REAL_LT_DIV2_EQ)
+
+lemma REAL_LE_DIV2_EQ: "ALL (x::hollight.real) (xa::hollight.real) xb::hollight.real.
+ real_lt (real_of_num (0::nat)) xb -->
+ real_le (real_div x xb) (real_div xa xb) = real_le x xa"
+ by (import hollight REAL_LE_DIV2_EQ)
+
+lemma REAL_MUL_2: "ALL x::hollight.real.
+ real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) x =
+ real_add x x"
+ by (import hollight REAL_MUL_2)
+
+lemma REAL_POW_EQ_0: "ALL (x::hollight.real) n::nat.
+ (real_pow x n = real_of_num (0::nat)) =
+ (x = real_of_num (0::nat) & n ~= (0::nat))"
+ by (import hollight REAL_POW_EQ_0)
+
+lemma REAL_LE_MUL2: "ALL (w::hollight.real) (x::hollight.real) (y::hollight.real)
+ z::hollight.real.
+ real_le (real_of_num (0::nat)) w &
+ real_le w x & real_le (real_of_num (0::nat)) y & real_le y z -->
+ real_le (real_mul w y) (real_mul x z)"
+ by (import hollight REAL_LE_MUL2)
+
+lemma REAL_LT_MUL2: "ALL (w::hollight.real) (x::hollight.real) (y::hollight.real)
+ z::hollight.real.
+ real_le (real_of_num (0::nat)) w &
+ real_lt w x & real_le (real_of_num (0::nat)) y & real_lt y z -->
+ real_lt (real_mul w y) (real_mul x z)"
+ by (import hollight REAL_LT_MUL2)
+
+lemma REAL_LT_SQUARE: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) (real_mul x x) =
+ (x ~= real_of_num (0::nat))"
+ by (import hollight REAL_LT_SQUARE)
+
+lemma REAL_INV_LE_1: "ALL x::hollight.real.
+ real_le (real_of_num (NUMERAL_BIT1 (0::nat))) x -->
+ real_le (real_inv x) (real_of_num (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight REAL_INV_LE_1)
+
+lemma REAL_POW_LE_1: "ALL (n::nat) x::hollight.real.
+ real_le (real_of_num (NUMERAL_BIT1 (0::nat))) x -->
+ real_le (real_of_num (NUMERAL_BIT1 (0::nat))) (real_pow x n)"
+ by (import hollight REAL_POW_LE_1)
+
+lemma REAL_POW_1_LE: "ALL (n::nat) x::hollight.real.
+ real_le (real_of_num (0::nat)) x &
+ real_le x (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ real_le (real_pow x n) (real_of_num (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight REAL_POW_1_LE)
+
+lemma REAL_POW_1: "ALL x::hollight.real. real_pow x (NUMERAL_BIT1 (0::nat)) = x"
+ by (import hollight REAL_POW_1)
+
+lemma REAL_POW_ONE: "ALL n::nat.
+ real_pow (real_of_num (NUMERAL_BIT1 (0::nat))) n =
+ real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight REAL_POW_ONE)
+
+lemma REAL_LT_INV2: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_of_num (0::nat)) x & real_lt x y -->
+ real_lt (real_inv y) (real_inv x)"
+ by (import hollight REAL_LT_INV2)
+
+lemma REAL_LE_INV2: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_of_num (0::nat)) x & real_le x y -->
+ real_le (real_inv y) (real_inv x)"
+ by (import hollight REAL_LE_INV2)
+
+lemma REAL_INV_1_LE: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x &
+ real_le x (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ real_le (real_of_num (NUMERAL_BIT1 (0::nat))) (real_inv x)"
+ by (import hollight REAL_INV_1_LE)
+
+lemma REAL_SUB_INV: "ALL (x::hollight.real) xa::hollight.real.
+ x ~= real_of_num (0::nat) & xa ~= real_of_num (0::nat) -->
+ real_sub (real_inv x) (real_inv xa) =
+ real_div (real_sub xa x) (real_mul x xa)"
+ by (import hollight REAL_SUB_INV)
+
+lemma REAL_DOWN: "ALL d::hollight.real.
+ real_lt (real_of_num (0::nat)) d -->
+ (EX x::hollight.real. real_lt (real_of_num (0::nat)) x & real_lt x d)"
+ by (import hollight REAL_DOWN)
+
+lemma REAL_DOWN2: "ALL (d1::hollight.real) d2::hollight.real.
+ real_lt (real_of_num (0::nat)) d1 & real_lt (real_of_num (0::nat)) d2 -->
+ (EX e::hollight.real.
+ real_lt (real_of_num (0::nat)) e & real_lt e d1 & real_lt e d2)"
+ by (import hollight REAL_DOWN2)
+
+lemma REAL_POW_LE2: "ALL (n::nat) (x::hollight.real) y::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le x y -->
+ real_le (real_pow x n) (real_pow y n)"
+ by (import hollight REAL_POW_LE2)
+
+lemma REAL_POW_MONO: "ALL (m::nat) (n::nat) x::hollight.real.
+ real_le (real_of_num (NUMERAL_BIT1 (0::nat))) x & <= m n -->
+ real_le (real_pow x m) (real_pow x n)"
+ by (import hollight REAL_POW_MONO)
+
+lemma REAL_POW_LT2: "ALL (n::nat) (x::hollight.real) y::hollight.real.
+ n ~= (0::nat) & real_le (real_of_num (0::nat)) x & real_lt x y -->
+ real_lt (real_pow x n) (real_pow y n)"
+ by (import hollight REAL_POW_LT2)
+
+lemma REAL_POW_MONO_LT: "ALL (m::nat) (n::nat) x::hollight.real.
+ real_lt (real_of_num (NUMERAL_BIT1 (0::nat))) x & < m n -->
+ real_lt (real_pow x m) (real_pow x n)"
+ by (import hollight REAL_POW_MONO_LT)
+
+lemma REAL_POW_POW: "ALL (x::hollight.real) (m::nat) n::nat.
+ real_pow (real_pow x m) n = real_pow x (m * n)"
+ by (import hollight REAL_POW_POW)
+
+lemma REAL_EQ_RCANCEL_IMP: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ z ~= real_of_num (0::nat) & real_mul x z = real_mul y z --> x = y"
+ by (import hollight REAL_EQ_RCANCEL_IMP)
+
+lemma REAL_EQ_LCANCEL_IMP: "ALL (x::hollight.real) (xa::hollight.real) xb::hollight.real.
+ xb ~= real_of_num (0::nat) & real_mul xb x = real_mul xb xa --> x = xa"
+ by (import hollight REAL_EQ_LCANCEL_IMP)
+
+lemma REAL_LT_DIV: "ALL (x::hollight.real) xa::hollight.real.
+ real_lt (real_of_num (0::nat)) x & real_lt (real_of_num (0::nat)) xa -->
+ real_lt (real_of_num (0::nat)) (real_div x xa)"
+ by (import hollight REAL_LT_DIV)
+
+lemma REAL_LE_DIV: "ALL (x::hollight.real) xa::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le (real_of_num (0::nat)) xa -->
+ real_le (real_of_num (0::nat)) (real_div x xa)"
+ by (import hollight REAL_LE_DIV)
+
+lemma REAL_DIV_POW2: "ALL (x::hollight.real) (m::nat) n::nat.
+ x ~= real_of_num (0::nat) -->
+ real_div (real_pow x m) (real_pow x n) =
+ COND (<= n m) (real_pow x (m - n)) (real_inv (real_pow x (n - m)))"
+ by (import hollight REAL_DIV_POW2)
+
+lemma REAL_DIV_POW2_ALT: "ALL (x::hollight.real) (m::nat) n::nat.
+ x ~= real_of_num (0::nat) -->
+ real_div (real_pow x m) (real_pow x n) =
+ COND (< n m) (real_pow x (m - n)) (real_inv (real_pow x (n - m)))"
+ by (import hollight REAL_DIV_POW2_ALT)
+
+lemma REAL_LT_POW2: "ALL x::nat.
+ real_lt (real_of_num (0::nat))
+ (real_pow (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) x)"
+ by (import hollight REAL_LT_POW2)
+
+lemma REAL_LE_POW2: "ALL n::nat.
+ real_le (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_pow (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) n)"
+ by (import hollight REAL_LE_POW2)
+
+lemma REAL_POW2_ABS: "ALL x::hollight.real.
+ real_pow (real_abs x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) =
+ real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight REAL_POW2_ABS)
+
+lemma REAL_LE_SQUARE_ABS: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_abs x) (real_abs y) =
+ real_le (real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ (real_pow y (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))"
+ by (import hollight REAL_LE_SQUARE_ABS)
+
+lemma REAL_WLOG_LE: "(ALL (x::hollight.real) y::hollight.real.
+ (P::hollight.real => hollight.real => bool) x y = P y x) &
+(ALL (x::hollight.real) y::hollight.real. real_le x y --> P x y) -->
+(ALL x::hollight.real. All (P x))"
+ by (import hollight REAL_WLOG_LE)
+
+lemma REAL_WLOG_LT: "(ALL x::hollight.real. (P::hollight.real => hollight.real => bool) x x) &
+(ALL (x::hollight.real) y::hollight.real. P x y = P y x) &
+(ALL (x::hollight.real) y::hollight.real. real_lt x y --> P x y) -->
+(ALL x::hollight.real. All (P x))"
+ by (import hollight REAL_WLOG_LT)
+
+constdefs
+ mod_real :: "hollight.real => hollight.real => hollight.real => bool"
+ "mod_real ==
+%(u::hollight.real) (ua::hollight.real) ub::hollight.real.
+ EX q::hollight.real. real_sub ua ub = real_mul q u"
+
+lemma DEF_mod_real: "mod_real =
+(%(u::hollight.real) (ua::hollight.real) ub::hollight.real.
+ EX q::hollight.real. real_sub ua ub = real_mul q u)"
+ by (import hollight DEF_mod_real)
+
+constdefs
+ DECIMAL :: "nat => nat => hollight.real"
+ "DECIMAL == %(u::nat) ua::nat. real_div (real_of_num u) (real_of_num ua)"
+
+lemma DEF_DECIMAL: "DECIMAL = (%(u::nat) ua::nat. real_div (real_of_num u) (real_of_num ua))"
+ by (import hollight DEF_DECIMAL)
+
+lemma RAT_LEMMA1: "(y1::hollight.real) ~= real_of_num (0::nat) &
+(y2::hollight.real) ~= real_of_num (0::nat) -->
+real_add (real_div (x1::hollight.real) y1)
+ (real_div (x2::hollight.real) y2) =
+real_mul (real_add (real_mul x1 y2) (real_mul x2 y1))
+ (real_mul (real_inv y1) (real_inv y2))"
+ by (import hollight RAT_LEMMA1)
+
+lemma RAT_LEMMA2: "real_lt (real_of_num (0::nat)) (y1::hollight.real) &
+real_lt (real_of_num (0::nat)) (y2::hollight.real) -->
+real_add (real_div (x1::hollight.real) y1)
+ (real_div (x2::hollight.real) y2) =
+real_mul (real_add (real_mul x1 y2) (real_mul x2 y1))
+ (real_mul (real_inv y1) (real_inv y2))"
+ by (import hollight RAT_LEMMA2)
+
+lemma RAT_LEMMA3: "real_lt (real_of_num (0::nat)) (y1::hollight.real) &
+real_lt (real_of_num (0::nat)) (y2::hollight.real) -->
+real_sub (real_div (x1::hollight.real) y1)
+ (real_div (x2::hollight.real) y2) =
+real_mul (real_sub (real_mul x1 y2) (real_mul x2 y1))
+ (real_mul (real_inv y1) (real_inv y2))"
+ by (import hollight RAT_LEMMA3)
+
+lemma RAT_LEMMA4: "real_lt (real_of_num (0::nat)) (y1::hollight.real) &
+real_lt (real_of_num (0::nat)) (y2::hollight.real) -->
+real_le (real_div (x1::hollight.real) y1)
+ (real_div (x2::hollight.real) y2) =
+real_le (real_mul x1 y2) (real_mul x2 y1)"
+ by (import hollight RAT_LEMMA4)
+
+lemma RAT_LEMMA5: "real_lt (real_of_num (0::nat)) (y1::hollight.real) &
+real_lt (real_of_num (0::nat)) (y2::hollight.real) -->
+(real_div (x1::hollight.real) y1 = real_div (x2::hollight.real) y2) =
+(real_mul x1 y2 = real_mul x2 y1)"
+ by (import hollight RAT_LEMMA5)
+
+constdefs
+ is_int :: "hollight.real => bool"
+ "is_int ==
+%u::hollight.real.
+ EX n::nat. u = real_of_num n | u = real_neg (real_of_num n)"
+
+lemma DEF_is_int: "is_int =
+(%u::hollight.real.
+ EX n::nat. u = real_of_num n | u = real_neg (real_of_num n))"
+ by (import hollight DEF_is_int)
+
+typedef (open) int = "Collect is_int" morphisms "dest_int" "mk_int"
+ apply (rule light_ex_imp_nonempty[where t="real_of_num (NUMERAL (0::nat))"])
+ by (import hollight TYDEF_int)
+
+syntax
+ dest_int :: _
+
+syntax
+ mk_int :: _
+
+lemmas "TYDEF_int_@intern" = typedef_hol2hollight
+ [where a="a :: hollight.int" and r=r ,
+ OF type_definition_int]
+
+lemma dest_int_rep: "ALL x::hollight.int.
+ EX n::nat.
+ dest_int x = real_of_num n | dest_int x = real_neg (real_of_num n)"
+ by (import hollight dest_int_rep)
+
+constdefs
+ int_le :: "hollight.int => hollight.int => bool"
+ "int_le ==
+%(u::hollight.int) ua::hollight.int. real_le (dest_int u) (dest_int ua)"
+
+lemma DEF_int_le: "int_le =
+(%(u::hollight.int) ua::hollight.int. real_le (dest_int u) (dest_int ua))"
+ by (import hollight DEF_int_le)
+
+constdefs
+ int_lt :: "hollight.int => hollight.int => bool"
+ "int_lt ==
+%(u::hollight.int) ua::hollight.int. real_lt (dest_int u) (dest_int ua)"
+
+lemma DEF_int_lt: "int_lt =
+(%(u::hollight.int) ua::hollight.int. real_lt (dest_int u) (dest_int ua))"
+ by (import hollight DEF_int_lt)
+
+constdefs
+ int_ge :: "hollight.int => hollight.int => bool"
+ "int_ge ==
+%(u::hollight.int) ua::hollight.int.
+ hollight.real_ge (dest_int u) (dest_int ua)"
+
+lemma DEF_int_ge: "int_ge =
+(%(u::hollight.int) ua::hollight.int.
+ hollight.real_ge (dest_int u) (dest_int ua))"
+ by (import hollight DEF_int_ge)
+
+constdefs
+ int_gt :: "hollight.int => hollight.int => bool"
+ "int_gt ==
+%(u::hollight.int) ua::hollight.int.
+ hollight.real_gt (dest_int u) (dest_int ua)"
+
+lemma DEF_int_gt: "int_gt =
+(%(u::hollight.int) ua::hollight.int.
+ hollight.real_gt (dest_int u) (dest_int ua))"
+ by (import hollight DEF_int_gt)
+
+constdefs
+ int_of_num :: "nat => hollight.int"
+ "int_of_num == %u::nat. mk_int (real_of_num u)"
+
+lemma DEF_int_of_num: "int_of_num = (%u::nat. mk_int (real_of_num u))"
+ by (import hollight DEF_int_of_num)
+
+lemma int_of_num_th: "ALL x::nat. dest_int (int_of_num x) = real_of_num x"
+ by (import hollight int_of_num_th)
+
+constdefs
+ int_neg :: "hollight.int => hollight.int"
+ "int_neg == %u::hollight.int. mk_int (real_neg (dest_int u))"
+
+lemma DEF_int_neg: "int_neg = (%u::hollight.int. mk_int (real_neg (dest_int u)))"
+ by (import hollight DEF_int_neg)
+
+lemma int_neg_th: "ALL x::hollight.int. dest_int (int_neg x) = real_neg (dest_int x)"
+ by (import hollight int_neg_th)
+
+constdefs
+ int_add :: "hollight.int => hollight.int => hollight.int"
+ "int_add ==
+%(u::hollight.int) ua::hollight.int.
+ mk_int (real_add (dest_int u) (dest_int ua))"
+
+lemma DEF_int_add: "int_add =
+(%(u::hollight.int) ua::hollight.int.
+ mk_int (real_add (dest_int u) (dest_int ua)))"
+ by (import hollight DEF_int_add)
+
+lemma int_add_th: "ALL (x::hollight.int) xa::hollight.int.
+ dest_int (int_add x xa) = real_add (dest_int x) (dest_int xa)"
+ by (import hollight int_add_th)
+
+constdefs
+ int_sub :: "hollight.int => hollight.int => hollight.int"
+ "int_sub ==
+%(u::hollight.int) ua::hollight.int.
+ mk_int (real_sub (dest_int u) (dest_int ua))"
+
+lemma DEF_int_sub: "int_sub =
+(%(u::hollight.int) ua::hollight.int.
+ mk_int (real_sub (dest_int u) (dest_int ua)))"
+ by (import hollight DEF_int_sub)
+
+lemma int_sub_th: "ALL (x::hollight.int) xa::hollight.int.
+ dest_int (int_sub x xa) = real_sub (dest_int x) (dest_int xa)"
+ by (import hollight int_sub_th)
+
+constdefs
+ int_mul :: "hollight.int => hollight.int => hollight.int"
+ "int_mul ==
+%(u::hollight.int) ua::hollight.int.
+ mk_int (real_mul (dest_int u) (dest_int ua))"
+
+lemma DEF_int_mul: "int_mul =
+(%(u::hollight.int) ua::hollight.int.
+ mk_int (real_mul (dest_int u) (dest_int ua)))"
+ by (import hollight DEF_int_mul)
+
+lemma int_mul_th: "ALL (x::hollight.int) y::hollight.int.
+ dest_int (int_mul x y) = real_mul (dest_int x) (dest_int y)"
+ by (import hollight int_mul_th)
+
+constdefs
+ int_abs :: "hollight.int => hollight.int"
+ "int_abs == %u::hollight.int. mk_int (real_abs (dest_int u))"
+
+lemma DEF_int_abs: "int_abs = (%u::hollight.int. mk_int (real_abs (dest_int u)))"
+ by (import hollight DEF_int_abs)
+
+lemma int_abs_th: "ALL x::hollight.int. dest_int (int_abs x) = real_abs (dest_int x)"
+ by (import hollight int_abs_th)
+
+constdefs
+ int_max :: "hollight.int => hollight.int => hollight.int"
+ "int_max ==
+%(u::hollight.int) ua::hollight.int.
+ mk_int (real_max (dest_int u) (dest_int ua))"
+
+lemma DEF_int_max: "int_max =
+(%(u::hollight.int) ua::hollight.int.
+ mk_int (real_max (dest_int u) (dest_int ua)))"
+ by (import hollight DEF_int_max)
+
+lemma int_max_th: "ALL (x::hollight.int) y::hollight.int.
+ dest_int (int_max x y) = real_max (dest_int x) (dest_int y)"
+ by (import hollight int_max_th)
+
+constdefs
+ int_min :: "hollight.int => hollight.int => hollight.int"
+ "int_min ==
+%(u::hollight.int) ua::hollight.int.
+ mk_int (real_min (dest_int u) (dest_int ua))"
+
+lemma DEF_int_min: "int_min =
+(%(u::hollight.int) ua::hollight.int.
+ mk_int (real_min (dest_int u) (dest_int ua)))"
+ by (import hollight DEF_int_min)
+
+lemma int_min_th: "ALL (x::hollight.int) y::hollight.int.
+ dest_int (int_min x y) = real_min (dest_int x) (dest_int y)"
+ by (import hollight int_min_th)
+
+constdefs
+ int_pow :: "hollight.int => nat => hollight.int"
+ "int_pow == %(u::hollight.int) ua::nat. mk_int (real_pow (dest_int u) ua)"
+
+lemma DEF_int_pow: "int_pow = (%(u::hollight.int) ua::nat. mk_int (real_pow (dest_int u) ua))"
+ by (import hollight DEF_int_pow)
+
+lemma int_pow_th: "ALL (x::hollight.int) xa::nat.
+ dest_int (int_pow x xa) = real_pow (dest_int x) xa"
+ by (import hollight int_pow_th)
+
+lemma INT_IMAGE: "ALL x::hollight.int.
+ (EX n::nat. x = int_of_num n) | (EX n::nat. x = int_neg (int_of_num n))"
+ by (import hollight INT_IMAGE)
+
+lemma INT_LT_DISCRETE: "ALL (x::hollight.int) y::hollight.int.
+ int_lt x y = int_le (int_add x (int_of_num (NUMERAL_BIT1 (0::nat)))) y"
+ by (import hollight INT_LT_DISCRETE)
+
+lemma INT_GT_DISCRETE: "ALL (x::hollight.int) xa::hollight.int.
+ int_gt x xa = int_ge x (int_add xa (int_of_num (NUMERAL_BIT1 (0::nat))))"
+ by (import hollight INT_GT_DISCRETE)
+
+lemma INT_FORALL_POS: "(ALL n::nat. (P::hollight.int => bool) (int_of_num n)) =
+(ALL i::hollight.int. int_le (int_of_num (0::nat)) i --> P i)"
+ by (import hollight INT_FORALL_POS)
+
+lemma INT_ABS_MUL_1: "ALL (x::hollight.int) y::hollight.int.
+ (int_abs (int_mul x y) = int_of_num (NUMERAL_BIT1 (0::nat))) =
+ (int_abs x = int_of_num (NUMERAL_BIT1 (0::nat)) &
+ int_abs y = int_of_num (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight INT_ABS_MUL_1)
+
+lemma INT_POW: "int_pow (x::hollight.int) (0::nat) = int_of_num (NUMERAL_BIT1 (0::nat)) &
+(ALL xa::nat. int_pow x (Suc xa) = int_mul x (int_pow x xa))"
+ by (import hollight INT_POW)
+
+lemma INT_ABS: "ALL x::hollight.int.
+ int_abs x = COND (int_le (int_of_num (0::nat)) x) x (int_neg x)"
+ by (import hollight INT_ABS)
+
+lemma INT_GE: "ALL (x::hollight.int) xa::hollight.int. int_ge x xa = int_le xa x"
+ by (import hollight INT_GE)
+
+lemma INT_GT: "ALL (x::hollight.int) xa::hollight.int. int_gt x xa = int_lt xa x"
+ by (import hollight INT_GT)
+
+lemma INT_LT: "ALL (x::hollight.int) xa::hollight.int. int_lt x xa = (~ int_le xa x)"
+ by (import hollight INT_LT)
+
+lemma INT_ARCH: "ALL (x::hollight.int) d::hollight.int.
+ d ~= int_of_num (0::nat) --> (EX c::hollight.int. int_lt x (int_mul c d))"
+ by (import hollight INT_ARCH)
+
+constdefs
+ mod_int :: "hollight.int => hollight.int => hollight.int => bool"
+ "mod_int ==
+%(u::hollight.int) (ua::hollight.int) ub::hollight.int.
+ EX q::hollight.int. int_sub ua ub = int_mul q u"
+
+lemma DEF_mod_int: "mod_int =
+(%(u::hollight.int) (ua::hollight.int) ub::hollight.int.
+ EX q::hollight.int. int_sub ua ub = int_mul q u)"
+ by (import hollight DEF_mod_int)
+
+constdefs
+ IN :: "'A::type => ('A::type => bool) => bool"
+ "IN == %(u::'A::type) ua::'A::type => bool. ua u"
+
+lemma DEF_IN: "IN = (%(u::'A::type) ua::'A::type => bool. ua u)"
+ by (import hollight DEF_IN)
+
+lemma EXTENSION: "ALL (x::'A::type => bool) xa::'A::type => bool.
+ (x = xa) = (ALL xb::'A::type. IN xb x = IN xb xa)"
+ by (import hollight EXTENSION)
+
+constdefs
+ GSPEC :: "('A::type => bool) => 'A::type => bool"
+ "GSPEC == %u::'A::type => bool. u"
+
+lemma DEF_GSPEC: "GSPEC = (%u::'A::type => bool. u)"
+ by (import hollight DEF_GSPEC)
+
+constdefs
+ SETSPEC :: "'q_36941::type => bool => 'q_36941::type => bool"
+ "SETSPEC == %(u::'q_36941::type) (ua::bool) ub::'q_36941::type. ua & u = ub"
+
+lemma DEF_SETSPEC: "SETSPEC = (%(u::'q_36941::type) (ua::bool) ub::'q_36941::type. ua & u = ub)"
+ by (import hollight DEF_SETSPEC)
+
+lemma IN_ELIM_THM: "(ALL (P::(bool => 'q_36974::type => bool) => bool) x::'q_36974::type.
+ IN x (GSPEC (%v::'q_36974::type. P (SETSPEC v))) =
+ P (%(p::bool) t::'q_36974::type. p & x = t)) &
+(ALL (p::'q_37005::type => bool) x::'q_37005::type.
+ IN x
+ (GSPEC (%v::'q_37005::type. EX y::'q_37005::type. SETSPEC v (p y) y)) =
+ p x) &
+(ALL (P::(bool => 'q_37033::type => bool) => bool) x::'q_37033::type.
+ GSPEC (%v::'q_37033::type. P (SETSPEC v)) x =
+ P (%(p::bool) t::'q_37033::type. p & x = t)) &
+(ALL (p::'q_37062::type => bool) x::'q_37062::type.
+ GSPEC (%v::'q_37062::type. EX y::'q_37062::type. SETSPEC v (p y) y) x =
+ p x) &
+(ALL (p::'q_37079::type => bool) x::'q_37079::type. IN x p = p x)"
+ by (import hollight IN_ELIM_THM)
+
+constdefs
+ EMPTY :: "'A::type => bool"
+ "EMPTY == %x::'A::type. False"
+
+lemma DEF_EMPTY: "EMPTY = (%x::'A::type. False)"
+ by (import hollight DEF_EMPTY)
+
+constdefs
+ INSERT :: "'A::type => ('A::type => bool) => 'A::type => bool"
+ "INSERT == %(u::'A::type) (ua::'A::type => bool) y::'A::type. IN y ua | y = u"
+
+lemma DEF_INSERT: "INSERT =
+(%(u::'A::type) (ua::'A::type => bool) y::'A::type. IN y ua | y = u)"
+ by (import hollight DEF_INSERT)
+
+consts
+ UNIV :: "'A::type => bool"
+
+defs
+ UNIV_def: "hollight.UNIV == %x::'A::type. True"
+
+lemma DEF_UNIV: "hollight.UNIV = (%x::'A::type. True)"
+ by (import hollight DEF_UNIV)
+
+consts
+ UNION :: "('A::type => bool) => ('A::type => bool) => 'A::type => bool"
+
+defs
+ UNION_def: "hollight.UNION ==
+%(u::'A::type => bool) ua::'A::type => bool.
+ GSPEC (%ub::'A::type. EX x::'A::type. SETSPEC ub (IN x u | IN x ua) x)"
+
+lemma DEF_UNION: "hollight.UNION =
+(%(u::'A::type => bool) ua::'A::type => bool.
+ GSPEC (%ub::'A::type. EX x::'A::type. SETSPEC ub (IN x u | IN x ua) x))"
+ by (import hollight DEF_UNION)
+
+constdefs
+ UNIONS :: "(('A::type => bool) => bool) => 'A::type => bool"
+ "UNIONS ==
+%u::('A::type => bool) => bool.
+ GSPEC
+ (%ua::'A::type.
+ EX x::'A::type.
+ SETSPEC ua (EX ua::'A::type => bool. IN ua u & IN x ua) x)"
+
+lemma DEF_UNIONS: "UNIONS =
+(%u::('A::type => bool) => bool.
+ GSPEC
+ (%ua::'A::type.
+ EX x::'A::type.
+ SETSPEC ua (EX ua::'A::type => bool. IN ua u & IN x ua) x))"
+ by (import hollight DEF_UNIONS)
+
+consts
+ INTER :: "('A::type => bool) => ('A::type => bool) => 'A::type => bool"
+
+defs
+ INTER_def: "hollight.INTER ==
+%(u::'A::type => bool) ua::'A::type => bool.
+ GSPEC (%ub::'A::type. EX x::'A::type. SETSPEC ub (IN x u & IN x ua) x)"
+
+lemma DEF_INTER: "hollight.INTER =
+(%(u::'A::type => bool) ua::'A::type => bool.
+ GSPEC (%ub::'A::type. EX x::'A::type. SETSPEC ub (IN x u & IN x ua) x))"
+ by (import hollight DEF_INTER)
+
+constdefs
+ INTERS :: "(('A::type => bool) => bool) => 'A::type => bool"
+ "INTERS ==
+%u::('A::type => bool) => bool.
+ GSPEC
+ (%ua::'A::type.
+ EX x::'A::type.
+ SETSPEC ua (ALL ua::'A::type => bool. IN ua u --> IN x ua) x)"
+
+lemma DEF_INTERS: "INTERS =
+(%u::('A::type => bool) => bool.
+ GSPEC
+ (%ua::'A::type.
+ EX x::'A::type.
+ SETSPEC ua (ALL ua::'A::type => bool. IN ua u --> IN x ua) x))"
+ by (import hollight DEF_INTERS)
+
+constdefs
+ DIFF :: "('A::type => bool) => ('A::type => bool) => 'A::type => bool"
+ "DIFF ==
+%(u::'A::type => bool) ua::'A::type => bool.
+ GSPEC (%ub::'A::type. EX x::'A::type. SETSPEC ub (IN x u & ~ IN x ua) x)"
+
+lemma DEF_DIFF: "DIFF =
+(%(u::'A::type => bool) ua::'A::type => bool.
+ GSPEC
+ (%ub::'A::type. EX x::'A::type. SETSPEC ub (IN x u & ~ IN x ua) x))"
+ by (import hollight DEF_DIFF)
+
+lemma INSERT: "INSERT (x::'A::type) (s::'A::type => bool) =
+GSPEC (%u::'A::type. EX y::'A::type. SETSPEC u (IN y s | y = x) y)"
+ by (import hollight INSERT)
+
+constdefs
+ DELETE :: "('A::type => bool) => 'A::type => 'A::type => bool"
+ "DELETE ==
+%(u::'A::type => bool) ua::'A::type.
+ GSPEC (%ub::'A::type. EX y::'A::type. SETSPEC ub (IN y u & y ~= ua) y)"
+
+lemma DEF_DELETE: "DELETE =
+(%(u::'A::type => bool) ua::'A::type.
+ GSPEC (%ub::'A::type. EX y::'A::type. SETSPEC ub (IN y u & y ~= ua) y))"
+ by (import hollight DEF_DELETE)
+
+constdefs
+ SUBSET :: "('A::type => bool) => ('A::type => bool) => bool"
+ "SUBSET ==
+%(u::'A::type => bool) ua::'A::type => bool.
+ ALL x::'A::type. IN x u --> IN x ua"
+
+lemma DEF_SUBSET: "SUBSET =
+(%(u::'A::type => bool) ua::'A::type => bool.
+ ALL x::'A::type. IN x u --> IN x ua)"
+ by (import hollight DEF_SUBSET)
+
+constdefs
+ PSUBSET :: "('A::type => bool) => ('A::type => bool) => bool"
+ "PSUBSET ==
+%(u::'A::type => bool) ua::'A::type => bool. SUBSET u ua & u ~= ua"
+
+lemma DEF_PSUBSET: "PSUBSET =
+(%(u::'A::type => bool) ua::'A::type => bool. SUBSET u ua & u ~= ua)"
+ by (import hollight DEF_PSUBSET)
+
+constdefs
+ DISJOINT :: "('A::type => bool) => ('A::type => bool) => bool"
+ "DISJOINT ==
+%(u::'A::type => bool) ua::'A::type => bool. hollight.INTER u ua = EMPTY"
+
+lemma DEF_DISJOINT: "DISJOINT =
+(%(u::'A::type => bool) ua::'A::type => bool. hollight.INTER u ua = EMPTY)"
+ by (import hollight DEF_DISJOINT)
+
+constdefs
+ SING :: "('A::type => bool) => bool"
+ "SING == %u::'A::type => bool. EX x::'A::type. u = INSERT x EMPTY"
+
+lemma DEF_SING: "SING = (%u::'A::type => bool. EX x::'A::type. u = INSERT x EMPTY)"
+ by (import hollight DEF_SING)
+
+constdefs
+ FINITE :: "('A::type => bool) => bool"
+ "FINITE ==
+%a::'A::type => bool.
+ ALL FINITE'::('A::type => bool) => bool.
+ (ALL a::'A::type => bool.
+ a = EMPTY |
+ (EX (x::'A::type) s::'A::type => bool.
+ a = INSERT x s & FINITE' s) -->
+ FINITE' a) -->
+ FINITE' a"
+
+lemma DEF_FINITE: "FINITE =
+(%a::'A::type => bool.
+ ALL FINITE'::('A::type => bool) => bool.
+ (ALL a::'A::type => bool.
+ a = EMPTY |
+ (EX (x::'A::type) s::'A::type => bool.
+ a = INSERT x s & FINITE' s) -->
+ FINITE' a) -->
+ FINITE' a)"
+ by (import hollight DEF_FINITE)
+
+constdefs
+ INFINITE :: "('A::type => bool) => bool"
+ "INFINITE == %u::'A::type => bool. ~ FINITE u"
+
+lemma DEF_INFINITE: "INFINITE = (%u::'A::type => bool. ~ FINITE u)"
+ by (import hollight DEF_INFINITE)
+
+constdefs
+ IMAGE :: "('A::type => 'B::type) => ('A::type => bool) => 'B::type => bool"
+ "IMAGE ==
+%(u::'A::type => 'B::type) ua::'A::type => bool.
+ GSPEC
+ (%ub::'B::type.
+ EX y::'B::type. SETSPEC ub (EX x::'A::type. IN x ua & y = u x) y)"
+
+lemma DEF_IMAGE: "IMAGE =
+(%(u::'A::type => 'B::type) ua::'A::type => bool.
+ GSPEC
+ (%ub::'B::type.
+ EX y::'B::type. SETSPEC ub (EX x::'A::type. IN x ua & y = u x) y))"
+ by (import hollight DEF_IMAGE)
+
+constdefs
+ INJ :: "('A::type => 'B::type) => ('A::type => bool) => ('B::type => bool) => bool"
+ "INJ ==
+%(u::'A::type => 'B::type) (ua::'A::type => bool) ub::'B::type => bool.
+ (ALL x::'A::type. IN x ua --> IN (u x) ub) &
+ (ALL (x::'A::type) y::'A::type. IN x ua & IN y ua & u x = u y --> x = y)"
+
+lemma DEF_INJ: "INJ =
+(%(u::'A::type => 'B::type) (ua::'A::type => bool) ub::'B::type => bool.
+ (ALL x::'A::type. IN x ua --> IN (u x) ub) &
+ (ALL (x::'A::type) y::'A::type.
+ IN x ua & IN y ua & u x = u y --> x = y))"
+ by (import hollight DEF_INJ)
+
+constdefs
+ SURJ :: "('A::type => 'B::type) => ('A::type => bool) => ('B::type => bool) => bool"
+ "SURJ ==
+%(u::'A::type => 'B::type) (ua::'A::type => bool) ub::'B::type => bool.
+ (ALL x::'A::type. IN x ua --> IN (u x) ub) &
+ (ALL x::'B::type. IN x ub --> (EX y::'A::type. IN y ua & u y = x))"
+
+lemma DEF_SURJ: "SURJ =
+(%(u::'A::type => 'B::type) (ua::'A::type => bool) ub::'B::type => bool.
+ (ALL x::'A::type. IN x ua --> IN (u x) ub) &
+ (ALL x::'B::type. IN x ub --> (EX y::'A::type. IN y ua & u y = x)))"
+ by (import hollight DEF_SURJ)
+
+constdefs
+ BIJ :: "('A::type => 'B::type) => ('A::type => bool) => ('B::type => bool) => bool"
+ "BIJ ==
+%(u::'A::type => 'B::type) (ua::'A::type => bool) ub::'B::type => bool.
+ INJ u ua ub & SURJ u ua ub"
+
+lemma DEF_BIJ: "BIJ =
+(%(u::'A::type => 'B::type) (ua::'A::type => bool) ub::'B::type => bool.
+ INJ u ua ub & SURJ u ua ub)"
+ by (import hollight DEF_BIJ)
+
+constdefs
+ CHOICE :: "('A::type => bool) => 'A::type"
+ "CHOICE == %u::'A::type => bool. SOME x::'A::type. IN x u"
+
+lemma DEF_CHOICE: "CHOICE = (%u::'A::type => bool. SOME x::'A::type. IN x u)"
+ by (import hollight DEF_CHOICE)
+
+constdefs
+ REST :: "('A::type => bool) => 'A::type => bool"
+ "REST == %u::'A::type => bool. DELETE u (CHOICE u)"
+
+lemma DEF_REST: "REST = (%u::'A::type => bool. DELETE u (CHOICE u))"
+ by (import hollight DEF_REST)
+
+constdefs
+ CARD_GE :: "('q_37578::type => bool) => ('q_37575::type => bool) => bool"
+ "CARD_GE ==
+%(u::'q_37578::type => bool) ua::'q_37575::type => bool.
+ EX f::'q_37578::type => 'q_37575::type.
+ ALL y::'q_37575::type.
+ IN y ua --> (EX x::'q_37578::type. IN x u & y = f x)"
+
+lemma DEF_CARD_GE: "CARD_GE =
+(%(u::'q_37578::type => bool) ua::'q_37575::type => bool.
+ EX f::'q_37578::type => 'q_37575::type.
+ ALL y::'q_37575::type.
+ IN y ua --> (EX x::'q_37578::type. IN x u & y = f x))"
+ by (import hollight DEF_CARD_GE)
+
+constdefs
+ CARD_LE :: "('q_37587::type => bool) => ('q_37586::type => bool) => bool"
+ "CARD_LE ==
+%(u::'q_37587::type => bool) ua::'q_37586::type => bool. CARD_GE ua u"
+
+lemma DEF_CARD_LE: "CARD_LE =
+(%(u::'q_37587::type => bool) ua::'q_37586::type => bool. CARD_GE ua u)"
+ by (import hollight DEF_CARD_LE)
+
+constdefs
+ CARD_EQ :: "('q_37597::type => bool) => ('q_37598::type => bool) => bool"
+ "CARD_EQ ==
+%(u::'q_37597::type => bool) ua::'q_37598::type => bool.
+ CARD_LE u ua & CARD_LE ua u"
+
+lemma DEF_CARD_EQ: "CARD_EQ =
+(%(u::'q_37597::type => bool) ua::'q_37598::type => bool.
+ CARD_LE u ua & CARD_LE ua u)"
+ by (import hollight DEF_CARD_EQ)
+
+constdefs
+ CARD_GT :: "('q_37612::type => bool) => ('q_37613::type => bool) => bool"
+ "CARD_GT ==
+%(u::'q_37612::type => bool) ua::'q_37613::type => bool.
+ CARD_GE u ua & ~ CARD_GE ua u"
+
+lemma DEF_CARD_GT: "CARD_GT =
+(%(u::'q_37612::type => bool) ua::'q_37613::type => bool.
+ CARD_GE u ua & ~ CARD_GE ua u)"
+ by (import hollight DEF_CARD_GT)
+
+constdefs
+ CARD_LT :: "('q_37628::type => bool) => ('q_37629::type => bool) => bool"
+ "CARD_LT ==
+%(u::'q_37628::type => bool) ua::'q_37629::type => bool.
+ CARD_LE u ua & ~ CARD_LE ua u"
+
+lemma DEF_CARD_LT: "CARD_LT =
+(%(u::'q_37628::type => bool) ua::'q_37629::type => bool.
+ CARD_LE u ua & ~ CARD_LE ua u)"
+ by (import hollight DEF_CARD_LT)
+
+constdefs
+ COUNTABLE :: "('q_37642::type => bool) => bool"
+ "(op ==::(('q_37642::type => bool) => bool)
+ => (('q_37642::type => bool) => bool) => prop)
+ (COUNTABLE::('q_37642::type => bool) => bool)
+ ((CARD_GE::(nat => bool) => ('q_37642::type => bool) => bool)
+ (hollight.UNIV::nat => bool))"
+
+lemma DEF_COUNTABLE: "(op =::(('q_37642::type => bool) => bool)
+ => (('q_37642::type => bool) => bool) => bool)
+ (COUNTABLE::('q_37642::type => bool) => bool)
+ ((CARD_GE::(nat => bool) => ('q_37642::type => bool) => bool)
+ (hollight.UNIV::nat => bool))"
+ by (import hollight DEF_COUNTABLE)
+
+lemma NOT_IN_EMPTY: "ALL x::'A::type. ~ IN x EMPTY"
+ by (import hollight NOT_IN_EMPTY)
+
+lemma IN_UNIV: "ALL x::'A::type. IN x hollight.UNIV"
+ by (import hollight IN_UNIV)
+
+lemma IN_UNION: "ALL (x::'A::type => bool) (xa::'A::type => bool) xb::'A::type.
+ IN xb (hollight.UNION x xa) = (IN xb x | IN xb xa)"
+ by (import hollight IN_UNION)
+
+lemma IN_UNIONS: "ALL (x::('A::type => bool) => bool) xa::'A::type.
+ IN xa (UNIONS x) = (EX t::'A::type => bool. IN t x & IN xa t)"
+ by (import hollight IN_UNIONS)
+
+lemma IN_INTER: "ALL (x::'A::type => bool) (xa::'A::type => bool) xb::'A::type.
+ IN xb (hollight.INTER x xa) = (IN xb x & IN xb xa)"
+ by (import hollight IN_INTER)
+
+lemma IN_INTERS: "ALL (x::('A::type => bool) => bool) xa::'A::type.
+ IN xa (INTERS x) = (ALL t::'A::type => bool. IN t x --> IN xa t)"
+ by (import hollight IN_INTERS)
+
+lemma IN_DIFF: "ALL (x::'A::type => bool) (xa::'A::type => bool) xb::'A::type.
+ IN xb (DIFF x xa) = (IN xb x & ~ IN xb xa)"
+ by (import hollight IN_DIFF)
+
+lemma IN_INSERT: "ALL (x::'A::type) (xa::'A::type) xb::'A::type => bool.
+ IN x (INSERT xa xb) = (x = xa | IN x xb)"
+ by (import hollight IN_INSERT)
+
+lemma IN_DELETE: "ALL (x::'A::type => bool) (xa::'A::type) xb::'A::type.
+ IN xa (DELETE x xb) = (IN xa x & xa ~= xb)"
+ by (import hollight IN_DELETE)
+
+lemma IN_SING: "ALL (x::'A::type) xa::'A::type. IN x (INSERT xa EMPTY) = (x = xa)"
+ by (import hollight IN_SING)
+
+lemma IN_IMAGE: "ALL (x::'B::type) (xa::'A::type => bool) xb::'A::type => 'B::type.
+ IN x (IMAGE xb xa) = (EX xc::'A::type. x = xb xc & IN xc xa)"
+ by (import hollight IN_IMAGE)
+
+lemma IN_REST: "ALL (x::'A::type) xa::'A::type => bool.
+ IN x (REST xa) = (IN x xa & x ~= CHOICE xa)"
+ by (import hollight IN_REST)
+
+lemma CHOICE_DEF: "ALL x::'A::type => bool. x ~= EMPTY --> IN (CHOICE x) x"
+ by (import hollight CHOICE_DEF)
+
+lemma NOT_EQUAL_SETS: "ALL (x::'A::type => bool) xa::'A::type => bool.
+ (x ~= xa) = (EX xb::'A::type. IN xb xa = (~ IN xb x))"
+ by (import hollight NOT_EQUAL_SETS)
+
+lemma MEMBER_NOT_EMPTY: "ALL x::'A::type => bool. (EX xa::'A::type. IN xa x) = (x ~= EMPTY)"
+ by (import hollight MEMBER_NOT_EMPTY)
+
+lemma UNIV_NOT_EMPTY: "(Not::bool => bool)
+ ((op =::('A::type => bool) => ('A::type => bool) => bool)
+ (hollight.UNIV::'A::type => bool) (EMPTY::'A::type => bool))"
+ by (import hollight UNIV_NOT_EMPTY)
+
+lemma EMPTY_NOT_UNIV: "(Not::bool => bool)
+ ((op =::('A::type => bool) => ('A::type => bool) => bool)
+ (EMPTY::'A::type => bool) (hollight.UNIV::'A::type => bool))"
+ by (import hollight EMPTY_NOT_UNIV)
+
+lemma EQ_UNIV: "(ALL x::'A::type. IN x (s::'A::type => bool)) = (s = hollight.UNIV)"
+ by (import hollight EQ_UNIV)
+
+lemma SUBSET_TRANS: "ALL (x::'A::type => bool) (xa::'A::type => bool) xb::'A::type => bool.
+ SUBSET x xa & SUBSET xa xb --> SUBSET x xb"
+ by (import hollight SUBSET_TRANS)
+
+lemma SUBSET_REFL: "ALL x::'A::type => bool. SUBSET x x"
+ by (import hollight SUBSET_REFL)
+
+lemma SUBSET_ANTISYM: "ALL (x::'A::type => bool) xa::'A::type => bool.
+ SUBSET x xa & SUBSET xa x --> x = xa"
+ by (import hollight SUBSET_ANTISYM)
+
+lemma EMPTY_SUBSET: "(All::(('A::type => bool) => bool) => bool)
+ ((SUBSET::('A::type => bool) => ('A::type => bool) => bool)
+ (EMPTY::'A::type => bool))"
+ by (import hollight EMPTY_SUBSET)
+
+lemma SUBSET_EMPTY: "ALL x::'A::type => bool. SUBSET x EMPTY = (x = EMPTY)"
+ by (import hollight SUBSET_EMPTY)
+
+lemma SUBSET_UNIV: "ALL x::'A::type => bool. SUBSET x hollight.UNIV"
+ by (import hollight SUBSET_UNIV)
+
+lemma UNIV_SUBSET: "ALL x::'A::type => bool. SUBSET hollight.UNIV x = (x = hollight.UNIV)"
+ by (import hollight UNIV_SUBSET)
+
+lemma PSUBSET_TRANS: "ALL (x::'A::type => bool) (xa::'A::type => bool) xb::'A::type => bool.
+ PSUBSET x xa & PSUBSET xa xb --> PSUBSET x xb"
+ by (import hollight PSUBSET_TRANS)
+
+lemma PSUBSET_SUBSET_TRANS: "ALL (x::'A::type => bool) (xa::'A::type => bool) xb::'A::type => bool.
+ PSUBSET x xa & SUBSET xa xb --> PSUBSET x xb"
+ by (import hollight PSUBSET_SUBSET_TRANS)
+
+lemma SUBSET_PSUBSET_TRANS: "ALL (x::'A::type => bool) (xa::'A::type => bool) xb::'A::type => bool.
+ SUBSET x xa & PSUBSET xa xb --> PSUBSET x xb"
+ by (import hollight SUBSET_PSUBSET_TRANS)
+
+lemma PSUBSET_IRREFL: "ALL x::'A::type => bool. ~ PSUBSET x x"
+ by (import hollight PSUBSET_IRREFL)
+
+lemma NOT_PSUBSET_EMPTY: "ALL x::'A::type => bool. ~ PSUBSET x EMPTY"
+ by (import hollight NOT_PSUBSET_EMPTY)
+
+lemma NOT_UNIV_PSUBSET: "ALL x::'A::type => bool. ~ PSUBSET hollight.UNIV x"
+ by (import hollight NOT_UNIV_PSUBSET)
+
+lemma PSUBSET_UNIV: "ALL x::'A::type => bool.
+ PSUBSET x hollight.UNIV = (EX xa::'A::type. ~ IN xa x)"
+ by (import hollight PSUBSET_UNIV)
+
+lemma UNION_ASSOC: "ALL (x::'A::type => bool) (xa::'A::type => bool) xb::'A::type => bool.
+ hollight.UNION (hollight.UNION x xa) xb =
+ hollight.UNION x (hollight.UNION xa xb)"
+ by (import hollight UNION_ASSOC)
+
+lemma UNION_IDEMPOT: "ALL x::'A::type => bool. hollight.UNION x x = x"
+ by (import hollight UNION_IDEMPOT)
+
+lemma UNION_COMM: "ALL (x::'A::type => bool) xa::'A::type => bool.
+ hollight.UNION x xa = hollight.UNION xa x"
+ by (import hollight UNION_COMM)
+
+lemma SUBSET_UNION: "(ALL (x::'A::type => bool) xa::'A::type => bool.
+ SUBSET x (hollight.UNION x xa)) &
+(ALL (x::'A::type => bool) xa::'A::type => bool.
+ SUBSET x (hollight.UNION xa x))"
+ by (import hollight SUBSET_UNION)
+
+lemma SUBSET_UNION_ABSORPTION: "ALL (x::'A::type => bool) xa::'A::type => bool.
+ SUBSET x xa = (hollight.UNION x xa = xa)"
+ by (import hollight SUBSET_UNION_ABSORPTION)
+
+lemma UNION_EMPTY: "(ALL x::'A::type => bool. hollight.UNION EMPTY x = x) &
+(ALL x::'A::type => bool. hollight.UNION x EMPTY = x)"
+ by (import hollight UNION_EMPTY)
+
+lemma UNION_UNIV: "(ALL x::'A::type => bool. hollight.UNION hollight.UNIV x = hollight.UNIV) &
+(ALL x::'A::type => bool. hollight.UNION x hollight.UNIV = hollight.UNIV)"
+ by (import hollight UNION_UNIV)
+
+lemma EMPTY_UNION: "ALL (x::'A::type => bool) xa::'A::type => bool.
+ (hollight.UNION x xa = EMPTY) = (x = EMPTY & xa = EMPTY)"
+ by (import hollight EMPTY_UNION)
+
+lemma UNION_SUBSET: "ALL (x::'q_38479::type => bool) (xa::'q_38479::type => bool)
+ xb::'q_38479::type => bool.
+ SUBSET (hollight.UNION x xa) xb = (SUBSET x xb & SUBSET xa xb)"
+ by (import hollight UNION_SUBSET)
+
+lemma INTER_ASSOC: "ALL (x::'A::type => bool) (xa::'A::type => bool) xb::'A::type => bool.
+ hollight.INTER (hollight.INTER x xa) xb =
+ hollight.INTER x (hollight.INTER xa xb)"
+ by (import hollight INTER_ASSOC)
+
+lemma INTER_IDEMPOT: "ALL x::'A::type => bool. hollight.INTER x x = x"
+ by (import hollight INTER_IDEMPOT)
+
+lemma INTER_COMM: "ALL (x::'A::type => bool) xa::'A::type => bool.
+ hollight.INTER x xa = hollight.INTER xa x"
+ by (import hollight INTER_COMM)
+
+lemma INTER_SUBSET: "(ALL (x::'A::type => bool) xa::'A::type => bool.
+ SUBSET (hollight.INTER x xa) x) &
+(ALL (x::'A::type => bool) xa::'A::type => bool.
+ SUBSET (hollight.INTER xa x) x)"
+ by (import hollight INTER_SUBSET)
+
+lemma SUBSET_INTER_ABSORPTION: "ALL (x::'A::type => bool) xa::'A::type => bool.
+ SUBSET x xa = (hollight.INTER x xa = x)"
+ by (import hollight SUBSET_INTER_ABSORPTION)
+
+lemma INTER_EMPTY: "(ALL x::'A::type => bool. hollight.INTER EMPTY x = EMPTY) &
+(ALL x::'A::type => bool. hollight.INTER x EMPTY = EMPTY)"
+ by (import hollight INTER_EMPTY)
+
+lemma INTER_UNIV: "(ALL x::'A::type => bool. hollight.INTER hollight.UNIV x = x) &
+(ALL x::'A::type => bool. hollight.INTER x hollight.UNIV = x)"
+ by (import hollight INTER_UNIV)
+
+lemma UNION_OVER_INTER: "ALL (x::'A::type => bool) (xa::'A::type => bool) xb::'A::type => bool.
+ hollight.INTER x (hollight.UNION xa xb) =
+ hollight.UNION (hollight.INTER x xa) (hollight.INTER x xb)"
+ by (import hollight UNION_OVER_INTER)
+
+lemma INTER_OVER_UNION: "ALL (x::'A::type => bool) (xa::'A::type => bool) xb::'A::type => bool.
+ hollight.UNION x (hollight.INTER xa xb) =
+ hollight.INTER (hollight.UNION x xa) (hollight.UNION x xb)"
+ by (import hollight INTER_OVER_UNION)
+
+lemma IN_DISJOINT: "ALL (x::'A::type => bool) xa::'A::type => bool.
+ DISJOINT x xa = (~ (EX xb::'A::type. IN xb x & IN xb xa))"
+ by (import hollight IN_DISJOINT)
+
+lemma DISJOINT_SYM: "ALL (x::'A::type => bool) xa::'A::type => bool.
+ DISJOINT x xa = DISJOINT xa x"
+ by (import hollight DISJOINT_SYM)
+
+lemma DISJOINT_EMPTY: "ALL x::'A::type => bool. DISJOINT EMPTY x & DISJOINT x EMPTY"
+ by (import hollight DISJOINT_EMPTY)
+
+lemma DISJOINT_EMPTY_REFL: "ALL x::'A::type => bool. (x = EMPTY) = DISJOINT x x"
+ by (import hollight DISJOINT_EMPTY_REFL)
+
+lemma DISJOINT_UNION: "ALL (x::'A::type => bool) (xa::'A::type => bool) xb::'A::type => bool.
+ DISJOINT (hollight.UNION x xa) xb = (DISJOINT x xb & DISJOINT xa xb)"
+ by (import hollight DISJOINT_UNION)
+
+lemma DIFF_EMPTY: "ALL x::'A::type => bool. DIFF x EMPTY = x"
+ by (import hollight DIFF_EMPTY)
+
+lemma EMPTY_DIFF: "ALL x::'A::type => bool. DIFF EMPTY x = EMPTY"
+ by (import hollight EMPTY_DIFF)
+
+lemma DIFF_UNIV: "ALL x::'A::type => bool. DIFF x hollight.UNIV = EMPTY"
+ by (import hollight DIFF_UNIV)
+
+lemma DIFF_DIFF: "ALL (x::'A::type => bool) xa::'A::type => bool.
+ DIFF (DIFF x xa) xa = DIFF x xa"
+ by (import hollight DIFF_DIFF)
+
+lemma DIFF_EQ_EMPTY: "ALL x::'A::type => bool. DIFF x x = EMPTY"
+ by (import hollight DIFF_EQ_EMPTY)
+
+lemma SUBSET_DIFF: "ALL (x::'q_38897::type => bool) xa::'q_38897::type => bool.
+ SUBSET (DIFF x xa) x"
+ by (import hollight SUBSET_DIFF)
+
+lemma COMPONENT: "ALL (x::'A::type) s::'A::type => bool. IN x (INSERT x s)"
+ by (import hollight COMPONENT)
+
+lemma DECOMPOSITION: "ALL (s::'A::type => bool) x::'A::type.
+ IN x s = (EX t::'A::type => bool. s = INSERT x t & ~ IN x t)"
+ by (import hollight DECOMPOSITION)
+
+lemma SET_CASES: "ALL s::'A::type => bool.
+ s = EMPTY |
+ (EX (x::'A::type) t::'A::type => bool. s = INSERT x t & ~ IN x t)"
+ by (import hollight SET_CASES)
+
+lemma ABSORPTION: "ALL (x::'A::type) xa::'A::type => bool. IN x xa = (INSERT x xa = xa)"
+ by (import hollight ABSORPTION)
+
+lemma INSERT_INSERT: "ALL (x::'A::type) xa::'A::type => bool. INSERT x (INSERT x xa) = INSERT x xa"
+ by (import hollight INSERT_INSERT)
+
+lemma INSERT_COMM: "ALL (x::'A::type) (xa::'A::type) xb::'A::type => bool.
+ INSERT x (INSERT xa xb) = INSERT xa (INSERT x xb)"
+ by (import hollight INSERT_COMM)
+
+lemma INSERT_UNIV: "ALL x::'A::type. INSERT x hollight.UNIV = hollight.UNIV"
+ by (import hollight INSERT_UNIV)
+
+lemma NOT_INSERT_EMPTY: "ALL (x::'A::type) xa::'A::type => bool. INSERT x xa ~= EMPTY"
+ by (import hollight NOT_INSERT_EMPTY)
+
+lemma NOT_EMPTY_INSERT: "ALL (x::'A::type) xa::'A::type => bool. EMPTY ~= INSERT x xa"
+ by (import hollight NOT_EMPTY_INSERT)
+
+lemma INSERT_UNION: "ALL (x::'A::type) (s::'A::type => bool) t::'A::type => bool.
+ hollight.UNION (INSERT x s) t =
+ COND (IN x t) (hollight.UNION s t) (INSERT x (hollight.UNION s t))"
+ by (import hollight INSERT_UNION)
+
+lemma INSERT_UNION_EQ: "ALL (x::'A::type) (xa::'A::type => bool) xb::'A::type => bool.
+ hollight.UNION (INSERT x xa) xb = INSERT x (hollight.UNION xa xb)"
+ by (import hollight INSERT_UNION_EQ)
+
+lemma INSERT_INTER: "ALL (x::'A::type) (s::'A::type => bool) t::'A::type => bool.
+ hollight.INTER (INSERT x s) t =
+ COND (IN x t) (INSERT x (hollight.INTER s t)) (hollight.INTER s t)"
+ by (import hollight INSERT_INTER)
+
+lemma DISJOINT_INSERT: "ALL (x::'A::type) (xa::'A::type => bool) xb::'A::type => bool.
+ DISJOINT (INSERT x xa) xb = (DISJOINT xa xb & ~ IN x xb)"
+ by (import hollight DISJOINT_INSERT)
+
+lemma INSERT_SUBSET: "ALL (x::'A::type) (xa::'A::type => bool) xb::'A::type => bool.
+ SUBSET (INSERT x xa) xb = (IN x xb & SUBSET xa xb)"
+ by (import hollight INSERT_SUBSET)
+
+lemma SUBSET_INSERT: "ALL (x::'A::type) xa::'A::type => bool.
+ ~ IN x xa -->
+ (ALL xb::'A::type => bool. SUBSET xa (INSERT x xb) = SUBSET xa xb)"
+ by (import hollight SUBSET_INSERT)
+
+lemma INSERT_DIFF: "ALL (s::'A::type => bool) (t::'A::type => bool) x::'A::type.
+ DIFF (INSERT x s) t = COND (IN x t) (DIFF s t) (INSERT x (DIFF s t))"
+ by (import hollight INSERT_DIFF)
+
+lemma INSERT_AC: "INSERT (x::'q_39353::type)
+ (INSERT (y::'q_39353::type) (s::'q_39353::type => bool)) =
+INSERT y (INSERT x s) &
+INSERT x (INSERT x s) = INSERT x s"
+ by (import hollight INSERT_AC)
+
+lemma INTER_ACI: "hollight.INTER (p::'q_39420::type => bool) (q::'q_39420::type => bool) =
+hollight.INTER q p &
+hollight.INTER (hollight.INTER p q) (r::'q_39420::type => bool) =
+hollight.INTER p (hollight.INTER q r) &
+hollight.INTER p (hollight.INTER q r) =
+hollight.INTER q (hollight.INTER p r) &
+hollight.INTER p p = p &
+hollight.INTER p (hollight.INTER p q) = hollight.INTER p q"
+ by (import hollight INTER_ACI)
+
+lemma UNION_ACI: "hollight.UNION (p::'q_39486::type => bool) (q::'q_39486::type => bool) =
+hollight.UNION q p &
+hollight.UNION (hollight.UNION p q) (r::'q_39486::type => bool) =
+hollight.UNION p (hollight.UNION q r) &
+hollight.UNION p (hollight.UNION q r) =
+hollight.UNION q (hollight.UNION p r) &
+hollight.UNION p p = p &
+hollight.UNION p (hollight.UNION p q) = hollight.UNION p q"
+ by (import hollight UNION_ACI)
+
+lemma DELETE_NON_ELEMENT: "ALL (x::'A::type) xa::'A::type => bool. (~ IN x xa) = (DELETE xa x = xa)"
+ by (import hollight DELETE_NON_ELEMENT)
+
+lemma IN_DELETE_EQ: "ALL (s::'A::type => bool) (x::'A::type) x'::'A::type.
+ (IN x s = IN x' s) = (IN x (DELETE s x') = IN x' (DELETE s x))"
+ by (import hollight IN_DELETE_EQ)
+
+lemma EMPTY_DELETE: "ALL x::'A::type. DELETE EMPTY x = EMPTY"
+ by (import hollight EMPTY_DELETE)
+
+lemma DELETE_DELETE: "ALL (x::'A::type) xa::'A::type => bool. DELETE (DELETE xa x) x = DELETE xa x"
+ by (import hollight DELETE_DELETE)
+
+lemma DELETE_COMM: "ALL (x::'A::type) (xa::'A::type) xb::'A::type => bool.
+ DELETE (DELETE xb x) xa = DELETE (DELETE xb xa) x"
+ by (import hollight DELETE_COMM)
+
+lemma DELETE_SUBSET: "ALL (x::'A::type) xa::'A::type => bool. SUBSET (DELETE xa x) xa"
+ by (import hollight DELETE_SUBSET)
+
+lemma SUBSET_DELETE: "ALL (x::'A::type) (xa::'A::type => bool) xb::'A::type => bool.
+ SUBSET xa (DELETE xb x) = (~ IN x xa & SUBSET xa xb)"
+ by (import hollight SUBSET_DELETE)
+
+lemma SUBSET_INSERT_DELETE: "ALL (x::'A::type) (xa::'A::type => bool) xb::'A::type => bool.
+ SUBSET xa (INSERT x xb) = SUBSET (DELETE xa x) xb"
+ by (import hollight SUBSET_INSERT_DELETE)
+
+lemma DIFF_INSERT: "ALL (x::'A::type => bool) (xa::'A::type => bool) xb::'A::type.
+ DIFF x (INSERT xb xa) = DIFF (DELETE x xb) xa"
+ by (import hollight DIFF_INSERT)
+
+lemma PSUBSET_INSERT_SUBSET: "ALL (x::'A::type => bool) xa::'A::type => bool.
+ PSUBSET x xa = (EX xb::'A::type. ~ IN xb x & SUBSET (INSERT xb x) xa)"
+ by (import hollight PSUBSET_INSERT_SUBSET)
+
+lemma PSUBSET_MEMBER: "ALL (x::'A::type => bool) xa::'A::type => bool.
+ PSUBSET x xa = (SUBSET x xa & (EX y::'A::type. IN y xa & ~ IN y x))"
+ by (import hollight PSUBSET_MEMBER)
+
+lemma DELETE_INSERT: "ALL (x::'A::type) (y::'A::type) s::'A::type => bool.
+ DELETE (INSERT x s) y = COND (x = y) (DELETE s y) (INSERT x (DELETE s y))"
+ by (import hollight DELETE_INSERT)
+
+lemma INSERT_DELETE: "ALL (x::'A::type) xa::'A::type => bool.
+ IN x xa --> INSERT x (DELETE xa x) = xa"
+ by (import hollight INSERT_DELETE)
+
+lemma DELETE_INTER: "ALL (x::'A::type => bool) (xa::'A::type => bool) xb::'A::type.
+ hollight.INTER (DELETE x xb) xa = DELETE (hollight.INTER x xa) xb"
+ by (import hollight DELETE_INTER)
+
+lemma DISJOINT_DELETE_SYM: "ALL (x::'A::type => bool) (xa::'A::type => bool) xb::'A::type.
+ DISJOINT (DELETE x xb) xa = DISJOINT (DELETE xa xb) x"
+ by (import hollight DISJOINT_DELETE_SYM)
+
+lemma UNIONS_0: "(op =::('q_39893::type => bool) => ('q_39893::type => bool) => bool)
+ ((UNIONS::(('q_39893::type => bool) => bool) => 'q_39893::type => bool)
+ (EMPTY::('q_39893::type => bool) => bool))
+ (EMPTY::'q_39893::type => bool)"
+ by (import hollight UNIONS_0)
+
+lemma UNIONS_1: "UNIONS (INSERT (s::'q_39899::type => bool) EMPTY) = s"
+ by (import hollight UNIONS_1)
+
+lemma UNIONS_2: "UNIONS
+ (INSERT (s::'q_39919::type => bool)
+ (INSERT (t::'q_39919::type => bool) EMPTY)) =
+hollight.UNION s t"
+ by (import hollight UNIONS_2)
+
+lemma UNIONS_INSERT: "UNIONS
+ (INSERT (s::'q_39933::type => bool)
+ (u::('q_39933::type => bool) => bool)) =
+hollight.UNION s (UNIONS u)"
+ by (import hollight UNIONS_INSERT)
+
+lemma FORALL_IN_UNIONS: "ALL (x::'q_39975::type => bool) xa::('q_39975::type => bool) => bool.
+ (ALL xb::'q_39975::type. IN xb (UNIONS xa) --> x xb) =
+ (ALL (t::'q_39975::type => bool) xb::'q_39975::type.
+ IN t xa & IN xb t --> x xb)"
+ by (import hollight FORALL_IN_UNIONS)
+
+lemma EMPTY_UNIONS: "ALL x::('q_40001::type => bool) => bool.
+ (UNIONS x = EMPTY) =
+ (ALL xa::'q_40001::type => bool. IN xa x --> xa = EMPTY)"
+ by (import hollight EMPTY_UNIONS)
+
+lemma IMAGE_CLAUSES: "IMAGE (f::'q_40027::type => 'q_40031::type) EMPTY = EMPTY &
+IMAGE f (INSERT (x::'q_40027::type) (s::'q_40027::type => bool)) =
+INSERT (f x) (IMAGE f s)"
+ by (import hollight IMAGE_CLAUSES)
+
+lemma IMAGE_UNION: "ALL (x::'q_40054::type => 'q_40065::type) (xa::'q_40054::type => bool)
+ xb::'q_40054::type => bool.
+ IMAGE x (hollight.UNION xa xb) = hollight.UNION (IMAGE x xa) (IMAGE x xb)"
+ by (import hollight IMAGE_UNION)
+
+lemma IMAGE_o: "ALL (x::'q_40098::type => 'q_40094::type)
+ (xa::'q_40089::type => 'q_40098::type) xb::'q_40089::type => bool.
+ IMAGE (x o xa) xb = IMAGE x (IMAGE xa xb)"
+ by (import hollight IMAGE_o)
+
+lemma IMAGE_SUBSET: "ALL (x::'q_40116::type => 'q_40127::type) (xa::'q_40116::type => bool)
+ xb::'q_40116::type => bool.
+ SUBSET xa xb --> SUBSET (IMAGE x xa) (IMAGE x xb)"
+ by (import hollight IMAGE_SUBSET)
+
+lemma IMAGE_DIFF_INJ: "(ALL (x::'q_40158::type) y::'q_40158::type.
+ (f::'q_40158::type => 'q_40169::type) x = f y --> x = y) -->
+IMAGE f (DIFF (s::'q_40158::type => bool) (t::'q_40158::type => bool)) =
+DIFF (IMAGE f s) (IMAGE f t)"
+ by (import hollight IMAGE_DIFF_INJ)
+
+lemma IMAGE_DELETE_INJ: "(ALL x::'q_40204::type.
+ (f::'q_40204::type => 'q_40203::type) x = f (a::'q_40204::type) -->
+ x = a) -->
+IMAGE f (DELETE (s::'q_40204::type => bool) a) = DELETE (IMAGE f s) (f a)"
+ by (import hollight IMAGE_DELETE_INJ)
+
+lemma IMAGE_EQ_EMPTY: "ALL (x::'q_40227::type => 'q_40223::type) xa::'q_40227::type => bool.
+ (IMAGE x xa = EMPTY) = (xa = EMPTY)"
+ by (import hollight IMAGE_EQ_EMPTY)
+
+lemma FORALL_IN_IMAGE: "ALL (x::'q_40263::type => 'q_40262::type) xa::'q_40263::type => bool.
+ (ALL xb::'q_40262::type.
+ IN xb (IMAGE x xa) --> (P::'q_40262::type => bool) xb) =
+ (ALL xb::'q_40263::type. IN xb xa --> P (x xb))"
+ by (import hollight FORALL_IN_IMAGE)
+
+lemma EXISTS_IN_IMAGE: "ALL (x::'q_40299::type => 'q_40298::type) xa::'q_40299::type => bool.
+ (EX xb::'q_40298::type.
+ IN xb (IMAGE x xa) & (P::'q_40298::type => bool) xb) =
+ (EX xb::'q_40299::type. IN xb xa & P (x xb))"
+ by (import hollight EXISTS_IN_IMAGE)
+
+lemma SUBSET_IMAGE: "ALL (f::'A::type => 'B::type) (s::'B::type => bool) t::'A::type => bool.
+ SUBSET s (IMAGE f t) =
+ (EX x::'A::type => bool. SUBSET x t & s = IMAGE f x)"
+ by (import hollight SUBSET_IMAGE)
+
+lemma IMAGE_CONST: "ALL (s::'q_40385::type => bool) c::'q_40390::type.
+ IMAGE (%x::'q_40385::type. c) s = COND (s = EMPTY) EMPTY (INSERT c EMPTY)"
+ by (import hollight IMAGE_CONST)
+
+lemma SIMPLE_IMAGE: "ALL (x::'q_40418::type => 'q_40422::type) xa::'q_40418::type => bool.
+ GSPEC
+ (%u::'q_40422::type.
+ EX xb::'q_40418::type. SETSPEC u (IN xb xa) (x xb)) =
+ IMAGE x xa"
+ by (import hollight SIMPLE_IMAGE)
+
+lemma EMPTY_GSPEC: "GSPEC (%u::'q_40439::type. Ex (SETSPEC u False)) = EMPTY"
+ by (import hollight EMPTY_GSPEC)
+
+lemma FINITE_INDUCT_STRONG: "ALL P::('A::type => bool) => bool.
+ P EMPTY &
+ (ALL (x::'A::type) s::'A::type => bool.
+ P s & ~ IN x s & FINITE s --> P (INSERT x s)) -->
+ (ALL s::'A::type => bool. FINITE s --> P s)"
+ by (import hollight FINITE_INDUCT_STRONG)
+
+lemma FINITE_SUBSET: "ALL (x::'A::type => bool) t::'A::type => bool.
+ FINITE t & SUBSET x t --> FINITE x"
+ by (import hollight FINITE_SUBSET)
+
+lemma FINITE_UNION_IMP: "ALL (x::'A::type => bool) xa::'A::type => bool.
+ FINITE x & FINITE xa --> FINITE (hollight.UNION x xa)"
+ by (import hollight FINITE_UNION_IMP)
+
+lemma FINITE_UNION: "ALL (s::'A::type => bool) t::'A::type => bool.
+ FINITE (hollight.UNION s t) = (FINITE s & FINITE t)"
+ by (import hollight FINITE_UNION)
+
+lemma FINITE_INTER: "ALL (s::'A::type => bool) t::'A::type => bool.
+ FINITE s | FINITE t --> FINITE (hollight.INTER s t)"
+ by (import hollight FINITE_INTER)
+
+lemma FINITE_INSERT: "ALL (s::'A::type => bool) x::'A::type. FINITE (INSERT x s) = FINITE s"
+ by (import hollight FINITE_INSERT)
+
+lemma FINITE_DELETE_IMP: "ALL (s::'A::type => bool) x::'A::type. FINITE s --> FINITE (DELETE s x)"
+ by (import hollight FINITE_DELETE_IMP)
+
+lemma FINITE_DELETE: "ALL (s::'A::type => bool) x::'A::type. FINITE (DELETE s x) = FINITE s"
+ by (import hollight FINITE_DELETE)
+
+lemma FINITE_UNIONS: "ALL s::('q_40774::type => bool) => bool.
+ FINITE s -->
+ FINITE (UNIONS s) = (ALL t::'q_40774::type => bool. IN t s --> FINITE t)"
+ by (import hollight FINITE_UNIONS)
+
+lemma FINITE_IMAGE_EXPAND: "ALL (f::'A::type => 'B::type) s::'A::type => bool.
+ FINITE s -->
+ FINITE
+ (GSPEC
+ (%u::'B::type.
+ EX y::'B::type. SETSPEC u (EX x::'A::type. IN x s & y = f x) y))"
+ by (import hollight FINITE_IMAGE_EXPAND)
+
+lemma FINITE_IMAGE: "ALL (x::'A::type => 'B::type) xa::'A::type => bool.
+ FINITE xa --> FINITE (IMAGE x xa)"
+ by (import hollight FINITE_IMAGE)
+
+lemma FINITE_IMAGE_INJ_GENERAL: "ALL (f::'A::type => 'B::type) (x::'B::type => bool) s::'A::type => bool.
+ (ALL (x::'A::type) y::'A::type. IN x s & IN y s & f x = f y --> x = y) &
+ FINITE x -->
+ FINITE
+ (GSPEC
+ (%u::'A::type. EX xa::'A::type. SETSPEC u (IN xa s & IN (f xa) x) xa))"
+ by (import hollight FINITE_IMAGE_INJ_GENERAL)
+
+lemma FINITE_IMAGE_INJ: "ALL (f::'A::type => 'B::type) A::'B::type => bool.
+ (ALL (x::'A::type) y::'A::type. f x = f y --> x = y) & FINITE A -->
+ FINITE (GSPEC (%u::'A::type. EX x::'A::type. SETSPEC u (IN (f x) A) x))"
+ by (import hollight FINITE_IMAGE_INJ)
+
+lemma INFINITE_IMAGE_INJ: "ALL f::'A::type => 'B::type.
+ (ALL (x::'A::type) y::'A::type. f x = f y --> x = y) -->
+ (ALL s::'A::type => bool. INFINITE s --> INFINITE (IMAGE f s))"
+ by (import hollight INFINITE_IMAGE_INJ)
+
+lemma INFINITE_NONEMPTY: "ALL s::'q_41257::type => bool. INFINITE s --> s ~= EMPTY"
+ by (import hollight INFINITE_NONEMPTY)
+
+lemma INFINITE_DIFF_FINITE: "ALL (s::'A::type => bool) t::'A::type => bool.
+ INFINITE s & FINITE t --> INFINITE (DIFF s t)"
+ by (import hollight INFINITE_DIFF_FINITE)
+
+lemma FINITE_SUBSET_IMAGE: "ALL (f::'A::type => 'B::type) (s::'A::type => bool) t::'B::type => bool.
+ (FINITE t & SUBSET t (IMAGE f s)) =
+ (EX x::'A::type => bool. FINITE x & SUBSET x s & t = IMAGE f x)"
+ by (import hollight FINITE_SUBSET_IMAGE)
+
+lemma FINITE_SUBSET_IMAGE_IMP: "ALL (f::'A::type => 'B::type) (s::'A::type => bool) t::'B::type => bool.
+ FINITE t & SUBSET t (IMAGE f s) -->
+ (EX s'::'A::type => bool.
+ FINITE s' & SUBSET s' s & SUBSET t (IMAGE f s'))"
+ by (import hollight FINITE_SUBSET_IMAGE_IMP)
+
+lemma FINITE_SUBSETS: "ALL s::'A::type => bool.
+ FINITE s -->
+ FINITE
+ (GSPEC
+ (%u::'A::type => bool.
+ EX t::'A::type => bool. SETSPEC u (SUBSET t s) t))"
+ by (import hollight FINITE_SUBSETS)
+
+lemma FINITE_DIFF: "ALL (s::'q_41555::type => bool) t::'q_41555::type => bool.
+ FINITE s --> FINITE (DIFF s t)"
+ by (import hollight FINITE_DIFF)
+
+constdefs
+ FINREC :: "('q_41615::type => 'q_41614::type => 'q_41614::type)
+=> 'q_41614::type
+ => ('q_41615::type => bool) => 'q_41614::type => nat => bool"
+ "FINREC ==
+SOME FINREC::('q_41615::type => 'q_41614::type => 'q_41614::type)
+ => 'q_41614::type
+ => ('q_41615::type => bool)
+ => 'q_41614::type => nat => bool.
+ (ALL (f::'q_41615::type => 'q_41614::type => 'q_41614::type)
+ (s::'q_41615::type => bool) (a::'q_41614::type) b::'q_41614::type.
+ FINREC f b s a (0::nat) = (s = EMPTY & a = b)) &
+ (ALL (b::'q_41614::type) (s::'q_41615::type => bool) (n::nat)
+ (a::'q_41614::type)
+ f::'q_41615::type => 'q_41614::type => 'q_41614::type.
+ FINREC f b s a (Suc n) =
+ (EX (x::'q_41615::type) c::'q_41614::type.
+ IN x s & FINREC f b (DELETE s x) c n & a = f x c))"
+
+lemma DEF_FINREC: "FINREC =
+(SOME FINREC::('q_41615::type => 'q_41614::type => 'q_41614::type)
+ => 'q_41614::type
+ => ('q_41615::type => bool)
+ => 'q_41614::type => nat => bool.
+ (ALL (f::'q_41615::type => 'q_41614::type => 'q_41614::type)
+ (s::'q_41615::type => bool) (a::'q_41614::type) b::'q_41614::type.
+ FINREC f b s a (0::nat) = (s = EMPTY & a = b)) &
+ (ALL (b::'q_41614::type) (s::'q_41615::type => bool) (n::nat)
+ (a::'q_41614::type)
+ f::'q_41615::type => 'q_41614::type => 'q_41614::type.
+ FINREC f b s a (Suc n) =
+ (EX (x::'q_41615::type) c::'q_41614::type.
+ IN x s & FINREC f b (DELETE s x) c n & a = f x c)))"
+ by (import hollight DEF_FINREC)
+
+lemma FINREC_1_LEMMA: "ALL (x::'q_41660::type => 'q_41659::type => 'q_41659::type)
+ (xa::'q_41659::type) (xb::'q_41660::type => bool) xc::'q_41659::type.
+ FINREC x xa xb xc (Suc (0::nat)) =
+ (EX xd::'q_41660::type. xb = INSERT xd EMPTY & xc = x xd xa)"
+ by (import hollight FINREC_1_LEMMA)
+
+lemma FINREC_SUC_LEMMA: "ALL (f::'A::type => 'B::type => 'B::type) b::'B::type.
+ (ALL (x::'A::type) (y::'A::type) s::'B::type.
+ x ~= y --> f x (f y s) = f y (f x s)) -->
+ (ALL (n::nat) (s::'A::type => bool) z::'B::type.
+ FINREC f b s z (Suc n) -->
+ (ALL x::'A::type.
+ IN x s -->
+ (EX w::'B::type. FINREC f b (DELETE s x) w n & z = f x w)))"
+ by (import hollight FINREC_SUC_LEMMA)
+
+lemma FINREC_UNIQUE_LEMMA: "ALL (f::'A::type => 'B::type => 'B::type) b::'B::type.
+ (ALL (x::'A::type) (y::'A::type) s::'B::type.
+ x ~= y --> f x (f y s) = f y (f x s)) -->
+ (ALL (n1::nat) (n2::nat) (s::'A::type => bool) (a1::'B::type)
+ a2::'B::type.
+ FINREC f b s a1 n1 & FINREC f b s a2 n2 --> a1 = a2 & n1 = n2)"
+ by (import hollight FINREC_UNIQUE_LEMMA)
+
+lemma FINREC_EXISTS_LEMMA: "ALL (f::'A::type => 'B::type => 'B::type) (b::'B::type) s::'A::type => bool.
+ FINITE s --> (EX a::'B::type. Ex (FINREC f b s a))"
+ by (import hollight FINREC_EXISTS_LEMMA)
+
+lemma FINREC_FUN_LEMMA: "ALL (P::'A::type => bool) R::'A::type => 'B::type => 'C::type => bool.
+ (ALL s::'A::type. P s --> (EX a::'B::type. Ex (R s a))) &
+ (ALL (n1::'C::type) (n2::'C::type) (s::'A::type) (a1::'B::type)
+ a2::'B::type. R s a1 n1 & R s a2 n2 --> a1 = a2 & n1 = n2) -->
+ (EX x::'A::type => 'B::type.
+ ALL (s::'A::type) a::'B::type. P s --> Ex (R s a) = (x s = a))"
+ by (import hollight FINREC_FUN_LEMMA)
+
+lemma FINREC_FUN: "ALL (f::'A::type => 'B::type => 'B::type) b::'B::type.
+ (ALL (x::'A::type) (y::'A::type) s::'B::type.
+ x ~= y --> f x (f y s) = f y (f x s)) -->
+ (EX g::('A::type => bool) => 'B::type.
+ g EMPTY = b &
+ (ALL (s::'A::type => bool) x::'A::type.
+ FINITE s & IN x s --> g s = f x (g (DELETE s x))))"
+ by (import hollight FINREC_FUN)
+
+lemma SET_RECURSION_LEMMA: "ALL (f::'A::type => 'B::type => 'B::type) b::'B::type.
+ (ALL (x::'A::type) (y::'A::type) s::'B::type.
+ x ~= y --> f x (f y s) = f y (f x s)) -->
+ (EX g::('A::type => bool) => 'B::type.
+ g EMPTY = b &
+ (ALL (x::'A::type) s::'A::type => bool.
+ FINITE s --> g (INSERT x s) = COND (IN x s) (g s) (f x (g s))))"
+ by (import hollight SET_RECURSION_LEMMA)
+
+constdefs
+ ITSET :: "('q_42316::type => 'q_42315::type => 'q_42315::type)
+=> ('q_42316::type => bool) => 'q_42315::type => 'q_42315::type"
+ "ITSET ==
+%(u::'q_42316::type => 'q_42315::type => 'q_42315::type)
+ (ua::'q_42316::type => bool) ub::'q_42315::type.
+ (SOME g::('q_42316::type => bool) => 'q_42315::type.
+ g EMPTY = ub &
+ (ALL (x::'q_42316::type) s::'q_42316::type => bool.
+ FINITE s --> g (INSERT x s) = COND (IN x s) (g s) (u x (g s))))
+ ua"
+
+lemma DEF_ITSET: "ITSET =
+(%(u::'q_42316::type => 'q_42315::type => 'q_42315::type)
+ (ua::'q_42316::type => bool) ub::'q_42315::type.
+ (SOME g::('q_42316::type => bool) => 'q_42315::type.
+ g EMPTY = ub &
+ (ALL (x::'q_42316::type) s::'q_42316::type => bool.
+ FINITE s --> g (INSERT x s) = COND (IN x s) (g s) (u x (g s))))
+ ua)"
+ by (import hollight DEF_ITSET)
+
+lemma FINITE_RECURSION: "ALL (f::'A::type => 'B::type => 'B::type) b::'B::type.
+ (ALL (x::'A::type) (y::'A::type) s::'B::type.
+ x ~= y --> f x (f y s) = f y (f x s)) -->
+ ITSET f EMPTY b = b &
+ (ALL (x::'A::type) xa::'A::type => bool.
+ FINITE xa -->
+ ITSET f (INSERT x xa) b =
+ COND (IN x xa) (ITSET f xa b) (f x (ITSET f xa b)))"
+ by (import hollight FINITE_RECURSION)
+
+lemma FINITE_RECURSION_DELETE: "ALL (f::'A::type => 'B::type => 'B::type) b::'B::type.
+ (ALL (x::'A::type) (y::'A::type) s::'B::type.
+ x ~= y --> f x (f y s) = f y (f x s)) -->
+ ITSET f EMPTY b = b &
+ (ALL (x::'A::type) s::'A::type => bool.
+ FINITE s -->
+ ITSET f s b =
+ COND (IN x s) (f x (ITSET f (DELETE s x) b))
+ (ITSET f (DELETE s x) b))"
+ by (import hollight FINITE_RECURSION_DELETE)
+
+lemma ITSET_EQ: "ALL (x::'q_42621::type => bool)
+ (xa::'q_42621::type => 'q_42622::type => 'q_42622::type)
+ (xb::'q_42621::type => 'q_42622::type => 'q_42622::type)
+ xc::'q_42622::type.
+ FINITE x &
+ (ALL xc::'q_42621::type. IN xc x --> xa xc = xb xc) &
+ (ALL (x::'q_42621::type) (y::'q_42621::type) s::'q_42622::type.
+ x ~= y --> xa x (xa y s) = xa y (xa x s)) &
+ (ALL (x::'q_42621::type) (y::'q_42621::type) s::'q_42622::type.
+ x ~= y --> xb x (xb y s) = xb y (xb x s)) -->
+ ITSET xa x xc = ITSET xb x xc"
+ by (import hollight ITSET_EQ)
+
+lemma SUBSET_RESTRICT: "ALL (x::'q_42655::type => bool) xa::'q_42655::type => bool.
+ SUBSET
+ (GSPEC
+ (%u::'q_42655::type.
+ EX xb::'q_42655::type. SETSPEC u (IN xb x & xa xb) xb))
+ x"
+ by (import hollight SUBSET_RESTRICT)
+
+lemma FINITE_RESTRICT: "ALL (s::'A::type => bool) p::'q_42673::type.
+ FINITE s -->
+ FINITE
+ (GSPEC
+ (%u::'A::type.
+ EX x::'A::type. SETSPEC u (IN x s & (P::'A::type => bool) x) x))"
+ by (import hollight FINITE_RESTRICT)
+
+constdefs
+ CARD :: "('q_42709::type => bool) => nat"
+ "CARD ==
+%u::'q_42709::type => bool. ITSET (%x::'q_42709::type. Suc) u (0::nat)"
+
+lemma DEF_CARD: "CARD =
+(%u::'q_42709::type => bool. ITSET (%x::'q_42709::type. Suc) u (0::nat))"
+ by (import hollight DEF_CARD)
+
+lemma CARD_CLAUSES: "(op &::bool => bool => bool)
+ ((op =::nat => nat => bool)
+ ((CARD::('A::type => bool) => nat) (EMPTY::'A::type => bool)) (0::nat))
+ ((All::('A::type => bool) => bool)
+ (%x::'A::type.
+ (All::(('A::type => bool) => bool) => bool)
+ (%s::'A::type => bool.
+ (op -->::bool => bool => bool)
+ ((FINITE::('A::type => bool) => bool) s)
+ ((op =::nat => nat => bool)
+ ((CARD::('A::type => bool) => nat)
+ ((INSERT::'A::type
+ => ('A::type => bool) => 'A::type => bool)
+ x s))
+ ((COND::bool => nat => nat => nat)
+ ((IN::'A::type => ('A::type => bool) => bool) x s)
+ ((CARD::('A::type => bool) => nat) s)
+ ((Suc::nat => nat)
+ ((CARD::('A::type => bool) => nat) s)))))))"
+ by (import hollight CARD_CLAUSES)
+
+lemma CARD_UNION: "ALL (x::'A::type => bool) xa::'A::type => bool.
+ FINITE x & FINITE xa & hollight.INTER x xa = EMPTY -->
+ CARD (hollight.UNION x xa) = CARD x + CARD xa"
+ by (import hollight CARD_UNION)
+
+lemma CARD_DELETE: "ALL (x::'A::type) s::'A::type => bool.
+ FINITE s -->
+ CARD (DELETE s x) =
+ COND (IN x s) (CARD s - NUMERAL_BIT1 (0::nat)) (CARD s)"
+ by (import hollight CARD_DELETE)
+
+lemma CARD_UNION_EQ: "ALL (s::'q_42954::type => bool) (t::'q_42954::type => bool)
+ u::'q_42954::type => bool.
+ FINITE u & hollight.INTER s t = EMPTY & hollight.UNION s t = u -->
+ CARD s + CARD t = CARD u"
+ by (import hollight CARD_UNION_EQ)
+
+constdefs
+ HAS_SIZE :: "('q_42990::type => bool) => nat => bool"
+ "HAS_SIZE == %(u::'q_42990::type => bool) ua::nat. FINITE u & CARD u = ua"
+
+lemma DEF_HAS_SIZE: "HAS_SIZE = (%(u::'q_42990::type => bool) ua::nat. FINITE u & CARD u = ua)"
+ by (import hollight DEF_HAS_SIZE)
+
+lemma HAS_SIZE_CARD: "ALL (x::'q_43009::type => bool) xa::nat. HAS_SIZE x xa --> CARD x = xa"
+ by (import hollight HAS_SIZE_CARD)
+
+lemma HAS_SIZE_0: "ALL (s::'A::type => bool) n::'q_43025::type.
+ HAS_SIZE s (0::nat) = (s = EMPTY)"
+ by (import hollight HAS_SIZE_0)
+
+lemma HAS_SIZE_SUC: "ALL (s::'A::type => bool) n::nat.
+ HAS_SIZE s (Suc n) =
+ (s ~= EMPTY & (ALL x::'A::type. IN x s --> HAS_SIZE (DELETE s x) n))"
+ by (import hollight HAS_SIZE_SUC)
+
+lemma HAS_SIZE_UNION: "ALL (x::'q_43147::type => bool) (xa::'q_43147::type => bool) (xb::nat)
+ xc::nat.
+ HAS_SIZE x xb & HAS_SIZE xa xc & DISJOINT x xa -->
+ HAS_SIZE (hollight.UNION x xa) (xb + xc)"
+ by (import hollight HAS_SIZE_UNION)
+
+lemma HAS_SIZE_UNIONS: "ALL (x::'A::type => bool) (xa::'A::type => 'B::type => bool) (xb::nat)
+ xc::nat.
+ HAS_SIZE x xb &
+ (ALL xb::'A::type. IN xb x --> HAS_SIZE (xa xb) xc) &
+ (ALL (xb::'A::type) y::'A::type.
+ IN xb x & IN y x & xb ~= y --> DISJOINT (xa xb) (xa y)) -->
+ HAS_SIZE
+ (UNIONS
+ (GSPEC
+ (%u::'B::type => bool.
+ EX xb::'A::type. SETSPEC u (IN xb x) (xa xb))))
+ (xb * xc)"
+ by (import hollight HAS_SIZE_UNIONS)
+
+lemma HAS_SIZE_CLAUSES: "HAS_SIZE (s::'q_43395::type => bool) (0::nat) = (s = EMPTY) &
+HAS_SIZE s (Suc (n::nat)) =
+(EX (a::'q_43395::type) t::'q_43395::type => bool.
+ HAS_SIZE t n & ~ IN a t & s = INSERT a t)"
+ by (import hollight HAS_SIZE_CLAUSES)
+
+lemma CARD_SUBSET_EQ: "ALL (a::'A::type => bool) b::'A::type => bool.
+ FINITE b & SUBSET a b & CARD a = CARD b --> a = b"
+ by (import hollight CARD_SUBSET_EQ)
+
+lemma CARD_SUBSET: "ALL (a::'A::type => bool) b::'A::type => bool.
+ SUBSET a b & FINITE b --> <= (CARD a) (CARD b)"
+ by (import hollight CARD_SUBSET)
+
+lemma CARD_SUBSET_LE: "ALL (a::'A::type => bool) b::'A::type => bool.
+ FINITE b & SUBSET a b & <= (CARD b) (CARD a) --> a = b"
+ by (import hollight CARD_SUBSET_LE)
+
+lemma CARD_EQ_0: "ALL s::'q_43711::type => bool.
+ FINITE s --> (CARD s = (0::nat)) = (s = EMPTY)"
+ by (import hollight CARD_EQ_0)
+
+lemma CARD_PSUBSET: "ALL (a::'A::type => bool) b::'A::type => bool.
+ PSUBSET a b & FINITE b --> < (CARD a) (CARD b)"
+ by (import hollight CARD_PSUBSET)
+
+lemma CARD_UNION_LE: "ALL (s::'A::type => bool) t::'A::type => bool.
+ FINITE s & FINITE t --> <= (CARD (hollight.UNION s t)) (CARD s + CARD t)"
+ by (import hollight CARD_UNION_LE)
+
+lemma CARD_UNIONS_LE: "ALL (x::'A::type => bool) (xa::'A::type => 'B::type => bool) (xb::nat)
+ xc::nat.
+ HAS_SIZE x xb &
+ (ALL xb::'A::type. IN xb x --> FINITE (xa xb) & <= (CARD (xa xb)) xc) -->
+ <= (CARD
+ (UNIONS
+ (GSPEC
+ (%u::'B::type => bool.
+ EX xb::'A::type. SETSPEC u (IN xb x) (xa xb)))))
+ (xb * xc)"
+ by (import hollight CARD_UNIONS_LE)
+
+lemma CARD_IMAGE_INJ: "ALL (f::'A::type => 'B::type) x::'A::type => bool.
+ (ALL (xa::'A::type) y::'A::type.
+ IN xa x & IN y x & f xa = f y --> xa = y) &
+ FINITE x -->
+ CARD (IMAGE f x) = CARD x"
+ by (import hollight CARD_IMAGE_INJ)
+
+lemma HAS_SIZE_IMAGE_INJ: "ALL (x::'A::type => 'B::type) (xa::'A::type => bool) xb::nat.
+ (ALL (xb::'A::type) y::'A::type.
+ IN xb xa & IN y xa & x xb = x y --> xb = y) &
+ HAS_SIZE xa xb -->
+ HAS_SIZE (IMAGE x xa) xb"
+ by (import hollight HAS_SIZE_IMAGE_INJ)
+
+lemma CARD_IMAGE_LE: "ALL (f::'A::type => 'B::type) s::'A::type => bool.
+ FINITE s --> <= (CARD (IMAGE f s)) (CARD s)"
+ by (import hollight CARD_IMAGE_LE)
+
+lemma CHOOSE_SUBSET: "ALL s::'A::type => bool.
+ FINITE s -->
+ (ALL n::nat.
+ <= n (CARD s) -->
+ (EX t::'A::type => bool. SUBSET t s & HAS_SIZE t n))"
+ by (import hollight CHOOSE_SUBSET)
+
+lemma HAS_SIZE_PRODUCT_DEPENDENT: "ALL (x::'A::type => bool) (xa::nat) (xb::'A::type => 'B::type => bool)
+ xc::nat.
+ HAS_SIZE x xa & (ALL xa::'A::type. IN xa x --> HAS_SIZE (xb xa) xc) -->
+ HAS_SIZE
+ (GSPEC
+ (%u::'A::type * 'B::type.
+ EX (xa::'A::type) y::'B::type.
+ SETSPEC u (IN xa x & IN y (xb xa)) (xa, y)))
+ (xa * xc)"
+ by (import hollight HAS_SIZE_PRODUCT_DEPENDENT)
+
+lemma FINITE_PRODUCT_DEPENDENT: "ALL (x::'A::type => bool) xa::'A::type => 'B::type => bool.
+ FINITE x & (ALL xb::'A::type. IN xb x --> FINITE (xa xb)) -->
+ FINITE
+ (GSPEC
+ (%u::'A::type * 'B::type.
+ EX (xb::'A::type) y::'B::type.
+ SETSPEC u (IN xb x & IN y (xa xb)) (xb, y)))"
+ by (import hollight FINITE_PRODUCT_DEPENDENT)
+
+lemma FINITE_PRODUCT: "ALL (x::'A::type => bool) xa::'B::type => bool.
+ FINITE x & FINITE xa -->
+ FINITE
+ (GSPEC
+ (%u::'A::type * 'B::type.
+ EX (xb::'A::type) y::'B::type.
+ SETSPEC u (IN xb x & IN y xa) (xb, y)))"
+ by (import hollight FINITE_PRODUCT)
+
+lemma CARD_PRODUCT: "ALL (s::'A::type => bool) t::'B::type => bool.
+ FINITE s & FINITE t -->
+ CARD
+ (GSPEC
+ (%u::'A::type * 'B::type.
+ EX (x::'A::type) y::'B::type.
+ SETSPEC u (IN x s & IN y t) (x, y))) =
+ CARD s * CARD t"
+ by (import hollight CARD_PRODUCT)
+
+lemma HAS_SIZE_PRODUCT: "ALL (x::'A::type => bool) (xa::nat) (xb::'B::type => bool) xc::nat.
+ HAS_SIZE x xa & HAS_SIZE xb xc -->
+ HAS_SIZE
+ (GSPEC
+ (%u::'A::type * 'B::type.
+ EX (xa::'A::type) y::'B::type.
+ SETSPEC u (IN xa x & IN y xb) (xa, y)))
+ (xa * xc)"
+ by (import hollight HAS_SIZE_PRODUCT)
+
+lemma HAS_SIZE_FUNSPACE: "ALL (d::'B::type) (n::nat) (t::'B::type => bool) (m::nat)
+ s::'A::type => bool.
+ HAS_SIZE s m & HAS_SIZE t n -->
+ HAS_SIZE
+ (GSPEC
+ (%u::'A::type => 'B::type.
+ EX f::'A::type => 'B::type.
+ SETSPEC u
+ ((ALL x::'A::type. IN x s --> IN (f x) t) &
+ (ALL x::'A::type. ~ IN x s --> f x = d))
+ f))
+ (EXP n m)"
+ by (import hollight HAS_SIZE_FUNSPACE)
+
+lemma CARD_FUNSPACE: "ALL (s::'q_45066::type => bool) t::'q_45063::type => bool.
+ FINITE s & FINITE t -->
+ CARD
+ (GSPEC
+ (%u::'q_45066::type => 'q_45063::type.
+ EX f::'q_45066::type => 'q_45063::type.
+ SETSPEC u
+ ((ALL x::'q_45066::type. IN x s --> IN (f x) t) &
+ (ALL x::'q_45066::type.
+ ~ IN x s --> f x = (d::'q_45063::type)))
+ f)) =
+ EXP (CARD t) (CARD s)"
+ by (import hollight CARD_FUNSPACE)
+
+lemma FINITE_FUNSPACE: "ALL (s::'q_45132::type => bool) t::'q_45129::type => bool.
+ FINITE s & FINITE t -->
+ FINITE
+ (GSPEC
+ (%u::'q_45132::type => 'q_45129::type.
+ EX f::'q_45132::type => 'q_45129::type.
+ SETSPEC u
+ ((ALL x::'q_45132::type. IN x s --> IN (f x) t) &
+ (ALL x::'q_45132::type.
+ ~ IN x s --> f x = (d::'q_45129::type)))
+ f))"
+ by (import hollight FINITE_FUNSPACE)
+
+lemma HAS_SIZE_POWERSET: "ALL (s::'A::type => bool) n::nat.
+ HAS_SIZE s n -->
+ HAS_SIZE
+ (GSPEC
+ (%u::'A::type => bool.
+ EX t::'A::type => bool. SETSPEC u (SUBSET t s) t))
+ (EXP (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) n)"
+ by (import hollight HAS_SIZE_POWERSET)
+
+lemma CARD_POWERSET: "ALL s::'A::type => bool.
+ FINITE s -->
+ CARD
+ (GSPEC
+ (%u::'A::type => bool.
+ EX t::'A::type => bool. SETSPEC u (SUBSET t s) t)) =
+ EXP (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) (CARD s)"
+ by (import hollight CARD_POWERSET)
+
+lemma FINITE_POWERSET: "ALL s::'A::type => bool.
+ FINITE s -->
+ FINITE
+ (GSPEC
+ (%u::'A::type => bool.
+ EX t::'A::type => bool. SETSPEC u (SUBSET t s) t))"
+ by (import hollight FINITE_POWERSET)
+
+lemma CARD_GE_REFL: "ALL s::'A::type => bool. CARD_GE s s"
+ by (import hollight CARD_GE_REFL)
+
+lemma CARD_GE_TRANS: "ALL (s::'A::type => bool) (t::'B::type => bool) u::'C::type => bool.
+ CARD_GE s t & CARD_GE t u --> CARD_GE s u"
+ by (import hollight CARD_GE_TRANS)
+
+lemma FINITE_HAS_SIZE_LEMMA: "ALL s::'A::type => bool.
+ FINITE s -->
+ (EX n::nat. CARD_GE (GSPEC (%u::nat. EX x::nat. SETSPEC u (< x n) x)) s)"
+ by (import hollight FINITE_HAS_SIZE_LEMMA)
+
+lemma HAS_SIZE_NUMSEG_LT: "ALL n::nat. HAS_SIZE (GSPEC (%u::nat. EX m::nat. SETSPEC u (< m n) m)) n"
+ by (import hollight HAS_SIZE_NUMSEG_LT)
+
+lemma CARD_NUMSEG_LT: "ALL x::nat. CARD (GSPEC (%u::nat. EX m::nat. SETSPEC u (< m x) m)) = x"
+ by (import hollight CARD_NUMSEG_LT)
+
+lemma FINITE_NUMSEG_LT: "ALL x::nat. FINITE (GSPEC (%u::nat. EX m::nat. SETSPEC u (< m x) m))"
+ by (import hollight FINITE_NUMSEG_LT)
+
+lemma HAS_SIZE_NUMSEG_LE: "ALL x::nat.
+ HAS_SIZE (GSPEC (%xa::nat. EX xb::nat. SETSPEC xa (<= xb x) xb))
+ (x + NUMERAL_BIT1 (0::nat))"
+ by (import hollight HAS_SIZE_NUMSEG_LE)
+
+lemma FINITE_NUMSEG_LE: "ALL x::nat. FINITE (GSPEC (%u::nat. EX m::nat. SETSPEC u (<= m x) m))"
+ by (import hollight FINITE_NUMSEG_LE)
+
+lemma CARD_NUMSEG_LE: "ALL x::nat.
+ CARD (GSPEC (%u::nat. EX m::nat. SETSPEC u (<= m x) m)) =
+ x + NUMERAL_BIT1 (0::nat)"
+ by (import hollight CARD_NUMSEG_LE)
+
+lemma num_FINITE: "ALL s::nat => bool. FINITE s = (EX a::nat. ALL x::nat. IN x s --> <= x a)"
+ by (import hollight num_FINITE)
+
+lemma num_FINITE_AVOID: "ALL s::nat => bool. FINITE s --> (EX a::nat. ~ IN a s)"
+ by (import hollight num_FINITE_AVOID)
+
+lemma num_INFINITE: "(INFINITE::(nat => bool) => bool) (hollight.UNIV::nat => bool)"
+ by (import hollight num_INFINITE)
+
+lemma HAS_SIZE_INDEX: "ALL (x::'A::type => bool) n::nat.
+ HAS_SIZE x n -->
+ (EX f::nat => 'A::type.
+ (ALL m::nat. < m n --> IN (f m) x) &
+ (ALL xa::'A::type. IN xa x --> (EX! m::nat. < m n & f m = xa)))"
+ by (import hollight HAS_SIZE_INDEX)
+
+constdefs
+ set_of_list :: "'q_45759::type hollight.list => 'q_45759::type => bool"
+ "set_of_list ==
+SOME set_of_list::'q_45759::type hollight.list => 'q_45759::type => bool.
+ set_of_list NIL = EMPTY &
+ (ALL (h::'q_45759::type) t::'q_45759::type hollight.list.
+ set_of_list (CONS h t) = INSERT h (set_of_list t))"
+
+lemma DEF_set_of_list: "set_of_list =
+(SOME set_of_list::'q_45759::type hollight.list => 'q_45759::type => bool.
+ set_of_list NIL = EMPTY &
+ (ALL (h::'q_45759::type) t::'q_45759::type hollight.list.
+ set_of_list (CONS h t) = INSERT h (set_of_list t)))"
+ by (import hollight DEF_set_of_list)
+
+constdefs
+ list_of_set :: "('q_45777::type => bool) => 'q_45777::type hollight.list"
+ "list_of_set ==
+%u::'q_45777::type => bool.
+ SOME l::'q_45777::type hollight.list.
+ set_of_list l = u & LENGTH l = CARD u"
+
+lemma DEF_list_of_set: "list_of_set =
+(%u::'q_45777::type => bool.
+ SOME l::'q_45777::type hollight.list.
+ set_of_list l = u & LENGTH l = CARD u)"
+ by (import hollight DEF_list_of_set)
+
+lemma LIST_OF_SET_PROPERTIES: "ALL x::'A::type => bool.
+ FINITE x -->
+ set_of_list (list_of_set x) = x & LENGTH (list_of_set x) = CARD x"
+ by (import hollight LIST_OF_SET_PROPERTIES)
+
+lemma SET_OF_LIST_OF_SET: "ALL s::'q_45826::type => bool. FINITE s --> set_of_list (list_of_set s) = s"
+ by (import hollight SET_OF_LIST_OF_SET)
+
+lemma LENGTH_LIST_OF_SET: "ALL s::'q_45842::type => bool. FINITE s --> LENGTH (list_of_set s) = CARD s"
+ by (import hollight LENGTH_LIST_OF_SET)
+
+lemma MEM_LIST_OF_SET: "ALL s::'A::type => bool.
+ FINITE s --> (ALL x::'A::type. MEM x (list_of_set s) = IN x s)"
+ by (import hollight MEM_LIST_OF_SET)
+
+lemma FINITE_SET_OF_LIST: "ALL l::'q_45887::type hollight.list. FINITE (set_of_list l)"
+ by (import hollight FINITE_SET_OF_LIST)
+
+lemma IN_SET_OF_LIST: "ALL (x::'q_45905::type) l::'q_45905::type hollight.list.
+ IN x (set_of_list l) = MEM x l"
+ by (import hollight IN_SET_OF_LIST)
+
+lemma SET_OF_LIST_APPEND: "ALL (x::'q_45930::type hollight.list) xa::'q_45930::type hollight.list.
+ set_of_list (APPEND x xa) =
+ hollight.UNION (set_of_list x) (set_of_list xa)"
+ by (import hollight SET_OF_LIST_APPEND)
+
+constdefs
+ pairwise :: "('q_45989::type => 'q_45989::type => bool)
+=> ('q_45989::type => bool) => bool"
+ "pairwise ==
+%(u::'q_45989::type => 'q_45989::type => bool) ua::'q_45989::type => bool.
+ ALL (x::'q_45989::type) y::'q_45989::type.
+ IN x ua & IN y ua & x ~= y --> u x y"
+
+lemma DEF_pairwise: "pairwise =
+(%(u::'q_45989::type => 'q_45989::type => bool) ua::'q_45989::type => bool.
+ ALL (x::'q_45989::type) y::'q_45989::type.
+ IN x ua & IN y ua & x ~= y --> u x y)"
+ by (import hollight DEF_pairwise)
+
+constdefs
+ PAIRWISE :: "('q_46011::type => 'q_46011::type => bool)
+=> 'q_46011::type hollight.list => bool"
+ "PAIRWISE ==
+SOME PAIRWISE::('q_46011::type => 'q_46011::type => bool)
+ => 'q_46011::type hollight.list => bool.
+ (ALL r::'q_46011::type => 'q_46011::type => bool.
+ PAIRWISE r NIL = True) &
+ (ALL (h::'q_46011::type) (r::'q_46011::type => 'q_46011::type => bool)
+ t::'q_46011::type hollight.list.
+ PAIRWISE r (CONS h t) = (ALL_list (r h) t & PAIRWISE r t))"
+
+lemma DEF_PAIRWISE: "PAIRWISE =
+(SOME PAIRWISE::('q_46011::type => 'q_46011::type => bool)
+ => 'q_46011::type hollight.list => bool.
+ (ALL r::'q_46011::type => 'q_46011::type => bool.
+ PAIRWISE r NIL = True) &
+ (ALL (h::'q_46011::type) (r::'q_46011::type => 'q_46011::type => bool)
+ t::'q_46011::type hollight.list.
+ PAIRWISE r (CONS h t) = (ALL_list (r h) t & PAIRWISE r t)))"
+ by (import hollight DEF_PAIRWISE)
+
+typedef (open) ('A) finite_image = "(Collect::('A::type => bool) => 'A::type set)
+ (%x::'A::type.
+ (op |::bool => bool => bool)
+ ((op =::'A::type => 'A::type => bool) x
+ ((Eps::('A::type => bool) => 'A::type) (%z::'A::type. True::bool)))
+ ((FINITE::('A::type => bool) => bool)
+ (hollight.UNIV::'A::type => bool)))" morphisms "dest_finite_image" "mk_finite_image"
+ apply (rule light_ex_imp_nonempty[where t="(Eps::('A::type => bool) => 'A::type)
+ (%x::'A::type.
+ (op |::bool => bool => bool)
+ ((op =::'A::type => 'A::type => bool) x
+ ((Eps::('A::type => bool) => 'A::type) (%z::'A::type. True::bool)))
+ ((FINITE::('A::type => bool) => bool)
+ (hollight.UNIV::'A::type => bool)))"])
+ by (import hollight TYDEF_finite_image)
+
+syntax
+ dest_finite_image :: _
+
+syntax
+ mk_finite_image :: _
+
+lemmas "TYDEF_finite_image_@intern" = typedef_hol2hollight
+ [where a="a :: 'A::type finite_image" and r=r ,
+ OF type_definition_finite_image]
+
+lemma FINITE_IMAGE_IMAGE: "(op =::('A::type finite_image => bool)
+ => ('A::type finite_image => bool) => bool)
+ (hollight.UNIV::'A::type finite_image => bool)
+ ((IMAGE::('A::type => 'A::type finite_image)
+ => ('A::type => bool) => 'A::type finite_image => bool)
+ (mk_finite_image::'A::type => 'A::type finite_image)
+ ((COND::bool
+ => ('A::type => bool) => ('A::type => bool) => 'A::type => bool)
+ ((FINITE::('A::type => bool) => bool)
+ (hollight.UNIV::'A::type => bool))
+ (hollight.UNIV::'A::type => bool)
+ ((INSERT::'A::type => ('A::type => bool) => 'A::type => bool)
+ ((Eps::('A::type => bool) => 'A::type) (%z::'A::type. True::bool))
+ (EMPTY::'A::type => bool))))"
+ by (import hollight FINITE_IMAGE_IMAGE)
+
+constdefs
+ dimindex :: "('A::type => bool) => nat"
+ "(op ==::(('A::type => bool) => nat) => (('A::type => bool) => nat) => prop)
+ (dimindex::('A::type => bool) => nat)
+ (%u::'A::type => bool.
+ (COND::bool => nat => nat => nat)
+ ((FINITE::('A::type => bool) => bool)
+ (hollight.UNIV::'A::type => bool))
+ ((CARD::('A::type => bool) => nat) (hollight.UNIV::'A::type => bool))
+ ((NUMERAL_BIT1::nat => nat) (0::nat)))"
+
+lemma DEF_dimindex: "(op =::(('A::type => bool) => nat) => (('A::type => bool) => nat) => bool)
+ (dimindex::('A::type => bool) => nat)
+ (%u::'A::type => bool.
+ (COND::bool => nat => nat => nat)
+ ((FINITE::('A::type => bool) => bool)
+ (hollight.UNIV::'A::type => bool))
+ ((CARD::('A::type => bool) => nat) (hollight.UNIV::'A::type => bool))
+ ((NUMERAL_BIT1::nat => nat) (0::nat)))"
+ by (import hollight DEF_dimindex)
+
+lemma HAS_SIZE_FINITE_IMAGE: "(All::(('A::type => bool) => bool) => bool)
+ (%s::'A::type => bool.
+ (HAS_SIZE::('A::type finite_image => bool) => nat => bool)
+ (hollight.UNIV::'A::type finite_image => bool)
+ ((dimindex::('A::type => bool) => nat) s))"
+ by (import hollight HAS_SIZE_FINITE_IMAGE)
+
+lemma CARD_FINITE_IMAGE: "(All::(('A::type => bool) => bool) => bool)
+ (%s::'A::type => bool.
+ (op =::nat => nat => bool)
+ ((CARD::('A::type finite_image => bool) => nat)
+ (hollight.UNIV::'A::type finite_image => bool))
+ ((dimindex::('A::type => bool) => nat) s))"
+ by (import hollight CARD_FINITE_IMAGE)
+
+lemma FINITE_FINITE_IMAGE: "(FINITE::('A::type finite_image => bool) => bool)
+ (hollight.UNIV::'A::type finite_image => bool)"
+ by (import hollight FINITE_FINITE_IMAGE)
+
+lemma DIMINDEX_NONZERO: "ALL s::'A::type => bool. dimindex s ~= (0::nat)"
+ by (import hollight DIMINDEX_NONZERO)
+
+lemma DIMINDEX_GE_1: "ALL x::'A::type => bool. <= (NUMERAL_BIT1 (0::nat)) (dimindex x)"
+ by (import hollight DIMINDEX_GE_1)
+
+lemma DIMINDEX_FINITE_IMAGE: "ALL (s::'A::type finite_image => bool) t::'A::type => bool.
+ dimindex s = dimindex t"
+ by (import hollight DIMINDEX_FINITE_IMAGE)
+
+constdefs
+ finite_index :: "nat => 'A::type"
+ "(op ==::(nat => 'A::type) => (nat => 'A::type) => prop)
+ (finite_index::nat => 'A::type)
+ ((Eps::((nat => 'A::type) => bool) => nat => 'A::type)
+ (%f::nat => 'A::type.
+ (All::('A::type => bool) => bool)
+ (%x::'A::type.
+ (Ex1::(nat => bool) => bool)
+ (%n::nat.
+ (op &::bool => bool => bool)
+ ((<=::nat => nat => bool)
+ ((NUMERAL_BIT1::nat => nat) (0::nat)) n)
+ ((op &::bool => bool => bool)
+ ((<=::nat => nat => bool) n
+ ((dimindex::('A::type => bool) => nat)
+ (hollight.UNIV::'A::type => bool)))
+ ((op =::'A::type => 'A::type => bool) (f n) x))))))"
+
+lemma DEF_finite_index: "(op =::(nat => 'A::type) => (nat => 'A::type) => bool)
+ (finite_index::nat => 'A::type)
+ ((Eps::((nat => 'A::type) => bool) => nat => 'A::type)
+ (%f::nat => 'A::type.
+ (All::('A::type => bool) => bool)
+ (%x::'A::type.
+ (Ex1::(nat => bool) => bool)
+ (%n::nat.
+ (op &::bool => bool => bool)
+ ((<=::nat => nat => bool)
+ ((NUMERAL_BIT1::nat => nat) (0::nat)) n)
+ ((op &::bool => bool => bool)
+ ((<=::nat => nat => bool) n
+ ((dimindex::('A::type => bool) => nat)
+ (hollight.UNIV::'A::type => bool)))
+ ((op =::'A::type => 'A::type => bool) (f n) x))))))"
+ by (import hollight DEF_finite_index)
+
+lemma FINITE_INDEX_WORKS_FINITE: "(op -->::bool => bool => bool)
+ ((FINITE::('N::type => bool) => bool) (hollight.UNIV::'N::type => bool))
+ ((All::('N::type => bool) => bool)
+ (%x::'N::type.
+ (Ex1::(nat => bool) => bool)
+ (%xa::nat.
+ (op &::bool => bool => bool)
+ ((<=::nat => nat => bool) ((NUMERAL_BIT1::nat => nat) (0::nat))
+ xa)
+ ((op &::bool => bool => bool)
+ ((<=::nat => nat => bool) xa
+ ((dimindex::('N::type => bool) => nat)
+ (hollight.UNIV::'N::type => bool)))
+ ((op =::'N::type => 'N::type => bool)
+ ((finite_index::nat => 'N::type) xa) x)))))"
+ by (import hollight FINITE_INDEX_WORKS_FINITE)
+
+lemma FINITE_INDEX_WORKS: "(All::('A::type finite_image => bool) => bool)
+ (%i::'A::type finite_image.
+ (Ex1::(nat => bool) => bool)
+ (%n::nat.
+ (op &::bool => bool => bool)
+ ((<=::nat => nat => bool) ((NUMERAL_BIT1::nat => nat) (0::nat))
+ n)
+ ((op &::bool => bool => bool)
+ ((<=::nat => nat => bool) n
+ ((dimindex::('A::type => bool) => nat)
+ (hollight.UNIV::'A::type => bool)))
+ ((op =::'A::type finite_image => 'A::type finite_image => bool)
+ ((finite_index::nat => 'A::type finite_image) n) i))))"
+ by (import hollight FINITE_INDEX_WORKS)
+
+lemma FINITE_INDEX_INJ: "(All::(nat => bool) => bool)
+ (%x::nat.
+ (All::(nat => bool) => bool)
+ (%xa::nat.
+ (op -->::bool => bool => bool)
+ ((op &::bool => bool => bool)
+ ((<=::nat => nat => bool) ((NUMERAL_BIT1::nat => nat) (0::nat))
+ x)
+ ((op &::bool => bool => bool)
+ ((<=::nat => nat => bool) x
+ ((dimindex::('A::type => bool) => nat)
+ (hollight.UNIV::'A::type => bool)))
+ ((op &::bool => bool => bool)
+ ((<=::nat => nat => bool)
+ ((NUMERAL_BIT1::nat => nat) (0::nat)) xa)
+ ((<=::nat => nat => bool) xa
+ ((dimindex::('A::type => bool) => nat)
+ (hollight.UNIV::'A::type => bool))))))
+ ((op =::bool => bool => bool)
+ ((op =::'A::type => 'A::type => bool)
+ ((finite_index::nat => 'A::type) x)
+ ((finite_index::nat => 'A::type) xa))
+ ((op =::nat => nat => bool) x xa))))"
+ by (import hollight FINITE_INDEX_INJ)
+
+lemma FORALL_FINITE_INDEX: "(op =::bool => bool => bool)
+ ((All::('N::type finite_image => bool) => bool)
+ (P::'N::type finite_image => bool))
+ ((All::(nat => bool) => bool)
+ (%i::nat.
+ (op -->::bool => bool => bool)
+ ((op &::bool => bool => bool)
+ ((<=::nat => nat => bool) ((NUMERAL_BIT1::nat => nat) (0::nat)) i)
+ ((<=::nat => nat => bool) i
+ ((dimindex::('N::type => bool) => nat)
+ (hollight.UNIV::'N::type => bool))))
+ (P ((finite_index::nat => 'N::type finite_image) i))))"
+ by (import hollight FORALL_FINITE_INDEX)
+
+typedef (open) ('A, 'B) cart = "(Collect::(('B::type finite_image => 'A::type) => bool)
+ => ('B::type finite_image => 'A::type) set)
+ (%f::'B::type finite_image => 'A::type. True::bool)" morphisms "dest_cart" "mk_cart"
+ apply (rule light_ex_imp_nonempty[where t="(Eps::(('B::type finite_image => 'A::type) => bool)
+ => 'B::type finite_image => 'A::type)
+ (%f::'B::type finite_image => 'A::type. True::bool)"])
+ by (import hollight TYDEF_cart)
+
+syntax
+ dest_cart :: _
+
+syntax
+ mk_cart :: _
+
+lemmas "TYDEF_cart_@intern" = typedef_hol2hollight
+ [where a="a :: ('A::type, 'B::type) cart" and r=r ,
+ OF type_definition_cart]
+
+consts
+ "$" :: "('q_46418::type, 'q_46425::type) cart => nat => 'q_46418::type" ("$")
+
+defs
+ "$_def": "$ ==
+%(u::('q_46418::type, 'q_46425::type) cart) ua::nat.
+ dest_cart u (finite_index ua)"
+
+lemma "DEF_$": "$ =
+(%(u::('q_46418::type, 'q_46425::type) cart) ua::nat.
+ dest_cart u (finite_index ua))"
+ by (import hollight "DEF_$")
+
+lemma CART_EQ: "(All::(('A::type, 'B::type) cart => bool) => bool)
+ (%x::('A::type, 'B::type) cart.
+ (All::(('A::type, 'B::type) cart => bool) => bool)
+ (%y::('A::type, 'B::type) cart.
+ (op =::bool => bool => bool)
+ ((op =::('A::type, 'B::type) cart
+ => ('A::type, 'B::type) cart => bool)
+ x y)
+ ((All::(nat => bool) => bool)
+ (%xa::nat.
+ (op -->::bool => bool => bool)
+ ((op &::bool => bool => bool)
+ ((<=::nat => nat => bool)
+ ((NUMERAL_BIT1::nat => nat) (0::nat)) xa)
+ ((<=::nat => nat => bool) xa
+ ((dimindex::('B::type => bool) => nat)
+ (hollight.UNIV::'B::type => bool))))
+ ((op =::'A::type => 'A::type => bool)
+ (($::('A::type, 'B::type) cart => nat => 'A::type) x xa)
+ (($::('A::type, 'B::type) cart => nat => 'A::type) y
+ xa))))))"
+ by (import hollight CART_EQ)
+
+constdefs
+ lambda :: "(nat => 'A::type) => ('A::type, 'B::type) cart"
+ "(op ==::((nat => 'A::type) => ('A::type, 'B::type) cart)
+ => ((nat => 'A::type) => ('A::type, 'B::type) cart) => prop)
+ (lambda::(nat => 'A::type) => ('A::type, 'B::type) cart)
+ (%u::nat => 'A::type.
+ (Eps::(('A::type, 'B::type) cart => bool) => ('A::type, 'B::type) cart)
+ (%f::('A::type, 'B::type) cart.
+ (All::(nat => bool) => bool)
+ (%i::nat.
+ (op -->::bool => bool => bool)
+ ((op &::bool => bool => bool)
+ ((<=::nat => nat => bool)
+ ((NUMERAL_BIT1::nat => nat) (0::nat)) i)
+ ((<=::nat => nat => bool) i
+ ((dimindex::('B::type => bool) => nat)
+ (hollight.UNIV::'B::type => bool))))
+ ((op =::'A::type => 'A::type => bool)
+ (($::('A::type, 'B::type) cart => nat => 'A::type) f i)
+ (u i)))))"
+
+lemma DEF_lambda: "(op =::((nat => 'A::type) => ('A::type, 'B::type) cart)
+ => ((nat => 'A::type) => ('A::type, 'B::type) cart) => bool)
+ (lambda::(nat => 'A::type) => ('A::type, 'B::type) cart)
+ (%u::nat => 'A::type.
+ (Eps::(('A::type, 'B::type) cart => bool) => ('A::type, 'B::type) cart)
+ (%f::('A::type, 'B::type) cart.
+ (All::(nat => bool) => bool)
+ (%i::nat.
+ (op -->::bool => bool => bool)
+ ((op &::bool => bool => bool)
+ ((<=::nat => nat => bool)
+ ((NUMERAL_BIT1::nat => nat) (0::nat)) i)
+ ((<=::nat => nat => bool) i
+ ((dimindex::('B::type => bool) => nat)
+ (hollight.UNIV::'B::type => bool))))
+ ((op =::'A::type => 'A::type => bool)
+ (($::('A::type, 'B::type) cart => nat => 'A::type) f i)
+ (u i)))))"
+ by (import hollight DEF_lambda)
+
+lemma LAMBDA_BETA: "(All::(nat => bool) => bool)
+ (%x::nat.
+ (op -->::bool => bool => bool)
+ ((op &::bool => bool => bool)
+ ((<=::nat => nat => bool) ((NUMERAL_BIT1::nat => nat) (0::nat)) x)
+ ((<=::nat => nat => bool) x
+ ((dimindex::('B::type => bool) => nat)
+ (hollight.UNIV::'B::type => bool))))
+ ((op =::'A::type => 'A::type => bool)
+ (($::('A::type, 'B::type) cart => nat => 'A::type)
+ ((lambda::(nat => 'A::type) => ('A::type, 'B::type) cart)
+ (g::nat => 'A::type))
+ x)
+ (g x)))"
+ by (import hollight LAMBDA_BETA)
+
+lemma LAMBDA_UNIQUE: "(All::(('A::type, 'B::type) cart => bool) => bool)
+ (%x::('A::type, 'B::type) cart.
+ (All::((nat => 'A::type) => bool) => bool)
+ (%xa::nat => 'A::type.
+ (op =::bool => bool => bool)
+ ((All::(nat => bool) => bool)
+ (%i::nat.
+ (op -->::bool => bool => bool)
+ ((op &::bool => bool => bool)
+ ((<=::nat => nat => bool)
+ ((NUMERAL_BIT1::nat => nat) (0::nat)) i)
+ ((<=::nat => nat => bool) i
+ ((dimindex::('B::type => bool) => nat)
+ (hollight.UNIV::'B::type => bool))))
+ ((op =::'A::type => 'A::type => bool)
+ (($::('A::type, 'B::type) cart => nat => 'A::type) x i)
+ (xa i))))
+ ((op =::('A::type, 'B::type) cart
+ => ('A::type, 'B::type) cart => bool)
+ ((lambda::(nat => 'A::type) => ('A::type, 'B::type) cart) xa)
+ x)))"
+ by (import hollight LAMBDA_UNIQUE)
+
+lemma LAMBDA_ETA: "ALL x::('q_46616::type, 'q_46620::type) cart. lambda ($ x) = x"
+ by (import hollight LAMBDA_ETA)
+
+typedef (open) ('A, 'B) finite_sum = "(Collect::(('A::type finite_image, 'B::type finite_image) sum => bool)
+ => ('A::type finite_image, 'B::type finite_image) sum set)
+ (%x::('A::type finite_image, 'B::type finite_image) sum. True::bool)" morphisms "dest_finite_sum" "mk_finite_sum"
+ apply (rule light_ex_imp_nonempty[where t="(Eps::(('A::type finite_image, 'B::type finite_image) sum => bool)
+ => ('A::type finite_image, 'B::type finite_image) sum)
+ (%x::('A::type finite_image, 'B::type finite_image) sum. True::bool)"])
+ by (import hollight TYDEF_finite_sum)
+
+syntax
+ dest_finite_sum :: _
+
+syntax
+ mk_finite_sum :: _
+
+lemmas "TYDEF_finite_sum_@intern" = typedef_hol2hollight
+ [where a="a :: ('A::type, 'B::type) finite_sum" and r=r ,
+ OF type_definition_finite_sum]
+
+constdefs
+ pastecart :: "('A::type, 'M::type) cart
+=> ('A::type, 'N::type) cart
+ => ('A::type, ('M::type, 'N::type) finite_sum) cart"
+ "(op ==::(('A::type, 'M::type) cart
+ => ('A::type, 'N::type) cart
+ => ('A::type, ('M::type, 'N::type) finite_sum) cart)
+ => (('A::type, 'M::type) cart
+ => ('A::type, 'N::type) cart
+ => ('A::type, ('M::type, 'N::type) finite_sum) cart)
+ => prop)
+ (pastecart::('A::type, 'M::type) cart
+ => ('A::type, 'N::type) cart
+ => ('A::type, ('M::type, 'N::type) finite_sum) cart)
+ (%(u::('A::type, 'M::type) cart) ua::('A::type, 'N::type) cart.
+ (lambda::(nat => 'A::type)
+ => ('A::type, ('M::type, 'N::type) finite_sum) cart)
+ (%i::nat.
+ (COND::bool => 'A::type => 'A::type => 'A::type)
+ ((<=::nat => nat => bool) i
+ ((dimindex::('M::type => bool) => nat)
+ (hollight.UNIV::'M::type => bool)))
+ (($::('A::type, 'M::type) cart => nat => 'A::type) u i)
+ (($::('A::type, 'N::type) cart => nat => 'A::type) ua
+ ((op -::nat => nat => nat) i
+ ((dimindex::('M::type => bool) => nat)
+ (hollight.UNIV::'M::type => bool))))))"
+
+lemma DEF_pastecart: "(op =::(('A::type, 'M::type) cart
+ => ('A::type, 'N::type) cart
+ => ('A::type, ('M::type, 'N::type) finite_sum) cart)
+ => (('A::type, 'M::type) cart
+ => ('A::type, 'N::type) cart
+ => ('A::type, ('M::type, 'N::type) finite_sum) cart)
+ => bool)
+ (pastecart::('A::type, 'M::type) cart
+ => ('A::type, 'N::type) cart
+ => ('A::type, ('M::type, 'N::type) finite_sum) cart)
+ (%(u::('A::type, 'M::type) cart) ua::('A::type, 'N::type) cart.
+ (lambda::(nat => 'A::type)
+ => ('A::type, ('M::type, 'N::type) finite_sum) cart)
+ (%i::nat.
+ (COND::bool => 'A::type => 'A::type => 'A::type)
+ ((<=::nat => nat => bool) i
+ ((dimindex::('M::type => bool) => nat)
+ (hollight.UNIV::'M::type => bool)))
+ (($::('A::type, 'M::type) cart => nat => 'A::type) u i)
+ (($::('A::type, 'N::type) cart => nat => 'A::type) ua
+ ((op -::nat => nat => nat) i
+ ((dimindex::('M::type => bool) => nat)
+ (hollight.UNIV::'M::type => bool))))))"
+ by (import hollight DEF_pastecart)
+
+constdefs
+ fstcart :: "('A::type, ('M::type, 'N::type) finite_sum) cart
+=> ('A::type, 'M::type) cart"
+ "fstcart ==
+%u::('A::type, ('M::type, 'N::type) finite_sum) cart. lambda ($ u)"
+
+lemma DEF_fstcart: "fstcart =
+(%u::('A::type, ('M::type, 'N::type) finite_sum) cart. lambda ($ u))"
+ by (import hollight DEF_fstcart)
+
+constdefs
+ sndcart :: "('A::type, ('M::type, 'N::type) finite_sum) cart
+=> ('A::type, 'N::type) cart"
+ "(op ==::(('A::type, ('M::type, 'N::type) finite_sum) cart
+ => ('A::type, 'N::type) cart)
+ => (('A::type, ('M::type, 'N::type) finite_sum) cart
+ => ('A::type, 'N::type) cart)
+ => prop)
+ (sndcart::('A::type, ('M::type, 'N::type) finite_sum) cart
+ => ('A::type, 'N::type) cart)
+ (%u::('A::type, ('M::type, 'N::type) finite_sum) cart.
+ (lambda::(nat => 'A::type) => ('A::type, 'N::type) cart)
+ (%i::nat.
+ ($::('A::type, ('M::type, 'N::type) finite_sum) cart
+ => nat => 'A::type)
+ u ((op +::nat => nat => nat) i
+ ((dimindex::('M::type => bool) => nat)
+ (hollight.UNIV::'M::type => bool)))))"
+
+lemma DEF_sndcart: "(op =::(('A::type, ('M::type, 'N::type) finite_sum) cart
+ => ('A::type, 'N::type) cart)
+ => (('A::type, ('M::type, 'N::type) finite_sum) cart
+ => ('A::type, 'N::type) cart)
+ => bool)
+ (sndcart::('A::type, ('M::type, 'N::type) finite_sum) cart
+ => ('A::type, 'N::type) cart)
+ (%u::('A::type, ('M::type, 'N::type) finite_sum) cart.
+ (lambda::(nat => 'A::type) => ('A::type, 'N::type) cart)
+ (%i::nat.
+ ($::('A::type, ('M::type, 'N::type) finite_sum) cart
+ => nat => 'A::type)
+ u ((op +::nat => nat => nat) i
+ ((dimindex::('M::type => bool) => nat)
+ (hollight.UNIV::'M::type => bool)))))"
+ by (import hollight DEF_sndcart)
+
+lemma DIMINDEX_HAS_SIZE_FINITE_SUM: "(HAS_SIZE::(('M::type, 'N::type) finite_sum => bool) => nat => bool)
+ (hollight.UNIV::('M::type, 'N::type) finite_sum => bool)
+ ((op +::nat => nat => nat)
+ ((dimindex::('M::type => bool) => nat) (hollight.UNIV::'M::type => bool))
+ ((dimindex::('N::type => bool) => nat)
+ (hollight.UNIV::'N::type => bool)))"
+ by (import hollight DIMINDEX_HAS_SIZE_FINITE_SUM)
+
+lemma DIMINDEX_FINITE_SUM: "(op =::nat => nat => bool)
+ ((dimindex::(('M::type, 'N::type) finite_sum => bool) => nat)
+ (hollight.UNIV::('M::type, 'N::type) finite_sum => bool))
+ ((op +::nat => nat => nat)
+ ((dimindex::('M::type => bool) => nat) (hollight.UNIV::'M::type => bool))
+ ((dimindex::('N::type => bool) => nat)
+ (hollight.UNIV::'N::type => bool)))"
+ by (import hollight DIMINDEX_FINITE_SUM)
+
+lemma FSTCART_PASTECART: "ALL (x::('A::type, 'M::type) cart) xa::('A::type, 'N::type) cart.
+ fstcart (pastecart x xa) = x"
+ by (import hollight FSTCART_PASTECART)
+
+lemma SNDCART_PASTECART: "ALL (x::('A::type, 'M::type) cart) xa::('A::type, 'N::type) cart.
+ sndcart (pastecart x xa) = xa"
+ by (import hollight SNDCART_PASTECART)
+
+lemma PASTECART_FST_SND: "ALL x::('q_46940::type, ('q_46937::type, 'q_46935::type) finite_sum) cart.
+ pastecart (fstcart x) (sndcart x) = x"
+ by (import hollight PASTECART_FST_SND)
+
+lemma PASTECART_EQ: "ALL (x::('q_46978::type, ('q_46968::type, 'q_46979::type) finite_sum) cart)
+ y::('q_46978::type, ('q_46968::type, 'q_46979::type) finite_sum) cart.
+ (x = y) = (fstcart x = fstcart y & sndcart x = sndcart y)"
+ by (import hollight PASTECART_EQ)
+
+lemma FORALL_PASTECART: "All (P::('q_46999::type, ('q_47000::type, 'q_47001::type) finite_sum) cart
+ => bool) =
+(ALL (x::('q_46999::type, 'q_47000::type) cart)
+ y::('q_46999::type, 'q_47001::type) cart. P (pastecart x y))"
+ by (import hollight FORALL_PASTECART)
+
+lemma EXISTS_PASTECART: "Ex (P::('q_47021::type, ('q_47022::type, 'q_47023::type) finite_sum) cart
+ => bool) =
+(EX (x::('q_47021::type, 'q_47022::type) cart)
+ y::('q_47021::type, 'q_47023::type) cart. P (pastecart x y))"
+ by (import hollight EXISTS_PASTECART)
+
+lemma SURJECTIVE_IFF_INJECTIVE_GEN: "ALL (s::'A::type => bool) (t::'B::type => bool) f::'A::type => 'B::type.
+ FINITE s & FINITE t & CARD s = CARD t & SUBSET (IMAGE f s) t -->
+ (ALL y::'B::type. IN y t --> (EX x::'A::type. IN x s & f x = y)) =
+ (ALL (x::'A::type) y::'A::type. IN x s & IN y s & f x = f y --> x = y)"
+ by (import hollight SURJECTIVE_IFF_INJECTIVE_GEN)
+
+lemma SURJECTIVE_IFF_INJECTIVE: "ALL (x::'A::type => bool) xa::'A::type => 'A::type.
+ FINITE x & SUBSET (IMAGE xa x) x -->
+ (ALL y::'A::type. IN y x --> (EX xb::'A::type. IN xb x & xa xb = y)) =
+ (ALL (xb::'A::type) y::'A::type.
+ IN xb x & IN y x & xa xb = xa y --> xb = y)"
+ by (import hollight SURJECTIVE_IFF_INJECTIVE)
+
+lemma IMAGE_IMP_INJECTIVE_GEN: "ALL (s::'A::type => bool) (t::'B::type => bool) f::'A::type => 'B::type.
+ FINITE s & CARD s = CARD t & IMAGE f s = t -->
+ (ALL (x::'A::type) y::'A::type. IN x s & IN y s & f x = f y --> x = y)"
+ by (import hollight IMAGE_IMP_INJECTIVE_GEN)
+
+lemma IMAGE_IMP_INJECTIVE: "ALL (s::'q_47348::type => bool) f::'q_47348::type => 'q_47348::type.
+ FINITE s & IMAGE f s = s -->
+ (ALL (x::'q_47348::type) y::'q_47348::type.
+ IN x s & IN y s & f x = f y --> x = y)"
+ by (import hollight IMAGE_IMP_INJECTIVE)
+
+lemma CARD_LE_INJ: "ALL (x::'A::type => bool) xa::'B::type => bool.
+ FINITE x & FINITE xa & <= (CARD x) (CARD xa) -->
+ (EX f::'A::type => 'B::type.
+ SUBSET (IMAGE f x) xa &
+ (ALL (xa::'A::type) y::'A::type.
+ IN xa x & IN y x & f xa = f y --> xa = y))"
+ by (import hollight CARD_LE_INJ)
+
+lemma FORALL_IN_CLAUSES: "(ALL x::'q_47454::type => bool.
+ (ALL xa::'q_47454::type. IN xa EMPTY --> x xa) = True) &
+(ALL (x::'q_47494::type => bool) (xa::'q_47494::type)
+ xb::'q_47494::type => bool.
+ (ALL xc::'q_47494::type. IN xc (INSERT xa xb) --> x xc) =
+ (x xa & (ALL xa::'q_47494::type. IN xa xb --> x xa)))"
+ by (import hollight FORALL_IN_CLAUSES)
+
+lemma EXISTS_IN_CLAUSES: "(ALL x::'q_47514::type => bool.
+ (EX xa::'q_47514::type. IN xa EMPTY & x xa) = False) &
+(ALL (x::'q_47554::type => bool) (xa::'q_47554::type)
+ xb::'q_47554::type => bool.
+ (EX xc::'q_47554::type. IN xc (INSERT xa xb) & x xc) =
+ (x xa | (EX xa::'q_47554::type. IN xa xb & x xa)))"
+ by (import hollight EXISTS_IN_CLAUSES)
+
+lemma SURJECTIVE_ON_RIGHT_INVERSE: "ALL (x::'q_47610::type => 'q_47611::type) xa::'q_47611::type => bool.
+ (ALL xb::'q_47611::type.
+ IN xb xa -->
+ (EX xa::'q_47610::type.
+ IN xa (s::'q_47610::type => bool) & x xa = xb)) =
+ (EX g::'q_47611::type => 'q_47610::type.
+ ALL y::'q_47611::type. IN y xa --> IN (g y) s & x (g y) = y)"
+ by (import hollight SURJECTIVE_ON_RIGHT_INVERSE)
+
+lemma INJECTIVE_ON_LEFT_INVERSE: "ALL (x::'q_47704::type => 'q_47707::type) xa::'q_47704::type => bool.
+ (ALL (xb::'q_47704::type) y::'q_47704::type.
+ IN xb xa & IN y xa & x xb = x y --> xb = y) =
+ (EX xb::'q_47707::type => 'q_47704::type.
+ ALL xc::'q_47704::type. IN xc xa --> xb (x xc) = xc)"
+ by (import hollight INJECTIVE_ON_LEFT_INVERSE)
+
+lemma SURJECTIVE_RIGHT_INVERSE: "(ALL y::'q_47732::type.
+ EX x::'q_47735::type. (f::'q_47735::type => 'q_47732::type) x = y) =
+(EX g::'q_47732::type => 'q_47735::type. ALL y::'q_47732::type. f (g y) = y)"
+ by (import hollight SURJECTIVE_RIGHT_INVERSE)
+
+lemma INJECTIVE_LEFT_INVERSE: "(ALL (x::'q_47769::type) xa::'q_47769::type.
+ (f::'q_47769::type => 'q_47772::type) x = f xa --> x = xa) =
+(EX g::'q_47772::type => 'q_47769::type. ALL x::'q_47769::type. g (f x) = x)"
+ by (import hollight INJECTIVE_LEFT_INVERSE)
+
+lemma FUNCTION_FACTORS_RIGHT: "ALL (x::'q_47808::type => 'q_47809::type)
+ xa::'q_47796::type => 'q_47809::type.
+ (ALL xb::'q_47808::type. EX y::'q_47796::type. xa y = x xb) =
+ (EX xb::'q_47808::type => 'q_47796::type. x = xa o xb)"
+ by (import hollight FUNCTION_FACTORS_RIGHT)
+
+lemma FUNCTION_FACTORS_LEFT: "ALL (x::'q_47881::type => 'q_47882::type)
+ xa::'q_47881::type => 'q_47861::type.
+ (ALL (xb::'q_47881::type) y::'q_47881::type.
+ xa xb = xa y --> x xb = x y) =
+ (EX xb::'q_47861::type => 'q_47882::type. x = xb o xa)"
+ by (import hollight FUNCTION_FACTORS_LEFT)
+
+constdefs
+ dotdot :: "nat => nat => nat => bool"
+ "dotdot ==
+%(u::nat) ua::nat.
+ GSPEC (%ub::nat. EX x::nat. SETSPEC ub (<= u x & <= x ua) x)"
+
+lemma DEF__dot__dot_: "dotdot =
+(%(u::nat) ua::nat.
+ GSPEC (%ub::nat. EX x::nat. SETSPEC ub (<= u x & <= x ua) x))"
+ by (import hollight DEF__dot__dot_)
+
+lemma FINITE_NUMSEG: "ALL (m::nat) n::nat. FINITE (dotdot m n)"
+ by (import hollight FINITE_NUMSEG)
+
+lemma NUMSEG_COMBINE_R: "ALL (x::'q_47957::type) (p::nat) m::nat.
+ <= m p & <= p (n::nat) -->
+ hollight.UNION (dotdot m p) (dotdot (p + NUMERAL_BIT1 (0::nat)) n) =
+ dotdot m n"
+ by (import hollight NUMSEG_COMBINE_R)
+
+lemma NUMSEG_COMBINE_L: "ALL (x::'q_47995::type) (p::nat) m::nat.
+ <= m p & <= p (n::nat) -->
+ hollight.UNION (dotdot m (p - NUMERAL_BIT1 (0::nat))) (dotdot p n) =
+ dotdot m n"
+ by (import hollight NUMSEG_COMBINE_L)
+
+lemma NUMSEG_LREC: "ALL (x::nat) xa::nat.
+ <= x xa -->
+ INSERT x (dotdot (x + NUMERAL_BIT1 (0::nat)) xa) = dotdot x xa"
+ by (import hollight NUMSEG_LREC)
+
+lemma NUMSEG_RREC: "ALL (x::nat) xa::nat.
+ <= x xa -->
+ INSERT xa (dotdot x (xa - NUMERAL_BIT1 (0::nat))) = dotdot x xa"
+ by (import hollight NUMSEG_RREC)
+
+lemma NUMSEG_REC: "ALL (x::nat) xa::nat.
+ <= x (Suc xa) --> dotdot x (Suc xa) = INSERT (Suc xa) (dotdot x xa)"
+ by (import hollight NUMSEG_REC)
+
+lemma IN_NUMSEG: "ALL (x::nat) (xa::nat) xb::nat. IN xb (dotdot x xa) = (<= x xb & <= xb xa)"
+ by (import hollight IN_NUMSEG)
+
+lemma NUMSEG_SING: "ALL x::nat. dotdot x x = INSERT x EMPTY"
+ by (import hollight NUMSEG_SING)
+
+lemma NUMSEG_EMPTY: "ALL (x::nat) xa::nat. (dotdot x xa = EMPTY) = < xa x"
+ by (import hollight NUMSEG_EMPTY)
+
+lemma CARD_NUMSEG_LEMMA: "ALL (m::nat) d::nat. CARD (dotdot m (m + d)) = d + NUMERAL_BIT1 (0::nat)"
+ by (import hollight CARD_NUMSEG_LEMMA)
+
+lemma CARD_NUMSEG: "ALL (m::nat) n::nat. CARD (dotdot m n) = n + NUMERAL_BIT1 (0::nat) - m"
+ by (import hollight CARD_NUMSEG)
+
+lemma HAS_SIZE_NUMSEG: "ALL (x::nat) xa::nat.
+ HAS_SIZE (dotdot x xa) (xa + NUMERAL_BIT1 (0::nat) - x)"
+ by (import hollight HAS_SIZE_NUMSEG)
+
+lemma CARD_NUMSEG_1: "ALL x::nat. CARD (dotdot (NUMERAL_BIT1 (0::nat)) x) = x"
+ by (import hollight CARD_NUMSEG_1)
+
+lemma HAS_SIZE_NUMSEG_1: "ALL x::nat. HAS_SIZE (dotdot (NUMERAL_BIT1 (0::nat)) x) x"
+ by (import hollight HAS_SIZE_NUMSEG_1)
+
+lemma NUMSEG_CLAUSES: "(ALL m::nat.
+ dotdot m (0::nat) = COND (m = (0::nat)) (INSERT (0::nat) EMPTY) EMPTY) &
+(ALL (m::nat) n::nat.
+ dotdot m (Suc n) =
+ COND (<= m (Suc n)) (INSERT (Suc n) (dotdot m n)) (dotdot m n))"
+ by (import hollight NUMSEG_CLAUSES)
+
+lemma FINITE_INDEX_NUMSEG: "ALL s::'A::type => bool.
+ FINITE s =
+ (EX f::nat => 'A::type.
+ (ALL (i::nat) j::nat.
+ IN i (dotdot (NUMERAL_BIT1 (0::nat)) (CARD s)) &
+ IN j (dotdot (NUMERAL_BIT1 (0::nat)) (CARD s)) & f i = f j -->
+ i = j) &
+ s = IMAGE f (dotdot (NUMERAL_BIT1 (0::nat)) (CARD s)))"
+ by (import hollight FINITE_INDEX_NUMSEG)
+
+lemma FINITE_INDEX_NUMBERS: "ALL s::'A::type => bool.
+ FINITE s =
+ (EX (k::nat => bool) f::nat => 'A::type.
+ (ALL (i::nat) j::nat. IN i k & IN j k & f i = f j --> i = j) &
+ FINITE k & s = IMAGE f k)"
+ by (import hollight FINITE_INDEX_NUMBERS)
+
+lemma DISJOINT_NUMSEG: "ALL (x::nat) (xa::nat) (xb::nat) xc::nat.
+ DISJOINT (dotdot x xa) (dotdot xb xc) =
+ (< xa xb | < xc x | < xa x | < xc xb)"
+ by (import hollight DISJOINT_NUMSEG)
+
+lemma NUMSEG_ADD_SPLIT: "ALL (x::nat) (xa::nat) xb::nat.
+ <= x (xa + NUMERAL_BIT1 (0::nat)) -->
+ dotdot x (xa + xb) =
+ hollight.UNION (dotdot x xa)
+ (dotdot (xa + NUMERAL_BIT1 (0::nat)) (xa + xb))"
+ by (import hollight NUMSEG_ADD_SPLIT)
+
+lemma NUMSEG_OFFSET_IMAGE: "ALL (x::nat) (xa::nat) xb::nat.
+ dotdot (x + xb) (xa + xb) = IMAGE (%i::nat. i + xb) (dotdot x xa)"
+ by (import hollight NUMSEG_OFFSET_IMAGE)
+
+lemma SUBSET_NUMSEG: "ALL (m::nat) (n::nat) (p::nat) q::nat.
+ SUBSET (dotdot m n) (dotdot p q) = (< n m | <= p m & <= n q)"
+ by (import hollight SUBSET_NUMSEG)
+
+constdefs
+ neutral :: "('q_48776::type => 'q_48776::type => 'q_48776::type) => 'q_48776::type"
+ "neutral ==
+%u::'q_48776::type => 'q_48776::type => 'q_48776::type.
+ SOME x::'q_48776::type. ALL y::'q_48776::type. u x y = y & u y x = y"
+
+lemma DEF_neutral: "neutral =
+(%u::'q_48776::type => 'q_48776::type => 'q_48776::type.
+ SOME x::'q_48776::type. ALL y::'q_48776::type. u x y = y & u y x = y)"
+ by (import hollight DEF_neutral)
+
+constdefs
+ monoidal :: "('A::type => 'A::type => 'A::type) => bool"
+ "monoidal ==
+%u::'A::type => 'A::type => 'A::type.
+ (ALL (x::'A::type) y::'A::type. u x y = u y x) &
+ (ALL (x::'A::type) (y::'A::type) z::'A::type.
+ u x (u y z) = u (u x y) z) &
+ (ALL x::'A::type. u (neutral u) x = x)"
+
+lemma DEF_monoidal: "monoidal =
+(%u::'A::type => 'A::type => 'A::type.
+ (ALL (x::'A::type) y::'A::type. u x y = u y x) &
+ (ALL (x::'A::type) (y::'A::type) z::'A::type.
+ u x (u y z) = u (u x y) z) &
+ (ALL x::'A::type. u (neutral u) x = x))"
+ by (import hollight DEF_monoidal)
+
+constdefs
+ support :: "('B::type => 'B::type => 'B::type)
+=> ('A::type => 'B::type) => ('A::type => bool) => 'A::type => bool"
+ "support ==
+%(u::'B::type => 'B::type => 'B::type) (ua::'A::type => 'B::type)
+ ub::'A::type => bool.
+ GSPEC
+ (%uc::'A::type.
+ EX x::'A::type. SETSPEC uc (IN x ub & ua x ~= neutral u) x)"
+
+lemma DEF_support: "support =
+(%(u::'B::type => 'B::type => 'B::type) (ua::'A::type => 'B::type)
+ ub::'A::type => bool.
+ GSPEC
+ (%uc::'A::type.
+ EX x::'A::type. SETSPEC uc (IN x ub & ua x ~= neutral u) x))"
+ by (import hollight DEF_support)
+
+constdefs
+ iterate :: "('q_48881::type => 'q_48881::type => 'q_48881::type)
+=> ('A::type => bool) => ('A::type => 'q_48881::type) => 'q_48881::type"
+ "iterate ==
+%(u::'q_48881::type => 'q_48881::type => 'q_48881::type)
+ (ua::'A::type => bool) ub::'A::type => 'q_48881::type.
+ ITSET (%x::'A::type. u (ub x)) (support u ub ua) (neutral u)"
+
+lemma DEF_iterate: "iterate =
+(%(u::'q_48881::type => 'q_48881::type => 'q_48881::type)
+ (ua::'A::type => bool) ub::'A::type => 'q_48881::type.
+ ITSET (%x::'A::type. u (ub x)) (support u ub ua) (neutral u))"
+ by (import hollight DEF_iterate)
+
+lemma IN_SUPPORT: "ALL (x::'q_48924::type => 'q_48924::type => 'q_48924::type)
+ (xa::'q_48927::type => 'q_48924::type) (xb::'q_48927::type)
+ xc::'q_48927::type => bool.
+ IN xb (support x xa xc) = (IN xb xc & xa xb ~= neutral x)"
+ by (import hollight IN_SUPPORT)
+
+lemma SUPPORT_SUPPORT: "ALL (x::'q_48949::type => 'q_48949::type => 'q_48949::type)
+ (xa::'q_48960::type => 'q_48949::type) xb::'q_48960::type => bool.
+ support x xa (support x xa xb) = support x xa xb"
+ by (import hollight SUPPORT_SUPPORT)
+
+lemma SUPPORT_EMPTY: "ALL (x::'q_48985::type => 'q_48985::type => 'q_48985::type)
+ (xa::'q_48999::type => 'q_48985::type) xb::'q_48999::type => bool.
+ (ALL xc::'q_48999::type. IN xc xb --> xa xc = neutral x) =
+ (support x xa xb = EMPTY)"
+ by (import hollight SUPPORT_EMPTY)
+
+lemma SUPPORT_SUBSET: "ALL (x::'q_49019::type => 'q_49019::type => 'q_49019::type)
+ (xa::'q_49020::type => 'q_49019::type) xb::'q_49020::type => bool.
+ SUBSET (support x xa xb) xb"
+ by (import hollight SUPPORT_SUBSET)
+
+lemma FINITE_SUPPORT: "ALL (u::'q_49043::type => 'q_49043::type => 'q_49043::type)
+ (f::'q_49037::type => 'q_49043::type) s::'q_49037::type => bool.
+ FINITE s --> FINITE (support u f s)"
+ by (import hollight FINITE_SUPPORT)
+
+lemma SUPPORT_CLAUSES: "(ALL x::'q_49061::type => 'q_49091::type.
+ support (u_4215::'q_49091::type => 'q_49091::type => 'q_49091::type) x
+ EMPTY =
+ EMPTY) &
+(ALL (x::'q_49109::type => 'q_49091::type) (xa::'q_49109::type)
+ xb::'q_49109::type => bool.
+ support u_4215 x (INSERT xa xb) =
+ COND (x xa = neutral u_4215) (support u_4215 x xb)
+ (INSERT xa (support u_4215 x xb))) &
+(ALL (x::'q_49142::type => 'q_49091::type) (xa::'q_49142::type)
+ xb::'q_49142::type => bool.
+ support u_4215 x (DELETE xb xa) = DELETE (support u_4215 x xb) xa) &
+(ALL (x::'q_49180::type => 'q_49091::type) (xa::'q_49180::type => bool)
+ xb::'q_49180::type => bool.
+ support u_4215 x (hollight.UNION xa xb) =
+ hollight.UNION (support u_4215 x xa) (support u_4215 x xb)) &
+(ALL (x::'q_49218::type => 'q_49091::type) (xa::'q_49218::type => bool)
+ xb::'q_49218::type => bool.
+ support u_4215 x (hollight.INTER xa xb) =
+ hollight.INTER (support u_4215 x xa) (support u_4215 x xb)) &
+(ALL (x::'q_49254::type => 'q_49091::type) (xa::'q_49254::type => bool)
+ xb::'q_49254::type => bool.
+ support u_4215 x (DIFF xa xb) =
+ DIFF (support u_4215 x xa) (support u_4215 x xb))"
+ by (import hollight SUPPORT_CLAUSES)
+
+lemma ITERATE_SUPPORT: "ALL (x::'q_49275::type => 'q_49275::type => 'q_49275::type)
+ (xa::'q_49276::type => 'q_49275::type) xb::'q_49276::type => bool.
+ FINITE (support x xa xb) -->
+ iterate x (support x xa xb) xa = iterate x xb xa"
+ by (import hollight ITERATE_SUPPORT)
+
+lemma SUPPORT_DELTA: "ALL (x::'q_49320::type => 'q_49320::type => 'q_49320::type)
+ (xa::'q_49348::type => bool) (xb::'q_49348::type => 'q_49320::type)
+ xc::'q_49348::type.
+ support x (%xa::'q_49348::type. COND (xa = xc) (xb xa) (neutral x)) xa =
+ COND (IN xc xa) (support x xb (INSERT xc EMPTY)) EMPTY"
+ by (import hollight SUPPORT_DELTA)
+
+lemma FINITE_SUPPORT_DELTA: "ALL (x::'q_49369::type => 'q_49369::type => 'q_49369::type)
+ (xa::'q_49378::type => 'q_49369::type) xb::'q_49378::type.
+ FINITE
+ (support x (%xc::'q_49378::type. COND (xc = xb) (xa xc) (neutral x))
+ (s::'q_49378::type => bool))"
+ by (import hollight FINITE_SUPPORT_DELTA)
+
+lemma ITERATE_CLAUSES_GEN: "ALL u_4215::'B::type => 'B::type => 'B::type.
+ monoidal u_4215 -->
+ (ALL f::'A::type => 'B::type. iterate u_4215 EMPTY f = neutral u_4215) &
+ (ALL (f::'A::type => 'B::type) (x::'A::type) s::'A::type => bool.
+ monoidal u_4215 & FINITE (support u_4215 f s) -->
+ iterate u_4215 (INSERT x s) f =
+ COND (IN x s) (iterate u_4215 s f)
+ (u_4215 (f x) (iterate u_4215 s f)))"
+ by (import hollight ITERATE_CLAUSES_GEN)
+
+lemma ITERATE_CLAUSES: "ALL x::'q_49546::type => 'q_49546::type => 'q_49546::type.
+ monoidal x -->
+ (ALL f::'q_49504::type => 'q_49546::type.
+ iterate x EMPTY f = neutral x) &
+ (ALL (f::'q_49548::type => 'q_49546::type) (xa::'q_49548::type)
+ s::'q_49548::type => bool.
+ FINITE s -->
+ iterate x (INSERT xa s) f =
+ COND (IN xa s) (iterate x s f) (x (f xa) (iterate x s f)))"
+ by (import hollight ITERATE_CLAUSES)
+
+lemma ITERATE_UNION: "ALL u_4215::'q_49634::type => 'q_49634::type => 'q_49634::type.
+ monoidal u_4215 -->
+ (ALL (f::'q_49619::type => 'q_49634::type) (s::'q_49619::type => bool)
+ x::'q_49619::type => bool.
+ FINITE s & FINITE x & DISJOINT s x -->
+ iterate u_4215 (hollight.UNION s x) f =
+ u_4215 (iterate u_4215 s f) (iterate u_4215 x f))"
+ by (import hollight ITERATE_UNION)
+
+lemma ITERATE_UNION_GEN: "ALL u_4215::'B::type => 'B::type => 'B::type.
+ monoidal u_4215 -->
+ (ALL (f::'A::type => 'B::type) (s::'A::type => bool) t::'A::type => bool.
+ FINITE (support u_4215 f s) &
+ FINITE (support u_4215 f t) &
+ DISJOINT (support u_4215 f s) (support u_4215 f t) -->
+ iterate u_4215 (hollight.UNION s t) f =
+ u_4215 (iterate u_4215 s f) (iterate u_4215 t f))"
+ by (import hollight ITERATE_UNION_GEN)
+
+lemma ITERATE_DIFF: "ALL u::'q_49777::type => 'q_49777::type => 'q_49777::type.
+ monoidal u -->
+ (ALL (f::'q_49773::type => 'q_49777::type) (s::'q_49773::type => bool)
+ t::'q_49773::type => bool.
+ FINITE s & SUBSET t s -->
+ u (iterate u (DIFF s t) f) (iterate u t f) = iterate u s f)"
+ by (import hollight ITERATE_DIFF)
+
+lemma ITERATE_DIFF_GEN: "ALL u_4215::'B::type => 'B::type => 'B::type.
+ monoidal u_4215 -->
+ (ALL (f::'A::type => 'B::type) (s::'A::type => bool) t::'A::type => bool.
+ FINITE (support u_4215 f s) &
+ SUBSET (support u_4215 f t) (support u_4215 f s) -->
+ u_4215 (iterate u_4215 (DIFF s t) f) (iterate u_4215 t f) =
+ iterate u_4215 s f)"
+ by (import hollight ITERATE_DIFF_GEN)
+
+lemma ITERATE_CLOSED: "ALL u_4215::'B::type => 'B::type => 'B::type.
+ monoidal u_4215 -->
+ (ALL P::'B::type => bool.
+ P (neutral u_4215) &
+ (ALL (x::'B::type) y::'B::type. P x & P y --> P (u_4215 x y)) -->
+ (ALL (f::'A::type => 'B::type) x::'A::type => bool.
+ FINITE x & (ALL xa::'A::type. IN xa x --> P (f xa)) -->
+ P (iterate u_4215 x f)))"
+ by (import hollight ITERATE_CLOSED)
+
+lemma ITERATE_CLOSED_GEN: "ALL u_4215::'B::type => 'B::type => 'B::type.
+ monoidal u_4215 -->
+ (ALL P::'B::type => bool.
+ P (neutral u_4215) &
+ (ALL (x::'B::type) y::'B::type. P x & P y --> P (u_4215 x y)) -->
+ (ALL (f::'A::type => 'B::type) s::'A::type => bool.
+ FINITE (support u_4215 f s) &
+ (ALL x::'A::type. IN x s & f x ~= neutral u_4215 --> P (f x)) -->
+ P (iterate u_4215 s f)))"
+ by (import hollight ITERATE_CLOSED_GEN)
+
+lemma ITERATE_RELATED: "ALL u_4215::'B::type => 'B::type => 'B::type.
+ monoidal u_4215 -->
+ (ALL R::'B::type => 'B::type => bool.
+ R (neutral u_4215) (neutral u_4215) &
+ (ALL (x1::'B::type) (y1::'B::type) (x2::'B::type) y2::'B::type.
+ R x1 x2 & R y1 y2 --> R (u_4215 x1 y1) (u_4215 x2 y2)) -->
+ (ALL (f::'A::type => 'B::type) (g::'A::type => 'B::type)
+ x::'A::type => bool.
+ FINITE x & (ALL xa::'A::type. IN xa x --> R (f xa) (g xa)) -->
+ R (iterate u_4215 x f) (iterate u_4215 x g)))"
+ by (import hollight ITERATE_RELATED)
+
+lemma ITERATE_EQ_NEUTRAL: "ALL u_4215::'B::type => 'B::type => 'B::type.
+ monoidal u_4215 -->
+ (ALL (f::'A::type => 'B::type) s::'A::type => bool.
+ (ALL x::'A::type. IN x s --> f x = neutral u_4215) -->
+ iterate u_4215 s f = neutral u_4215)"
+ by (import hollight ITERATE_EQ_NEUTRAL)
+
+lemma ITERATE_SING: "ALL x::'B::type => 'B::type => 'B::type.
+ monoidal x -->
+ (ALL (f::'A::type => 'B::type) xa::'A::type.
+ iterate x (INSERT xa EMPTY) f = f xa)"
+ by (import hollight ITERATE_SING)
+
+lemma ITERATE_DELTA: "ALL u_4215::'q_50229::type => 'q_50229::type => 'q_50229::type.
+ monoidal u_4215 -->
+ (ALL (x::'q_50248::type => 'q_50229::type) (xa::'q_50248::type)
+ xb::'q_50248::type => bool.
+ iterate u_4215 xb
+ (%xb::'q_50248::type. COND (xb = xa) (x xb) (neutral u_4215)) =
+ COND (IN xa xb) (x xa) (neutral u_4215))"
+ by (import hollight ITERATE_DELTA)
+
+lemma ITERATE_IMAGE: "ALL u_4215::'q_50327::type => 'q_50327::type => 'q_50327::type.
+ monoidal u_4215 -->
+ (ALL (f::'q_50326::type => 'q_50298::type)
+ (g::'q_50298::type => 'q_50327::type) x::'q_50326::type => bool.
+ FINITE x &
+ (ALL (xa::'q_50326::type) y::'q_50326::type.
+ IN xa x & IN y x & f xa = f y --> xa = y) -->
+ iterate u_4215 (IMAGE f x) g = iterate u_4215 x (g o f))"
+ by (import hollight ITERATE_IMAGE)
+
+constdefs
+ nsum :: "('q_50348::type => bool) => ('q_50348::type => nat) => nat"
+ "(op ==::(('q_50348::type => bool) => ('q_50348::type => nat) => nat)
+ => (('q_50348::type => bool) => ('q_50348::type => nat) => nat)
+ => prop)
+ (nsum::('q_50348::type => bool) => ('q_50348::type => nat) => nat)
+ ((iterate::(nat => nat => nat)
+ => ('q_50348::type => bool) => ('q_50348::type => nat) => nat)
+ (op +::nat => nat => nat))"
+
+lemma DEF_nsum: "(op =::(('q_50348::type => bool) => ('q_50348::type => nat) => nat)
+ => (('q_50348::type => bool) => ('q_50348::type => nat) => nat)
+ => bool)
+ (nsum::('q_50348::type => bool) => ('q_50348::type => nat) => nat)
+ ((iterate::(nat => nat => nat)
+ => ('q_50348::type => bool) => ('q_50348::type => nat) => nat)
+ (op +::nat => nat => nat))"
+ by (import hollight DEF_nsum)
+
+lemma NEUTRAL_ADD: "neutral op + = (0::nat)"
+ by (import hollight NEUTRAL_ADD)
+
+lemma NEUTRAL_MUL: "neutral op * = NUMERAL_BIT1 (0::nat)"
+ by (import hollight NEUTRAL_MUL)
+
+lemma MONOIDAL_ADD: "(monoidal::(nat => nat => nat) => bool) (op +::nat => nat => nat)"
+ by (import hollight MONOIDAL_ADD)
+
+lemma MONOIDAL_MUL: "(monoidal::(nat => nat => nat) => bool) (op *::nat => nat => nat)"
+ by (import hollight MONOIDAL_MUL)
+
+lemma NSUM_CLAUSES: "(ALL x::'q_50386::type => nat. nsum EMPTY x = (0::nat)) &
+(ALL (x::'q_50425::type) (xa::'q_50425::type => nat)
+ xb::'q_50425::type => bool.
+ FINITE xb -->
+ nsum (INSERT x xb) xa = COND (IN x xb) (nsum xb xa) (xa x + nsum xb xa))"
+ by (import hollight NSUM_CLAUSES)
+
+lemma NSUM_UNION: "ALL (x::'q_50451::type => nat) (xa::'q_50451::type => bool)
+ xb::'q_50451::type => bool.
+ FINITE xa & FINITE xb & DISJOINT xa xb -->
+ nsum (hollight.UNION xa xb) x = nsum xa x + nsum xb x"
+ by (import hollight NSUM_UNION)
+
+lemma NSUM_DIFF: "ALL (f::'q_50506::type => nat) (s::'q_50506::type => bool)
+ t::'q_50506::type => bool.
+ FINITE s & SUBSET t s --> nsum (DIFF s t) f = nsum s f - nsum t f"
+ by (import hollight NSUM_DIFF)
+
+lemma NSUM_SUPPORT: "ALL (x::'q_50545::type => nat) xa::'q_50545::type => bool.
+ FINITE (support op + x xa) --> nsum (support op + x xa) x = nsum xa x"
+ by (import hollight NSUM_SUPPORT)
+
+lemma NSUM_ADD: "ALL (f::'q_50591::type => nat) (g::'q_50591::type => nat)
+ s::'q_50591::type => bool.
+ FINITE s --> nsum s (%x::'q_50591::type. f x + g x) = nsum s f + nsum s g"
+ by (import hollight NSUM_ADD)
+
+lemma NSUM_CMUL: "ALL (f::'q_50629::type => nat) (c::nat) s::'q_50629::type => bool.
+ FINITE s --> nsum s (%x::'q_50629::type. c * f x) = c * nsum s f"
+ by (import hollight NSUM_CMUL)
+
+lemma NSUM_LE: "ALL (x::'q_50668::type => nat) (xa::'q_50668::type => nat)
+ xb::'q_50668::type => bool.
+ FINITE xb & (ALL xc::'q_50668::type. IN xc xb --> <= (x xc) (xa xc)) -->
+ <= (nsum xb x) (nsum xb xa)"
+ by (import hollight NSUM_LE)
+
+lemma NSUM_LT: "ALL (f::'A::type => nat) (g::'A::type => nat) s::'A::type => bool.
+ FINITE s &
+ (ALL x::'A::type. IN x s --> <= (f x) (g x)) &
+ (EX x::'A::type. IN x s & < (f x) (g x)) -->
+ < (nsum s f) (nsum s g)"
+ by (import hollight NSUM_LT)
+
+lemma NSUM_LT_ALL: "ALL (f::'q_50790::type => nat) (g::'q_50790::type => nat)
+ s::'q_50790::type => bool.
+ FINITE s &
+ s ~= EMPTY & (ALL x::'q_50790::type. IN x s --> < (f x) (g x)) -->
+ < (nsum s f) (nsum s g)"
+ by (import hollight NSUM_LT_ALL)
+
+lemma NSUM_EQ: "ALL (x::'q_50832::type => nat) (xa::'q_50832::type => nat)
+ xb::'q_50832::type => bool.
+ FINITE xb & (ALL xc::'q_50832::type. IN xc xb --> x xc = xa xc) -->
+ nsum xb x = nsum xb xa"
+ by (import hollight NSUM_EQ)
+
+lemma NSUM_CONST: "ALL (c::nat) s::'q_50862::type => bool.
+ FINITE s --> nsum s (%n::'q_50862::type. c) = CARD s * c"
+ by (import hollight NSUM_CONST)
+
+lemma NSUM_EQ_0: "ALL (x::'A::type => nat) xa::'A::type => bool.
+ (ALL xb::'A::type. IN xb xa --> x xb = (0::nat)) --> nsum xa x = (0::nat)"
+ by (import hollight NSUM_EQ_0)
+
+lemma NSUM_0: "ALL x::'A::type => bool. nsum x (%n::'A::type. 0::nat) = (0::nat)"
+ by (import hollight NSUM_0)
+
+lemma NSUM_POS_LE: "ALL (x::'q_50941::type => nat) xa::'q_50941::type => bool.
+ FINITE xa & (ALL xb::'q_50941::type. IN xb xa --> <= (0::nat) (x xb)) -->
+ <= (0::nat) (nsum xa x)"
+ by (import hollight NSUM_POS_LE)
+
+lemma NSUM_POS_BOUND: "ALL (f::'A::type => nat) (b::nat) x::'A::type => bool.
+ FINITE x &
+ (ALL xa::'A::type. IN xa x --> <= (0::nat) (f xa)) & <= (nsum x f) b -->
+ (ALL xa::'A::type. IN xa x --> <= (f xa) b)"
+ by (import hollight NSUM_POS_BOUND)
+
+lemma NSUM_POS_EQ_0: "ALL (x::'q_51076::type => nat) xa::'q_51076::type => bool.
+ FINITE xa &
+ (ALL xb::'q_51076::type. IN xb xa --> <= (0::nat) (x xb)) &
+ nsum xa x = (0::nat) -->
+ (ALL xb::'q_51076::type. IN xb xa --> x xb = (0::nat))"
+ by (import hollight NSUM_POS_EQ_0)
+
+lemma NSUM_SING: "ALL (x::'q_51096::type => nat) xa::'q_51096::type.
+ nsum (INSERT xa EMPTY) x = x xa"
+ by (import hollight NSUM_SING)
+
+lemma NSUM_DELTA: "ALL (x::'A::type => bool) xa::'A::type.
+ nsum x (%x::'A::type. COND (x = xa) (b::nat) (0::nat)) =
+ COND (IN xa x) b (0::nat)"
+ by (import hollight NSUM_DELTA)
+
+lemma NSUM_SWAP: "ALL (f::'A::type => 'B::type => nat) (x::'A::type => bool)
+ xa::'B::type => bool.
+ FINITE x & FINITE xa -->
+ nsum x (%i::'A::type. nsum xa (f i)) =
+ nsum xa (%j::'B::type. nsum x (%i::'A::type. f i j))"
+ by (import hollight NSUM_SWAP)
+
+lemma NSUM_IMAGE: "ALL (x::'q_51236::type => 'q_51212::type) (xa::'q_51212::type => nat)
+ xb::'q_51236::type => bool.
+ FINITE xb &
+ (ALL (xa::'q_51236::type) y::'q_51236::type.
+ IN xa xb & IN y xb & x xa = x y --> xa = y) -->
+ nsum (IMAGE x xb) xa = nsum xb (xa o x)"
+ by (import hollight NSUM_IMAGE)
+
+lemma NSUM_SUPERSET: "ALL (f::'A::type => nat) (u::'A::type => bool) v::'A::type => bool.
+ FINITE u &
+ SUBSET u v & (ALL x::'A::type. IN x v & ~ IN x u --> f x = (0::nat)) -->
+ nsum v f = nsum u f"
+ by (import hollight NSUM_SUPERSET)
+
+lemma NSUM_UNION_RZERO: "ALL (f::'A::type => nat) (u::'A::type => bool) v::'A::type => bool.
+ FINITE u & (ALL x::'A::type. IN x v & ~ IN x u --> f x = (0::nat)) -->
+ nsum (hollight.UNION u v) f = nsum u f"
+ by (import hollight NSUM_UNION_RZERO)
+
+lemma NSUM_UNION_LZERO: "ALL (f::'A::type => nat) (u::'A::type => bool) v::'A::type => bool.
+ FINITE v & (ALL x::'A::type. IN x u & ~ IN x v --> f x = (0::nat)) -->
+ nsum (hollight.UNION u v) f = nsum v f"
+ by (import hollight NSUM_UNION_LZERO)
+
+lemma NSUM_RESTRICT: "ALL (f::'q_51457::type => nat) s::'q_51457::type => bool.
+ FINITE s -->
+ nsum s (%x::'q_51457::type. COND (IN x s) (f x) (0::nat)) = nsum s f"
+ by (import hollight NSUM_RESTRICT)
+
+lemma NSUM_BOUND: "ALL (x::'A::type => bool) (xa::'A::type => nat) xb::nat.
+ FINITE x & (ALL xc::'A::type. IN xc x --> <= (xa xc) xb) -->
+ <= (nsum x xa) (CARD x * xb)"
+ by (import hollight NSUM_BOUND)
+
+lemma NSUM_BOUND_GEN: "ALL (x::'A::type => bool) (xa::'q_51532::type) b::nat.
+ FINITE x &
+ x ~= EMPTY &
+ (ALL xa::'A::type.
+ IN xa x --> <= ((f::'A::type => nat) xa) (DIV b (CARD x))) -->
+ <= (nsum x f) b"
+ by (import hollight NSUM_BOUND_GEN)
+
+lemma NSUM_BOUND_LT: "ALL (s::'A::type => bool) (f::'A::type => nat) b::nat.
+ FINITE s &
+ (ALL x::'A::type. IN x s --> <= (f x) b) &
+ (EX x::'A::type. IN x s & < (f x) b) -->
+ < (nsum s f) (CARD s * b)"
+ by (import hollight NSUM_BOUND_LT)
+
+lemma NSUM_BOUND_LT_ALL: "ALL (s::'q_51675::type => bool) (f::'q_51675::type => nat) b::nat.
+ FINITE s & s ~= EMPTY & (ALL x::'q_51675::type. IN x s --> < (f x) b) -->
+ < (nsum s f) (CARD s * b)"
+ by (import hollight NSUM_BOUND_LT_ALL)
+
+lemma NSUM_BOUND_LT_GEN: "ALL (s::'A::type => bool) (t::'q_51717::type) b::nat.
+ FINITE s &
+ s ~= EMPTY &
+ (ALL x::'A::type.
+ IN x s --> < ((f::'A::type => nat) x) (DIV b (CARD s))) -->
+ < (nsum s f) b"
+ by (import hollight NSUM_BOUND_LT_GEN)
+
+lemma NSUM_UNION_EQ: "ALL (s::'q_51776::type => bool) (t::'q_51776::type => bool)
+ u::'q_51776::type => bool.
+ FINITE u & hollight.INTER s t = EMPTY & hollight.UNION s t = u -->
+ nsum s (f::'q_51776::type => nat) + nsum t f = nsum u f"
+ by (import hollight NSUM_UNION_EQ)
+
+lemma NSUM_EQ_SUPERSET: "ALL (f::'A::type => nat) (s::'A::type => bool) t::'A::type => bool.
+ FINITE t &
+ SUBSET t s &
+ (ALL x::'A::type. IN x t --> f x = (g::'A::type => nat) x) &
+ (ALL x::'A::type. IN x s & ~ IN x t --> f x = (0::nat)) -->
+ nsum s f = nsum t g"
+ by (import hollight NSUM_EQ_SUPERSET)
+
+lemma NSUM_RESTRICT_SET: "ALL (s::'A::type => bool) (f::'A::type => nat) r::'q_51887::type.
+ FINITE s -->
+ nsum
+ (GSPEC
+ (%u::'A::type.
+ EX x::'A::type. SETSPEC u (IN x s & (P::'A::type => bool) x) x))
+ f =
+ nsum s (%x::'A::type. COND (P x) (f x) (0::nat))"
+ by (import hollight NSUM_RESTRICT_SET)
+
+lemma NSUM_NSUM_RESTRICT: "ALL (R::'q_52016::type => 'q_52015::type => bool)
+ (f::'q_52016::type => 'q_52015::type => nat) (s::'q_52016::type => bool)
+ t::'q_52015::type => bool.
+ FINITE s & FINITE t -->
+ nsum s
+ (%x::'q_52016::type.
+ nsum
+ (GSPEC
+ (%u::'q_52015::type.
+ EX y::'q_52015::type. SETSPEC u (IN y t & R x y) y))
+ (f x)) =
+ nsum t
+ (%y::'q_52015::type.
+ nsum
+ (GSPEC
+ (%u::'q_52016::type.
+ EX x::'q_52016::type. SETSPEC u (IN x s & R x y) x))
+ (%x::'q_52016::type. f x y))"
+ by (import hollight NSUM_NSUM_RESTRICT)
+
+lemma CARD_EQ_NSUM: "ALL x::'q_52035::type => bool.
+ FINITE x --> CARD x = nsum x (%x::'q_52035::type. NUMERAL_BIT1 (0::nat))"
+ by (import hollight CARD_EQ_NSUM)
+
+lemma NSUM_MULTICOUNT_GEN: "ALL (R::'A::type => 'B::type => bool) (s::'A::type => bool)
+ (t::'B::type => bool) k::'B::type => nat.
+ FINITE s &
+ FINITE t &
+ (ALL j::'B::type.
+ IN j t -->
+ CARD
+ (GSPEC
+ (%u::'A::type. EX i::'A::type. SETSPEC u (IN i s & R i j) i)) =
+ k j) -->
+ nsum s
+ (%i::'A::type.
+ CARD
+ (GSPEC
+ (%u::'B::type. EX j::'B::type. SETSPEC u (IN j t & R i j) j))) =
+ nsum t k"
+ by (import hollight NSUM_MULTICOUNT_GEN)
+
+lemma NSUM_MULTICOUNT: "ALL (R::'A::type => 'B::type => bool) (s::'A::type => bool)
+ (t::'B::type => bool) k::nat.
+ FINITE s &
+ FINITE t &
+ (ALL j::'B::type.
+ IN j t -->
+ CARD
+ (GSPEC
+ (%u::'A::type. EX i::'A::type. SETSPEC u (IN i s & R i j) i)) =
+ k) -->
+ nsum s
+ (%i::'A::type.
+ CARD
+ (GSPEC
+ (%u::'B::type. EX j::'B::type. SETSPEC u (IN j t & R i j) j))) =
+ k * CARD t"
+ by (import hollight NSUM_MULTICOUNT)
+
+lemma NSUM_IMAGE_GEN: "ALL (f::'A::type => 'B::type) (g::'A::type => nat) s::'A::type => bool.
+ FINITE s -->
+ nsum s g =
+ nsum (IMAGE f s)
+ (%y::'B::type.
+ nsum
+ (GSPEC
+ (%u::'A::type. EX x::'A::type. SETSPEC u (IN x s & f x = y) x))
+ g)"
+ by (import hollight NSUM_IMAGE_GEN)
+
+lemma NSUM_SUBSET: "ALL (u::'A::type => bool) (v::'A::type => bool) f::'A::type => nat.
+ FINITE u &
+ FINITE v & (ALL x::'A::type. IN x (DIFF u v) --> f x = (0::nat)) -->
+ <= (nsum u f) (nsum v f)"
+ by (import hollight NSUM_SUBSET)
+
+lemma NSUM_SUBSET_SIMPLE: "ALL (u::'q_52495::type => bool) (v::'q_52495::type => bool)
+ f::'q_52495::type => nat.
+ FINITE v & SUBSET u v --> <= (nsum u f) (nsum v f)"
+ by (import hollight NSUM_SUBSET_SIMPLE)
+
+lemma NSUM_ADD_NUMSEG: "ALL (x::nat => nat) (xa::nat => nat) (xb::nat) xc::nat.
+ nsum (dotdot xb xc) (%i::nat. x i + xa i) =
+ nsum (dotdot xb xc) x + nsum (dotdot xb xc) xa"
+ by (import hollight NSUM_ADD_NUMSEG)
+
+lemma NSUM_CMUL_NUMSEG: "ALL (x::nat => nat) (xa::nat) (xb::nat) xc::nat.
+ nsum (dotdot xb xc) (%i::nat. xa * x i) = xa * nsum (dotdot xb xc) x"
+ by (import hollight NSUM_CMUL_NUMSEG)
+
+lemma NSUM_LE_NUMSEG: "ALL (x::nat => nat) (xa::nat => nat) (xb::nat) xc::nat.
+ (ALL i::nat. <= xb i & <= i xc --> <= (x i) (xa i)) -->
+ <= (nsum (dotdot xb xc) x) (nsum (dotdot xb xc) xa)"
+ by (import hollight NSUM_LE_NUMSEG)
+
+lemma NSUM_EQ_NUMSEG: "ALL (f::nat => nat) (g::nat => nat) (m::nat) n::nat.
+ (ALL i::nat. <= m i & <= i n --> f i = g i) -->
+ nsum (dotdot m n) f = nsum (dotdot m n) g"
+ by (import hollight NSUM_EQ_NUMSEG)
+
+lemma NSUM_CONST_NUMSEG: "ALL (x::nat) (xa::nat) xb::nat.
+ nsum (dotdot xa xb) (%n::nat. x) = (xb + NUMERAL_BIT1 (0::nat) - xa) * x"
+ by (import hollight NSUM_CONST_NUMSEG)
+
+lemma NSUM_EQ_0_NUMSEG: "ALL (x::nat => nat) xa::'q_52734::type.
+ (ALL i::nat. <= (m::nat) i & <= i (n::nat) --> x i = (0::nat)) -->
+ nsum (dotdot m n) x = (0::nat)"
+ by (import hollight NSUM_EQ_0_NUMSEG)
+
+lemma NSUM_TRIV_NUMSEG: "ALL (f::nat => nat) (m::nat) n::nat.
+ < n m --> nsum (dotdot m n) f = (0::nat)"
+ by (import hollight NSUM_TRIV_NUMSEG)
+
+lemma NSUM_POS_LE_NUMSEG: "ALL (x::nat) (xa::nat) xb::nat => nat.
+ (ALL p::nat. <= x p & <= p xa --> <= (0::nat) (xb p)) -->
+ <= (0::nat) (nsum (dotdot x xa) xb)"
+ by (import hollight NSUM_POS_LE_NUMSEG)
+
+lemma NSUM_POS_EQ_0_NUMSEG: "ALL (f::nat => nat) (m::nat) n::nat.
+ (ALL p::nat. <= m p & <= p n --> <= (0::nat) (f p)) &
+ nsum (dotdot m n) f = (0::nat) -->
+ (ALL p::nat. <= m p & <= p n --> f p = (0::nat))"
+ by (import hollight NSUM_POS_EQ_0_NUMSEG)
+
+lemma NSUM_SING_NUMSEG: "ALL (x::nat => nat) xa::nat. nsum (dotdot xa xa) x = x xa"
+ by (import hollight NSUM_SING_NUMSEG)
+
+lemma NSUM_CLAUSES_NUMSEG: "(ALL x::nat.
+ nsum (dotdot x (0::nat)) (f::nat => nat) =
+ COND (x = (0::nat)) (f (0::nat)) (0::nat)) &
+(ALL (x::nat) xa::nat.
+ nsum (dotdot x (Suc xa)) f =
+ COND (<= x (Suc xa)) (nsum (dotdot x xa) f + f (Suc xa))
+ (nsum (dotdot x xa) f))"
+ by (import hollight NSUM_CLAUSES_NUMSEG)
+
+lemma NSUM_SWAP_NUMSEG: "ALL (a::nat) (b::nat) (c::nat) (d::nat) f::nat => nat => nat.
+ nsum (dotdot a b) (%i::nat. nsum (dotdot c d) (f i)) =
+ nsum (dotdot c d) (%j::nat. nsum (dotdot a b) (%i::nat. f i j))"
+ by (import hollight NSUM_SWAP_NUMSEG)
+
+lemma NSUM_ADD_SPLIT: "ALL (x::nat => nat) (xa::nat) (xb::nat) xc::nat.
+ <= xa (xb + NUMERAL_BIT1 (0::nat)) -->
+ nsum (dotdot xa (xb + xc)) x =
+ nsum (dotdot xa xb) x +
+ nsum (dotdot (xb + NUMERAL_BIT1 (0::nat)) (xb + xc)) x"
+ by (import hollight NSUM_ADD_SPLIT)
+
+lemma NSUM_OFFSET: "ALL (x::nat => nat) (xa::nat) xb::nat.
+ nsum (dotdot (xa + xb) ((n::nat) + xb)) x =
+ nsum (dotdot xa n) (%i::nat. x (i + xb))"
+ by (import hollight NSUM_OFFSET)
+
+lemma NSUM_OFFSET_0: "ALL (x::nat => nat) (xa::nat) xb::nat.
+ <= xa xb -->
+ nsum (dotdot xa xb) x =
+ nsum (dotdot (0::nat) (xb - xa)) (%i::nat. x (i + xa))"
+ by (import hollight NSUM_OFFSET_0)
+
+lemma NSUM_CLAUSES_LEFT: "ALL (x::nat => nat) (xa::nat) xb::nat.
+ <= xa xb -->
+ nsum (dotdot xa xb) x =
+ x xa + nsum (dotdot (xa + NUMERAL_BIT1 (0::nat)) xb) x"
+ by (import hollight NSUM_CLAUSES_LEFT)
+
+lemma NSUM_CLAUSES_RIGHT: "ALL (f::nat => nat) (m::nat) n::nat.
+ < (0::nat) n & <= m n -->
+ nsum (dotdot m n) f = nsum (dotdot m (n - NUMERAL_BIT1 (0::nat))) f + f n"
+ by (import hollight NSUM_CLAUSES_RIGHT)
+
+consts
+ sum :: "('q_53311::type => bool)
+=> ('q_53311::type => hollight.real) => hollight.real"
+
+defs
+ sum_def: "(op ==::(('q_53311::type => bool)
+ => ('q_53311::type => hollight.real) => hollight.real)
+ => (('q_53311::type => bool)
+ => ('q_53311::type => hollight.real) => hollight.real)
+ => prop)
+ (hollight.sum::('q_53311::type => bool)
+ => ('q_53311::type => hollight.real) => hollight.real)
+ ((iterate::(hollight.real => hollight.real => hollight.real)
+ => ('q_53311::type => bool)
+ => ('q_53311::type => hollight.real) => hollight.real)
+ (real_add::hollight.real => hollight.real => hollight.real))"
+
+lemma DEF_sum: "(op =::(('q_53311::type => bool)
+ => ('q_53311::type => hollight.real) => hollight.real)
+ => (('q_53311::type => bool)
+ => ('q_53311::type => hollight.real) => hollight.real)
+ => bool)
+ (hollight.sum::('q_53311::type => bool)
+ => ('q_53311::type => hollight.real) => hollight.real)
+ ((iterate::(hollight.real => hollight.real => hollight.real)
+ => ('q_53311::type => bool)
+ => ('q_53311::type => hollight.real) => hollight.real)
+ (real_add::hollight.real => hollight.real => hollight.real))"
+ by (import hollight DEF_sum)
+
+lemma NEUTRAL_REAL_ADD: "neutral real_add = real_of_num (0::nat)"
+ by (import hollight NEUTRAL_REAL_ADD)
+
+lemma NEUTRAL_REAL_MUL: "neutral real_mul = real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight NEUTRAL_REAL_MUL)
+
+lemma MONOIDAL_REAL_ADD: "monoidal real_add"
+ by (import hollight MONOIDAL_REAL_ADD)
+
+lemma MONOIDAL_REAL_MUL: "monoidal real_mul"
+ by (import hollight MONOIDAL_REAL_MUL)
+
+lemma SUM_CLAUSES: "(ALL x::'q_53353::type => hollight.real.
+ hollight.sum EMPTY x = real_of_num (0::nat)) &
+(ALL (x::'q_53394::type) (xa::'q_53394::type => hollight.real)
+ xb::'q_53394::type => bool.
+ FINITE xb -->
+ hollight.sum (INSERT x xb) xa =
+ COND (IN x xb) (hollight.sum xb xa)
+ (real_add (xa x) (hollight.sum xb xa)))"
+ by (import hollight SUM_CLAUSES)
+
+lemma SUM_UNION: "ALL (x::'q_53420::type => hollight.real) (xa::'q_53420::type => bool)
+ xb::'q_53420::type => bool.
+ FINITE xa & FINITE xb & DISJOINT xa xb -->
+ hollight.sum (hollight.UNION xa xb) x =
+ real_add (hollight.sum xa x) (hollight.sum xb x)"
+ by (import hollight SUM_UNION)
+
+lemma SUM_SUPPORT: "ALL (x::'q_53499::type => hollight.real) xa::'q_53499::type => bool.
+ FINITE (support real_add x xa) -->
+ hollight.sum (support real_add x xa) x = hollight.sum xa x"
+ by (import hollight SUM_SUPPORT)
+
+lemma SUM_LT: "ALL (f::'A::type => hollight.real) (g::'A::type => hollight.real)
+ s::'A::type => bool.
+ FINITE s &
+ (ALL x::'A::type. IN x s --> real_le (f x) (g x)) &
+ (EX x::'A::type. IN x s & real_lt (f x) (g x)) -->
+ real_lt (hollight.sum s f) (hollight.sum s g)"
+ by (import hollight SUM_LT)
+
+lemma SUM_LT_ALL: "ALL (f::'q_53825::type => hollight.real)
+ (g::'q_53825::type => hollight.real) s::'q_53825::type => bool.
+ FINITE s &
+ s ~= EMPTY & (ALL x::'q_53825::type. IN x s --> real_lt (f x) (g x)) -->
+ real_lt (hollight.sum s f) (hollight.sum s g)"
+ by (import hollight SUM_LT_ALL)
+
+lemma SUM_POS_LE: "ALL (x::'q_54040::type => hollight.real) xa::'q_54040::type => bool.
+ FINITE xa &
+ (ALL xb::'q_54040::type.
+ IN xb xa --> real_le (real_of_num (0::nat)) (x xb)) -->
+ real_le (real_of_num (0::nat)) (hollight.sum xa x)"
+ by (import hollight SUM_POS_LE)
+
+lemma SUM_POS_BOUND: "ALL (f::'A::type => hollight.real) (b::hollight.real) x::'A::type => bool.
+ FINITE x &
+ (ALL xa::'A::type. IN xa x --> real_le (real_of_num (0::nat)) (f xa)) &
+ real_le (hollight.sum x f) b -->
+ (ALL xa::'A::type. IN xa x --> real_le (f xa) b)"
+ by (import hollight SUM_POS_BOUND)
+
+lemma SUM_POS_EQ_0: "ALL (x::'q_54187::type => hollight.real) xa::'q_54187::type => bool.
+ FINITE xa &
+ (ALL xb::'q_54187::type.
+ IN xb xa --> real_le (real_of_num (0::nat)) (x xb)) &
+ hollight.sum xa x = real_of_num (0::nat) -->
+ (ALL xb::'q_54187::type. IN xb xa --> x xb = real_of_num (0::nat))"
+ by (import hollight SUM_POS_EQ_0)
+
+lemma SUM_SING: "ALL (x::'q_54209::type => hollight.real) xa::'q_54209::type.
+ hollight.sum (INSERT xa EMPTY) x = x xa"
+ by (import hollight SUM_SING)
+
+lemma SUM_DELTA: "ALL (x::'A::type => bool) xa::'A::type.
+ hollight.sum x
+ (%x::'A::type.
+ COND (x = xa) (b::hollight.real) (real_of_num (0::nat))) =
+ COND (IN xa x) b (real_of_num (0::nat))"
+ by (import hollight SUM_DELTA)
+
+lemma SUM_IMAGE: "ALL (x::'q_54353::type => 'q_54329::type)
+ (xa::'q_54329::type => hollight.real) xb::'q_54353::type => bool.
+ FINITE xb &
+ (ALL (xa::'q_54353::type) y::'q_54353::type.
+ IN xa xb & IN y xb & x xa = x y --> xa = y) -->
+ hollight.sum (IMAGE x xb) xa = hollight.sum xb (xa o x)"
+ by (import hollight SUM_IMAGE)
+
+lemma SUM_SUPERSET: "ALL (f::'A::type => hollight.real) (u::'A::type => bool)
+ v::'A::type => bool.
+ FINITE u &
+ SUBSET u v &
+ (ALL x::'A::type. IN x v & ~ IN x u --> f x = real_of_num (0::nat)) -->
+ hollight.sum v f = hollight.sum u f"
+ by (import hollight SUM_SUPERSET)
+
+lemma SUM_UNION_RZERO: "ALL (f::'A::type => hollight.real) (u::'A::type => bool)
+ v::'A::type => bool.
+ FINITE u &
+ (ALL x::'A::type. IN x v & ~ IN x u --> f x = real_of_num (0::nat)) -->
+ hollight.sum (hollight.UNION u v) f = hollight.sum u f"
+ by (import hollight SUM_UNION_RZERO)
+
+lemma SUM_UNION_LZERO: "ALL (f::'A::type => hollight.real) (u::'A::type => bool)
+ v::'A::type => bool.
+ FINITE v &
+ (ALL x::'A::type. IN x u & ~ IN x v --> f x = real_of_num (0::nat)) -->
+ hollight.sum (hollight.UNION u v) f = hollight.sum v f"
+ by (import hollight SUM_UNION_LZERO)
+
+lemma SUM_RESTRICT: "ALL (f::'q_54580::type => hollight.real) s::'q_54580::type => bool.
+ FINITE s -->
+ hollight.sum s
+ (%x::'q_54580::type. COND (IN x s) (f x) (real_of_num (0::nat))) =
+ hollight.sum s f"
+ by (import hollight SUM_RESTRICT)
+
+lemma SUM_BOUND_GEN: "ALL (s::'A::type => bool) (t::'q_54639::type) b::hollight.real.
+ FINITE s &
+ s ~= EMPTY &
+ (ALL x::'A::type.
+ IN x s -->
+ real_le ((f::'A::type => hollight.real) x)
+ (real_div b (real_of_num (CARD s)))) -->
+ real_le (hollight.sum s f) b"
+ by (import hollight SUM_BOUND_GEN)
+
+lemma SUM_ABS_BOUND: "ALL (s::'A::type => bool) (f::'A::type => hollight.real) b::hollight.real.
+ FINITE s & (ALL x::'A::type. IN x s --> real_le (real_abs (f x)) b) -->
+ real_le (real_abs (hollight.sum s f)) (real_mul (real_of_num (CARD s)) b)"
+ by (import hollight SUM_ABS_BOUND)
+
+lemma SUM_BOUND_LT: "ALL (s::'A::type => bool) (f::'A::type => hollight.real) b::hollight.real.
+ FINITE s &
+ (ALL x::'A::type. IN x s --> real_le (f x) b) &
+ (EX x::'A::type. IN x s & real_lt (f x) b) -->
+ real_lt (hollight.sum s f) (real_mul (real_of_num (CARD s)) b)"
+ by (import hollight SUM_BOUND_LT)
+
+lemma SUM_BOUND_LT_ALL: "ALL (s::'q_54844::type => bool) (f::'q_54844::type => hollight.real)
+ b::hollight.real.
+ FINITE s &
+ s ~= EMPTY & (ALL x::'q_54844::type. IN x s --> real_lt (f x) b) -->
+ real_lt (hollight.sum s f) (real_mul (real_of_num (CARD s)) b)"
+ by (import hollight SUM_BOUND_LT_ALL)
+
+lemma SUM_BOUND_LT_GEN: "ALL (s::'A::type => bool) (t::'q_54866::type) b::hollight.real.
+ FINITE s &
+ s ~= EMPTY &
+ (ALL x::'A::type.
+ IN x s -->
+ real_lt ((f::'A::type => hollight.real) x)
+ (real_div b (real_of_num (CARD s)))) -->
+ real_lt (hollight.sum s f) b"
+ by (import hollight SUM_BOUND_LT_GEN)
+
+lemma SUM_UNION_EQ: "ALL (s::'q_54927::type => bool) (t::'q_54927::type => bool)
+ u::'q_54927::type => bool.
+ FINITE u & hollight.INTER s t = EMPTY & hollight.UNION s t = u -->
+ real_add (hollight.sum s (f::'q_54927::type => hollight.real))
+ (hollight.sum t f) =
+ hollight.sum u f"
+ by (import hollight SUM_UNION_EQ)
+
+lemma SUM_EQ_SUPERSET: "ALL (f::'A::type => hollight.real) (s::'A::type => bool)
+ t::'A::type => bool.
+ FINITE t &
+ SUBSET t s &
+ (ALL x::'A::type. IN x t --> f x = (g::'A::type => hollight.real) x) &
+ (ALL x::'A::type. IN x s & ~ IN x t --> f x = real_of_num (0::nat)) -->
+ hollight.sum s f = hollight.sum t g"
+ by (import hollight SUM_EQ_SUPERSET)
+
+lemma SUM_RESTRICT_SET: "ALL (s::'A::type => bool) (f::'A::type => hollight.real) r::'q_55040::type.
+ FINITE s -->
+ hollight.sum
+ (GSPEC
+ (%u::'A::type.
+ EX x::'A::type. SETSPEC u (IN x s & (P::'A::type => bool) x) x))
+ f =
+ hollight.sum s (%x::'A::type. COND (P x) (f x) (real_of_num (0::nat)))"
+ by (import hollight SUM_RESTRICT_SET)
+
+lemma SUM_SUM_RESTRICT: "ALL (R::'q_55171::type => 'q_55170::type => bool)
+ (f::'q_55171::type => 'q_55170::type => hollight.real)
+ (s::'q_55171::type => bool) t::'q_55170::type => bool.
+ FINITE s & FINITE t -->
+ hollight.sum s
+ (%x::'q_55171::type.
+ hollight.sum
+ (GSPEC
+ (%u::'q_55170::type.
+ EX y::'q_55170::type. SETSPEC u (IN y t & R x y) y))
+ (f x)) =
+ hollight.sum t
+ (%y::'q_55170::type.
+ hollight.sum
+ (GSPEC
+ (%u::'q_55171::type.
+ EX x::'q_55171::type. SETSPEC u (IN x s & R x y) x))
+ (%x::'q_55171::type. f x y))"
+ by (import hollight SUM_SUM_RESTRICT)
+
+lemma CARD_EQ_SUM: "ALL x::'q_55192::type => bool.
+ FINITE x -->
+ real_of_num (CARD x) =
+ hollight.sum x (%x::'q_55192::type. real_of_num (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight CARD_EQ_SUM)
+
+lemma SUM_MULTICOUNT_GEN: "ALL (R::'A::type => 'B::type => bool) (s::'A::type => bool)
+ (t::'B::type => bool) k::'B::type => nat.
+ FINITE s &
+ FINITE t &
+ (ALL j::'B::type.
+ IN j t -->
+ CARD
+ (GSPEC
+ (%u::'A::type. EX i::'A::type. SETSPEC u (IN i s & R i j) i)) =
+ k j) -->
+ hollight.sum s
+ (%i::'A::type.
+ real_of_num
+ (CARD
+ (GSPEC
+ (%u::'B::type.
+ EX j::'B::type. SETSPEC u (IN j t & R i j) j)))) =
+ hollight.sum t (%i::'B::type. real_of_num (k i))"
+ by (import hollight SUM_MULTICOUNT_GEN)
+
+lemma SUM_MULTICOUNT: "ALL (R::'A::type => 'B::type => bool) (s::'A::type => bool)
+ (t::'B::type => bool) k::nat.
+ FINITE s &
+ FINITE t &
+ (ALL j::'B::type.
+ IN j t -->
+ CARD
+ (GSPEC
+ (%u::'A::type. EX i::'A::type. SETSPEC u (IN i s & R i j) i)) =
+ k) -->
+ hollight.sum s
+ (%i::'A::type.
+ real_of_num
+ (CARD
+ (GSPEC
+ (%u::'B::type.
+ EX j::'B::type. SETSPEC u (IN j t & R i j) j)))) =
+ real_of_num (k * CARD t)"
+ by (import hollight SUM_MULTICOUNT)
+
+lemma SUM_IMAGE_GEN: "ALL (f::'A::type => 'B::type) (g::'A::type => hollight.real)
+ s::'A::type => bool.
+ FINITE s -->
+ hollight.sum s g =
+ hollight.sum (IMAGE f s)
+ (%y::'B::type.
+ hollight.sum
+ (GSPEC
+ (%u::'A::type. EX x::'A::type. SETSPEC u (IN x s & f x = y) x))
+ g)"
+ by (import hollight SUM_IMAGE_GEN)
+
+lemma REAL_OF_NUM_SUM: "ALL (f::'q_55589::type => nat) s::'q_55589::type => bool.
+ FINITE s -->
+ real_of_num (nsum s f) =
+ hollight.sum s (%x::'q_55589::type. real_of_num (f x))"
+ by (import hollight REAL_OF_NUM_SUM)
+
+lemma SUM_SUBSET: "ALL (u::'A::type => bool) (v::'A::type => bool)
+ f::'A::type => hollight.real.
+ FINITE u &
+ FINITE v &
+ (ALL x::'A::type.
+ IN x (DIFF u v) --> real_le (f x) (real_of_num (0::nat))) &
+ (ALL x::'A::type.
+ IN x (DIFF v u) --> real_le (real_of_num (0::nat)) (f x)) -->
+ real_le (hollight.sum u f) (hollight.sum v f)"
+ by (import hollight SUM_SUBSET)
+
+lemma SUM_SUBSET_SIMPLE: "ALL (u::'A::type => bool) (v::'A::type => bool)
+ f::'A::type => hollight.real.
+ FINITE v &
+ SUBSET u v &
+ (ALL x::'A::type.
+ IN x (DIFF v u) --> real_le (real_of_num (0::nat)) (f x)) -->
+ real_le (hollight.sum u f) (hollight.sum v f)"
+ by (import hollight SUM_SUBSET_SIMPLE)
+
+lemma SUM_ADD_NUMSEG: "ALL (x::nat => hollight.real) (xa::nat => hollight.real) (xb::nat) xc::nat.
+ hollight.sum (dotdot xb xc) (%i::nat. real_add (x i) (xa i)) =
+ real_add (hollight.sum (dotdot xb xc) x) (hollight.sum (dotdot xb xc) xa)"
+ by (import hollight SUM_ADD_NUMSEG)
+
+lemma SUM_CMUL_NUMSEG: "ALL (x::nat => hollight.real) (xa::hollight.real) (xb::nat) xc::nat.
+ hollight.sum (dotdot xb xc) (%i::nat. real_mul xa (x i)) =
+ real_mul xa (hollight.sum (dotdot xb xc) x)"
+ by (import hollight SUM_CMUL_NUMSEG)
+
+lemma SUM_NEG_NUMSEG: "ALL (x::nat => hollight.real) (xa::nat) xb::nat.
+ hollight.sum (dotdot xa xb) (%i::nat. real_neg (x i)) =
+ real_neg (hollight.sum (dotdot xa xb) x)"
+ by (import hollight SUM_NEG_NUMSEG)
+
+lemma SUM_SUB_NUMSEG: "ALL (x::nat => hollight.real) (xa::nat => hollight.real) (xb::nat) xc::nat.
+ hollight.sum (dotdot xb xc) (%i::nat. real_sub (x i) (xa i)) =
+ real_sub (hollight.sum (dotdot xb xc) x) (hollight.sum (dotdot xb xc) xa)"
+ by (import hollight SUM_SUB_NUMSEG)
+
+lemma SUM_LE_NUMSEG: "ALL (x::nat => hollight.real) (xa::nat => hollight.real) (xb::nat) xc::nat.
+ (ALL i::nat. <= xb i & <= i xc --> real_le (x i) (xa i)) -->
+ real_le (hollight.sum (dotdot xb xc) x) (hollight.sum (dotdot xb xc) xa)"
+ by (import hollight SUM_LE_NUMSEG)
+
+lemma SUM_EQ_NUMSEG: "ALL (f::nat => hollight.real) (g::nat => hollight.real) (m::nat) n::nat.
+ (ALL i::nat. <= m i & <= i n --> f i = g i) -->
+ hollight.sum (dotdot m n) f = hollight.sum (dotdot m n) g"
+ by (import hollight SUM_EQ_NUMSEG)
+
+lemma SUM_ABS_NUMSEG: "ALL (x::nat => hollight.real) (xa::nat) xb::nat.
+ real_le (real_abs (hollight.sum (dotdot xa xb) x))
+ (hollight.sum (dotdot xa xb) (%i::nat. real_abs (x i)))"
+ by (import hollight SUM_ABS_NUMSEG)
+
+lemma SUM_CONST_NUMSEG: "ALL (x::hollight.real) (xa::nat) xb::nat.
+ hollight.sum (dotdot xa xb) (%n::nat. x) =
+ real_mul (real_of_num (xb + NUMERAL_BIT1 (0::nat) - xa)) x"
+ by (import hollight SUM_CONST_NUMSEG)
+
+lemma SUM_EQ_0_NUMSEG: "ALL (x::nat => hollight.real) xa::'q_56115::type.
+ (ALL i::nat.
+ <= (m::nat) i & <= i (n::nat) --> x i = real_of_num (0::nat)) -->
+ hollight.sum (dotdot m n) x = real_of_num (0::nat)"
+ by (import hollight SUM_EQ_0_NUMSEG)
+
+lemma SUM_TRIV_NUMSEG: "ALL (f::nat => hollight.real) (m::nat) n::nat.
+ < n m --> hollight.sum (dotdot m n) f = real_of_num (0::nat)"
+ by (import hollight SUM_TRIV_NUMSEG)
+
+lemma SUM_POS_LE_NUMSEG: "ALL (x::nat) (xa::nat) xb::nat => hollight.real.
+ (ALL p::nat.
+ <= x p & <= p xa --> real_le (real_of_num (0::nat)) (xb p)) -->
+ real_le (real_of_num (0::nat)) (hollight.sum (dotdot x xa) xb)"
+ by (import hollight SUM_POS_LE_NUMSEG)
+
+lemma SUM_POS_EQ_0_NUMSEG: "ALL (f::nat => hollight.real) (m::nat) n::nat.
+ (ALL p::nat. <= m p & <= p n --> real_le (real_of_num (0::nat)) (f p)) &
+ hollight.sum (dotdot m n) f = real_of_num (0::nat) -->
+ (ALL p::nat. <= m p & <= p n --> f p = real_of_num (0::nat))"
+ by (import hollight SUM_POS_EQ_0_NUMSEG)
+
+lemma SUM_SING_NUMSEG: "ALL (x::nat => hollight.real) xa::nat. hollight.sum (dotdot xa xa) x = x xa"
+ by (import hollight SUM_SING_NUMSEG)
+
+lemma SUM_CLAUSES_NUMSEG: "(ALL x::nat.
+ hollight.sum (dotdot x (0::nat)) (f::nat => hollight.real) =
+ COND (x = (0::nat)) (f (0::nat)) (real_of_num (0::nat))) &
+(ALL (x::nat) xa::nat.
+ hollight.sum (dotdot x (Suc xa)) f =
+ COND (<= x (Suc xa))
+ (real_add (hollight.sum (dotdot x xa) f) (f (Suc xa)))
+ (hollight.sum (dotdot x xa) f))"
+ by (import hollight SUM_CLAUSES_NUMSEG)
+
+lemma SUM_SWAP_NUMSEG: "ALL (a::nat) (b::nat) (c::nat) (d::nat) f::nat => nat => hollight.real.
+ hollight.sum (dotdot a b) (%i::nat. hollight.sum (dotdot c d) (f i)) =
+ hollight.sum (dotdot c d)
+ (%j::nat. hollight.sum (dotdot a b) (%i::nat. f i j))"
+ by (import hollight SUM_SWAP_NUMSEG)
+
+lemma SUM_ADD_SPLIT: "ALL (x::nat => hollight.real) (xa::nat) (xb::nat) xc::nat.
+ <= xa (xb + NUMERAL_BIT1 (0::nat)) -->
+ hollight.sum (dotdot xa (xb + xc)) x =
+ real_add (hollight.sum (dotdot xa xb) x)
+ (hollight.sum (dotdot (xb + NUMERAL_BIT1 (0::nat)) (xb + xc)) x)"
+ by (import hollight SUM_ADD_SPLIT)
+
+lemma SUM_OFFSET_0: "ALL (x::nat => hollight.real) (xa::nat) xb::nat.
+ <= xa xb -->
+ hollight.sum (dotdot xa xb) x =
+ hollight.sum (dotdot (0::nat) (xb - xa)) (%i::nat. x (i + xa))"
+ by (import hollight SUM_OFFSET_0)
+
+lemma SUM_CLAUSES_LEFT: "ALL (x::nat => hollight.real) (xa::nat) xb::nat.
+ <= xa xb -->
+ hollight.sum (dotdot xa xb) x =
+ real_add (x xa) (hollight.sum (dotdot (xa + NUMERAL_BIT1 (0::nat)) xb) x)"
+ by (import hollight SUM_CLAUSES_LEFT)
+
+lemma SUM_CLAUSES_RIGHT: "ALL (f::nat => hollight.real) (m::nat) n::nat.
+ < (0::nat) n & <= m n -->
+ hollight.sum (dotdot m n) f =
+ real_add (hollight.sum (dotdot m (n - NUMERAL_BIT1 (0::nat))) f) (f n)"
+ by (import hollight SUM_CLAUSES_RIGHT)
+
+lemma REAL_OF_NUM_SUM_NUMSEG: "ALL (x::nat => nat) (xa::nat) xb::nat.
+ real_of_num (nsum (dotdot xa xb) x) =
+ hollight.sum (dotdot xa xb) (%i::nat. real_of_num (x i))"
+ by (import hollight REAL_OF_NUM_SUM_NUMSEG)
+
+constdefs
+ CASEWISE :: "(('q_56787::type => 'q_56791::type) *
+ ('q_56792::type => 'q_56787::type => 'q_56751::type)) hollight.list
+=> 'q_56792::type => 'q_56791::type => 'q_56751::type"
+ "CASEWISE ==
+SOME CASEWISE::(('q_56787::type => 'q_56791::type) *
+ ('q_56792::type
+ => 'q_56787::type => 'q_56751::type)) hollight.list
+ => 'q_56792::type => 'q_56791::type => 'q_56751::type.
+ (ALL (f::'q_56792::type) x::'q_56791::type.
+ CASEWISE NIL f x = (SOME y::'q_56751::type. True)) &
+ (ALL (h::('q_56787::type => 'q_56791::type) *
+ ('q_56792::type => 'q_56787::type => 'q_56751::type))
+ (t::(('q_56787::type => 'q_56791::type) *
+ ('q_56792::type
+ => 'q_56787::type => 'q_56751::type)) hollight.list)
+ (f::'q_56792::type) x::'q_56791::type.
+ CASEWISE (CONS h t) f x =
+ COND (EX y::'q_56787::type. fst h y = x)
+ (snd h f (SOME y::'q_56787::type. fst h y = x)) (CASEWISE t f x))"
+
+lemma DEF_CASEWISE: "CASEWISE =
+(SOME CASEWISE::(('q_56787::type => 'q_56791::type) *
+ ('q_56792::type
+ => 'q_56787::type => 'q_56751::type)) hollight.list
+ => 'q_56792::type => 'q_56791::type => 'q_56751::type.
+ (ALL (f::'q_56792::type) x::'q_56791::type.
+ CASEWISE NIL f x = (SOME y::'q_56751::type. True)) &
+ (ALL (h::('q_56787::type => 'q_56791::type) *
+ ('q_56792::type => 'q_56787::type => 'q_56751::type))
+ (t::(('q_56787::type => 'q_56791::type) *
+ ('q_56792::type
+ => 'q_56787::type => 'q_56751::type)) hollight.list)
+ (f::'q_56792::type) x::'q_56791::type.
+ CASEWISE (CONS h t) f x =
+ COND (EX y::'q_56787::type. fst h y = x)
+ (snd h f (SOME y::'q_56787::type. fst h y = x)) (CASEWISE t f x)))"
+ by (import hollight DEF_CASEWISE)
+
+lemma CASEWISE: "(op &::bool => bool => bool)
+ ((op =::'q_56811::type => 'q_56811::type => bool)
+ ((CASEWISE::(('q_56803::type => 'q_56851::type) *
+ ('q_56852::type
+ => 'q_56803::type => 'q_56811::type)) hollight.list
+ => 'q_56852::type => 'q_56851::type => 'q_56811::type)
+ (NIL::(('q_56803::type => 'q_56851::type) *
+ ('q_56852::type
+ => 'q_56803::type => 'q_56811::type)) hollight.list)
+ (f::'q_56852::type) (x::'q_56851::type))
+ ((Eps::('q_56811::type => bool) => 'q_56811::type)
+ (%y::'q_56811::type. True::bool)))
+ ((op =::'q_56812::type => 'q_56812::type => bool)
+ ((CASEWISE::(('q_56854::type => 'q_56851::type) *
+ ('q_56852::type
+ => 'q_56854::type => 'q_56812::type)) hollight.list
+ => 'q_56852::type => 'q_56851::type => 'q_56812::type)
+ ((CONS::('q_56854::type => 'q_56851::type) *
+ ('q_56852::type => 'q_56854::type => 'q_56812::type)
+ => (('q_56854::type => 'q_56851::type) *
+ ('q_56852::type
+ => 'q_56854::type => 'q_56812::type)) hollight.list
+ => (('q_56854::type => 'q_56851::type) *
+ ('q_56852::type
+ => 'q_56854::type => 'q_56812::type)) hollight.list)
+ ((Pair::('q_56854::type => 'q_56851::type)
+ => ('q_56852::type => 'q_56854::type => 'q_56812::type)
+ => ('q_56854::type => 'q_56851::type) *
+ ('q_56852::type => 'q_56854::type => 'q_56812::type))
+ (s::'q_56854::type => 'q_56851::type)
+ (t::'q_56852::type => 'q_56854::type => 'q_56812::type))
+ (clauses::(('q_56854::type => 'q_56851::type) *
+ ('q_56852::type
+ => 'q_56854::type => 'q_56812::type)) hollight.list))
+ f x)
+ ((COND::bool => 'q_56812::type => 'q_56812::type => 'q_56812::type)
+ ((Ex::('q_56854::type => bool) => bool)
+ (%y::'q_56854::type.
+ (op =::'q_56851::type => 'q_56851::type => bool) (s y) x))
+ (t f ((Eps::('q_56854::type => bool) => 'q_56854::type)
+ (%y::'q_56854::type.
+ (op =::'q_56851::type => 'q_56851::type => bool) (s y) x)))
+ ((CASEWISE::(('q_56854::type => 'q_56851::type) *
+ ('q_56852::type
+ => 'q_56854::type => 'q_56812::type)) hollight.list
+ => 'q_56852::type => 'q_56851::type => 'q_56812::type)
+ clauses f x)))"
+ by (import hollight CASEWISE)
+
+lemma CASEWISE_CASES: "ALL (clauses::(('q_56946::type => 'q_56943::type) *
+ ('q_56944::type
+ => 'q_56946::type => 'q_56953::type)) hollight.list)
+ (c::'q_56944::type) x::'q_56943::type.
+ (EX (s::'q_56946::type => 'q_56943::type)
+ (t::'q_56944::type => 'q_56946::type => 'q_56953::type)
+ a::'q_56946::type.
+ MEM (s, t) clauses & s a = x & CASEWISE clauses c x = t c a) |
+ ~ (EX (s::'q_56946::type => 'q_56943::type)
+ (t::'q_56944::type => 'q_56946::type => 'q_56953::type)
+ a::'q_56946::type. MEM (s, t) clauses & s a = x) &
+ CASEWISE clauses c x = (SOME y::'q_56953::type. True)"
+ by (import hollight CASEWISE_CASES)
+
+lemma CASEWISE_WORKS: "ALL (x::(('P::type => 'A::type) *
+ ('C::type => 'P::type => 'B::type)) hollight.list)
+ xa::'C::type.
+ (ALL (s::'P::type => 'A::type) (t::'C::type => 'P::type => 'B::type)
+ (s'::'P::type => 'A::type) (t'::'C::type => 'P::type => 'B::type)
+ (xb::'P::type) y::'P::type.
+ MEM (s, t) x & MEM (s', t') x & s xb = s' y -->
+ t xa xb = t' xa y) -->
+ ALL_list
+ (GABS
+ (%f::('P::type => 'A::type) * ('C::type => 'P::type => 'B::type)
+ => bool.
+ ALL (s::'P::type => 'A::type) t::'C::type => 'P::type => 'B::type.
+ GEQ (f (s, t))
+ (ALL xb::'P::type. CASEWISE x xa (s xb) = t xa xb)))
+ x"
+ by (import hollight CASEWISE_WORKS)
+
+constdefs
+ admissible :: "('q_57089::type => 'q_57082::type => bool)
+=> (('q_57089::type => 'q_57085::type) => 'q_57095::type => bool)
+ => ('q_57095::type => 'q_57082::type)
+ => (('q_57089::type => 'q_57085::type)
+ => 'q_57095::type => 'q_57090::type)
+ => bool"
+ "admissible ==
+%(u::'q_57089::type => 'q_57082::type => bool)
+ (ua::('q_57089::type => 'q_57085::type) => 'q_57095::type => bool)
+ (ub::'q_57095::type => 'q_57082::type)
+ uc::('q_57089::type => 'q_57085::type)
+ => 'q_57095::type => 'q_57090::type.
+ ALL (f::'q_57089::type => 'q_57085::type)
+ (g::'q_57089::type => 'q_57085::type) a::'q_57095::type.
+ ua f a &
+ ua g a & (ALL z::'q_57089::type. u z (ub a) --> f z = g z) -->
+ uc f a = uc g a"
+
+lemma DEF_admissible: "admissible =
+(%(u::'q_57089::type => 'q_57082::type => bool)
+ (ua::('q_57089::type => 'q_57085::type) => 'q_57095::type => bool)
+ (ub::'q_57095::type => 'q_57082::type)
+ uc::('q_57089::type => 'q_57085::type)
+ => 'q_57095::type => 'q_57090::type.
+ ALL (f::'q_57089::type => 'q_57085::type)
+ (g::'q_57089::type => 'q_57085::type) a::'q_57095::type.
+ ua f a &
+ ua g a & (ALL z::'q_57089::type. u z (ub a) --> f z = g z) -->
+ uc f a = uc g a)"
+ by (import hollight DEF_admissible)
+
+constdefs
+ tailadmissible :: "('A::type => 'A::type => bool)
+=> (('A::type => 'B::type) => 'P::type => bool)
+ => ('P::type => 'A::type)
+ => (('A::type => 'B::type) => 'P::type => 'B::type) => bool"
+ "tailadmissible ==
+%(u::'A::type => 'A::type => bool)
+ (ua::('A::type => 'B::type) => 'P::type => bool)
+ (ub::'P::type => 'A::type)
+ uc::('A::type => 'B::type) => 'P::type => 'B::type.
+ EX (P::('A::type => 'B::type) => 'P::type => bool)
+ (G::('A::type => 'B::type) => 'P::type => 'A::type)
+ H::('A::type => 'B::type) => 'P::type => 'B::type.
+ (ALL (f::'A::type => 'B::type) (a::'P::type) y::'A::type.
+ P f a & u y (G f a) --> u y (ub a)) &
+ (ALL (f::'A::type => 'B::type) (g::'A::type => 'B::type) a::'P::type.
+ (ALL z::'A::type. u z (ub a) --> f z = g z) -->
+ P f a = P g a & G f a = G g a & H f a = H g a) &
+ (ALL (f::'A::type => 'B::type) a::'P::type.
+ ua f a --> uc f a = COND (P f a) (f (G f a)) (H f a))"
+
+lemma DEF_tailadmissible: "tailadmissible =
+(%(u::'A::type => 'A::type => bool)
+ (ua::('A::type => 'B::type) => 'P::type => bool)
+ (ub::'P::type => 'A::type)
+ uc::('A::type => 'B::type) => 'P::type => 'B::type.
+ EX (P::('A::type => 'B::type) => 'P::type => bool)
+ (G::('A::type => 'B::type) => 'P::type => 'A::type)
+ H::('A::type => 'B::type) => 'P::type => 'B::type.
+ (ALL (f::'A::type => 'B::type) (a::'P::type) y::'A::type.
+ P f a & u y (G f a) --> u y (ub a)) &
+ (ALL (f::'A::type => 'B::type) (g::'A::type => 'B::type) a::'P::type.
+ (ALL z::'A::type. u z (ub a) --> f z = g z) -->
+ P f a = P g a & G f a = G g a & H f a = H g a) &
+ (ALL (f::'A::type => 'B::type) a::'P::type.
+ ua f a --> uc f a = COND (P f a) (f (G f a)) (H f a)))"
+ by (import hollight DEF_tailadmissible)
+
+constdefs
+ superadmissible :: "('q_57239::type => 'q_57239::type => bool)
+=> (('q_57239::type => 'q_57241::type) => 'q_57247::type => bool)
+ => ('q_57247::type => 'q_57239::type)
+ => (('q_57239::type => 'q_57241::type)
+ => 'q_57247::type => 'q_57241::type)
+ => bool"
+ "superadmissible ==
+%(u::'q_57239::type => 'q_57239::type => bool)
+ (ua::('q_57239::type => 'q_57241::type) => 'q_57247::type => bool)
+ (ub::'q_57247::type => 'q_57239::type)
+ uc::('q_57239::type => 'q_57241::type)
+ => 'q_57247::type => 'q_57241::type.
+ admissible u
+ (%(f::'q_57239::type => 'q_57241::type) a::'q_57247::type. True) ub
+ ua -->
+ tailadmissible u ua ub uc"
+
+lemma DEF_superadmissible: "superadmissible =
+(%(u::'q_57239::type => 'q_57239::type => bool)
+ (ua::('q_57239::type => 'q_57241::type) => 'q_57247::type => bool)
+ (ub::'q_57247::type => 'q_57239::type)
+ uc::('q_57239::type => 'q_57241::type)
+ => 'q_57247::type => 'q_57241::type.
+ admissible u
+ (%(f::'q_57239::type => 'q_57241::type) a::'q_57247::type. True) ub
+ ua -->
+ tailadmissible u ua ub uc)"
+ by (import hollight DEF_superadmissible)
+
+lemma SUPERADMISSIBLE_COND: "ALL (x::'A::type => 'A::type => bool)
+ (xa::('A::type => 'B::type) => 'P::type => bool)
+ (xb::('A::type => 'B::type) => 'P::type => bool)
+ (xc::'P::type => 'A::type)
+ (xd::('A::type => 'B::type) => 'P::type => 'B::type)
+ xe::('A::type => 'B::type) => 'P::type => 'B::type.
+ admissible x xa xc xb &
+ superadmissible x
+ (%(f::'A::type => 'B::type) x::'P::type. xa f x & xb f x) xc xd &
+ superadmissible x
+ (%(f::'A::type => 'B::type) x::'P::type. xa f x & ~ xb f x) xc xe -->
+ superadmissible x xa xc
+ (%(f::'A::type => 'B::type) x::'P::type.
+ COND (xb f x) (xd f x) (xe f x))"
+ by (import hollight SUPERADMISSIBLE_COND)
+
+lemma ADMISSIBLE_IMP_SUPERADMISSIBLE: "ALL (x::'A::type => 'A::type => bool)
+ (xa::('A::type => 'B::type) => 'P::type => bool)
+ (xb::'P::type => 'A::type)
+ xc::('A::type => 'B::type) => 'P::type => 'B::type.
+ admissible x xa xb xc --> superadmissible x xa xb xc"
+ by (import hollight ADMISSIBLE_IMP_SUPERADMISSIBLE)
+
+lemma TAIL_IMP_SUPERADMISSIBLE: "ALL (x::'A::type => 'A::type => bool)
+ (xa::('A::type => 'B::type) => 'P::type => bool)
+ (xb::'P::type => 'A::type)
+ xc::('A::type => 'B::type) => 'P::type => 'A::type.
+ admissible x xa xb xc &
+ (ALL (f::'A::type => 'B::type) a::'P::type.
+ xa f a --> (ALL y::'A::type. x y (xc f a) --> x y (xb a))) -->
+ superadmissible x xa xb
+ (%(f::'A::type => 'B::type) x::'P::type. f (xc f x))"
+ by (import hollight TAIL_IMP_SUPERADMISSIBLE)
+
+lemma ADMISSIBLE_COND: "ALL (u_354::'A::type => 'q_57627::type => bool)
+ (p::('A::type => 'B::type) => 'P::type => bool)
+ (P::('A::type => 'B::type) => 'P::type => bool)
+ (s::'P::type => 'q_57627::type)
+ (h::('A::type => 'B::type) => 'P::type => 'B::type)
+ k::('A::type => 'B::type) => 'P::type => 'B::type.
+ admissible u_354 p s P &
+ admissible u_354 (%(f::'A::type => 'B::type) x::'P::type. p f x & P f x)
+ s h &
+ admissible u_354
+ (%(f::'A::type => 'B::type) x::'P::type. p f x & ~ P f x) s k -->
+ admissible u_354 p s
+ (%(f::'A::type => 'B::type) x::'P::type. COND (P f x) (h f x) (k f x))"
+ by (import hollight ADMISSIBLE_COND)
+
+lemma ADMISSIBLE_CONST: "admissible (u_354::'q_57702::type => 'q_57701::type => bool)
+ (p::('q_57702::type => 'q_57703::type) => 'q_57704::type => bool)
+ (s::'q_57704::type => 'q_57701::type)
+ (%f::'q_57702::type => 'q_57703::type. c::'q_57704::type => 'q_57705::type)"
+ by (import hollight ADMISSIBLE_CONST)
+
+lemma ADMISSIBLE_COMB: "ALL (x::'A::type => 'A::type => bool)
+ (xa::('A::type => 'B::type) => 'P::type => bool)
+ (xb::'P::type => 'A::type)
+ (xc::('A::type => 'B::type) => 'P::type => 'C::type => 'D::type)
+ xd::('A::type => 'B::type) => 'P::type => 'C::type.
+ admissible x xa xb xc & admissible x xa xb xd -->
+ admissible x xa xb
+ (%(f::'A::type => 'B::type) x::'P::type. xc f x (xd f x))"
+ by (import hollight ADMISSIBLE_COMB)
+
+lemma ADMISSIBLE_BASE: "ALL (x::'A::type => 'A::type => bool)
+ (xa::('A::type => 'B::type) => 'P::type => bool)
+ (xb::'P::type => 'A::type) xc::'P::type => 'A::type.
+ (ALL (f::'A::type => 'B::type) a::'P::type.
+ xa f a --> x (xc a) (xb a)) -->
+ admissible x xa xb (%(f::'A::type => 'B::type) x::'P::type. f (xc x))"
+ by (import hollight ADMISSIBLE_BASE)
+
+lemma ADMISSIBLE_NEST: "ALL (x::'A::type => 'A::type => bool)
+ (xa::('A::type => 'B::type) => 'P::type => bool)
+ (xb::'P::type => 'A::type)
+ xc::('A::type => 'B::type) => 'P::type => 'A::type.
+ admissible x xa xb xc &
+ (ALL (f::'A::type => 'B::type) a::'P::type.
+ xa f a --> x (xc f a) (xb a)) -->
+ admissible x xa xb (%(f::'A::type => 'B::type) x::'P::type. f (xc f x))"
+ by (import hollight ADMISSIBLE_NEST)
+
+lemma ADMISSIBLE_LAMBDA: "ALL (x::'A::type => 'A::type => bool)
+ (xa::('A::type => 'B::type) => 'P::type => bool)
+ (xb::'P::type => 'A::type)
+ xc::'C::type => ('A::type => 'B::type) => 'P::type => 'D::type.
+ (ALL xd::'C::type. admissible x xa xb (xc xd)) -->
+ admissible x xa xb
+ (%(f::'A::type => 'B::type) (x::'P::type) u::'C::type. xc u f x)"
+ by (import hollight ADMISSIBLE_LAMBDA)
+
+lemma WF_REC_CASES: "ALL (u_354::'A::type => 'A::type => bool)
+ clauses::(('P::type => 'A::type) *
+ (('A::type => 'B::type)
+ => 'P::type => 'B::type)) hollight.list.
+ WF u_354 &
+ ALL_list
+ (GABS
+ (%f::('P::type => 'A::type) *
+ (('A::type => 'B::type) => 'P::type => 'B::type)
+ => bool.
+ ALL (s::'P::type => 'A::type)
+ t::('A::type => 'B::type) => 'P::type => 'B::type.
+ GEQ (f (s, t))
+ (EX (P::('A::type => 'B::type) => 'P::type => bool)
+ (G::('A::type => 'B::type) => 'P::type => 'A::type)
+ H::('A::type => 'B::type) => 'P::type => 'B::type.
+ (ALL (f::'A::type => 'B::type) (a::'P::type) y::'A::type.
+ P f a & u_354 y (G f a) --> u_354 y (s a)) &
+ (ALL (f::'A::type => 'B::type) (g::'A::type => 'B::type)
+ a::'P::type.
+ (ALL z::'A::type. u_354 z (s a) --> f z = g z) -->
+ P f a = P g a & G f a = G g a & H f a = H g a) &
+ (ALL (f::'A::type => 'B::type) a::'P::type.
+ t f a = COND (P f a) (f (G f a)) (H f a)))))
+ clauses -->
+ (EX f::'A::type => 'B::type. ALL x::'A::type. f x = CASEWISE clauses f x)"
+ by (import hollight WF_REC_CASES)
+
+lemma RECURSION_CASEWISE: "ALL clauses::(('P::type => 'A::type) *
+ (('A::type => 'B::type)
+ => 'P::type => 'B::type)) hollight.list.
+ (EX u::'A::type => 'A::type => bool.
+ WF u &
+ ALL_list
+ (GABS
+ (%f::('P::type => 'A::type) *
+ (('A::type => 'B::type) => 'P::type => 'B::type)
+ => bool.
+ ALL (s::'P::type => 'A::type)
+ t::('A::type => 'B::type) => 'P::type => 'B::type.
+ GEQ (f (s, t))
+ (tailadmissible u
+ (%(f::'A::type => 'B::type) a::'P::type. True) s t)))
+ clauses) &
+ (ALL (x::'P::type => 'A::type)
+ (xa::('A::type => 'B::type) => 'P::type => 'B::type)
+ (xb::'P::type => 'A::type)
+ (xc::('A::type => 'B::type) => 'P::type => 'B::type)
+ (xd::'A::type => 'B::type) (xe::'P::type) xf::'P::type.
+ MEM (x, xa) clauses & MEM (xb, xc) clauses -->
+ x xe = xb xf --> xa xd xe = xc xd xf) -->
+ (EX f::'A::type => 'B::type.
+ ALL_list
+ (GABS
+ (%fa::('P::type => 'A::type) *
+ (('A::type => 'B::type) => 'P::type => 'B::type)
+ => bool.
+ ALL (s::'P::type => 'A::type)
+ t::('A::type => 'B::type) => 'P::type => 'B::type.
+ GEQ (fa (s, t)) (ALL x::'P::type. f (s x) = t f x)))
+ clauses)"
+ by (import hollight RECURSION_CASEWISE)
+
+lemma cth: "ALL (p1::'A::type => 'q_58634::type)
+ (p2::'q_58645::type => 'A::type => 'q_58639::type)
+ (p1'::'A::type => 'q_58634::type)
+ p2'::'q_58645::type => 'A::type => 'q_58639::type.
+ (ALL (c::'q_58645::type) (x::'A::type) y::'A::type.
+ p1 x = p1' y --> p2 c x = p2' c y) -->
+ (ALL (c::'q_58645::type) (x::'A::type) y::'A::type.
+ p1' x = p1 y --> p2' c x = p2 c y)"
+ by (import hollight cth)
+
+lemma RECURSION_CASEWISE_PAIRWISE: "ALL x::(('q_58682::type => 'q_58662::type) *
+ (('q_58662::type => 'q_58678::type)
+ => 'q_58682::type => 'q_58678::type)) hollight.list.
+ (EX u::'q_58662::type => 'q_58662::type => bool.
+ WF u &
+ ALL_list
+ (GABS
+ (%f::('q_58682::type => 'q_58662::type) *
+ (('q_58662::type => 'q_58678::type)
+ => 'q_58682::type => 'q_58678::type)
+ => bool.
+ ALL (s::'q_58682::type => 'q_58662::type)
+ t::('q_58662::type => 'q_58678::type)
+ => 'q_58682::type => 'q_58678::type.
+ GEQ (f (s, t))
+ (tailadmissible u
+ (%(f::'q_58662::type => 'q_58678::type)
+ a::'q_58682::type. True)
+ s t)))
+ x) &
+ ALL_list
+ (GABS
+ (%f::('q_58682::type => 'q_58662::type) *
+ (('q_58662::type => 'q_58678::type)
+ => 'q_58682::type => 'q_58678::type)
+ => bool.
+ ALL (a::'q_58682::type => 'q_58662::type)
+ b::('q_58662::type => 'q_58678::type)
+ => 'q_58682::type => 'q_58678::type.
+ GEQ (f (a, b))
+ (ALL (c::'q_58662::type => 'q_58678::type) (x::'q_58682::type)
+ y::'q_58682::type. a x = a y --> b c x = b c y)))
+ x &
+ PAIRWISE
+ (GABS
+ (%f::('q_58682::type => 'q_58662::type) *
+ (('q_58662::type => 'q_58678::type)
+ => 'q_58682::type => 'q_58678::type)
+ => ('q_58682::type => 'q_58662::type) *
+ (('q_58662::type => 'q_58678::type)
+ => 'q_58682::type => 'q_58678::type)
+ => bool.
+ ALL (s::'q_58682::type => 'q_58662::type)
+ t::('q_58662::type => 'q_58678::type)
+ => 'q_58682::type => 'q_58678::type.
+ GEQ (f (s, t))
+ (GABS
+ (%f::('q_58682::type => 'q_58662::type) *
+ (('q_58662::type => 'q_58678::type)
+ => 'q_58682::type => 'q_58678::type)
+ => bool.
+ ALL (s'::'q_58682::type => 'q_58662::type)
+ t'::('q_58662::type => 'q_58678::type)
+ => 'q_58682::type => 'q_58678::type.
+ GEQ (f (s', t'))
+ (ALL (c::'q_58662::type => 'q_58678::type)
+ (x::'q_58682::type) y::'q_58682::type.
+ s x = s' y --> t c x = t' c y)))))
+ x -->
+ (EX f::'q_58662::type => 'q_58678::type.
+ ALL_list
+ (GABS
+ (%fa::('q_58682::type => 'q_58662::type) *
+ (('q_58662::type => 'q_58678::type)
+ => 'q_58682::type => 'q_58678::type)
+ => bool.
+ ALL (s::'q_58682::type => 'q_58662::type)
+ t::('q_58662::type => 'q_58678::type)
+ => 'q_58682::type => 'q_58678::type.
+ GEQ (fa (s, t)) (ALL x::'q_58682::type. f (s x) = t f x)))
+ x)"
+ by (import hollight RECURSION_CASEWISE_PAIRWISE)
+
+lemma SUPERADMISSIBLE_T: "superadmissible (u_354::'q_58792::type => 'q_58792::type => bool)
+ (%(f::'q_58792::type => 'q_58794::type) x::'q_58798::type. True)
+ (s::'q_58798::type => 'q_58792::type)
+ (t::('q_58792::type => 'q_58794::type)
+ => 'q_58798::type => 'q_58794::type) =
+tailadmissible u_354
+ (%(f::'q_58792::type => 'q_58794::type) x::'q_58798::type. True) s t"
+ by (import hollight SUPERADMISSIBLE_T)
+
+lemma SUB_SUB: "ALL (x::nat) xa::nat. <= xa x --> (ALL a::nat. a - (x - xa) = a + xa - x)"
+ by (import hollight SUB_SUB)
+
+lemma SUB_OLD: "(ALL m::nat. (0::nat) - m = (0::nat)) &
+(ALL (m::nat) n::nat. Suc m - n = COND (< m n) (0::nat) (Suc (m - n)))"
+ by (import hollight SUB_OLD)
+
+lemma real_le: "ALL (x::hollight.real) xa::hollight.real. real_le x xa = (~ real_lt xa x)"
+ by (import hollight real_le)
+
+lemma REAL_MUL_RID: "ALL x::hollight.real. real_mul x (real_of_num (NUMERAL_BIT1 (0::nat))) = x"
+ by (import hollight REAL_MUL_RID)
+
+lemma REAL_MUL_RINV: "ALL x::hollight.real.
+ x ~= real_of_num (0::nat) -->
+ real_mul x (real_inv x) = real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight REAL_MUL_RINV)
+
+lemma REAL_RDISTRIB: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_mul (real_add x y) z = real_add (real_mul x z) (real_mul y z)"
+ by (import hollight REAL_RDISTRIB)
+
+lemma REAL_EQ_LADD: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ (real_add x y = real_add x z) = (y = z)"
+ by (import hollight REAL_EQ_LADD)
+
+lemma REAL_EQ_RADD: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ (real_add x z = real_add y z) = (x = y)"
+ by (import hollight REAL_EQ_RADD)
+
+lemma REAL_ADD_LID_UNIQ: "ALL (x::hollight.real) y::hollight.real.
+ (real_add x y = y) = (x = real_of_num (0::nat))"
+ by (import hollight REAL_ADD_LID_UNIQ)
+
+lemma REAL_ADD_RID_UNIQ: "ALL (x::hollight.real) y::hollight.real.
+ (real_add x y = x) = (y = real_of_num (0::nat))"
+ by (import hollight REAL_ADD_RID_UNIQ)
+
+lemma REAL_LNEG_UNIQ: "ALL (x::hollight.real) y::hollight.real.
+ (real_add x y = real_of_num (0::nat)) = (x = real_neg y)"
+ by (import hollight REAL_LNEG_UNIQ)
+
+lemma REAL_RNEG_UNIQ: "ALL (x::hollight.real) y::hollight.real.
+ (real_add x y = real_of_num (0::nat)) = (y = real_neg x)"
+ by (import hollight REAL_RNEG_UNIQ)
+
+lemma REAL_NEG_ADD: "ALL (x::hollight.real) y::hollight.real.
+ real_neg (real_add x y) = real_add (real_neg x) (real_neg y)"
+ by (import hollight REAL_NEG_ADD)
+
+lemma REAL_MUL_LZERO: "ALL x::hollight.real.
+ real_mul (real_of_num (0::nat)) x = real_of_num (0::nat)"
+ by (import hollight REAL_MUL_LZERO)
+
+lemma REAL_MUL_RZERO: "ALL x::hollight.real.
+ real_mul x (real_of_num (0::nat)) = real_of_num (0::nat)"
+ by (import hollight REAL_MUL_RZERO)
+
+lemma REAL_NEG_LMUL: "ALL (x::hollight.real) y::hollight.real.
+ real_neg (real_mul x y) = real_mul (real_neg x) y"
+ by (import hollight REAL_NEG_LMUL)
+
+lemma REAL_NEG_RMUL: "ALL (x::hollight.real) y::hollight.real.
+ real_neg (real_mul x y) = real_mul x (real_neg y)"
+ by (import hollight REAL_NEG_RMUL)
+
+lemma REAL_NEGNEG: "ALL x::hollight.real. real_neg (real_neg x) = x"
+ by (import hollight REAL_NEGNEG)
+
+lemma REAL_NEG_MUL2: "ALL (x::hollight.real) xa::hollight.real.
+ real_mul (real_neg x) (real_neg xa) = real_mul x xa"
+ by (import hollight REAL_NEG_MUL2)
+
+lemma REAL_LT_LADD: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_add x y) (real_add x z) = real_lt y z"
+ by (import hollight REAL_LT_LADD)
+
+lemma REAL_LT_RADD: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_add x z) (real_add y z) = real_lt x y"
+ by (import hollight REAL_LT_RADD)
+
+lemma REAL_NOT_LT: "ALL (x::hollight.real) y::hollight.real. (~ real_lt x y) = real_le y x"
+ by (import hollight REAL_NOT_LT)
+
+lemma REAL_LT_ANTISYM: "ALL (x::hollight.real) y::hollight.real. ~ (real_lt x y & real_lt y x)"
+ by (import hollight REAL_LT_ANTISYM)
+
+lemma REAL_LT_GT: "ALL (x::hollight.real) y::hollight.real. real_lt x y --> ~ real_lt y x"
+ by (import hollight REAL_LT_GT)
+
+lemma REAL_LE_TOTAL: "ALL (x::hollight.real) y::hollight.real. real_le x y | real_le y x"
+ by (import hollight REAL_LE_TOTAL)
+
+lemma REAL_LE_REFL: "ALL x::hollight.real. real_le x x"
+ by (import hollight REAL_LE_REFL)
+
+lemma REAL_LE_LT: "ALL (x::hollight.real) y::hollight.real. real_le x y = (real_lt x y | x = y)"
+ by (import hollight REAL_LE_LT)
+
+lemma REAL_LT_LE: "ALL (x::hollight.real) y::hollight.real.
+ real_lt x y = (real_le x y & x ~= y)"
+ by (import hollight REAL_LT_LE)
+
+lemma REAL_LT_IMP_LE: "ALL (x::hollight.real) y::hollight.real. real_lt x y --> real_le x y"
+ by (import hollight REAL_LT_IMP_LE)
+
+lemma REAL_LTE_TRANS: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt x y & real_le y z --> real_lt x z"
+ by (import hollight REAL_LTE_TRANS)
+
+lemma REAL_LE_TRANS: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_le x y & real_le y z --> real_le x z"
+ by (import hollight REAL_LE_TRANS)
+
+lemma REAL_NEG_LT0: "ALL x::hollight.real.
+ real_lt (real_neg x) (real_of_num (0::nat)) =
+ real_lt (real_of_num (0::nat)) x"
+ by (import hollight REAL_NEG_LT0)
+
+lemma REAL_NEG_GT0: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) (real_neg x) =
+ real_lt x (real_of_num (0::nat))"
+ by (import hollight REAL_NEG_GT0)
+
+lemma REAL_NEG_LE0: "ALL x::hollight.real.
+ real_le (real_neg x) (real_of_num (0::nat)) =
+ real_le (real_of_num (0::nat)) x"
+ by (import hollight REAL_NEG_LE0)
+
+lemma REAL_NEG_GE0: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) (real_neg x) =
+ real_le x (real_of_num (0::nat))"
+ by (import hollight REAL_NEG_GE0)
+
+lemma REAL_LT_NEGTOTAL: "ALL x::hollight.real.
+ x = real_of_num (0::nat) |
+ real_lt (real_of_num (0::nat)) x |
+ real_lt (real_of_num (0::nat)) (real_neg x)"
+ by (import hollight REAL_LT_NEGTOTAL)
+
+lemma REAL_LE_NEGTOTAL: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) x |
+ real_le (real_of_num (0::nat)) (real_neg x)"
+ by (import hollight REAL_LE_NEGTOTAL)
+
+lemma REAL_LE_MUL: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le (real_of_num (0::nat)) y -->
+ real_le (real_of_num (0::nat)) (real_mul x y)"
+ by (import hollight REAL_LE_MUL)
+
+lemma REAL_LE_SQUARE: "ALL x::hollight.real. real_le (real_of_num (0::nat)) (real_mul x x)"
+ by (import hollight REAL_LE_SQUARE)
+
+lemma REAL_LT_01: "real_lt (real_of_num (0::nat)) (real_of_num (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight REAL_LT_01)
+
+lemma REAL_LE_LADD: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_le (real_add x y) (real_add x z) = real_le y z"
+ by (import hollight REAL_LE_LADD)
+
+lemma REAL_LE_RADD: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_le (real_add x z) (real_add y z) = real_le x y"
+ by (import hollight REAL_LE_RADD)
+
+lemma REAL_LT_ADD2: "ALL (w::hollight.real) (x::hollight.real) (y::hollight.real)
+ z::hollight.real.
+ real_lt w x & real_lt y z --> real_lt (real_add w y) (real_add x z)"
+ by (import hollight REAL_LT_ADD2)
+
+lemma REAL_LT_ADD: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_of_num (0::nat)) x & real_lt (real_of_num (0::nat)) y -->
+ real_lt (real_of_num (0::nat)) (real_add x y)"
+ by (import hollight REAL_LT_ADD)
+
+lemma REAL_LT_ADDNEG: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt y (real_add x (real_neg z)) = real_lt (real_add y z) x"
+ by (import hollight REAL_LT_ADDNEG)
+
+lemma REAL_LT_ADDNEG2: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_add x (real_neg y)) z = real_lt x (real_add z y)"
+ by (import hollight REAL_LT_ADDNEG2)
+
+lemma REAL_LT_ADD1: "ALL (x::hollight.real) y::hollight.real.
+ real_le x y -->
+ real_lt x (real_add y (real_of_num (NUMERAL_BIT1 (0::nat))))"
+ by (import hollight REAL_LT_ADD1)
+
+lemma REAL_SUB_ADD: "ALL (x::hollight.real) y::hollight.real. real_add (real_sub x y) y = x"
+ by (import hollight REAL_SUB_ADD)
+
+lemma REAL_SUB_ADD2: "ALL (x::hollight.real) y::hollight.real. real_add y (real_sub x y) = x"
+ by (import hollight REAL_SUB_ADD2)
+
+lemma REAL_SUB_REFL: "ALL x::hollight.real. real_sub x x = real_of_num (0::nat)"
+ by (import hollight REAL_SUB_REFL)
+
+lemma REAL_SUB_0: "ALL (x::hollight.real) y::hollight.real.
+ (real_sub x y = real_of_num (0::nat)) = (x = y)"
+ by (import hollight REAL_SUB_0)
+
+lemma REAL_LE_DOUBLE: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) (real_add x x) =
+ real_le (real_of_num (0::nat)) x"
+ by (import hollight REAL_LE_DOUBLE)
+
+lemma REAL_LE_NEGL: "ALL x::hollight.real.
+ real_le (real_neg x) x = real_le (real_of_num (0::nat)) x"
+ by (import hollight REAL_LE_NEGL)
+
+lemma REAL_LE_NEGR: "ALL x::hollight.real.
+ real_le x (real_neg x) = real_le x (real_of_num (0::nat))"
+ by (import hollight REAL_LE_NEGR)
+
+lemma REAL_NEG_EQ0: "ALL x::hollight.real.
+ (real_neg x = real_of_num (0::nat)) = (x = real_of_num (0::nat))"
+ by (import hollight REAL_NEG_EQ0)
+
+lemma REAL_NEG_0: "real_neg (real_of_num (0::nat)) = real_of_num (0::nat)"
+ by (import hollight REAL_NEG_0)
+
+lemma REAL_NEG_SUB: "ALL (x::hollight.real) y::hollight.real.
+ real_neg (real_sub x y) = real_sub y x"
+ by (import hollight REAL_NEG_SUB)
+
+lemma REAL_SUB_LT: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_of_num (0::nat)) (real_sub x y) = real_lt y x"
+ by (import hollight REAL_SUB_LT)
+
+lemma REAL_SUB_LE: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_of_num (0::nat)) (real_sub x y) = real_le y x"
+ by (import hollight REAL_SUB_LE)
+
+lemma REAL_EQ_LMUL: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ (real_mul x y = real_mul x z) = (x = real_of_num (0::nat) | y = z)"
+ by (import hollight REAL_EQ_LMUL)
+
+lemma REAL_EQ_RMUL: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ (real_mul x z = real_mul y z) = (z = real_of_num (0::nat) | x = y)"
+ by (import hollight REAL_EQ_RMUL)
+
+lemma REAL_SUB_LDISTRIB: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_mul x (real_sub y z) = real_sub (real_mul x y) (real_mul x z)"
+ by (import hollight REAL_SUB_LDISTRIB)
+
+lemma REAL_SUB_RDISTRIB: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_mul (real_sub x y) z = real_sub (real_mul x z) (real_mul y z)"
+ by (import hollight REAL_SUB_RDISTRIB)
+
+lemma REAL_NEG_EQ: "ALL (x::hollight.real) y::hollight.real. (real_neg x = y) = (x = real_neg y)"
+ by (import hollight REAL_NEG_EQ)
+
+lemma REAL_NEG_MINUS1: "ALL x::hollight.real.
+ real_neg x = real_mul (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) x"
+ by (import hollight REAL_NEG_MINUS1)
+
+lemma REAL_INV_NZ: "ALL x::hollight.real.
+ x ~= real_of_num (0::nat) --> real_inv x ~= real_of_num (0::nat)"
+ by (import hollight REAL_INV_NZ)
+
+lemma REAL_INVINV: "ALL x::hollight.real.
+ x ~= real_of_num (0::nat) --> real_inv (real_inv x) = x"
+ by (import hollight REAL_INVINV)
+
+lemma REAL_LT_IMP_NE: "ALL (x::hollight.real) y::hollight.real. real_lt x y --> x ~= y"
+ by (import hollight REAL_LT_IMP_NE)
+
+lemma REAL_INV_POS: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x -->
+ real_lt (real_of_num (0::nat)) (real_inv x)"
+ by (import hollight REAL_INV_POS)
+
+lemma REAL_LT_LMUL_0: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_of_num (0::nat)) x -->
+ real_lt (real_of_num (0::nat)) (real_mul x y) =
+ real_lt (real_of_num (0::nat)) y"
+ by (import hollight REAL_LT_LMUL_0)
+
+lemma REAL_LT_RMUL_0: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_of_num (0::nat)) y -->
+ real_lt (real_of_num (0::nat)) (real_mul x y) =
+ real_lt (real_of_num (0::nat)) x"
+ by (import hollight REAL_LT_RMUL_0)
+
+lemma REAL_LT_LMUL_EQ: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_of_num (0::nat)) x -->
+ real_lt (real_mul x y) (real_mul x z) = real_lt y z"
+ by (import hollight REAL_LT_LMUL_EQ)
+
+lemma REAL_LT_RMUL_EQ: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_of_num (0::nat)) z -->
+ real_lt (real_mul x z) (real_mul y z) = real_lt x y"
+ by (import hollight REAL_LT_RMUL_EQ)
+
+lemma REAL_LT_RMUL_IMP: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt x y & real_lt (real_of_num (0::nat)) z -->
+ real_lt (real_mul x z) (real_mul y z)"
+ by (import hollight REAL_LT_RMUL_IMP)
+
+lemma REAL_LT_LMUL_IMP: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt y z & real_lt (real_of_num (0::nat)) x -->
+ real_lt (real_mul x y) (real_mul x z)"
+ by (import hollight REAL_LT_LMUL_IMP)
+
+lemma REAL_LINV_UNIQ: "ALL (x::hollight.real) y::hollight.real.
+ real_mul x y = real_of_num (NUMERAL_BIT1 (0::nat)) --> x = real_inv y"
+ by (import hollight REAL_LINV_UNIQ)
+
+lemma REAL_RINV_UNIQ: "ALL (x::hollight.real) y::hollight.real.
+ real_mul x y = real_of_num (NUMERAL_BIT1 (0::nat)) --> y = real_inv x"
+ by (import hollight REAL_RINV_UNIQ)
+
+lemma REAL_NEG_INV: "ALL x::hollight.real.
+ x ~= real_of_num (0::nat) -->
+ real_neg (real_inv x) = real_inv (real_neg x)"
+ by (import hollight REAL_NEG_INV)
+
+lemma REAL_INV_1OVER: "ALL x::hollight.real.
+ real_inv x = real_div (real_of_num (NUMERAL_BIT1 (0::nat))) x"
+ by (import hollight REAL_INV_1OVER)
+
+lemma REAL: "ALL x::nat.
+ real_of_num (Suc x) =
+ real_add (real_of_num x) (real_of_num (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight REAL)
+
+lemma REAL_POS: "ALL n::nat. real_le (real_of_num (0::nat)) (real_of_num n)"
+ by (import hollight REAL_POS)
+
+lemma REAL_LE: "ALL (m::nat) n::nat. real_le (real_of_num m) (real_of_num n) = <= m n"
+ by (import hollight REAL_LE)
+
+lemma REAL_LT: "ALL (m::nat) n::nat. real_lt (real_of_num m) (real_of_num n) = < m n"
+ by (import hollight REAL_LT)
+
+lemma th: "((m::nat) = (n::nat)) = (<= m n & <= n m)"
+ by (import hollight th)
+
+lemma REAL_INJ: "ALL (m::nat) n::nat. (real_of_num m = real_of_num n) = (m = n)"
+ by (import hollight REAL_INJ)
+
+lemma REAL_ADD: "ALL (m::nat) n::nat.
+ real_add (real_of_num m) (real_of_num n) = real_of_num (m + n)"
+ by (import hollight REAL_ADD)
+
+lemma REAL_MUL: "ALL (m::nat) n::nat.
+ real_mul (real_of_num m) (real_of_num n) = real_of_num (m * n)"
+ by (import hollight REAL_MUL)
+
+lemma REAL_INV1: "real_inv (real_of_num (NUMERAL_BIT1 (0::nat))) =
+real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight REAL_INV1)
+
+lemma REAL_DIV_LZERO: "ALL x::hollight.real.
+ real_div (real_of_num (0::nat)) x = real_of_num (0::nat)"
+ by (import hollight REAL_DIV_LZERO)
+
+lemma REAL_LT_NZ: "ALL n::nat.
+ (real_of_num n ~= real_of_num (0::nat)) =
+ real_lt (real_of_num (0::nat)) (real_of_num n)"
+ by (import hollight REAL_LT_NZ)
+
+lemma REAL_NZ_IMP_LT: "ALL n::nat. n ~= (0::nat) --> real_lt (real_of_num (0::nat)) (real_of_num n)"
+ by (import hollight REAL_NZ_IMP_LT)
+
+lemma REAL_LT_RDIV_0: "ALL (y::hollight.real) z::hollight.real.
+ real_lt (real_of_num (0::nat)) z -->
+ real_lt (real_of_num (0::nat)) (real_div y z) =
+ real_lt (real_of_num (0::nat)) y"
+ by (import hollight REAL_LT_RDIV_0)
+
+lemma REAL_LT_RDIV: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_of_num (0::nat)) z -->
+ real_lt (real_div x z) (real_div y z) = real_lt x y"
+ by (import hollight REAL_LT_RDIV)
+
+lemma REAL_LT_FRACTION_0: "ALL (n::nat) d::hollight.real.
+ n ~= (0::nat) -->
+ real_lt (real_of_num (0::nat)) (real_div d (real_of_num n)) =
+ real_lt (real_of_num (0::nat)) d"
+ by (import hollight REAL_LT_FRACTION_0)
+
+lemma REAL_LT_MULTIPLE: "ALL (x::nat) xa::hollight.real.
+ < (NUMERAL_BIT1 (0::nat)) x -->
+ real_lt xa (real_mul (real_of_num x) xa) =
+ real_lt (real_of_num (0::nat)) xa"
+ by (import hollight REAL_LT_MULTIPLE)
+
+lemma REAL_LT_FRACTION: "ALL (n::nat) d::hollight.real.
+ < (NUMERAL_BIT1 (0::nat)) n -->
+ real_lt (real_div d (real_of_num n)) d = real_lt (real_of_num (0::nat)) d"
+ by (import hollight REAL_LT_FRACTION)
+
+lemma REAL_LT_HALF1: "ALL d::hollight.real.
+ real_lt (real_of_num (0::nat))
+ (real_div d (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) =
+ real_lt (real_of_num (0::nat)) d"
+ by (import hollight REAL_LT_HALF1)
+
+lemma REAL_LT_HALF2: "ALL d::hollight.real.
+ real_lt (real_div d (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ d =
+ real_lt (real_of_num (0::nat)) d"
+ by (import hollight REAL_LT_HALF2)
+
+lemma REAL_DOUBLE: "ALL x::hollight.real.
+ real_add x x =
+ real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) x"
+ by (import hollight REAL_DOUBLE)
+
+lemma REAL_HALF_DOUBLE: "ALL x::hollight.real.
+ real_add
+ (real_div x (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_div x (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) =
+ x"
+ by (import hollight REAL_HALF_DOUBLE)
+
+lemma REAL_SUB_SUB: "ALL (x::hollight.real) y::hollight.real.
+ real_sub (real_sub x y) x = real_neg y"
+ by (import hollight REAL_SUB_SUB)
+
+lemma REAL_LT_ADD_SUB: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_add x y) z = real_lt x (real_sub z y)"
+ by (import hollight REAL_LT_ADD_SUB)
+
+lemma REAL_LT_SUB_RADD: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_sub x y) z = real_lt x (real_add z y)"
+ by (import hollight REAL_LT_SUB_RADD)
+
+lemma REAL_LT_SUB_LADD: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt x (real_sub y z) = real_lt (real_add x z) y"
+ by (import hollight REAL_LT_SUB_LADD)
+
+lemma REAL_LE_SUB_LADD: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_le x (real_sub y z) = real_le (real_add x z) y"
+ by (import hollight REAL_LE_SUB_LADD)
+
+lemma REAL_LE_SUB_RADD: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_le (real_sub x y) z = real_le x (real_add z y)"
+ by (import hollight REAL_LE_SUB_RADD)
+
+lemma REAL_LT_NEG: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_neg x) (real_neg y) = real_lt y x"
+ by (import hollight REAL_LT_NEG)
+
+lemma REAL_LE_NEG: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_neg x) (real_neg y) = real_le y x"
+ by (import hollight REAL_LE_NEG)
+
+lemma REAL_SUB_LZERO: "ALL x::hollight.real. real_sub (real_of_num (0::nat)) x = real_neg x"
+ by (import hollight REAL_SUB_LZERO)
+
+lemma REAL_SUB_RZERO: "ALL x::hollight.real. real_sub x (real_of_num (0::nat)) = x"
+ by (import hollight REAL_SUB_RZERO)
+
+lemma REAL_LTE_ADD2: "ALL (w::hollight.real) (x::hollight.real) (y::hollight.real)
+ z::hollight.real.
+ real_lt w x & real_le y z --> real_lt (real_add w y) (real_add x z)"
+ by (import hollight REAL_LTE_ADD2)
+
+lemma REAL_LTE_ADD: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_of_num (0::nat)) x & real_le (real_of_num (0::nat)) y -->
+ real_lt (real_of_num (0::nat)) (real_add x y)"
+ by (import hollight REAL_LTE_ADD)
+
+lemma REAL_LT_MUL2_ALT: "ALL (x1::hollight.real) (x2::hollight.real) (y1::hollight.real)
+ y2::hollight.real.
+ real_le (real_of_num (0::nat)) x1 &
+ real_le (real_of_num (0::nat)) y1 & real_lt x1 x2 & real_lt y1 y2 -->
+ real_lt (real_mul x1 y1) (real_mul x2 y2)"
+ by (import hollight REAL_LT_MUL2_ALT)
+
+lemma REAL_SUB_LNEG: "ALL (x::hollight.real) y::hollight.real.
+ real_sub (real_neg x) y = real_neg (real_add x y)"
+ by (import hollight REAL_SUB_LNEG)
+
+lemma REAL_SUB_RNEG: "ALL (x::hollight.real) y::hollight.real.
+ real_sub x (real_neg y) = real_add x y"
+ by (import hollight REAL_SUB_RNEG)
+
+lemma REAL_SUB_NEG2: "ALL (x::hollight.real) y::hollight.real.
+ real_sub (real_neg x) (real_neg y) = real_sub y x"
+ by (import hollight REAL_SUB_NEG2)
+
+lemma REAL_SUB_TRIANGLE: "ALL (a::hollight.real) (b::hollight.real) c::hollight.real.
+ real_add (real_sub a b) (real_sub b c) = real_sub a c"
+ by (import hollight REAL_SUB_TRIANGLE)
+
+lemma REAL_INV_MUL_WEAK: "ALL (x::hollight.real) xa::hollight.real.
+ x ~= real_of_num (0::nat) & xa ~= real_of_num (0::nat) -->
+ real_inv (real_mul x xa) = real_mul (real_inv x) (real_inv xa)"
+ by (import hollight REAL_INV_MUL_WEAK)
+
+lemma REAL_LE_LMUL_LOCAL: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_of_num (0::nat)) x -->
+ real_le (real_mul x y) (real_mul x z) = real_le y z"
+ by (import hollight REAL_LE_LMUL_LOCAL)
+
+lemma REAL_LE_RMUL_EQ: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_of_num (0::nat)) z -->
+ real_le (real_mul x z) (real_mul y z) = real_le x y"
+ by (import hollight REAL_LE_RMUL_EQ)
+
+lemma REAL_SUB_INV2: "ALL (x::hollight.real) y::hollight.real.
+ x ~= real_of_num (0::nat) & y ~= real_of_num (0::nat) -->
+ real_sub (real_inv x) (real_inv y) =
+ real_div (real_sub y x) (real_mul x y)"
+ by (import hollight REAL_SUB_INV2)
+
+lemma REAL_SUB_SUB2: "ALL (x::hollight.real) y::hollight.real. real_sub x (real_sub x y) = y"
+ by (import hollight REAL_SUB_SUB2)
+
+lemma REAL_MEAN: "ALL (x::hollight.real) y::hollight.real.
+ real_lt x y --> (EX z::hollight.real. real_lt x z & real_lt z y)"
+ by (import hollight REAL_MEAN)
+
+lemma REAL_EQ_LMUL2: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ x ~= real_of_num (0::nat) --> (y = z) = (real_mul x y = real_mul x z)"
+ by (import hollight REAL_EQ_LMUL2)
+
+lemma REAL_LE_MUL2V: "ALL (x1::hollight.real) (x2::hollight.real) (y1::hollight.real)
+ y2::hollight.real.
+ real_le (real_of_num (0::nat)) x1 &
+ real_le (real_of_num (0::nat)) y1 & real_le x1 x2 & real_le y1 y2 -->
+ real_le (real_mul x1 y1) (real_mul x2 y2)"
+ by (import hollight REAL_LE_MUL2V)
+
+lemma REAL_LE_LDIV: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_of_num (0::nat)) x & real_le y (real_mul z x) -->
+ real_le (real_div y x) z"
+ by (import hollight REAL_LE_LDIV)
+
+lemma REAL_LE_RDIV: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt (real_of_num (0::nat)) x & real_le (real_mul y x) z -->
+ real_le y (real_div z x)"
+ by (import hollight REAL_LE_RDIV)
+
+lemma REAL_LT_1: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_lt x y -->
+ real_lt (real_div x y) (real_of_num (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight REAL_LT_1)
+
+lemma REAL_LE_LMUL_IMP: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le y z -->
+ real_le (real_mul x y) (real_mul x z)"
+ by (import hollight REAL_LE_LMUL_IMP)
+
+lemma REAL_LE_RMUL_IMP: "ALL (x::hollight.real) (xa::hollight.real) xb::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le xa xb -->
+ real_le (real_mul xa x) (real_mul xb x)"
+ by (import hollight REAL_LE_RMUL_IMP)
+
+lemma REAL_INV_LT1: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x &
+ real_lt x (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ real_lt (real_of_num (NUMERAL_BIT1 (0::nat))) (real_inv x)"
+ by (import hollight REAL_INV_LT1)
+
+lemma REAL_POS_NZ: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x --> x ~= real_of_num (0::nat)"
+ by (import hollight REAL_POS_NZ)
+
+lemma REAL_EQ_RMUL_IMP: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ z ~= real_of_num (0::nat) & real_mul x z = real_mul y z --> x = y"
+ by (import hollight REAL_EQ_RMUL_IMP)
+
+lemma REAL_EQ_LMUL_IMP: "ALL (x::hollight.real) (xa::hollight.real) xb::hollight.real.
+ x ~= real_of_num (0::nat) & real_mul x xa = real_mul x xb --> xa = xb"
+ by (import hollight REAL_EQ_LMUL_IMP)
+
+lemma REAL_FACT_NZ: "ALL n::nat. real_of_num (FACT n) ~= real_of_num (0::nat)"
+ by (import hollight REAL_FACT_NZ)
+
+lemma REAL_POSSQ: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) (real_mul x x) =
+ (x ~= real_of_num (0::nat))"
+ by (import hollight REAL_POSSQ)
+
+lemma REAL_SUMSQ: "ALL (x::hollight.real) y::hollight.real.
+ (real_add (real_mul x x) (real_mul y y) = real_of_num (0::nat)) =
+ (x = real_of_num (0::nat) & y = real_of_num (0::nat))"
+ by (import hollight REAL_SUMSQ)
+
+lemma REAL_EQ_NEG: "ALL (x::hollight.real) y::hollight.real. (real_neg x = real_neg y) = (x = y)"
+ by (import hollight REAL_EQ_NEG)
+
+lemma REAL_DIV_MUL2: "ALL (x::hollight.real) z::hollight.real.
+ x ~= real_of_num (0::nat) & z ~= real_of_num (0::nat) -->
+ (ALL y::hollight.real.
+ real_div y z = real_div (real_mul x y) (real_mul x z))"
+ by (import hollight REAL_DIV_MUL2)
+
+lemma REAL_MIDDLE1: "ALL (a::hollight.real) b::hollight.real.
+ real_le a b -->
+ real_le a
+ (real_div (real_add a b)
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))"
+ by (import hollight REAL_MIDDLE1)
+
+lemma REAL_MIDDLE2: "ALL (a::hollight.real) b::hollight.real.
+ real_le a b -->
+ real_le
+ (real_div (real_add a b)
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ b"
+ by (import hollight REAL_MIDDLE2)
+
+lemma ABS_ZERO: "ALL x::hollight.real.
+ (real_abs x = real_of_num (0::nat)) = (x = real_of_num (0::nat))"
+ by (import hollight ABS_ZERO)
+
+lemma ABS_0: "real_abs (real_of_num (0::nat)) = real_of_num (0::nat)"
+ by (import hollight ABS_0)
+
+lemma ABS_1: "real_abs (real_of_num (NUMERAL_BIT1 (0::nat))) =
+real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight ABS_1)
+
+lemma ABS_NEG: "ALL x::hollight.real. real_abs (real_neg x) = real_abs x"
+ by (import hollight ABS_NEG)
+
+lemma ABS_TRIANGLE: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_abs (real_add x y)) (real_add (real_abs x) (real_abs y))"
+ by (import hollight ABS_TRIANGLE)
+
+lemma ABS_POS: "ALL x::hollight.real. real_le (real_of_num (0::nat)) (real_abs x)"
+ by (import hollight ABS_POS)
+
+lemma ABS_MUL: "ALL (x::hollight.real) y::hollight.real.
+ real_abs (real_mul x y) = real_mul (real_abs x) (real_abs y)"
+ by (import hollight ABS_MUL)
+
+lemma ABS_LT_MUL2: "ALL (w::hollight.real) (x::hollight.real) (y::hollight.real)
+ z::hollight.real.
+ real_lt (real_abs w) y & real_lt (real_abs x) z -->
+ real_lt (real_abs (real_mul w x)) (real_mul y z)"
+ by (import hollight ABS_LT_MUL2)
+
+lemma ABS_SUB: "ALL (x::hollight.real) y::hollight.real.
+ real_abs (real_sub x y) = real_abs (real_sub y x)"
+ by (import hollight ABS_SUB)
+
+lemma ABS_NZ: "ALL x::hollight.real.
+ (x ~= real_of_num (0::nat)) = real_lt (real_of_num (0::nat)) (real_abs x)"
+ by (import hollight ABS_NZ)
+
+lemma ABS_INV: "ALL x::hollight.real.
+ x ~= real_of_num (0::nat) -->
+ real_abs (real_inv x) = real_inv (real_abs x)"
+ by (import hollight ABS_INV)
+
+lemma ABS_ABS: "ALL x::hollight.real. real_abs (real_abs x) = real_abs x"
+ by (import hollight ABS_ABS)
+
+lemma ABS_LE: "ALL x::hollight.real. real_le x (real_abs x)"
+ by (import hollight ABS_LE)
+
+lemma ABS_REFL: "ALL x::hollight.real. (real_abs x = x) = real_le (real_of_num (0::nat)) x"
+ by (import hollight ABS_REFL)
+
+lemma ABS_N: "ALL n::nat. real_abs (real_of_num n) = real_of_num n"
+ by (import hollight ABS_N)
+
+lemma ABS_BETWEEN: "ALL (x::hollight.real) (y::hollight.real) d::hollight.real.
+ (real_lt (real_of_num (0::nat)) d &
+ real_lt (real_sub x d) y & real_lt y (real_add x d)) =
+ real_lt (real_abs (real_sub y x)) d"
+ by (import hollight ABS_BETWEEN)
+
+lemma ABS_BOUND: "ALL (x::hollight.real) (y::hollight.real) d::hollight.real.
+ real_lt (real_abs (real_sub x y)) d --> real_lt y (real_add x d)"
+ by (import hollight ABS_BOUND)
+
+lemma ABS_STILLNZ: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_abs (real_sub x y)) (real_abs y) -->
+ x ~= real_of_num (0::nat)"
+ by (import hollight ABS_STILLNZ)
+
+lemma ABS_CASES: "ALL x::hollight.real.
+ x = real_of_num (0::nat) | real_lt (real_of_num (0::nat)) (real_abs x)"
+ by (import hollight ABS_CASES)
+
+lemma ABS_BETWEEN1: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt x z & real_lt (real_abs (real_sub y x)) (real_sub z x) -->
+ real_lt y z"
+ by (import hollight ABS_BETWEEN1)
+
+lemma ABS_SIGN: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_abs (real_sub x y)) y --> real_lt (real_of_num (0::nat)) x"
+ by (import hollight ABS_SIGN)
+
+lemma ABS_SIGN2: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_abs (real_sub x y)) (real_neg y) -->
+ real_lt x (real_of_num (0::nat))"
+ by (import hollight ABS_SIGN2)
+
+lemma ABS_DIV: "ALL y::hollight.real.
+ y ~= real_of_num (0::nat) -->
+ (ALL x::hollight.real.
+ real_abs (real_div x y) = real_div (real_abs x) (real_abs y))"
+ by (import hollight ABS_DIV)
+
+lemma ABS_CIRCLE: "ALL (x::hollight.real) (y::hollight.real) h::hollight.real.
+ real_lt (real_abs h) (real_sub (real_abs y) (real_abs x)) -->
+ real_lt (real_abs (real_add x h)) (real_abs y)"
+ by (import hollight ABS_CIRCLE)
+
+lemma REAL_SUB_ABS: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_sub (real_abs x) (real_abs y)) (real_abs (real_sub x y))"
+ by (import hollight REAL_SUB_ABS)
+
+lemma ABS_SUB_ABS: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_abs (real_sub (real_abs x) (real_abs y)))
+ (real_abs (real_sub x y))"
+ by (import hollight ABS_SUB_ABS)
+
+lemma ABS_BETWEEN2: "ALL (x0::hollight.real) (x::hollight.real) (y0::hollight.real)
+ y::hollight.real.
+ real_lt x0 y0 &
+ real_lt (real_abs (real_sub x x0))
+ (real_div (real_sub y0 x0)
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) &
+ real_lt (real_abs (real_sub y y0))
+ (real_div (real_sub y0 x0)
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) -->
+ real_lt x y"
+ by (import hollight ABS_BETWEEN2)
+
+lemma ABS_BOUNDS: "ALL (x::hollight.real) k::hollight.real.
+ real_le (real_abs x) k = (real_le (real_neg k) x & real_le x k)"
+ by (import hollight ABS_BOUNDS)
+
+lemma POW_0: "ALL n::nat. real_pow (real_of_num (0::nat)) (Suc n) = real_of_num (0::nat)"
+ by (import hollight POW_0)
+
+lemma POW_NZ: "ALL (c::hollight.real) n::nat.
+ c ~= real_of_num (0::nat) --> real_pow c n ~= real_of_num (0::nat)"
+ by (import hollight POW_NZ)
+
+lemma POW_INV: "ALL (c::hollight.real) x::nat.
+ c ~= real_of_num (0::nat) -->
+ real_inv (real_pow c x) = real_pow (real_inv c) x"
+ by (import hollight POW_INV)
+
+lemma POW_ABS: "ALL (c::hollight.real) n::nat.
+ real_pow (real_abs c) n = real_abs (real_pow c n)"
+ by (import hollight POW_ABS)
+
+lemma POW_PLUS1: "ALL (e::hollight.real) x::nat.
+ real_lt (real_of_num (0::nat)) e -->
+ real_le
+ (real_add (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_mul (real_of_num x) e))
+ (real_pow (real_add (real_of_num (NUMERAL_BIT1 (0::nat))) e) x)"
+ by (import hollight POW_PLUS1)
+
+lemma POW_ADD: "ALL (c::hollight.real) (m::nat) n::nat.
+ real_pow c (m + n) = real_mul (real_pow c m) (real_pow c n)"
+ by (import hollight POW_ADD)
+
+lemma POW_1: "ALL x::hollight.real. real_pow x (NUMERAL_BIT1 (0::nat)) = x"
+ by (import hollight POW_1)
+
+lemma POW_2: "ALL x::hollight.real.
+ real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) = real_mul x x"
+ by (import hollight POW_2)
+
+lemma POW_POS: "ALL (x::hollight.real) xa::nat.
+ real_le (real_of_num (0::nat)) x -->
+ real_le (real_of_num (0::nat)) (real_pow x xa)"
+ by (import hollight POW_POS)
+
+lemma POW_LE: "ALL (n::nat) (x::hollight.real) y::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le x y -->
+ real_le (real_pow x n) (real_pow y n)"
+ by (import hollight POW_LE)
+
+lemma POW_M1: "ALL n::nat.
+ real_abs (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) n) =
+ real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight POW_M1)
+
+lemma POW_MUL: "ALL (n::nat) (x::hollight.real) y::hollight.real.
+ real_pow (real_mul x y) n = real_mul (real_pow x n) (real_pow y n)"
+ by (import hollight POW_MUL)
+
+lemma REAL_LE_SQUARE_POW: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat))
+ (real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))"
+ by (import hollight REAL_LE_SQUARE_POW)
+
+lemma ABS_POW2: "ALL x::hollight.real.
+ real_abs (real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) =
+ real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight ABS_POW2)
+
+lemma REAL_LE1_POW2: "ALL x::hollight.real.
+ real_le (real_of_num (NUMERAL_BIT1 (0::nat))) x -->
+ real_le (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))"
+ by (import hollight REAL_LE1_POW2)
+
+lemma REAL_LT1_POW2: "ALL x::hollight.real.
+ real_lt (real_of_num (NUMERAL_BIT1 (0::nat))) x -->
+ real_lt (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))"
+ by (import hollight REAL_LT1_POW2)
+
+lemma POW_POS_LT: "ALL (x::hollight.real) n::nat.
+ real_lt (real_of_num (0::nat)) x -->
+ real_lt (real_of_num (0::nat)) (real_pow x (Suc n))"
+ by (import hollight POW_POS_LT)
+
+lemma POW_2_LE1: "ALL n::nat.
+ real_le (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_pow (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) n)"
+ by (import hollight POW_2_LE1)
+
+lemma POW_2_LT: "ALL n::nat.
+ real_lt (real_of_num n)
+ (real_pow (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) n)"
+ by (import hollight POW_2_LT)
+
+lemma POW_MINUS1: "ALL n::nat.
+ real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * n) =
+ real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight POW_MINUS1)
+
+lemma REAL_SUP_EXISTS: "ALL P::hollight.real => bool.
+ Ex P &
+ (EX z::hollight.real. ALL x::hollight.real. P x --> real_lt x z) -->
+ (EX s::hollight.real.
+ ALL y::hollight.real.
+ (EX x::hollight.real. P x & real_lt y x) = real_lt y s)"
+ by (import hollight REAL_SUP_EXISTS)
+
+constdefs
+ sup :: "(hollight.real => bool) => hollight.real"
+ "sup ==
+%u::hollight.real => bool.
+ SOME a::hollight.real.
+ (ALL x::hollight.real. IN x u --> real_le x a) &
+ (ALL b::hollight.real.
+ (ALL x::hollight.real. IN x u --> real_le x b) --> real_le a b)"
+
+lemma DEF_sup: "sup =
+(%u::hollight.real => bool.
+ SOME a::hollight.real.
+ (ALL x::hollight.real. IN x u --> real_le x a) &
+ (ALL b::hollight.real.
+ (ALL x::hollight.real. IN x u --> real_le x b) --> real_le a b))"
+ by (import hollight DEF_sup)
+
+lemma sup: "sup (P::hollight.real => bool) =
+(SOME s::hollight.real.
+ ALL y::hollight.real.
+ (EX x::hollight.real. P x & real_lt y x) = real_lt y s)"
+ by (import hollight sup)
+
+lemma REAL_SUP: "ALL P::hollight.real => bool.
+ Ex P &
+ (EX z::hollight.real. ALL x::hollight.real. P x --> real_lt x z) -->
+ (ALL y::hollight.real.
+ (EX x::hollight.real. P x & real_lt y x) = real_lt y (sup P))"
+ by (import hollight REAL_SUP)
+
+lemma REAL_SUP_UBOUND: "ALL P::hollight.real => bool.
+ Ex P &
+ (EX z::hollight.real. ALL x::hollight.real. P x --> real_lt x z) -->
+ (ALL y::hollight.real. P y --> real_le y (sup P))"
+ by (import hollight REAL_SUP_UBOUND)
+
+lemma SETOK_LE_LT: "ALL P::hollight.real => bool.
+ (Ex P &
+ (EX z::hollight.real. ALL x::hollight.real. P x --> real_le x z)) =
+ (Ex P &
+ (EX x::hollight.real. ALL xa::hollight.real. P xa --> real_lt xa x))"
+ by (import hollight SETOK_LE_LT)
+
+lemma REAL_SUP_LE: "ALL P::hollight.real => bool.
+ Ex P &
+ (EX z::hollight.real. ALL x::hollight.real. P x --> real_le x z) -->
+ (ALL y::hollight.real.
+ (EX x::hollight.real. P x & real_lt y x) = real_lt y (sup P))"
+ by (import hollight REAL_SUP_LE)
+
+lemma REAL_SUP_UBOUND_LE: "ALL P::hollight.real => bool.
+ Ex P &
+ (EX z::hollight.real. ALL x::hollight.real. P x --> real_le x z) -->
+ (ALL y::hollight.real. P y --> real_le y (sup P))"
+ by (import hollight REAL_SUP_UBOUND_LE)
+
+lemma REAL_ARCH_SIMPLE: "ALL x::hollight.real. EX n::nat. real_le x (real_of_num n)"
+ by (import hollight REAL_ARCH_SIMPLE)
+
+lemma REAL_ARCH: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x -->
+ (ALL y::hollight.real. EX n::nat. real_lt y (real_mul (real_of_num n) x))"
+ by (import hollight REAL_ARCH)
+
+lemma REAL_ARCH_LEAST: "ALL y::hollight.real.
+ real_lt (real_of_num (0::nat)) y -->
+ (ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) x -->
+ (EX n::nat.
+ real_le (real_mul (real_of_num n) y) x &
+ real_lt x (real_mul (real_of_num (Suc n)) y)))"
+ by (import hollight REAL_ARCH_LEAST)
+
+lemma sum_EXISTS: "EX x::nat * nat => (nat => hollight.real) => hollight.real.
+ (ALL (f::nat => hollight.real) n::nat.
+ x (n, 0::nat) f = real_of_num (0::nat)) &
+ (ALL (f::nat => hollight.real) (m::nat) n::nat.
+ x (n, Suc m) f = real_add (x (n, m) f) (f (n + m)))"
+ by (import hollight sum_EXISTS)
+
+constdefs
+ psum :: "nat * nat => (nat => hollight.real) => hollight.real"
+ "psum ==
+SOME sum::nat * nat => (nat => hollight.real) => hollight.real.
+ (ALL (f::nat => hollight.real) n::nat.
+ sum (n, 0::nat) f = real_of_num (0::nat)) &
+ (ALL (f::nat => hollight.real) (m::nat) n::nat.
+ sum (n, Suc m) f = real_add (sum (n, m) f) (f (n + m)))"
+
+lemma DEF_psum: "psum =
+(SOME sum::nat * nat => (nat => hollight.real) => hollight.real.
+ (ALL (f::nat => hollight.real) n::nat.
+ sum (n, 0::nat) f = real_of_num (0::nat)) &
+ (ALL (f::nat => hollight.real) (m::nat) n::nat.
+ sum (n, Suc m) f = real_add (sum (n, m) f) (f (n + m))))"
+ by (import hollight DEF_psum)
+
+lemma sum: "psum (n::nat, 0::nat) (f::nat => hollight.real) = real_of_num (0::nat) &
+psum (n, Suc (m::nat)) f = real_add (psum (n, m) f) (f (n + m))"
+ by (import hollight sum)
+
+lemma PSUM_SUM: "ALL (f::nat => hollight.real) (m::nat) n::nat.
+ psum (m, n) f =
+ hollight.sum
+ (GSPEC (%u::nat. EX i::nat. SETSPEC u (<= m i & < i (m + n)) i)) f"
+ by (import hollight PSUM_SUM)
+
+lemma PSUM_SUM_NUMSEG: "ALL (f::nat => hollight.real) (m::nat) n::nat.
+ ~ (m = (0::nat) & n = (0::nat)) -->
+ psum (m, n) f = hollight.sum (dotdot m (m + n - NUMERAL_BIT1 (0::nat))) f"
+ by (import hollight PSUM_SUM_NUMSEG)
+
+lemma SUM_TWO: "ALL (f::nat => hollight.real) (n::nat) p::nat.
+ real_add (psum (0::nat, n) f) (psum (n, p) f) = psum (0::nat, n + p) f"
+ by (import hollight SUM_TWO)
+
+lemma SUM_DIFF: "ALL (f::nat => hollight.real) (m::nat) n::nat.
+ psum (m, n) f = real_sub (psum (0::nat, m + n) f) (psum (0::nat, m) f)"
+ by (import hollight SUM_DIFF)
+
+lemma ABS_SUM: "ALL (f::nat => hollight.real) (m::nat) n::nat.
+ real_le (real_abs (psum (m, n) f))
+ (psum (m, n) (%n::nat. real_abs (f n)))"
+ by (import hollight ABS_SUM)
+
+lemma SUM_LE: "ALL (f::nat => hollight.real) (g::nat => hollight.real) (m::nat) n::nat.
+ (ALL r::nat. <= m r & < r (n + m) --> real_le (f r) (g r)) -->
+ real_le (psum (m, n) f) (psum (m, n) g)"
+ by (import hollight SUM_LE)
+
+lemma SUM_EQ: "ALL (f::nat => hollight.real) (g::nat => hollight.real) (m::nat) n::nat.
+ (ALL r::nat. <= m r & < r (n + m) --> f r = g r) -->
+ psum (m, n) f = psum (m, n) g"
+ by (import hollight SUM_EQ)
+
+lemma SUM_POS: "ALL f::nat => hollight.real.
+ (ALL n::nat. real_le (real_of_num (0::nat)) (f n)) -->
+ (ALL (m::nat) n::nat. real_le (real_of_num (0::nat)) (psum (m, n) f))"
+ by (import hollight SUM_POS)
+
+lemma SUM_POS_GEN: "ALL (f::nat => hollight.real) (m::nat) n::nat.
+ (ALL n::nat. <= m n --> real_le (real_of_num (0::nat)) (f n)) -->
+ real_le (real_of_num (0::nat)) (psum (m, n) f)"
+ by (import hollight SUM_POS_GEN)
+
+lemma SUM_ABS: "ALL (f::nat => hollight.real) (m::nat) x::nat.
+ real_abs (psum (m, x) (%m::nat. real_abs (f m))) =
+ psum (m, x) (%m::nat. real_abs (f m))"
+ by (import hollight SUM_ABS)
+
+lemma SUM_ABS_LE: "ALL (f::nat => hollight.real) (m::nat) n::nat.
+ real_le (real_abs (psum (m, n) f))
+ (psum (m, n) (%n::nat. real_abs (f n)))"
+ by (import hollight SUM_ABS_LE)
+
+lemma SUM_ZERO: "ALL (f::nat => hollight.real) N::nat.
+ (ALL n::nat. >= n N --> f n = real_of_num (0::nat)) -->
+ (ALL (m::nat) n::nat. >= m N --> psum (m, n) f = real_of_num (0::nat))"
+ by (import hollight SUM_ZERO)
+
+lemma SUM_ADD: "ALL (f::nat => hollight.real) (g::nat => hollight.real) (m::nat) n::nat.
+ psum (m, n) (%n::nat. real_add (f n) (g n)) =
+ real_add (psum (m, n) f) (psum (m, n) g)"
+ by (import hollight SUM_ADD)
+
+lemma SUM_CMUL: "ALL (f::nat => hollight.real) (c::hollight.real) (m::nat) n::nat.
+ psum (m, n) (%n::nat. real_mul c (f n)) = real_mul c (psum (m, n) f)"
+ by (import hollight SUM_CMUL)
+
+lemma SUM_NEG: "ALL (f::nat => hollight.real) (n::nat) d::nat.
+ psum (n, d) (%n::nat. real_neg (f n)) = real_neg (psum (n, d) f)"
+ by (import hollight SUM_NEG)
+
+lemma SUM_SUB: "ALL (f::nat => hollight.real) (g::nat => hollight.real) (m::nat) n::nat.
+ psum (m, n) (%x::nat. real_sub (f x) (g x)) =
+ real_sub (psum (m, n) f) (psum (m, n) g)"
+ by (import hollight SUM_SUB)
+
+lemma SUM_SUBST: "ALL (f::nat => hollight.real) (g::nat => hollight.real) (m::nat) n::nat.
+ (ALL p::nat. <= m p & < p (m + n) --> f p = g p) -->
+ psum (m, n) f = psum (m, n) g"
+ by (import hollight SUM_SUBST)
+
+lemma SUM_NSUB: "ALL (n::nat) (f::nat => hollight.real) c::hollight.real.
+ real_sub (psum (0::nat, n) f) (real_mul (real_of_num n) c) =
+ psum (0::nat, n) (%p::nat. real_sub (f p) c)"
+ by (import hollight SUM_NSUB)
+
+lemma SUM_BOUND: "ALL (f::nat => hollight.real) (K::hollight.real) (m::nat) n::nat.
+ (ALL p::nat. <= m p & < p (m + n) --> real_le (f p) K) -->
+ real_le (psum (m, n) f) (real_mul (real_of_num n) K)"
+ by (import hollight SUM_BOUND)
+
+lemma SUM_GROUP: "ALL (n::nat) (k::nat) f::nat => hollight.real.
+ psum (0::nat, n) (%m::nat. psum (m * k, k) f) = psum (0::nat, n * k) f"
+ by (import hollight SUM_GROUP)
+
+lemma SUM_1: "ALL (f::nat => hollight.real) n::nat.
+ psum (n, NUMERAL_BIT1 (0::nat)) f = f n"
+ by (import hollight SUM_1)
+
+lemma SUM_2: "ALL (f::nat => hollight.real) n::nat.
+ psum (n, NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) f =
+ real_add (f n) (f (n + NUMERAL_BIT1 (0::nat)))"
+ by (import hollight SUM_2)
+
+lemma SUM_OFFSET: "ALL (f::nat => hollight.real) (n::nat) k::nat.
+ psum (0::nat, n) (%m::nat. f (m + k)) =
+ real_sub (psum (0::nat, n + k) f) (psum (0::nat, k) f)"
+ by (import hollight SUM_OFFSET)
+
+lemma SUM_REINDEX: "ALL (f::nat => hollight.real) (m::nat) (k::nat) n::nat.
+ psum (m + k, n) f = psum (m, n) (%r::nat. f (r + k))"
+ by (import hollight SUM_REINDEX)
+
+lemma SUM_0: "ALL (m::nat) n::nat.
+ psum (m, n) (%r::nat. real_of_num (0::nat)) = real_of_num (0::nat)"
+ by (import hollight SUM_0)
+
+lemma SUM_CANCEL: "ALL (f::nat => hollight.real) (n::nat) d::nat.
+ psum (n, d) (%n::nat. real_sub (f (Suc n)) (f n)) =
+ real_sub (f (n + d)) (f n)"
+ by (import hollight SUM_CANCEL)
+
+lemma SUM_HORNER: "ALL (f::nat => hollight.real) (n::nat) x::hollight.real.
+ psum (0::nat, Suc n) (%i::nat. real_mul (f i) (real_pow x i)) =
+ real_add (f (0::nat))
+ (real_mul x
+ (psum (0::nat, n) (%i::nat. real_mul (f (Suc i)) (real_pow x i))))"
+ by (import hollight SUM_HORNER)
+
+lemma SUM_CONST: "ALL (c::hollight.real) n::nat.
+ psum (0::nat, n) (%m::nat. c) = real_mul (real_of_num n) c"
+ by (import hollight SUM_CONST)
+
+lemma SUM_SPLIT: "ALL (f::nat => hollight.real) (n::nat) p::nat.
+ real_add (psum (m::nat, n) f) (psum (m + n, p) f) = psum (m, n + p) f"
+ by (import hollight SUM_SPLIT)
+
+lemma SUM_SWAP: "ALL (f::nat => nat => hollight.real) (m1::nat) (n1::nat) (m2::nat) n2::nat.
+ psum (m1, n1) (%a::nat. psum (m2, n2) (f a)) =
+ psum (m2, n2) (%b::nat. psum (m1, n1) (%a::nat. f a b))"
+ by (import hollight SUM_SWAP)
+
+lemma SUM_EQ_0: "(ALL r::nat.
+ <= (m::nat) r & < r (m + (n::nat)) -->
+ (f::nat => hollight.real) r = real_of_num (0::nat)) -->
+psum (m, n) f = real_of_num (0::nat)"
+ by (import hollight SUM_EQ_0)
+
+lemma SUM_MORETERMS_EQ: "ALL (m::nat) (n::nat) p::nat.
+ <= n p &
+ (ALL r::nat.
+ <= (m + n) r & < r (m + p) -->
+ (f::nat => hollight.real) r = real_of_num (0::nat)) -->
+ psum (m, p) f = psum (m, n) f"
+ by (import hollight SUM_MORETERMS_EQ)
+
+lemma SUM_DIFFERENCES_EQ: "ALL (x::nat) (xa::nat) xb::nat.
+ <= xa xb &
+ (ALL r::nat.
+ <= (x + xa) r & < r (x + xb) -->
+ (f::nat => hollight.real) r = (g::nat => hollight.real) r) -->
+ real_sub (psum (x, xb) f) (psum (x, xa) f) =
+ real_sub (psum (x, xb) g) (psum (x, xa) g)"
+ by (import hollight SUM_DIFFERENCES_EQ)
+
+constdefs
+ re_Union :: "(('A::type => bool) => bool) => 'A::type => bool"
+ "re_Union ==
+%(u::('A::type => bool) => bool) x::'A::type.
+ EX s::'A::type => bool. u s & s x"
+
+lemma DEF_re_Union: "re_Union =
+(%(u::('A::type => bool) => bool) x::'A::type.
+ EX s::'A::type => bool. u s & s x)"
+ by (import hollight DEF_re_Union)
+
+constdefs
+ re_union :: "('A::type => bool) => ('A::type => bool) => 'A::type => bool"
+ "re_union ==
+%(u::'A::type => bool) (ua::'A::type => bool) x::'A::type. u x | ua x"
+
+lemma DEF_re_union: "re_union =
+(%(u::'A::type => bool) (ua::'A::type => bool) x::'A::type. u x | ua x)"
+ by (import hollight DEF_re_union)
+
+constdefs
+ re_intersect :: "('A::type => bool) => ('A::type => bool) => 'A::type => bool"
+ "re_intersect ==
+%(u::'A::type => bool) (ua::'A::type => bool) x::'A::type. u x & ua x"
+
+lemma DEF_re_intersect: "re_intersect =
+(%(u::'A::type => bool) (ua::'A::type => bool) x::'A::type. u x & ua x)"
+ by (import hollight DEF_re_intersect)
+
+constdefs
+ re_null :: "'A::type => bool"
+ "re_null == %x::'A::type. False"
+
+lemma DEF_re_null: "re_null = (%x::'A::type. False)"
+ by (import hollight DEF_re_null)
+
+constdefs
+ re_universe :: "'A::type => bool"
+ "re_universe == %x::'A::type. True"
+
+lemma DEF_re_universe: "re_universe = (%x::'A::type. True)"
+ by (import hollight DEF_re_universe)
+
+constdefs
+ re_subset :: "('A::type => bool) => ('A::type => bool) => bool"
+ "re_subset ==
+%(u::'A::type => bool) ua::'A::type => bool. ALL x::'A::type. u x --> ua x"
+
+lemma DEF_re_subset: "re_subset =
+(%(u::'A::type => bool) ua::'A::type => bool. ALL x::'A::type. u x --> ua x)"
+ by (import hollight DEF_re_subset)
+
+constdefs
+ re_compl :: "('A::type => bool) => 'A::type => bool"
+ "re_compl == %(u::'A::type => bool) x::'A::type. ~ u x"
+
+lemma DEF_re_compl: "re_compl = (%(u::'A::type => bool) x::'A::type. ~ u x)"
+ by (import hollight DEF_re_compl)
+
+lemma SUBSETA_REFL: "ALL S::'A::type => bool. re_subset S S"
+ by (import hollight SUBSETA_REFL)
+
+lemma COMPL_MEM: "ALL (S::'A::type => bool) x::'A::type. S x = (~ re_compl S x)"
+ by (import hollight COMPL_MEM)
+
+lemma SUBSETA_ANTISYM: "ALL (P::'A::type => bool) Q::'A::type => bool.
+ (re_subset P Q & re_subset Q P) = (P = Q)"
+ by (import hollight SUBSETA_ANTISYM)
+
+lemma SUBSETA_TRANS: "ALL (P::'A::type => bool) (Q::'A::type => bool) R::'A::type => bool.
+ re_subset P Q & re_subset Q R --> re_subset P R"
+ by (import hollight SUBSETA_TRANS)
+
+constdefs
+ istopology :: "(('A::type => bool) => bool) => bool"
+ "istopology ==
+%u::('A::type => bool) => bool.
+ u re_null &
+ u re_universe &
+ (ALL (a::'A::type => bool) b::'A::type => bool.
+ u a & u b --> u (re_intersect a b)) &
+ (ALL P::('A::type => bool) => bool. re_subset P u --> u (re_Union P))"
+
+lemma DEF_istopology: "istopology =
+(%u::('A::type => bool) => bool.
+ u re_null &
+ u re_universe &
+ (ALL (a::'A::type => bool) b::'A::type => bool.
+ u a & u b --> u (re_intersect a b)) &
+ (ALL P::('A::type => bool) => bool. re_subset P u --> u (re_Union P)))"
+ by (import hollight DEF_istopology)
+
+typedef (open) ('A) topology = "(Collect::((('A::type => bool) => bool) => bool)
+ => (('A::type => bool) => bool) set)
+ (istopology::(('A::type => bool) => bool) => bool)" morphisms "open" "topology"
+ apply (rule light_ex_imp_nonempty[where t="(Eps::((('A::type => bool) => bool) => bool) => ('A::type => bool) => bool)
+ (istopology::(('A::type => bool) => bool) => bool)"])
+ by (import hollight TYDEF_topology)
+
+syntax
+ "open" :: _
+
+syntax
+ topology :: _
+
+lemmas "TYDEF_topology_@intern" = typedef_hol2hollight
+ [where a="a :: 'A::type topology" and r=r ,
+ OF type_definition_topology]
+
+lemma TOPOLOGY: "ALL L::'A::type topology.
+ open L re_null &
+ open L re_universe &
+ (ALL (a::'A::type => bool) b::'A::type => bool.
+ open L a & open L b --> open L (re_intersect a b)) &
+ (ALL P::('A::type => bool) => bool.
+ re_subset P (open L) --> open L (re_Union P))"
+ by (import hollight TOPOLOGY)
+
+lemma TOPOLOGY_UNION: "ALL (x::'A::type topology) xa::('A::type => bool) => bool.
+ re_subset xa (open x) --> open x (re_Union xa)"
+ by (import hollight TOPOLOGY_UNION)
+
+constdefs
+ neigh :: "'A::type topology => ('A::type => bool) * 'A::type => bool"
+ "neigh ==
+%(u::'A::type topology) ua::('A::type => bool) * 'A::type.
+ EX P::'A::type => bool. open u P & re_subset P (fst ua) & P (snd ua)"
+
+lemma DEF_neigh: "neigh =
+(%(u::'A::type topology) ua::('A::type => bool) * 'A::type.
+ EX P::'A::type => bool. open u P & re_subset P (fst ua) & P (snd ua))"
+ by (import hollight DEF_neigh)
+
+lemma OPEN_OWN_NEIGH: "ALL (S::'A::type => bool) (top::'A::type topology) x::'A::type.
+ open top S & S x --> neigh top (S, x)"
+ by (import hollight OPEN_OWN_NEIGH)
+
+lemma OPEN_UNOPEN: "ALL (S::'A::type => bool) top::'A::type topology.
+ open top S =
+ (re_Union (%P::'A::type => bool. open top P & re_subset P S) = S)"
+ by (import hollight OPEN_UNOPEN)
+
+lemma OPEN_SUBOPEN: "ALL (S::'A::type => bool) top::'A::type topology.
+ open top S =
+ (ALL x::'A::type.
+ S x -->
+ (EX xa::'A::type => bool. xa x & open top xa & re_subset xa S))"
+ by (import hollight OPEN_SUBOPEN)
+
+lemma OPEN_NEIGH: "ALL (S::'A::type => bool) top::'A::type topology.
+ open top S =
+ (ALL x::'A::type.
+ S x -->
+ (EX xa::'A::type => bool. neigh top (xa, x) & re_subset xa S))"
+ by (import hollight OPEN_NEIGH)
+
+constdefs
+ closed :: "'A::type topology => ('A::type => bool) => bool"
+ "closed == %(u::'A::type topology) ua::'A::type => bool. open u (re_compl ua)"
+
+lemma DEF_closed: "closed =
+(%(u::'A::type topology) ua::'A::type => bool. open u (re_compl ua))"
+ by (import hollight DEF_closed)
+
+constdefs
+ limpt :: "'A::type topology => 'A::type => ('A::type => bool) => bool"
+ "limpt ==
+%(u::'A::type topology) (ua::'A::type) ub::'A::type => bool.
+ ALL N::'A::type => bool.
+ neigh u (N, ua) --> (EX y::'A::type. ua ~= y & ub y & N y)"
+
+lemma DEF_limpt: "limpt =
+(%(u::'A::type topology) (ua::'A::type) ub::'A::type => bool.
+ ALL N::'A::type => bool.
+ neigh u (N, ua) --> (EX y::'A::type. ua ~= y & ub y & N y))"
+ by (import hollight DEF_limpt)
+
+lemma CLOSED_LIMPT: "ALL (top::'A::type topology) S::'A::type => bool.
+ closed top S = (ALL x::'A::type. limpt top x S --> S x)"
+ by (import hollight CLOSED_LIMPT)
+
+constdefs
+ ismet :: "('A::type * 'A::type => hollight.real) => bool"
+ "ismet ==
+%u::'A::type * 'A::type => hollight.real.
+ (ALL (x::'A::type) y::'A::type.
+ (u (x, y) = real_of_num (0::nat)) = (x = y)) &
+ (ALL (x::'A::type) (y::'A::type) z::'A::type.
+ real_le (u (y, z)) (real_add (u (x, y)) (u (x, z))))"
+
+lemma DEF_ismet: "ismet =
+(%u::'A::type * 'A::type => hollight.real.
+ (ALL (x::'A::type) y::'A::type.
+ (u (x, y) = real_of_num (0::nat)) = (x = y)) &
+ (ALL (x::'A::type) (y::'A::type) z::'A::type.
+ real_le (u (y, z)) (real_add (u (x, y)) (u (x, z)))))"
+ by (import hollight DEF_ismet)
+
+typedef (open) ('A) metric = "(Collect::(('A::type * 'A::type => hollight.real) => bool)
+ => ('A::type * 'A::type => hollight.real) set)
+ (ismet::('A::type * 'A::type => hollight.real) => bool)" morphisms "mdist" "metric"
+ apply (rule light_ex_imp_nonempty[where t="(Eps::(('A::type * 'A::type => hollight.real) => bool)
+ => 'A::type * 'A::type => hollight.real)
+ (ismet::('A::type * 'A::type => hollight.real) => bool)"])
+ by (import hollight TYDEF_metric)
+
+syntax
+ mdist :: _
+
+syntax
+ metric :: _
+
+lemmas "TYDEF_metric_@intern" = typedef_hol2hollight
+ [where a="a :: 'A::type metric" and r=r ,
+ OF type_definition_metric]
+
+lemma METRIC_ISMET: "ALL m::'A::type metric. ismet (mdist m)"
+ by (import hollight METRIC_ISMET)
+
+lemma METRIC_ZERO: "ALL (m::'A::type metric) (x::'A::type) y::'A::type.
+ (mdist m (x, y) = real_of_num (0::nat)) = (x = y)"
+ by (import hollight METRIC_ZERO)
+
+lemma METRIC_SAME: "ALL (m::'A::type metric) x::'A::type. mdist m (x, x) = real_of_num (0::nat)"
+ by (import hollight METRIC_SAME)
+
+lemma METRIC_POS: "ALL (m::'A::type metric) (x::'A::type) y::'A::type.
+ real_le (real_of_num (0::nat)) (mdist m (x, y))"
+ by (import hollight METRIC_POS)
+
+lemma METRIC_SYM: "ALL (m::'A::type metric) (x::'A::type) y::'A::type.
+ mdist m (x, y) = mdist m (y, x)"
+ by (import hollight METRIC_SYM)
+
+lemma METRIC_TRIANGLE: "ALL (m::'A::type metric) (x::'A::type) (y::'A::type) z::'A::type.
+ real_le (mdist m (x, z)) (real_add (mdist m (x, y)) (mdist m (y, z)))"
+ by (import hollight METRIC_TRIANGLE)
+
+lemma METRIC_NZ: "ALL (m::'A::type metric) (x::'A::type) y::'A::type.
+ x ~= y --> real_lt (real_of_num (0::nat)) (mdist m (x, y))"
+ by (import hollight METRIC_NZ)
+
+constdefs
+ mtop :: "'A::type metric => 'A::type topology"
+ "mtop ==
+%u::'A::type metric.
+ topology
+ (%S::'A::type => bool.
+ ALL x::'A::type.
+ S x -->
+ (EX e::hollight.real.
+ real_lt (real_of_num (0::nat)) e &
+ (ALL y::'A::type. real_lt (mdist u (x, y)) e --> S y)))"
+
+lemma DEF_mtop: "mtop =
+(%u::'A::type metric.
+ topology
+ (%S::'A::type => bool.
+ ALL x::'A::type.
+ S x -->
+ (EX e::hollight.real.
+ real_lt (real_of_num (0::nat)) e &
+ (ALL y::'A::type. real_lt (mdist u (x, y)) e --> S y))))"
+ by (import hollight DEF_mtop)
+
+lemma mtop_istopology: "ALL m::'A::type metric.
+ istopology
+ (%S::'A::type => bool.
+ ALL x::'A::type.
+ S x -->
+ (EX e::hollight.real.
+ real_lt (real_of_num (0::nat)) e &
+ (ALL y::'A::type. real_lt (mdist m (x, y)) e --> S y)))"
+ by (import hollight mtop_istopology)
+
+lemma MTOP_OPEN: "ALL m::'A::type metric.
+ open (mtop m) (S::'A::type => bool) =
+ (ALL x::'A::type.
+ S x -->
+ (EX e::hollight.real.
+ real_lt (real_of_num (0::nat)) e &
+ (ALL y::'A::type. real_lt (mdist m (x, y)) e --> S y)))"
+ by (import hollight MTOP_OPEN)
+
+constdefs
+ ball :: "'A::type metric => 'A::type * hollight.real => 'A::type => bool"
+ "ball ==
+%(u::'A::type metric) (ua::'A::type * hollight.real) y::'A::type.
+ real_lt (mdist u (fst ua, y)) (snd ua)"
+
+lemma DEF_ball: "ball =
+(%(u::'A::type metric) (ua::'A::type * hollight.real) y::'A::type.
+ real_lt (mdist u (fst ua, y)) (snd ua))"
+ by (import hollight DEF_ball)
+
+lemma BALL_OPEN: "ALL (m::'A::type metric) (x::'A::type) e::hollight.real.
+ real_lt (real_of_num (0::nat)) e --> open (mtop m) (ball m (x, e))"
+ by (import hollight BALL_OPEN)
+
+lemma BALL_NEIGH: "ALL (m::'A::type metric) (x::'A::type) e::hollight.real.
+ real_lt (real_of_num (0::nat)) e --> neigh (mtop m) (ball m (x, e), x)"
+ by (import hollight BALL_NEIGH)
+
+lemma MTOP_LIMPT: "ALL (m::'A::type metric) (x::'A::type) S::'A::type => bool.
+ limpt (mtop m) x S =
+ (ALL e::hollight.real.
+ real_lt (real_of_num (0::nat)) e -->
+ (EX y::'A::type. x ~= y & S y & real_lt (mdist m (x, y)) e))"
+ by (import hollight MTOP_LIMPT)
+
+lemma ISMET_R1: "ismet
+ (GABS
+ (%f::hollight.real * hollight.real => hollight.real.
+ ALL (x::hollight.real) y::hollight.real.
+ GEQ (f (x, y)) (real_abs (real_sub y x))))"
+ by (import hollight ISMET_R1)
+
+constdefs
+ mr1 :: "hollight.real metric"
+ "mr1 ==
+metric
+ (GABS
+ (%f::hollight.real * hollight.real => hollight.real.
+ ALL (x::hollight.real) y::hollight.real.
+ GEQ (f (x, y)) (real_abs (real_sub y x))))"
+
+lemma DEF_mr1: "mr1 =
+metric
+ (GABS
+ (%f::hollight.real * hollight.real => hollight.real.
+ ALL (x::hollight.real) y::hollight.real.
+ GEQ (f (x, y)) (real_abs (real_sub y x))))"
+ by (import hollight DEF_mr1)
+
+lemma MR1_DEF: "ALL (x::hollight.real) y::hollight.real.
+ mdist mr1 (x, y) = real_abs (real_sub y x)"
+ by (import hollight MR1_DEF)
+
+lemma MR1_ADD: "ALL (x::hollight.real) d::hollight.real.
+ mdist mr1 (x, real_add x d) = real_abs d"
+ by (import hollight MR1_ADD)
+
+lemma MR1_SUB: "ALL (x::hollight.real) d::hollight.real.
+ mdist mr1 (x, real_sub x d) = real_abs d"
+ by (import hollight MR1_SUB)
+
+lemma MR1_ADD_LE: "ALL (x::hollight.real) d::hollight.real.
+ real_le (real_of_num (0::nat)) d --> mdist mr1 (x, real_add x d) = d"
+ by (import hollight MR1_ADD_LE)
+
+lemma MR1_SUB_LE: "ALL (x::hollight.real) d::hollight.real.
+ real_le (real_of_num (0::nat)) d --> mdist mr1 (x, real_sub x d) = d"
+ by (import hollight MR1_SUB_LE)
+
+lemma MR1_ADD_LT: "ALL (x::hollight.real) d::hollight.real.
+ real_lt (real_of_num (0::nat)) d --> mdist mr1 (x, real_add x d) = d"
+ by (import hollight MR1_ADD_LT)
+
+lemma MR1_SUB_LT: "ALL (x::hollight.real) d::hollight.real.
+ real_lt (real_of_num (0::nat)) d --> mdist mr1 (x, real_sub x d) = d"
+ by (import hollight MR1_SUB_LT)
+
+lemma MR1_BETWEEN1: "ALL (x::hollight.real) (y::hollight.real) z::hollight.real.
+ real_lt x z & real_lt (mdist mr1 (x, y)) (real_sub z x) --> real_lt y z"
+ by (import hollight MR1_BETWEEN1)
+
+lemma MR1_LIMPT: "ALL x::hollight.real. limpt (mtop mr1) x re_universe"
+ by (import hollight MR1_LIMPT)
+
+constdefs
+ dorder :: "('A::type => 'A::type => bool) => bool"
+ "dorder ==
+%u::'A::type => 'A::type => bool.
+ ALL (x::'A::type) y::'A::type.
+ u x x & u y y -->
+ (EX z::'A::type. u z z & (ALL w::'A::type. u w z --> u w x & u w y))"
+
+lemma DEF_dorder: "dorder =
+(%u::'A::type => 'A::type => bool.
+ ALL (x::'A::type) y::'A::type.
+ u x x & u y y -->
+ (EX z::'A::type. u z z & (ALL w::'A::type. u w z --> u w x & u w y)))"
+ by (import hollight DEF_dorder)
+
+constdefs
+ tends :: "('B::type => 'A::type)
+=> 'A::type => 'A::type topology * ('B::type => 'B::type => bool) => bool"
+ "tends ==
+%(u::'B::type => 'A::type) (ua::'A::type)
+ ub::'A::type topology * ('B::type => 'B::type => bool).
+ ALL N::'A::type => bool.
+ neigh (fst ub) (N, ua) -->
+ (EX n::'B::type.
+ snd ub n n & (ALL m::'B::type. snd ub m n --> N (u m)))"
+
+lemma DEF_tends: "tends =
+(%(u::'B::type => 'A::type) (ua::'A::type)
+ ub::'A::type topology * ('B::type => 'B::type => bool).
+ ALL N::'A::type => bool.
+ neigh (fst ub) (N, ua) -->
+ (EX n::'B::type.
+ snd ub n n & (ALL m::'B::type. snd ub m n --> N (u m))))"
+ by (import hollight DEF_tends)
+
+constdefs
+ bounded :: "'A::type metric * ('B::type => 'B::type => bool)
+=> ('B::type => 'A::type) => bool"
+ "bounded ==
+%(u::'A::type metric * ('B::type => 'B::type => bool))
+ ua::'B::type => 'A::type.
+ EX (k::hollight.real) (x::'A::type) N::'B::type.
+ snd u N N &
+ (ALL n::'B::type. snd u n N --> real_lt (mdist (fst u) (ua n, x)) k)"
+
+lemma DEF_bounded: "bounded =
+(%(u::'A::type metric * ('B::type => 'B::type => bool))
+ ua::'B::type => 'A::type.
+ EX (k::hollight.real) (x::'A::type) N::'B::type.
+ snd u N N &
+ (ALL n::'B::type. snd u n N --> real_lt (mdist (fst u) (ua n, x)) k))"
+ by (import hollight DEF_bounded)
+
+constdefs
+ tendsto :: "'A::type metric * 'A::type => 'A::type => 'A::type => bool"
+ "tendsto ==
+%(u::'A::type metric * 'A::type) (ua::'A::type) ub::'A::type.
+ real_lt (real_of_num (0::nat)) (mdist (fst u) (snd u, ua)) &
+ real_le (mdist (fst u) (snd u, ua)) (mdist (fst u) (snd u, ub))"
+
+lemma DEF_tendsto: "tendsto =
+(%(u::'A::type metric * 'A::type) (ua::'A::type) ub::'A::type.
+ real_lt (real_of_num (0::nat)) (mdist (fst u) (snd u, ua)) &
+ real_le (mdist (fst u) (snd u, ua)) (mdist (fst u) (snd u, ub)))"
+ by (import hollight DEF_tendsto)
+
+lemma DORDER_LEMMA: "ALL g::'A::type => 'A::type => bool.
+ dorder g -->
+ (ALL (P::'A::type => bool) Q::'A::type => bool.
+ (EX n::'A::type. g n n & (ALL m::'A::type. g m n --> P m)) &
+ (EX n::'A::type. g n n & (ALL m::'A::type. g m n --> Q m)) -->
+ (EX n::'A::type. g n n & (ALL m::'A::type. g m n --> P m & Q m)))"
+ by (import hollight DORDER_LEMMA)
+
+lemma DORDER_NGE: "dorder >="
+ by (import hollight DORDER_NGE)
+
+lemma DORDER_TENDSTO: "ALL (m::'A::type metric) x::'A::type. dorder (tendsto (m, x))"
+ by (import hollight DORDER_TENDSTO)
+
+lemma MTOP_TENDS: "ALL (d::'A::type metric) (g::'B::type => 'B::type => bool)
+ (x::'B::type => 'A::type) x0::'A::type.
+ tends x x0 (mtop d, g) =
+ (ALL e::hollight.real.
+ real_lt (real_of_num (0::nat)) e -->
+ (EX n::'B::type.
+ g n n &
+ (ALL m::'B::type. g m n --> real_lt (mdist d (x m, x0)) e)))"
+ by (import hollight MTOP_TENDS)
+
+lemma MTOP_TENDS_UNIQ: "ALL (g::'B::type => 'B::type => bool) d::'A::type metric.
+ dorder g -->
+ tends (x::'B::type => 'A::type) (x0::'A::type) (mtop d, g) &
+ tends x (x1::'A::type) (mtop d, g) -->
+ x0 = x1"
+ by (import hollight MTOP_TENDS_UNIQ)
+
+lemma SEQ_TENDS: "ALL (d::'A::type metric) (x::nat => 'A::type) x0::'A::type.
+ tends x x0 (mtop d, >=) =
+ (ALL xa::hollight.real.
+ real_lt (real_of_num (0::nat)) xa -->
+ (EX xb::nat.
+ ALL xc::nat. >= xc xb --> real_lt (mdist d (x xc, x0)) xa))"
+ by (import hollight SEQ_TENDS)
+
+lemma LIM_TENDS: "ALL (m1::'A::type metric) (m2::'B::type metric) (f::'A::type => 'B::type)
+ (x0::'A::type) y0::'B::type.
+ limpt (mtop m1) x0 re_universe -->
+ tends f y0 (mtop m2, tendsto (m1, x0)) =
+ (ALL e::hollight.real.
+ real_lt (real_of_num (0::nat)) e -->
+ (EX d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL x::'A::type.
+ real_lt (real_of_num (0::nat)) (mdist m1 (x, x0)) &
+ real_le (mdist m1 (x, x0)) d -->
+ real_lt (mdist m2 (f x, y0)) e)))"
+ by (import hollight LIM_TENDS)
+
+lemma LIM_TENDS2: "ALL (m1::'A::type metric) (m2::'B::type metric) (f::'A::type => 'B::type)
+ (x0::'A::type) y0::'B::type.
+ limpt (mtop m1) x0 re_universe -->
+ tends f y0 (mtop m2, tendsto (m1, x0)) =
+ (ALL e::hollight.real.
+ real_lt (real_of_num (0::nat)) e -->
+ (EX d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL x::'A::type.
+ real_lt (real_of_num (0::nat)) (mdist m1 (x, x0)) &
+ real_lt (mdist m1 (x, x0)) d -->
+ real_lt (mdist m2 (f x, y0)) e)))"
+ by (import hollight LIM_TENDS2)
+
+lemma MR1_BOUNDED: "ALL (g::'A::type => 'A::type => bool) f::'A::type => hollight.real.
+ bounded (mr1, g) f =
+ (EX (k::hollight.real) N::'A::type.
+ g N N & (ALL n::'A::type. g n N --> real_lt (real_abs (f n)) k))"
+ by (import hollight MR1_BOUNDED)
+
+lemma NET_NULL: "ALL (g::'A::type => 'A::type => bool) (x::'A::type => hollight.real)
+ x0::hollight.real.
+ tends x x0 (mtop mr1, g) =
+ tends (%n::'A::type. real_sub (x n) x0) (real_of_num (0::nat))
+ (mtop mr1, g)"
+ by (import hollight NET_NULL)
+
+lemma NET_CONV_BOUNDED: "ALL (g::'A::type => 'A::type => bool) (x::'A::type => hollight.real)
+ x0::hollight.real. tends x x0 (mtop mr1, g) --> bounded (mr1, g) x"
+ by (import hollight NET_CONV_BOUNDED)
+
+lemma NET_CONV_NZ: "ALL (g::'A::type => 'A::type => bool) (x::'A::type => hollight.real)
+ x0::hollight.real.
+ tends x x0 (mtop mr1, g) & x0 ~= real_of_num (0::nat) -->
+ (EX N::'A::type.
+ g N N & (ALL n::'A::type. g n N --> x n ~= real_of_num (0::nat)))"
+ by (import hollight NET_CONV_NZ)
+
+lemma NET_CONV_IBOUNDED: "ALL (g::'A::type => 'A::type => bool) (x::'A::type => hollight.real)
+ x0::hollight.real.
+ tends x x0 (mtop mr1, g) & x0 ~= real_of_num (0::nat) -->
+ bounded (mr1, g) (%n::'A::type. real_inv (x n))"
+ by (import hollight NET_CONV_IBOUNDED)
+
+lemma NET_NULL_ADD: "ALL g::'A::type => 'A::type => bool.
+ dorder g -->
+ (ALL (x::'A::type => hollight.real) y::'A::type => hollight.real.
+ tends x (real_of_num (0::nat)) (mtop mr1, g) &
+ tends y (real_of_num (0::nat)) (mtop mr1, g) -->
+ tends (%n::'A::type. real_add (x n) (y n)) (real_of_num (0::nat))
+ (mtop mr1, g))"
+ by (import hollight NET_NULL_ADD)
+
+lemma NET_NULL_MUL: "ALL g::'A::type => 'A::type => bool.
+ dorder g -->
+ (ALL (x::'A::type => hollight.real) y::'A::type => hollight.real.
+ bounded (mr1, g) x & tends y (real_of_num (0::nat)) (mtop mr1, g) -->
+ tends (%n::'A::type. real_mul (x n) (y n)) (real_of_num (0::nat))
+ (mtop mr1, g))"
+ by (import hollight NET_NULL_MUL)
+
+lemma NET_NULL_CMUL: "ALL (g::'A::type => 'A::type => bool) (k::hollight.real)
+ x::'A::type => hollight.real.
+ tends x (real_of_num (0::nat)) (mtop mr1, g) -->
+ tends (%n::'A::type. real_mul k (x n)) (real_of_num (0::nat))
+ (mtop mr1, g)"
+ by (import hollight NET_NULL_CMUL)
+
+lemma NET_ADD: "ALL (g::'A::type => 'A::type => bool) (x::'A::type => hollight.real)
+ (x0::hollight.real) (y::'A::type => hollight.real) y0::hollight.real.
+ dorder g -->
+ tends x x0 (mtop mr1, g) & tends y y0 (mtop mr1, g) -->
+ tends (%n::'A::type. real_add (x n) (y n)) (real_add x0 y0) (mtop mr1, g)"
+ by (import hollight NET_ADD)
+
+lemma NET_NEG: "ALL (g::'A::type => 'A::type => bool) (x::'A::type => hollight.real)
+ x0::hollight.real.
+ dorder g -->
+ tends x x0 (mtop mr1, g) =
+ tends (%n::'A::type. real_neg (x n)) (real_neg x0) (mtop mr1, g)"
+ by (import hollight NET_NEG)
+
+lemma NET_SUB: "ALL (g::'A::type => 'A::type => bool) (x::'A::type => hollight.real)
+ (x0::hollight.real) (y::'A::type => hollight.real) y0::hollight.real.
+ dorder g -->
+ tends x x0 (mtop mr1, g) & tends y y0 (mtop mr1, g) -->
+ tends (%xa::'A::type. real_sub (x xa) (y xa)) (real_sub x0 y0)
+ (mtop mr1, g)"
+ by (import hollight NET_SUB)
+
+lemma NET_MUL: "ALL (g::'A::type => 'A::type => bool) (x::'A::type => hollight.real)
+ (y::'A::type => hollight.real) (x0::hollight.real) y0::hollight.real.
+ dorder g -->
+ tends x x0 (mtop mr1, g) & tends y y0 (mtop mr1, g) -->
+ tends (%n::'A::type. real_mul (x n) (y n)) (real_mul x0 y0) (mtop mr1, g)"
+ by (import hollight NET_MUL)
+
+lemma NET_INV: "ALL (g::'A::type => 'A::type => bool) (x::'A::type => hollight.real)
+ x0::hollight.real.
+ dorder g -->
+ tends x x0 (mtop mr1, g) & x0 ~= real_of_num (0::nat) -->
+ tends (%n::'A::type. real_inv (x n)) (real_inv x0) (mtop mr1, g)"
+ by (import hollight NET_INV)
+
+lemma NET_DIV: "ALL (g::'A::type => 'A::type => bool) (x::'A::type => hollight.real)
+ (x0::hollight.real) (y::'A::type => hollight.real) y0::hollight.real.
+ dorder g -->
+ tends x x0 (mtop mr1, g) &
+ tends y y0 (mtop mr1, g) & y0 ~= real_of_num (0::nat) -->
+ tends (%xa::'A::type. real_div (x xa) (y xa)) (real_div x0 y0)
+ (mtop mr1, g)"
+ by (import hollight NET_DIV)
+
+lemma NET_ABS: "ALL (x::'A::type => hollight.real) x0::hollight.real.
+ tends x x0 (mtop mr1, g::'A::type => 'A::type => bool) -->
+ tends (%n::'A::type. real_abs (x n)) (real_abs x0) (mtop mr1, g)"
+ by (import hollight NET_ABS)
+
+lemma NET_SUM: "ALL g::'q_71813::type => 'q_71813::type => bool.
+ dorder g &
+ tends (%x::'q_71813::type. real_of_num (0::nat)) (real_of_num (0::nat))
+ (mtop mr1, g) -->
+ (ALL (x::nat) n::nat.
+ (ALL r::nat.
+ <= x r & < r (x + n) -->
+ tends ((f::nat => 'q_71813::type => hollight.real) r)
+ ((l::nat => hollight.real) r) (mtop mr1, g)) -->
+ tends (%xa::'q_71813::type. psum (x, n) (%r::nat. f r xa))
+ (psum (x, n) l) (mtop mr1, g))"
+ by (import hollight NET_SUM)
+
+lemma NET_LE: "ALL (g::'A::type => 'A::type => bool) (x::'A::type => hollight.real)
+ (x0::hollight.real) (y::'A::type => hollight.real) y0::hollight.real.
+ dorder g -->
+ tends x x0 (mtop mr1, g) &
+ tends y y0 (mtop mr1, g) &
+ (EX N::'A::type.
+ g N N & (ALL n::'A::type. g n N --> real_le (x n) (y n))) -->
+ real_le x0 y0"
+ by (import hollight NET_LE)
+
+constdefs
+ tends_num_real :: "(nat => hollight.real) => hollight.real => bool"
+ "tends_num_real ==
+%(u::nat => hollight.real) ua::hollight.real. tends u ua (mtop mr1, >=)"
+
+lemma DEF_tends_num_real: "tends_num_real =
+(%(u::nat => hollight.real) ua::hollight.real. tends u ua (mtop mr1, >=))"
+ by (import hollight DEF_tends_num_real)
+
+lemma SEQ: "ALL (x::nat => hollight.real) x0::hollight.real.
+ tends_num_real x x0 =
+ (ALL e::hollight.real.
+ real_lt (real_of_num (0::nat)) e -->
+ (EX N::nat.
+ ALL n::nat. >= n N --> real_lt (real_abs (real_sub (x n) x0)) e))"
+ by (import hollight SEQ)
+
+lemma SEQ_CONST: "ALL k::hollight.real. tends_num_real (%x::nat. k) k"
+ by (import hollight SEQ_CONST)
+
+lemma SEQ_ADD: "ALL (x::nat => hollight.real) (x0::hollight.real) (y::nat => hollight.real)
+ y0::hollight.real.
+ tends_num_real x x0 & tends_num_real y y0 -->
+ tends_num_real (%n::nat. real_add (x n) (y n)) (real_add x0 y0)"
+ by (import hollight SEQ_ADD)
+
+lemma SEQ_MUL: "ALL (x::nat => hollight.real) (x0::hollight.real) (y::nat => hollight.real)
+ y0::hollight.real.
+ tends_num_real x x0 & tends_num_real y y0 -->
+ tends_num_real (%n::nat. real_mul (x n) (y n)) (real_mul x0 y0)"
+ by (import hollight SEQ_MUL)
+
+lemma SEQ_NEG: "ALL (x::nat => hollight.real) x0::hollight.real.
+ tends_num_real x x0 =
+ tends_num_real (%n::nat. real_neg (x n)) (real_neg x0)"
+ by (import hollight SEQ_NEG)
+
+lemma SEQ_INV: "ALL (x::nat => hollight.real) x0::hollight.real.
+ tends_num_real x x0 & x0 ~= real_of_num (0::nat) -->
+ tends_num_real (%n::nat. real_inv (x n)) (real_inv x0)"
+ by (import hollight SEQ_INV)
+
+lemma SEQ_SUB: "ALL (x::nat => hollight.real) (x0::hollight.real) (y::nat => hollight.real)
+ y0::hollight.real.
+ tends_num_real x x0 & tends_num_real y y0 -->
+ tends_num_real (%n::nat. real_sub (x n) (y n)) (real_sub x0 y0)"
+ by (import hollight SEQ_SUB)
+
+lemma SEQ_DIV: "ALL (x::nat => hollight.real) (x0::hollight.real) (y::nat => hollight.real)
+ y0::hollight.real.
+ tends_num_real x x0 &
+ tends_num_real y y0 & y0 ~= real_of_num (0::nat) -->
+ tends_num_real (%n::nat. real_div (x n) (y n)) (real_div x0 y0)"
+ by (import hollight SEQ_DIV)
+
+lemma SEQ_UNIQ: "ALL (x::nat => hollight.real) (x1::hollight.real) x2::hollight.real.
+ tends_num_real x x1 & tends_num_real x x2 --> x1 = x2"
+ by (import hollight SEQ_UNIQ)
+
+lemma SEQ_NULL: "ALL (s::nat => hollight.real) l::hollight.real.
+ tends_num_real s l =
+ tends_num_real (%n::nat. real_sub (s n) l) (real_of_num (0::nat))"
+ by (import hollight SEQ_NULL)
+
+lemma SEQ_SUM: "ALL (f::nat => nat => hollight.real) (l::nat => hollight.real) (m::nat)
+ n::nat.
+ (ALL x::nat. <= m x & < x (m + n) --> tends_num_real (f x) (l x)) -->
+ tends_num_real (%k::nat. psum (m, n) (%r::nat. f r k)) (psum (m, n) l)"
+ by (import hollight SEQ_SUM)
+
+lemma SEQ_TRANSFORM: "ALL (x::nat => hollight.real) (xa::nat => hollight.real) (xb::hollight.real)
+ xc::nat.
+ (ALL n::nat. <= xc n --> x n = xa n) & tends_num_real x xb -->
+ tends_num_real xa xb"
+ by (import hollight SEQ_TRANSFORM)
+
+constdefs
+ convergent :: "(nat => hollight.real) => bool"
+ "convergent == %u::nat => hollight.real. Ex (tends_num_real u)"
+
+lemma DEF_convergent: "convergent = (%u::nat => hollight.real. Ex (tends_num_real u))"
+ by (import hollight DEF_convergent)
+
+constdefs
+ cauchy :: "(nat => hollight.real) => bool"
+ "cauchy ==
+%u::nat => hollight.real.
+ ALL e::hollight.real.
+ real_lt (real_of_num (0::nat)) e -->
+ (EX N::nat.
+ ALL (m::nat) n::nat.
+ >= m N & >= n N -->
+ real_lt (real_abs (real_sub (u m) (u n))) e)"
+
+lemma DEF_cauchy: "cauchy =
+(%u::nat => hollight.real.
+ ALL e::hollight.real.
+ real_lt (real_of_num (0::nat)) e -->
+ (EX N::nat.
+ ALL (m::nat) n::nat.
+ >= m N & >= n N -->
+ real_lt (real_abs (real_sub (u m) (u n))) e))"
+ by (import hollight DEF_cauchy)
+
+constdefs
+ lim :: "(nat => hollight.real) => hollight.real"
+ "lim == %u::nat => hollight.real. Eps (tends_num_real u)"
+
+lemma DEF_lim: "lim = (%u::nat => hollight.real. Eps (tends_num_real u))"
+ by (import hollight DEF_lim)
+
+lemma SEQ_LIM: "ALL f::nat => hollight.real. convergent f = tends_num_real f (lim f)"
+ by (import hollight SEQ_LIM)
+
+constdefs
+ subseq :: "(nat => nat) => bool"
+ "subseq == %u::nat => nat. ALL (m::nat) n::nat. < m n --> < (u m) (u n)"
+
+lemma DEF_subseq: "subseq = (%u::nat => nat. ALL (m::nat) n::nat. < m n --> < (u m) (u n))"
+ by (import hollight DEF_subseq)
+
+lemma SUBSEQ_SUC: "ALL f::nat => nat. subseq f = (ALL n::nat. < (f n) (f (Suc n)))"
+ by (import hollight SUBSEQ_SUC)
+
+consts
+ mono :: "(nat => hollight.real) => bool"
+
+defs
+ mono_def: "hollight.mono ==
+%u::nat => hollight.real.
+ (ALL (m::nat) n::nat. <= m n --> real_le (u m) (u n)) |
+ (ALL (m::nat) n::nat. <= m n --> hollight.real_ge (u m) (u n))"
+
+lemma DEF_mono: "hollight.mono =
+(%u::nat => hollight.real.
+ (ALL (m::nat) n::nat. <= m n --> real_le (u m) (u n)) |
+ (ALL (m::nat) n::nat. <= m n --> hollight.real_ge (u m) (u n)))"
+ by (import hollight DEF_mono)
+
+lemma MONO_SUC: "ALL f::nat => hollight.real.
+ hollight.mono f =
+ ((ALL x::nat. hollight.real_ge (f (Suc x)) (f x)) |
+ (ALL n::nat. real_le (f (Suc n)) (f n)))"
+ by (import hollight MONO_SUC)
+
+lemma MAX_LEMMA: "ALL (s::nat => hollight.real) N::nat.
+ EX k::hollight.real. ALL n::nat. < n N --> real_lt (real_abs (s n)) k"
+ by (import hollight MAX_LEMMA)
+
+lemma SEQ_BOUNDED: "ALL s::nat => hollight.real.
+ bounded (mr1, >=) s =
+ (EX k::hollight.real. ALL n::nat. real_lt (real_abs (s n)) k)"
+ by (import hollight SEQ_BOUNDED)
+
+lemma SEQ_BOUNDED_2: "ALL (f::nat => hollight.real) (k::hollight.real) K::hollight.real.
+ (ALL n::nat. real_le k (f n) & real_le (f n) K) --> bounded (mr1, >=) f"
+ by (import hollight SEQ_BOUNDED_2)
+
+lemma SEQ_CBOUNDED: "ALL f::nat => hollight.real. cauchy f --> bounded (mr1, >=) f"
+ by (import hollight SEQ_CBOUNDED)
+
+lemma SEQ_ICONV: "ALL f::nat => hollight.real.
+ bounded (mr1, >=) f &
+ (ALL (m::nat) n::nat. >= m n --> hollight.real_ge (f m) (f n)) -->
+ convergent f"
+ by (import hollight SEQ_ICONV)
+
+lemma SEQ_NEG_CONV: "ALL f::nat => hollight.real.
+ convergent f = convergent (%n::nat. real_neg (f n))"
+ by (import hollight SEQ_NEG_CONV)
+
+lemma SEQ_NEG_BOUNDED: "ALL f::nat => hollight.real.
+ bounded (mr1, >=) (%n::nat. real_neg (f n)) = bounded (mr1, >=) f"
+ by (import hollight SEQ_NEG_BOUNDED)
+
+lemma SEQ_BCONV: "ALL f::nat => hollight.real.
+ bounded (mr1, >=) f & hollight.mono f --> convergent f"
+ by (import hollight SEQ_BCONV)
+
+lemma SEQ_MONOSUB: "ALL s::nat => hollight.real.
+ EX f::nat => nat. subseq f & hollight.mono (%n::nat. s (f n))"
+ by (import hollight SEQ_MONOSUB)
+
+lemma SEQ_SBOUNDED: "ALL (s::nat => hollight.real) f::nat => nat.
+ bounded (mr1, >=) s --> bounded (mr1, >=) (%n::nat. s (f n))"
+ by (import hollight SEQ_SBOUNDED)
+
+lemma SEQ_SUBLE: "ALL (f::nat => nat) x::nat. subseq f --> <= x (f x)"
+ by (import hollight SEQ_SUBLE)
+
+lemma SEQ_DIRECT: "ALL f::nat => nat.
+ subseq f --> (ALL (N1::nat) N2::nat. EX x::nat. >= x N1 & >= (f x) N2)"
+ by (import hollight SEQ_DIRECT)
+
+lemma SEQ_CAUCHY: "ALL f::nat => hollight.real. cauchy f = convergent f"
+ by (import hollight SEQ_CAUCHY)
+
+lemma SEQ_LE: "ALL (f::nat => hollight.real) (g::nat => hollight.real) (l::hollight.real)
+ m::hollight.real.
+ tends_num_real f l &
+ tends_num_real g m &
+ (EX N::nat. ALL n::nat. >= n N --> real_le (f n) (g n)) -->
+ real_le l m"
+ by (import hollight SEQ_LE)
+
+lemma SEQ_LE_0: "ALL (x::nat => hollight.real) xa::nat => hollight.real.
+ tends_num_real x (real_of_num (0::nat)) &
+ (EX xb::nat.
+ ALL xc::nat.
+ >= xc xb --> real_le (real_abs (xa xc)) (real_abs (x xc))) -->
+ tends_num_real xa (real_of_num (0::nat))"
+ by (import hollight SEQ_LE_0)
+
+lemma SEQ_SUC: "ALL (f::nat => hollight.real) l::hollight.real.
+ tends_num_real f l = tends_num_real (%n::nat. f (Suc n)) l"
+ by (import hollight SEQ_SUC)
+
+lemma SEQ_ABS: "ALL f::nat => hollight.real.
+ tends_num_real (%n::nat. real_abs (f n)) (real_of_num (0::nat)) =
+ tends_num_real f (real_of_num (0::nat))"
+ by (import hollight SEQ_ABS)
+
+lemma SEQ_ABS_IMP: "ALL (f::nat => hollight.real) l::hollight.real.
+ tends_num_real f l -->
+ tends_num_real (%n::nat. real_abs (f n)) (real_abs l)"
+ by (import hollight SEQ_ABS_IMP)
+
+lemma SEQ_INV0: "ALL f::nat => hollight.real.
+ (ALL y::hollight.real.
+ EX N::nat. ALL n::nat. >= n N --> hollight.real_gt (f n) y) -->
+ tends_num_real (%n::nat. real_inv (f n)) (real_of_num (0::nat))"
+ by (import hollight SEQ_INV0)
+
+lemma SEQ_POWER_ABS: "ALL c::hollight.real.
+ real_lt (real_abs c) (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ tends_num_real (real_pow (real_abs c)) (real_of_num (0::nat))"
+ by (import hollight SEQ_POWER_ABS)
+
+lemma SEQ_POWER: "ALL c::hollight.real.
+ real_lt (real_abs c) (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ tends_num_real (real_pow c) (real_of_num (0::nat))"
+ by (import hollight SEQ_POWER)
+
+lemma NEST_LEMMA: "ALL (f::nat => hollight.real) g::nat => hollight.real.
+ (ALL n::nat. hollight.real_ge (f (Suc n)) (f n)) &
+ (ALL n::nat. real_le (g (Suc n)) (g n)) &
+ (ALL n::nat. real_le (f n) (g n)) -->
+ (EX (l::hollight.real) m::hollight.real.
+ real_le l m &
+ ((ALL n::nat. real_le (f n) l) & tends_num_real f l) &
+ (ALL n::nat. real_le m (g n)) & tends_num_real g m)"
+ by (import hollight NEST_LEMMA)
+
+lemma NEST_LEMMA_UNIQ: "ALL (f::nat => hollight.real) g::nat => hollight.real.
+ (ALL n::nat. hollight.real_ge (f (Suc n)) (f n)) &
+ (ALL n::nat. real_le (g (Suc n)) (g n)) &
+ (ALL n::nat. real_le (f n) (g n)) &
+ tends_num_real (%n::nat. real_sub (f n) (g n)) (real_of_num (0::nat)) -->
+ (EX l::hollight.real.
+ ((ALL n::nat. real_le (f n) l) & tends_num_real f l) &
+ (ALL n::nat. real_le l (g n)) & tends_num_real g l)"
+ by (import hollight NEST_LEMMA_UNIQ)
+
+lemma BOLZANO_LEMMA: "ALL P::hollight.real * hollight.real => bool.
+ (ALL (a::hollight.real) (b::hollight.real) c::hollight.real.
+ real_le a b & real_le b c & P (a, b) & P (b, c) --> P (a, c)) &
+ (ALL x::hollight.real.
+ EX d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL (a::hollight.real) b::hollight.real.
+ real_le a x & real_le x b & real_lt (real_sub b a) d -->
+ P (a, b))) -->
+ (ALL (a::hollight.real) b::hollight.real. real_le a b --> P (a, b))"
+ by (import hollight BOLZANO_LEMMA)
+
+constdefs
+ sums :: "(nat => hollight.real) => hollight.real => bool"
+ "sums ==
+%u::nat => hollight.real. tends_num_real (%n::nat. psum (0::nat, n) u)"
+
+lemma DEF_sums: "sums =
+(%u::nat => hollight.real. tends_num_real (%n::nat. psum (0::nat, n) u))"
+ by (import hollight DEF_sums)
+
+constdefs
+ summable :: "(nat => hollight.real) => bool"
+ "summable == %u::nat => hollight.real. Ex (sums u)"
+
+lemma DEF_summable: "summable = (%u::nat => hollight.real. Ex (sums u))"
+ by (import hollight DEF_summable)
+
+constdefs
+ suminf :: "(nat => hollight.real) => hollight.real"
+ "suminf == %u::nat => hollight.real. Eps (sums u)"
+
+lemma DEF_suminf: "suminf = (%u::nat => hollight.real. Eps (sums u))"
+ by (import hollight DEF_suminf)
+
+lemma SUM_SUMMABLE: "ALL (f::nat => hollight.real) l::hollight.real. sums f l --> summable f"
+ by (import hollight SUM_SUMMABLE)
+
+lemma SUMMABLE_SUM: "ALL f::nat => hollight.real. summable f --> sums f (suminf f)"
+ by (import hollight SUMMABLE_SUM)
+
+lemma SUM_UNIQ: "ALL (f::nat => hollight.real) x::hollight.real. sums f x --> x = suminf f"
+ by (import hollight SUM_UNIQ)
+
+lemma SER_UNIQ: "ALL (f::nat => hollight.real) (x::hollight.real) y::hollight.real.
+ sums f x & sums f y --> x = y"
+ by (import hollight SER_UNIQ)
+
+lemma SER_0: "ALL (f::nat => hollight.real) n::nat.
+ (ALL m::nat. <= n m --> f m = real_of_num (0::nat)) -->
+ sums f (psum (0::nat, n) f)"
+ by (import hollight SER_0)
+
+lemma SER_POS_LE: "ALL (f::nat => hollight.real) n::nat.
+ summable f &
+ (ALL m::nat. <= n m --> real_le (real_of_num (0::nat)) (f m)) -->
+ real_le (psum (0::nat, n) f) (suminf f)"
+ by (import hollight SER_POS_LE)
+
+lemma SER_POS_LT: "ALL (f::nat => hollight.real) n::nat.
+ summable f &
+ (ALL m::nat. <= n m --> real_lt (real_of_num (0::nat)) (f m)) -->
+ real_lt (psum (0::nat, n) f) (suminf f)"
+ by (import hollight SER_POS_LT)
+
+lemma SER_GROUP: "ALL (f::nat => hollight.real) k::nat.
+ summable f & < (0::nat) k -->
+ sums (%n::nat. psum (n * k, k) f) (suminf f)"
+ by (import hollight SER_GROUP)
+
+lemma SER_PAIR: "ALL f::nat => hollight.real.
+ summable f -->
+ sums
+ (%n::nat.
+ psum
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * n,
+ NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))
+ f)
+ (suminf f)"
+ by (import hollight SER_PAIR)
+
+lemma SER_OFFSET: "ALL f::nat => hollight.real.
+ summable f -->
+ (ALL k::nat.
+ sums (%n::nat. f (n + k)) (real_sub (suminf f) (psum (0::nat, k) f)))"
+ by (import hollight SER_OFFSET)
+
+lemma SER_OFFSET_REV: "ALL (f::nat => hollight.real) k::nat.
+ summable (%n::nat. f (n + k)) -->
+ sums f (real_add (psum (0::nat, k) f) (suminf (%n::nat. f (n + k))))"
+ by (import hollight SER_OFFSET_REV)
+
+lemma SER_POS_LT_PAIR: "ALL (f::nat => hollight.real) n::nat.
+ summable f &
+ (ALL d::nat.
+ real_lt (real_of_num (0::nat))
+ (real_add (f (n + NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * d))
+ (f (n +
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * d +
+ NUMERAL_BIT1 (0::nat)))))) -->
+ real_lt (psum (0::nat, n) f) (suminf f)"
+ by (import hollight SER_POS_LT_PAIR)
+
+lemma SER_ADD: "ALL (x::nat => hollight.real) (x0::hollight.real) (y::nat => hollight.real)
+ y0::hollight.real.
+ sums x x0 & sums y y0 -->
+ sums (%n::nat. real_add (x n) (y n)) (real_add x0 y0)"
+ by (import hollight SER_ADD)
+
+lemma SER_CMUL: "ALL (x::nat => hollight.real) (x0::hollight.real) c::hollight.real.
+ sums x x0 --> sums (%n::nat. real_mul c (x n)) (real_mul c x0)"
+ by (import hollight SER_CMUL)
+
+lemma SER_NEG: "ALL (x::nat => hollight.real) x0::hollight.real.
+ sums x x0 --> sums (%xa::nat. real_neg (x xa)) (real_neg x0)"
+ by (import hollight SER_NEG)
+
+lemma SER_SUB: "ALL (x::nat => hollight.real) (x0::hollight.real) (y::nat => hollight.real)
+ y0::hollight.real.
+ sums x x0 & sums y y0 -->
+ sums (%n::nat. real_sub (x n) (y n)) (real_sub x0 y0)"
+ by (import hollight SER_SUB)
+
+lemma SER_CDIV: "ALL (x::nat => hollight.real) (x0::hollight.real) c::hollight.real.
+ sums x x0 --> sums (%xa::nat. real_div (x xa) c) (real_div x0 c)"
+ by (import hollight SER_CDIV)
+
+lemma SER_CAUCHY: "ALL f::nat => hollight.real.
+ summable f =
+ (ALL e::hollight.real.
+ real_lt (real_of_num (0::nat)) e -->
+ (EX N::nat.
+ ALL (m::nat) n::nat.
+ >= m N --> real_lt (real_abs (psum (m, n) f)) e))"
+ by (import hollight SER_CAUCHY)
+
+lemma SER_ZERO: "ALL f::nat => hollight.real.
+ summable f --> tends_num_real f (real_of_num (0::nat))"
+ by (import hollight SER_ZERO)
+
+lemma SER_COMPAR: "ALL (f::nat => hollight.real) g::nat => hollight.real.
+ (EX x::nat. ALL xa::nat. >= xa x --> real_le (real_abs (f xa)) (g xa)) &
+ summable g -->
+ summable f"
+ by (import hollight SER_COMPAR)
+
+lemma SER_COMPARA: "ALL (f::nat => hollight.real) g::nat => hollight.real.
+ (EX x::nat. ALL xa::nat. >= xa x --> real_le (real_abs (f xa)) (g xa)) &
+ summable g -->
+ summable (%k::nat. real_abs (f k))"
+ by (import hollight SER_COMPARA)
+
+lemma SER_LE: "ALL (f::nat => hollight.real) g::nat => hollight.real.
+ (ALL n::nat. real_le (f n) (g n)) & summable f & summable g -->
+ real_le (suminf f) (suminf g)"
+ by (import hollight SER_LE)
+
+lemma SER_LE2: "ALL (f::nat => hollight.real) g::nat => hollight.real.
+ (ALL n::nat. real_le (real_abs (f n)) (g n)) & summable g -->
+ summable f & real_le (suminf f) (suminf g)"
+ by (import hollight SER_LE2)
+
+lemma SER_ACONV: "ALL f::nat => hollight.real.
+ summable (%n::nat. real_abs (f n)) --> summable f"
+ by (import hollight SER_ACONV)
+
+lemma SER_ABS: "ALL f::nat => hollight.real.
+ summable (%n::nat. real_abs (f n)) -->
+ real_le (real_abs (suminf f)) (suminf (%n::nat. real_abs (f n)))"
+ by (import hollight SER_ABS)
+
+lemma GP_FINITE: "ALL x::hollight.real.
+ x ~= real_of_num (NUMERAL_BIT1 (0::nat)) -->
+ (ALL n::nat.
+ psum (0::nat, n) (real_pow x) =
+ real_div
+ (real_sub (real_pow x n) (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (real_sub x (real_of_num (NUMERAL_BIT1 (0::nat)))))"
+ by (import hollight GP_FINITE)
+
+lemma GP: "ALL x::hollight.real.
+ real_lt (real_abs x) (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ sums (real_pow x)
+ (real_inv (real_sub (real_of_num (NUMERAL_BIT1 (0::nat))) x))"
+ by (import hollight GP)
+
+lemma ABS_NEG_LEMMA: "ALL (c::hollight.real) (x::hollight.real) y::hollight.real.
+ real_le c (real_of_num (0::nat)) -->
+ real_le (real_abs x) (real_mul c (real_abs y)) -->
+ x = real_of_num (0::nat)"
+ by (import hollight ABS_NEG_LEMMA)
+
+lemma SER_RATIO: "ALL (f::nat => hollight.real) (c::hollight.real) N::nat.
+ real_lt c (real_of_num (NUMERAL_BIT1 (0::nat))) &
+ (ALL n::nat.
+ >= n N -->
+ real_le (real_abs (f (Suc n))) (real_mul c (real_abs (f n)))) -->
+ summable f"
+ by (import hollight SER_RATIO)
+
+lemma SEQ_TRUNCATION: "ALL (f::nat => hollight.real) (l::hollight.real) (n::nat) b::hollight.real.
+ sums f l & (ALL m::nat. real_le (real_abs (psum (n, m) f)) b) -->
+ real_le (real_abs (real_sub l (psum (0::nat, n) f))) b"
+ by (import hollight SEQ_TRUNCATION)
+
+constdefs
+ tends_real_real :: "(hollight.real => hollight.real) => hollight.real => hollight.real => bool"
+ "tends_real_real ==
+%(u::hollight.real => hollight.real) (ua::hollight.real) ub::hollight.real.
+ tends u ua (mtop mr1, tendsto (mr1, ub))"
+
+lemma DEF_tends_real_real: "tends_real_real =
+(%(u::hollight.real => hollight.real) (ua::hollight.real) ub::hollight.real.
+ tends u ua (mtop mr1, tendsto (mr1, ub)))"
+ by (import hollight DEF_tends_real_real)
+
+lemma LIM: "ALL (f::hollight.real => hollight.real) (y0::hollight.real)
+ x0::hollight.real.
+ tends_real_real f y0 x0 =
+ (ALL e::hollight.real.
+ real_lt (real_of_num (0::nat)) e -->
+ (EX d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) (real_abs (real_sub x x0)) &
+ real_lt (real_abs (real_sub x x0)) d -->
+ real_lt (real_abs (real_sub (f x) y0)) e)))"
+ by (import hollight LIM)
+
+lemma LIM_CONST: "ALL k::hollight.real. All (tends_real_real (%x::hollight.real. k) k)"
+ by (import hollight LIM_CONST)
+
+lemma LIM_ADD: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (l::hollight.real) m::hollight.real.
+ tends_real_real f l (x::hollight.real) & tends_real_real g m x -->
+ tends_real_real (%x::hollight.real. real_add (f x) (g x)) (real_add l m)
+ x"
+ by (import hollight LIM_ADD)
+
+lemma LIM_MUL: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (l::hollight.real) m::hollight.real.
+ tends_real_real f l (x::hollight.real) & tends_real_real g m x -->
+ tends_real_real (%x::hollight.real. real_mul (f x) (g x)) (real_mul l m)
+ x"
+ by (import hollight LIM_MUL)
+
+lemma LIM_NEG: "ALL (f::hollight.real => hollight.real) l::hollight.real.
+ tends_real_real f l (x::hollight.real) =
+ tends_real_real (%x::hollight.real. real_neg (f x)) (real_neg l) x"
+ by (import hollight LIM_NEG)
+
+lemma LIM_INV: "ALL (f::hollight.real => hollight.real) l::hollight.real.
+ tends_real_real f l (x::hollight.real) & l ~= real_of_num (0::nat) -->
+ tends_real_real (%x::hollight.real. real_inv (f x)) (real_inv l) x"
+ by (import hollight LIM_INV)
+
+lemma LIM_SUB: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (l::hollight.real) m::hollight.real.
+ tends_real_real f l (x::hollight.real) & tends_real_real g m x -->
+ tends_real_real (%x::hollight.real. real_sub (f x) (g x)) (real_sub l m)
+ x"
+ by (import hollight LIM_SUB)
+
+lemma LIM_DIV: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (l::hollight.real) m::hollight.real.
+ tends_real_real f l (x::hollight.real) &
+ tends_real_real g m x & m ~= real_of_num (0::nat) -->
+ tends_real_real (%x::hollight.real. real_div (f x) (g x)) (real_div l m)
+ x"
+ by (import hollight LIM_DIV)
+
+lemma LIM_NULL: "ALL (f::hollight.real => hollight.real) (l::hollight.real) x::hollight.real.
+ tends_real_real f l x =
+ tends_real_real (%x::hollight.real. real_sub (f x) l)
+ (real_of_num (0::nat)) x"
+ by (import hollight LIM_NULL)
+
+lemma LIM_SUM: "ALL (f::nat => hollight.real => hollight.real) (l::nat => hollight.real)
+ (m::nat) (n::nat) x::hollight.real.
+ (ALL xa::nat.
+ <= m xa & < xa (m + n) --> tends_real_real (f xa) (l xa) x) -->
+ tends_real_real (%x::hollight.real. psum (m, n) (%r::nat. f r x))
+ (psum (m, n) l) x"
+ by (import hollight LIM_SUM)
+
+lemma LIM_X: "ALL x0::hollight.real. tends_real_real (%x::hollight.real. x) x0 x0"
+ by (import hollight LIM_X)
+
+lemma LIM_UNIQ: "ALL (f::hollight.real => hollight.real) (l::hollight.real)
+ (m::hollight.real) x::hollight.real.
+ tends_real_real f l x & tends_real_real f m x --> l = m"
+ by (import hollight LIM_UNIQ)
+
+lemma LIM_EQUAL: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (l::hollight.real) x0::hollight.real.
+ (ALL x::hollight.real. x ~= x0 --> f x = g x) -->
+ tends_real_real f l x0 = tends_real_real g l x0"
+ by (import hollight LIM_EQUAL)
+
+lemma LIM_TRANSFORM: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (x0::hollight.real) l::hollight.real.
+ tends_real_real (%x::hollight.real. real_sub (f x) (g x))
+ (real_of_num (0::nat)) x0 &
+ tends_real_real g l x0 -->
+ tends_real_real f l x0"
+ by (import hollight LIM_TRANSFORM)
+
+constdefs
+ diffl :: "(hollight.real => hollight.real) => hollight.real => hollight.real => bool"
+ "diffl ==
+%(u::hollight.real => hollight.real) (ua::hollight.real) ub::hollight.real.
+ tends_real_real
+ (%h::hollight.real. real_div (real_sub (u (real_add ub h)) (u ub)) h) ua
+ (real_of_num (0::nat))"
+
+lemma DEF_diffl: "diffl =
+(%(u::hollight.real => hollight.real) (ua::hollight.real) ub::hollight.real.
+ tends_real_real
+ (%h::hollight.real. real_div (real_sub (u (real_add ub h)) (u ub)) h)
+ ua (real_of_num (0::nat)))"
+ by (import hollight DEF_diffl)
+
+constdefs
+ contl :: "(hollight.real => hollight.real) => hollight.real => bool"
+ "contl ==
+%(u::hollight.real => hollight.real) ua::hollight.real.
+ tends_real_real (%h::hollight.real. u (real_add ua h)) (u ua)
+ (real_of_num (0::nat))"
+
+lemma DEF_contl: "contl =
+(%(u::hollight.real => hollight.real) ua::hollight.real.
+ tends_real_real (%h::hollight.real. u (real_add ua h)) (u ua)
+ (real_of_num (0::nat)))"
+ by (import hollight DEF_contl)
+
+constdefs
+ differentiable :: "(hollight.real => hollight.real) => hollight.real => bool"
+ "differentiable ==
+%(u::hollight.real => hollight.real) ua::hollight.real.
+ EX l::hollight.real. diffl u l ua"
+
+lemma DEF_differentiable: "differentiable =
+(%(u::hollight.real => hollight.real) ua::hollight.real.
+ EX l::hollight.real. diffl u l ua)"
+ by (import hollight DEF_differentiable)
+
+lemma DIFF_UNIQ: "ALL (f::hollight.real => hollight.real) (l::hollight.real)
+ (m::hollight.real) x::hollight.real. diffl f l x & diffl f m x --> l = m"
+ by (import hollight DIFF_UNIQ)
+
+lemma DIFF_CONT: "ALL (f::hollight.real => hollight.real) (l::hollight.real) x::hollight.real.
+ diffl f l x --> contl f x"
+ by (import hollight DIFF_CONT)
+
+lemma CONTL_LIM: "ALL (f::hollight.real => hollight.real) x::hollight.real.
+ contl f x = tends_real_real f (f x) x"
+ by (import hollight CONTL_LIM)
+
+lemma CONT_X: "All (contl (%x::hollight.real. x))"
+ by (import hollight CONT_X)
+
+lemma CONT_CONST: "All (contl (%x::hollight.real. k::hollight.real))"
+ by (import hollight CONT_CONST)
+
+lemma CONT_ADD: "ALL x::hollight.real.
+ contl (f::hollight.real => hollight.real) x &
+ contl (g::hollight.real => hollight.real) x -->
+ contl (%x::hollight.real. real_add (f x) (g x)) x"
+ by (import hollight CONT_ADD)
+
+lemma CONT_MUL: "ALL x::hollight.real.
+ contl (f::hollight.real => hollight.real) x &
+ contl (g::hollight.real => hollight.real) x -->
+ contl (%x::hollight.real. real_mul (f x) (g x)) x"
+ by (import hollight CONT_MUL)
+
+lemma CONT_NEG: "ALL x::hollight.real.
+ contl (f::hollight.real => hollight.real) x -->
+ contl (%x::hollight.real. real_neg (f x)) x"
+ by (import hollight CONT_NEG)
+
+lemma CONT_INV: "ALL x::hollight.real.
+ contl (f::hollight.real => hollight.real) x &
+ f x ~= real_of_num (0::nat) -->
+ contl (%x::hollight.real. real_inv (f x)) x"
+ by (import hollight CONT_INV)
+
+lemma CONT_SUB: "ALL x::hollight.real.
+ contl (f::hollight.real => hollight.real) x &
+ contl (g::hollight.real => hollight.real) x -->
+ contl (%x::hollight.real. real_sub (f x) (g x)) x"
+ by (import hollight CONT_SUB)
+
+lemma CONT_DIV: "ALL x::hollight.real.
+ contl (f::hollight.real => hollight.real) x &
+ contl (g::hollight.real => hollight.real) x &
+ g x ~= real_of_num (0::nat) -->
+ contl (%x::hollight.real. real_div (f x) (g x)) x"
+ by (import hollight CONT_DIV)
+
+lemma CONT_COMPOSE: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ x::hollight.real.
+ contl f x & contl g (f x) --> contl (%x::hollight.real. g (f x)) x"
+ by (import hollight CONT_COMPOSE)
+
+lemma IVT: "ALL (f::hollight.real => hollight.real) (a::hollight.real)
+ (b::hollight.real) y::hollight.real.
+ real_le a b &
+ (real_le (f a) y & real_le y (f b)) &
+ (ALL x::hollight.real. real_le a x & real_le x b --> contl f x) -->
+ (EX x::hollight.real. real_le a x & real_le x b & f x = y)"
+ by (import hollight IVT)
+
+lemma IVT2: "ALL (f::hollight.real => hollight.real) (a::hollight.real)
+ (b::hollight.real) y::hollight.real.
+ real_le a b &
+ (real_le (f b) y & real_le y (f a)) &
+ (ALL x::hollight.real. real_le a x & real_le x b --> contl f x) -->
+ (EX x::hollight.real. real_le a x & real_le x b & f x = y)"
+ by (import hollight IVT2)
+
+lemma DIFF_CONST: "ALL k::hollight.real.
+ All (diffl (%x::hollight.real. k) (real_of_num (0::nat)))"
+ by (import hollight DIFF_CONST)
+
+lemma DIFF_ADD: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (l::hollight.real) (m::hollight.real) x::hollight.real.
+ diffl f l x & diffl g m x -->
+ diffl (%x::hollight.real. real_add (f x) (g x)) (real_add l m) x"
+ by (import hollight DIFF_ADD)
+
+lemma DIFF_MUL: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (l::hollight.real) (m::hollight.real) x::hollight.real.
+ diffl f l x & diffl g m x -->
+ diffl (%x::hollight.real. real_mul (f x) (g x))
+ (real_add (real_mul l (g x)) (real_mul m (f x))) x"
+ by (import hollight DIFF_MUL)
+
+lemma DIFF_CMUL: "ALL (f::hollight.real => hollight.real) (c::hollight.real)
+ (l::hollight.real) x::hollight.real.
+ diffl f l x -->
+ diffl (%x::hollight.real. real_mul c (f x)) (real_mul c l) x"
+ by (import hollight DIFF_CMUL)
+
+lemma DIFF_NEG: "ALL (f::hollight.real => hollight.real) (l::hollight.real) x::hollight.real.
+ diffl f l x --> diffl (%x::hollight.real. real_neg (f x)) (real_neg l) x"
+ by (import hollight DIFF_NEG)
+
+lemma DIFF_SUB: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (l::hollight.real) (m::hollight.real) x::hollight.real.
+ diffl f l x & diffl g m x -->
+ diffl (%x::hollight.real. real_sub (f x) (g x)) (real_sub l m) x"
+ by (import hollight DIFF_SUB)
+
+lemma DIFF_CARAT: "ALL (f::hollight.real => hollight.real) (l::hollight.real) x::hollight.real.
+ diffl f l x =
+ (EX xa::hollight.real => hollight.real.
+ (ALL z::hollight.real.
+ real_sub (f z) (f x) = real_mul (xa z) (real_sub z x)) &
+ contl xa x & xa x = l)"
+ by (import hollight DIFF_CARAT)
+
+lemma DIFF_CHAIN: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (l::hollight.real) (m::hollight.real) x::hollight.real.
+ diffl f l (g x) & diffl g m x -->
+ diffl (%x::hollight.real. f (g x)) (real_mul l m) x"
+ by (import hollight DIFF_CHAIN)
+
+lemma DIFF_X: "All (diffl (%x::hollight.real. x) (real_of_num (NUMERAL_BIT1 (0::nat))))"
+ by (import hollight DIFF_X)
+
+lemma DIFF_POW: "ALL (n::nat) x::hollight.real.
+ diffl (%x::hollight.real. real_pow x n)
+ (real_mul (real_of_num n) (real_pow x (n - NUMERAL_BIT1 (0::nat)))) x"
+ by (import hollight DIFF_POW)
+
+lemma DIFF_XM1: "ALL x::hollight.real.
+ x ~= real_of_num (0::nat) -->
+ diffl real_inv
+ (real_neg
+ (real_pow (real_inv x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ x"
+ by (import hollight DIFF_XM1)
+
+lemma DIFF_INV: "ALL (f::hollight.real => hollight.real) (l::hollight.real) x::hollight.real.
+ diffl f l x & f x ~= real_of_num (0::nat) -->
+ diffl (%x::hollight.real. real_inv (f x))
+ (real_neg
+ (real_div l (real_pow (f x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ x"
+ by (import hollight DIFF_INV)
+
+lemma DIFF_DIV: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (l::hollight.real) m::hollight.real.
+ diffl f l (x::hollight.real) &
+ diffl g m x & g x ~= real_of_num (0::nat) -->
+ diffl (%x::hollight.real. real_div (f x) (g x))
+ (real_div (real_sub (real_mul l (g x)) (real_mul m (f x)))
+ (real_pow (g x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ x"
+ by (import hollight DIFF_DIV)
+
+lemma DIFF_SUM: "ALL (f::nat => hollight.real => hollight.real)
+ (f'::nat => hollight.real => hollight.real) (m::nat) (n::nat)
+ x::hollight.real.
+ (ALL r::nat. <= m r & < r (m + n) --> diffl (f r) (f' r x) x) -->
+ diffl (%x::hollight.real. psum (m, n) (%n::nat. f n x))
+ (psum (m, n) (%r::nat. f' r x)) x"
+ by (import hollight DIFF_SUM)
+
+lemma CONT_BOUNDED: "ALL (f::hollight.real => hollight.real) (a::hollight.real) b::hollight.real.
+ real_le a b &
+ (ALL x::hollight.real. real_le a x & real_le x b --> contl f x) -->
+ (EX M::hollight.real.
+ ALL x::hollight.real. real_le a x & real_le x b --> real_le (f x) M)"
+ by (import hollight CONT_BOUNDED)
+
+lemma CONT_BOUNDED_ABS: "ALL (f::hollight.real => hollight.real) (a::hollight.real) b::hollight.real.
+ (ALL x::hollight.real. real_le a x & real_le x b --> contl f x) -->
+ (EX M::hollight.real.
+ ALL x::hollight.real.
+ real_le a x & real_le x b --> real_le (real_abs (f x)) M)"
+ by (import hollight CONT_BOUNDED_ABS)
+
+lemma CONT_HASSUP: "ALL (f::hollight.real => hollight.real) (a::hollight.real) b::hollight.real.
+ real_le a b &
+ (ALL x::hollight.real. real_le a x & real_le x b --> contl f x) -->
+ (EX M::hollight.real.
+ (ALL x::hollight.real.
+ real_le a x & real_le x b --> real_le (f x) M) &
+ (ALL N::hollight.real.
+ real_lt N M -->
+ (EX x::hollight.real.
+ real_le a x & real_le x b & real_lt N (f x))))"
+ by (import hollight CONT_HASSUP)
+
+lemma CONT_ATTAINS: "ALL (f::hollight.real => hollight.real) (a::hollight.real) b::hollight.real.
+ real_le a b &
+ (ALL x::hollight.real. real_le a x & real_le x b --> contl f x) -->
+ (EX x::hollight.real.
+ (ALL xa::hollight.real.
+ real_le a xa & real_le xa b --> real_le (f xa) x) &
+ (EX xa::hollight.real. real_le a xa & real_le xa b & f xa = x))"
+ by (import hollight CONT_ATTAINS)
+
+lemma CONT_ATTAINS2: "ALL (f::hollight.real => hollight.real) (a::hollight.real) b::hollight.real.
+ real_le a b &
+ (ALL x::hollight.real. real_le a x & real_le x b --> contl f x) -->
+ (EX M::hollight.real.
+ (ALL x::hollight.real.
+ real_le a x & real_le x b --> real_le M (f x)) &
+ (EX x::hollight.real. real_le a x & real_le x b & f x = M))"
+ by (import hollight CONT_ATTAINS2)
+
+lemma CONT_ATTAINS_ALL: "ALL (f::hollight.real => hollight.real) (a::hollight.real) b::hollight.real.
+ real_le a b &
+ (ALL x::hollight.real. real_le a x & real_le x b --> contl f x) -->
+ (EX (L::hollight.real) M::hollight.real.
+ (ALL x::hollight.real.
+ real_le a x & real_le x b -->
+ real_le L (f x) & real_le (f x) M) &
+ (ALL y::hollight.real.
+ real_le L y & real_le y M -->
+ (EX x::hollight.real. real_le a x & real_le x b & f x = y)))"
+ by (import hollight CONT_ATTAINS_ALL)
+
+lemma DIFF_LINC: "ALL (f::hollight.real => hollight.real) (x::hollight.real) l::hollight.real.
+ diffl f l x & real_lt (real_of_num (0::nat)) l -->
+ (EX d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL h::hollight.real.
+ real_lt (real_of_num (0::nat)) h & real_lt h d -->
+ real_lt (f x) (f (real_add x h))))"
+ by (import hollight DIFF_LINC)
+
+lemma DIFF_LDEC: "ALL (f::hollight.real => hollight.real) (x::hollight.real) l::hollight.real.
+ diffl f l x & real_lt l (real_of_num (0::nat)) -->
+ (EX d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL h::hollight.real.
+ real_lt (real_of_num (0::nat)) h & real_lt h d -->
+ real_lt (f x) (f (real_sub x h))))"
+ by (import hollight DIFF_LDEC)
+
+lemma DIFF_LMAX: "ALL (f::hollight.real => hollight.real) (x::hollight.real) l::hollight.real.
+ diffl f l x &
+ (EX d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL y::hollight.real.
+ real_lt (real_abs (real_sub x y)) d --> real_le (f y) (f x))) -->
+ l = real_of_num (0::nat)"
+ by (import hollight DIFF_LMAX)
+
+lemma DIFF_LMIN: "ALL (f::hollight.real => hollight.real) (x::hollight.real) l::hollight.real.
+ diffl f l x &
+ (EX d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL y::hollight.real.
+ real_lt (real_abs (real_sub x y)) d --> real_le (f x) (f y))) -->
+ l = real_of_num (0::nat)"
+ by (import hollight DIFF_LMIN)
+
+lemma DIFF_LCONST: "ALL (f::hollight.real => hollight.real) (x::hollight.real) l::hollight.real.
+ diffl f l x &
+ (EX d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL y::hollight.real.
+ real_lt (real_abs (real_sub x y)) d --> f y = f x)) -->
+ l = real_of_num (0::nat)"
+ by (import hollight DIFF_LCONST)
+
+lemma INTERVAL_LEMMA_LT: "ALL (a::hollight.real) (b::hollight.real) x::hollight.real.
+ real_lt a x & real_lt x b -->
+ (EX xa::hollight.real.
+ real_lt (real_of_num (0::nat)) xa &
+ (ALL xb::hollight.real.
+ real_lt (real_abs (real_sub x xb)) xa -->
+ real_lt a xb & real_lt xb b))"
+ by (import hollight INTERVAL_LEMMA_LT)
+
+lemma INTERVAL_LEMMA: "ALL (a::hollight.real) (b::hollight.real) x::hollight.real.
+ real_lt a x & real_lt x b -->
+ (EX xa::hollight.real.
+ real_lt (real_of_num (0::nat)) xa &
+ (ALL y::hollight.real.
+ real_lt (real_abs (real_sub x y)) xa -->
+ real_le a y & real_le y b))"
+ by (import hollight INTERVAL_LEMMA)
+
+lemma ROLLE: "ALL (f::hollight.real => hollight.real) (a::hollight.real) b::hollight.real.
+ real_lt a b &
+ f a = f b &
+ (ALL x::hollight.real. real_le a x & real_le x b --> contl f x) &
+ (ALL x::hollight.real.
+ real_lt a x & real_lt x b --> differentiable f x) -->
+ (EX z::hollight.real.
+ real_lt a z & real_lt z b & diffl f (real_of_num (0::nat)) z)"
+ by (import hollight ROLLE)
+
+lemma MVT_LEMMA: "ALL (f::hollight.real => hollight.real) (a::hollight.real) b::hollight.real.
+ real_sub (f a)
+ (real_mul (real_div (real_sub (f b) (f a)) (real_sub b a)) a) =
+ real_sub (f b)
+ (real_mul (real_div (real_sub (f b) (f a)) (real_sub b a)) b)"
+ by (import hollight MVT_LEMMA)
+
+lemma MVT: "ALL (f::hollight.real => hollight.real) (a::hollight.real) b::hollight.real.
+ real_lt a b &
+ (ALL x::hollight.real. real_le a x & real_le x b --> contl f x) &
+ (ALL x::hollight.real.
+ real_lt a x & real_lt x b --> differentiable f x) -->
+ (EX (l::hollight.real) z::hollight.real.
+ real_lt a z &
+ real_lt z b &
+ diffl f l z & real_sub (f b) (f a) = real_mul (real_sub b a) l)"
+ by (import hollight MVT)
+
+lemma MVT_ALT: "ALL (f::hollight.real => hollight.real) (f'::hollight.real => hollight.real)
+ (a::hollight.real) b::hollight.real.
+ real_lt a b &
+ (ALL x::hollight.real.
+ real_le a x & real_le x b --> diffl f (f' x) x) -->
+ (EX z::hollight.real.
+ real_lt a z &
+ real_lt z b & real_sub (f b) (f a) = real_mul (real_sub b a) (f' z))"
+ by (import hollight MVT_ALT)
+
+lemma DIFF_ISCONST_END: "ALL (f::hollight.real => hollight.real) (a::hollight.real) b::hollight.real.
+ real_lt a b &
+ (ALL x::hollight.real. real_le a x & real_le x b --> contl f x) &
+ (ALL x::hollight.real.
+ real_lt a x & real_lt x b --> diffl f (real_of_num (0::nat)) x) -->
+ f b = f a"
+ by (import hollight DIFF_ISCONST_END)
+
+lemma DIFF_ISCONST: "ALL (f::hollight.real => hollight.real) (a::hollight.real) b::hollight.real.
+ real_lt a b &
+ (ALL x::hollight.real. real_le a x & real_le x b --> contl f x) &
+ (ALL x::hollight.real.
+ real_lt a x & real_lt x b --> diffl f (real_of_num (0::nat)) x) -->
+ (ALL x::hollight.real. real_le a x & real_le x b --> f x = f a)"
+ by (import hollight DIFF_ISCONST)
+
+lemma DIFF_ISCONST_END_SIMPLE: "ALL (f::hollight.real => hollight.real) (a::hollight.real) b::hollight.real.
+ real_lt a b &
+ (ALL x::hollight.real.
+ real_le a x & real_le x b --> diffl f (real_of_num (0::nat)) x) -->
+ f b = f a"
+ by (import hollight DIFF_ISCONST_END_SIMPLE)
+
+lemma DIFF_ISCONST_ALL: "ALL (x::hollight.real => hollight.real) (xa::hollight.real)
+ xb::hollight.real. All (diffl x (real_of_num (0::nat))) --> x xa = x xb"
+ by (import hollight DIFF_ISCONST_ALL)
+
+lemma INTERVAL_ABS: "ALL (x::hollight.real) (z::hollight.real) d::hollight.real.
+ (real_le (real_sub x d) z & real_le z (real_add x d)) =
+ real_le (real_abs (real_sub z x)) d"
+ by (import hollight INTERVAL_ABS)
+
+lemma CONT_INJ_LEMMA: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (x::hollight.real) d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL z::hollight.real.
+ real_le (real_abs (real_sub z x)) d --> g (f z) = z) &
+ (ALL z::hollight.real.
+ real_le (real_abs (real_sub z x)) d --> contl f z) -->
+ ~ (ALL z::hollight.real.
+ real_le (real_abs (real_sub z x)) d --> real_le (f z) (f x))"
+ by (import hollight CONT_INJ_LEMMA)
+
+lemma CONT_INJ_LEMMA2: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (x::hollight.real) d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL z::hollight.real.
+ real_le (real_abs (real_sub z x)) d --> g (f z) = z) &
+ (ALL z::hollight.real.
+ real_le (real_abs (real_sub z x)) d --> contl f z) -->
+ ~ (ALL z::hollight.real.
+ real_le (real_abs (real_sub z x)) d --> real_le (f x) (f z))"
+ by (import hollight CONT_INJ_LEMMA2)
+
+lemma CONT_INJ_RANGE: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (x::hollight.real) d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL z::hollight.real.
+ real_le (real_abs (real_sub z x)) d --> g (f z) = z) &
+ (ALL z::hollight.real.
+ real_le (real_abs (real_sub z x)) d --> contl f z) -->
+ (EX e::hollight.real.
+ real_lt (real_of_num (0::nat)) e &
+ (ALL y::hollight.real.
+ real_le (real_abs (real_sub y (f x))) e -->
+ (EX z::hollight.real.
+ real_le (real_abs (real_sub z x)) d & f z = y)))"
+ by (import hollight CONT_INJ_RANGE)
+
+lemma CONT_INVERSE: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (x::hollight.real) d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL z::hollight.real.
+ real_le (real_abs (real_sub z x)) d --> g (f z) = z) &
+ (ALL z::hollight.real.
+ real_le (real_abs (real_sub z x)) d --> contl f z) -->
+ contl g (f x)"
+ by (import hollight CONT_INVERSE)
+
+lemma DIFF_INVERSE: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (l::hollight.real) (x::hollight.real) d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL z::hollight.real.
+ real_le (real_abs (real_sub z x)) d --> g (f z) = z) &
+ (ALL z::hollight.real.
+ real_le (real_abs (real_sub z x)) d --> contl f z) &
+ diffl f l x & l ~= real_of_num (0::nat) -->
+ diffl g (real_inv l) (f x)"
+ by (import hollight DIFF_INVERSE)
+
+lemma DIFF_INVERSE_LT: "ALL (f::hollight.real => hollight.real) (g::hollight.real => hollight.real)
+ (l::hollight.real) (x::hollight.real) d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL z::hollight.real.
+ real_lt (real_abs (real_sub z x)) d --> g (f z) = z) &
+ (ALL z::hollight.real.
+ real_lt (real_abs (real_sub z x)) d --> contl f z) &
+ diffl f l x & l ~= real_of_num (0::nat) -->
+ diffl g (real_inv l) (f x)"
+ by (import hollight DIFF_INVERSE_LT)
+
+lemma IVT_DERIVATIVE_0: "ALL (f::hollight.real => hollight.real) (f'::hollight.real => hollight.real)
+ (a::hollight.real) b::hollight.real.
+ real_le a b &
+ (ALL x::hollight.real. real_le a x & real_le x b --> diffl f (f' x) x) &
+ hollight.real_gt (f' a) (real_of_num (0::nat)) &
+ real_lt (f' b) (real_of_num (0::nat)) -->
+ (EX z::hollight.real.
+ real_lt a z & real_lt z b & f' z = real_of_num (0::nat))"
+ by (import hollight IVT_DERIVATIVE_0)
+
+lemma IVT_DERIVATIVE_POS: "ALL (x::hollight.real => hollight.real) (xa::hollight.real => hollight.real)
+ (xb::hollight.real) (xc::hollight.real) xd::hollight.real.
+ real_le xb xc &
+ (ALL xd::hollight.real.
+ real_le xb xd & real_le xd xc --> diffl x (xa xd) xd) &
+ hollight.real_gt (xa xb) xd & real_lt (xa xc) xd -->
+ (EX z::hollight.real. real_lt xb z & real_lt z xc & xa z = xd)"
+ by (import hollight IVT_DERIVATIVE_POS)
+
+lemma IVT_DERIVATIVE_NEG: "ALL (x::hollight.real => hollight.real) (xa::hollight.real => hollight.real)
+ (xb::hollight.real) (xc::hollight.real) xd::hollight.real.
+ real_le xb xc &
+ (ALL xd::hollight.real.
+ real_le xb xd & real_le xd xc --> diffl x (xa xd) xd) &
+ real_lt (xa xb) xd & hollight.real_gt (xa xc) xd -->
+ (EX z::hollight.real. real_lt xb z & real_lt z xc & xa z = xd)"
+ by (import hollight IVT_DERIVATIVE_NEG)
+
+lemma SEQ_CONT_UNIFORM: "ALL (s::nat => hollight.real => hollight.real)
+ (f::hollight.real => hollight.real) x0::hollight.real.
+ (ALL e::hollight.real.
+ real_lt (real_of_num (0::nat)) e -->
+ (EX (N::nat) d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL (x::hollight.real) n::nat.
+ real_lt (real_abs (real_sub x x0)) d & >= n N -->
+ real_lt (real_abs (real_sub (s n x) (f x))) e))) &
+ (EX N::nat. ALL n::nat. >= n N --> contl (s n) x0) -->
+ contl f x0"
+ by (import hollight SEQ_CONT_UNIFORM)
+
+lemma SER_COMPARA_UNIFORM: "ALL (s::hollight.real => nat => hollight.real) (x0::hollight.real)
+ g::nat => hollight.real.
+ (EX (N::nat) d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL (n::nat) x::hollight.real.
+ real_lt (real_abs (real_sub x x0)) d & >= n N -->
+ real_le (real_abs (s x n)) (g n))) &
+ summable g -->
+ (EX (f::hollight.real => hollight.real) d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL e::hollight.real.
+ real_lt (real_of_num (0::nat)) e -->
+ (EX N::nat.
+ ALL (x::hollight.real) n::nat.
+ real_lt (real_abs (real_sub x x0)) d & >= n N -->
+ real_lt
+ (real_abs (real_sub (psum (0::nat, n) (s x)) (f x))) e)))"
+ by (import hollight SER_COMPARA_UNIFORM)
+
+lemma SER_COMPARA_UNIFORM_WEAK: "ALL (s::hollight.real => nat => hollight.real) (x0::hollight.real)
+ g::nat => hollight.real.
+ (EX (N::nat) d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL (n::nat) x::hollight.real.
+ real_lt (real_abs (real_sub x x0)) d & >= n N -->
+ real_le (real_abs (s x n)) (g n))) &
+ summable g -->
+ (EX f::hollight.real => hollight.real.
+ ALL e::hollight.real.
+ real_lt (real_of_num (0::nat)) e -->
+ (EX (N::nat) d::hollight.real.
+ real_lt (real_of_num (0::nat)) d &
+ (ALL (x::hollight.real) n::nat.
+ real_lt (real_abs (real_sub x x0)) d & >= n N -->
+ real_lt
+ (real_abs (real_sub (psum (0::nat, n) (s x)) (f x))) e)))"
+ by (import hollight SER_COMPARA_UNIFORM_WEAK)
+
+lemma POWDIFF_LEMMA: "ALL (n::nat) (x::hollight.real) y::hollight.real.
+ psum (0::nat, Suc n)
+ (%p::nat. real_mul (real_pow x p) (real_pow y (Suc n - p))) =
+ real_mul y
+ (psum (0::nat, Suc n)
+ (%p::nat. real_mul (real_pow x p) (real_pow y (n - p))))"
+ by (import hollight POWDIFF_LEMMA)
+
+lemma POWDIFF: "ALL (n::nat) (x::hollight.real) y::hollight.real.
+ real_sub (real_pow x (Suc n)) (real_pow y (Suc n)) =
+ real_mul (real_sub x y)
+ (psum (0::nat, Suc n)
+ (%p::nat. real_mul (real_pow x p) (real_pow y (n - p))))"
+ by (import hollight POWDIFF)
+
+lemma POWREV: "ALL (n::nat) (x::hollight.real) y::hollight.real.
+ psum (0::nat, Suc n)
+ (%xa::nat. real_mul (real_pow x xa) (real_pow y (n - xa))) =
+ psum (0::nat, Suc n)
+ (%xa::nat. real_mul (real_pow x (n - xa)) (real_pow y xa))"
+ by (import hollight POWREV)
+
+lemma POWSER_INSIDEA: "ALL (f::nat => hollight.real) (x::hollight.real) z::hollight.real.
+ summable (%n::nat. real_mul (f n) (real_pow x n)) &
+ real_lt (real_abs z) (real_abs x) -->
+ summable (%n::nat. real_mul (real_abs (f n)) (real_pow z n))"
+ by (import hollight POWSER_INSIDEA)
+
+lemma POWSER_INSIDE: "ALL (f::nat => hollight.real) (x::hollight.real) z::hollight.real.
+ summable (%n::nat. real_mul (f n) (real_pow x n)) &
+ real_lt (real_abs z) (real_abs x) -->
+ summable (%n::nat. real_mul (f n) (real_pow z n))"
+ by (import hollight POWSER_INSIDE)
+
+constdefs
+ diffs :: "(nat => hollight.real) => nat => hollight.real"
+ "diffs ==
+%(u::nat => hollight.real) n::nat.
+ real_mul (real_of_num (Suc n)) (u (Suc n))"
+
+lemma DEF_diffs: "diffs =
+(%(u::nat => hollight.real) n::nat.
+ real_mul (real_of_num (Suc n)) (u (Suc n)))"
+ by (import hollight DEF_diffs)
+
+lemma DIFFS_NEG: "ALL c::nat => hollight.real.
+ diffs (%n::nat. real_neg (c n)) = (%x::nat. real_neg (diffs c x))"
+ by (import hollight DIFFS_NEG)
+
+lemma DIFFS_LEMMA: "ALL (n::nat) (c::nat => hollight.real) x::hollight.real.
+ psum (0::nat, n) (%n::nat. real_mul (diffs c n) (real_pow x n)) =
+ real_add
+ (psum (0::nat, n)
+ (%n::nat.
+ real_mul (real_of_num n)
+ (real_mul (c n) (real_pow x (n - NUMERAL_BIT1 (0::nat))))))
+ (real_mul (real_of_num n)
+ (real_mul (c n) (real_pow x (n - NUMERAL_BIT1 (0::nat)))))"
+ by (import hollight DIFFS_LEMMA)
+
+lemma DIFFS_LEMMA2: "ALL (n::nat) (c::nat => hollight.real) x::hollight.real.
+ psum (0::nat, n)
+ (%n::nat.
+ real_mul (real_of_num n)
+ (real_mul (c n) (real_pow x (n - NUMERAL_BIT1 (0::nat))))) =
+ real_sub
+ (psum (0::nat, n) (%n::nat. real_mul (diffs c n) (real_pow x n)))
+ (real_mul (real_of_num n)
+ (real_mul (c n) (real_pow x (n - NUMERAL_BIT1 (0::nat)))))"
+ by (import hollight DIFFS_LEMMA2)
+
+lemma DIFFS_EQUIV: "ALL (c::nat => hollight.real) x::hollight.real.
+ summable (%n::nat. real_mul (diffs c n) (real_pow x n)) -->
+ sums
+ (%n::nat.
+ real_mul (real_of_num n)
+ (real_mul (c n) (real_pow x (n - NUMERAL_BIT1 (0::nat)))))
+ (suminf (%n::nat. real_mul (diffs c n) (real_pow x n)))"
+ by (import hollight DIFFS_EQUIV)
+
+lemma TERMDIFF_LEMMA1: "ALL (m::nat) (z::hollight.real) h::hollight.real.
+ psum (0::nat, m)
+ (%p::nat.
+ real_sub (real_mul (real_pow (real_add z h) (m - p)) (real_pow z p))
+ (real_pow z m)) =
+ psum (0::nat, m)
+ (%p::nat.
+ real_mul (real_pow z p)
+ (real_sub (real_pow (real_add z h) (m - p)) (real_pow z (m - p))))"
+ by (import hollight TERMDIFF_LEMMA1)
+
+lemma TERMDIFF_LEMMA2: "ALL (z::hollight.real) h::hollight.real.
+ h ~= real_of_num (0::nat) -->
+ real_sub
+ (real_div (real_sub (real_pow (real_add z h) (n::nat)) (real_pow z n))
+ h)
+ (real_mul (real_of_num n) (real_pow z (n - NUMERAL_BIT1 (0::nat)))) =
+ real_mul h
+ (psum (0::nat, n - NUMERAL_BIT1 (0::nat))
+ (%p::nat.
+ real_mul (real_pow z p)
+ (psum (0::nat, n - NUMERAL_BIT1 (0::nat) - p)
+ (%q::nat.
+ real_mul (real_pow (real_add z h) q)
+ (real_pow z
+ (n - NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) - p - q))))))"
+ by (import hollight TERMDIFF_LEMMA2)
+
+lemma TERMDIFF_LEMMA3: "ALL (z::hollight.real) (h::hollight.real) (n::nat) K::hollight.real.
+ h ~= real_of_num (0::nat) &
+ real_le (real_abs z) K & real_le (real_abs (real_add z h)) K -->
+ real_le
+ (real_abs
+ (real_sub
+ (real_div (real_sub (real_pow (real_add z h) n) (real_pow z n)) h)
+ (real_mul (real_of_num n)
+ (real_pow z (n - NUMERAL_BIT1 (0::nat))))))
+ (real_mul (real_of_num n)
+ (real_mul (real_of_num (n - NUMERAL_BIT1 (0::nat)))
+ (real_mul (real_pow K (n - NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ (real_abs h))))"
+ by (import hollight TERMDIFF_LEMMA3)
+
+lemma TERMDIFF_LEMMA4: "ALL (f::hollight.real => hollight.real) (K::hollight.real) k::hollight.real.
+ real_lt (real_of_num (0::nat)) k &
+ (ALL h::hollight.real.
+ real_lt (real_of_num (0::nat)) (real_abs h) &
+ real_lt (real_abs h) k -->
+ real_le (real_abs (f h)) (real_mul K (real_abs h))) -->
+ tends_real_real f (real_of_num (0::nat)) (real_of_num (0::nat))"
+ by (import hollight TERMDIFF_LEMMA4)
+
+lemma TERMDIFF_LEMMA5: "ALL (f::nat => hollight.real) (g::hollight.real => nat => hollight.real)
+ k::hollight.real.
+ real_lt (real_of_num (0::nat)) k &
+ summable f &
+ (ALL h::hollight.real.
+ real_lt (real_of_num (0::nat)) (real_abs h) &
+ real_lt (real_abs h) k -->
+ (ALL n::nat.
+ real_le (real_abs (g h n)) (real_mul (f n) (real_abs h)))) -->
+ tends_real_real (%h::hollight.real. suminf (g h)) (real_of_num (0::nat))
+ (real_of_num (0::nat))"
+ by (import hollight TERMDIFF_LEMMA5)
+
+lemma TERMDIFF: "ALL (c::nat => hollight.real) K::hollight.real.
+ summable (%n::nat. real_mul (c n) (real_pow K n)) &
+ summable (%n::nat. real_mul (diffs c n) (real_pow K n)) &
+ summable (%n::nat. real_mul (diffs (diffs c) n) (real_pow K n)) &
+ real_lt (real_abs (x::hollight.real)) (real_abs K) -->
+ diffl
+ (%x::hollight.real. suminf (%n::nat. real_mul (c n) (real_pow x n)))
+ (suminf (%n::nat. real_mul (diffs c n) (real_pow x n))) x"
+ by (import hollight TERMDIFF)
+
+lemma SEQ_NPOW: "ALL x::hollight.real.
+ real_lt (real_abs x) (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ tends_num_real (%n::nat. real_mul (real_of_num n) (real_pow x n))
+ (real_of_num (0::nat))"
+ by (import hollight SEQ_NPOW)
+
+lemma TERMDIFF_CONVERGES: "ALL K::hollight.real.
+ (ALL x::hollight.real.
+ real_lt (real_abs x) K -->
+ summable
+ (%n::nat.
+ real_mul ((c::nat => hollight.real) n) (real_pow x n))) -->
+ (ALL x::hollight.real.
+ real_lt (real_abs x) K -->
+ summable (%n::nat. real_mul (diffs c n) (real_pow x n)))"
+ by (import hollight TERMDIFF_CONVERGES)
+
+lemma TERMDIFF_STRONG: "ALL (c::nat => hollight.real) (K::hollight.real) x::hollight.real.
+ summable (%n::nat. real_mul (c n) (real_pow K n)) &
+ real_lt (real_abs x) (real_abs K) -->
+ diffl
+ (%x::hollight.real. suminf (%n::nat. real_mul (c n) (real_pow x n)))
+ (suminf (%n::nat. real_mul (diffs c n) (real_pow x n))) x"
+ by (import hollight TERMDIFF_STRONG)
+
+lemma POWSER_0: "ALL a::nat => hollight.real.
+ sums (%n::nat. real_mul (a n) (real_pow (real_of_num (0::nat)) n))
+ (a (0::nat))"
+ by (import hollight POWSER_0)
+
+lemma POWSER_LIMIT_0: "ALL (f::hollight.real => hollight.real) (a::nat => hollight.real)
+ s::hollight.real.
+ real_lt (real_of_num (0::nat)) s &
+ (ALL x::hollight.real.
+ real_lt (real_abs x) s -->
+ sums (%n::nat. real_mul (a n) (real_pow x n)) (f x)) -->
+ tends_real_real f (a (0::nat)) (real_of_num (0::nat))"
+ by (import hollight POWSER_LIMIT_0)
+
+lemma POWSER_LIMIT_0_STRONG: "ALL (f::hollight.real => hollight.real) (a::nat => hollight.real)
+ s::hollight.real.
+ real_lt (real_of_num (0::nat)) s &
+ (ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) (real_abs x) &
+ real_lt (real_abs x) s -->
+ sums (%n::nat. real_mul (a n) (real_pow x n)) (f x)) -->
+ tends_real_real f (a (0::nat)) (real_of_num (0::nat))"
+ by (import hollight POWSER_LIMIT_0_STRONG)
+
+lemma POWSER_EQUAL_0: "ALL (f::hollight.real => hollight.real) (a::nat => hollight.real)
+ (b::nat => hollight.real) P::hollight.real => bool.
+ (ALL e::hollight.real.
+ real_lt (real_of_num (0::nat)) e -->
+ (EX x::hollight.real.
+ P x &
+ real_lt (real_of_num (0::nat)) (real_abs x) &
+ real_lt (real_abs x) e)) &
+ (ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) (real_abs x) & P x -->
+ sums (%n::nat. real_mul (a n) (real_pow x n)) (f x) &
+ sums (%n::nat. real_mul (b n) (real_pow x n)) (f x)) -->
+ a (0::nat) = b (0::nat)"
+ by (import hollight POWSER_EQUAL_0)
+
+lemma POWSER_EQUAL: "ALL (f::hollight.real => hollight.real) (a::nat => hollight.real)
+ (b::nat => hollight.real) P::hollight.real => bool.
+ (ALL e::hollight.real.
+ real_lt (real_of_num (0::nat)) e -->
+ (EX x::hollight.real.
+ P x &
+ real_lt (real_of_num (0::nat)) (real_abs x) &
+ real_lt (real_abs x) e)) &
+ (ALL x::hollight.real.
+ P x -->
+ sums (%n::nat. real_mul (a n) (real_pow x n)) (f x) &
+ sums (%n::nat. real_mul (b n) (real_pow x n)) (f x)) -->
+ a = b"
+ by (import hollight POWSER_EQUAL)
+
+lemma MULT_DIV_2: "ALL n::nat.
+ DIV (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * n)
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) =
+ n"
+ by (import hollight MULT_DIV_2)
+
+lemma EVEN_DIV2: "ALL n::nat.
+ ~ EVEN n -->
+ DIV (Suc n) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) =
+ Suc (DIV (n - NUMERAL_BIT1 (0::nat))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))"
+ by (import hollight EVEN_DIV2)
+
+lemma POW_ZERO: "ALL (n::nat) x::hollight.real.
+ real_pow x n = real_of_num (0::nat) --> x = real_of_num (0::nat)"
+ by (import hollight POW_ZERO)
+
+lemma POW_ZERO_EQ: "ALL (n::nat) x::hollight.real.
+ (real_pow x (Suc n) = real_of_num (0::nat)) = (x = real_of_num (0::nat))"
+ by (import hollight POW_ZERO_EQ)
+
+lemma POW_LT: "ALL (n::nat) (x::hollight.real) y::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_lt x y -->
+ real_lt (real_pow x (Suc n)) (real_pow y (Suc n))"
+ by (import hollight POW_LT)
+
+lemma POW_EQ: "ALL (n::nat) (x::hollight.real) y::hollight.real.
+ real_le (real_of_num (0::nat)) x &
+ real_le (real_of_num (0::nat)) y &
+ real_pow x (Suc n) = real_pow y (Suc n) -->
+ x = y"
+ by (import hollight POW_EQ)
+
+constdefs
+ exp :: "hollight.real => hollight.real"
+ "exp ==
+%u::hollight.real.
+ suminf
+ (%n::nat. real_mul (real_inv (real_of_num (FACT n))) (real_pow u n))"
+
+lemma DEF_exp: "exp =
+(%u::hollight.real.
+ suminf
+ (%n::nat. real_mul (real_inv (real_of_num (FACT n))) (real_pow u n)))"
+ by (import hollight DEF_exp)
+
+constdefs
+ sin :: "hollight.real => hollight.real"
+ "sin ==
+%u::hollight.real.
+ suminf
+ (%n::nat.
+ real_mul
+ (COND (EVEN n) (real_of_num (0::nat))
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV (n - NUMERAL_BIT1 (0::nat))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num (FACT n))))
+ (real_pow u n))"
+
+lemma DEF_sin: "sin =
+(%u::hollight.real.
+ suminf
+ (%n::nat.
+ real_mul
+ (COND (EVEN n) (real_of_num (0::nat))
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV (n - NUMERAL_BIT1 (0::nat))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num (FACT n))))
+ (real_pow u n)))"
+ by (import hollight DEF_sin)
+
+constdefs
+ cos :: "hollight.real => hollight.real"
+ "cos ==
+%u::hollight.real.
+ suminf
+ (%n::nat.
+ real_mul
+ (COND (EVEN n)
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV n (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num (FACT n)))
+ (real_of_num (0::nat)))
+ (real_pow u n))"
+
+lemma DEF_cos: "cos =
+(%u::hollight.real.
+ suminf
+ (%n::nat.
+ real_mul
+ (COND (EVEN n)
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV n (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num (FACT n)))
+ (real_of_num (0::nat)))
+ (real_pow u n)))"
+ by (import hollight DEF_cos)
+
+lemma REAL_EXP_CONVERGES: "ALL x::hollight.real.
+ sums (%n::nat. real_mul (real_inv (real_of_num (FACT n))) (real_pow x n))
+ (exp x)"
+ by (import hollight REAL_EXP_CONVERGES)
+
+lemma SIN_CONVERGES: "ALL x::hollight.real.
+ sums
+ (%n::nat.
+ real_mul
+ (COND (EVEN n) (real_of_num (0::nat))
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV (n - NUMERAL_BIT1 (0::nat))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num (FACT n))))
+ (real_pow x n))
+ (sin x)"
+ by (import hollight SIN_CONVERGES)
+
+lemma COS_CONVERGES: "ALL x::hollight.real.
+ sums
+ (%n::nat.
+ real_mul
+ (COND (EVEN n)
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV n (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num (FACT n)))
+ (real_of_num (0::nat)))
+ (real_pow x n))
+ (cos x)"
+ by (import hollight COS_CONVERGES)
+
+lemma REAL_EXP_FDIFF: "diffs (%n::nat. real_inv (real_of_num (FACT n))) =
+(%n::nat. real_inv (real_of_num (FACT n)))"
+ by (import hollight REAL_EXP_FDIFF)
+
+lemma SIN_FDIFF: "diffs
+ (%n::nat.
+ COND (EVEN n) (real_of_num (0::nat))
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV (n - NUMERAL_BIT1 (0::nat))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num (FACT n)))) =
+(%n::nat.
+ COND (EVEN n)
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV n (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num (FACT n)))
+ (real_of_num (0::nat)))"
+ by (import hollight SIN_FDIFF)
+
+lemma COS_FDIFF: "diffs
+ (%n::nat.
+ COND (EVEN n)
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV n (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num (FACT n)))
+ (real_of_num (0::nat))) =
+(%n::nat.
+ real_neg
+ (COND (EVEN n) (real_of_num (0::nat))
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV (n - NUMERAL_BIT1 (0::nat))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num (FACT n)))))"
+ by (import hollight COS_FDIFF)
+
+lemma SIN_NEGLEMMA: "ALL x::hollight.real.
+ real_neg (sin x) =
+ suminf
+ (%n::nat.
+ real_neg
+ (real_mul
+ (COND (EVEN n) (real_of_num (0::nat))
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV (n - NUMERAL_BIT1 (0::nat))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num (FACT n))))
+ (real_pow x n)))"
+ by (import hollight SIN_NEGLEMMA)
+
+lemma DIFF_EXP: "ALL x::hollight.real. diffl exp (exp x) x"
+ by (import hollight DIFF_EXP)
+
+lemma DIFF_SIN: "ALL x::hollight.real. diffl sin (cos x) x"
+ by (import hollight DIFF_SIN)
+
+lemma DIFF_COS: "ALL x::hollight.real. diffl cos (real_neg (sin x)) x"
+ by (import hollight DIFF_COS)
+
+lemma DIFF_COMPOSITE: "(diffl (f::hollight.real => hollight.real) (l::hollight.real)
+ (x::hollight.real) &
+ f x ~= real_of_num (0::nat) -->
+ diffl (%x::hollight.real. real_inv (f x))
+ (real_neg
+ (real_div l (real_pow (f x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ x) &
+(diffl f l x &
+ diffl (g::hollight.real => hollight.real) (m::hollight.real) x &
+ g x ~= real_of_num (0::nat) -->
+ diffl (%x::hollight.real. real_div (f x) (g x))
+ (real_div (real_sub (real_mul l (g x)) (real_mul m (f x)))
+ (real_pow (g x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ x) &
+(diffl f l x & diffl g m x -->
+ diffl (%x::hollight.real. real_add (f x) (g x)) (real_add l m) x) &
+(diffl f l x & diffl g m x -->
+ diffl (%x::hollight.real. real_mul (f x) (g x))
+ (real_add (real_mul l (g x)) (real_mul m (f x))) x) &
+(diffl f l x & diffl g m x -->
+ diffl (%x::hollight.real. real_sub (f x) (g x)) (real_sub l m) x) &
+(diffl f l x --> diffl (%x::hollight.real. real_neg (f x)) (real_neg l) x) &
+(diffl g m x -->
+ diffl (%x::hollight.real. real_pow (g x) (n::nat))
+ (real_mul
+ (real_mul (real_of_num n) (real_pow (g x) (n - NUMERAL_BIT1 (0::nat))))
+ m)
+ x) &
+(diffl g m x -->
+ diffl (%x::hollight.real. exp (g x)) (real_mul (exp (g x)) m) x) &
+(diffl g m x -->
+ diffl (%x::hollight.real. sin (g x)) (real_mul (cos (g x)) m) x) &
+(diffl g m x -->
+ diffl (%x::hollight.real. cos (g x)) (real_mul (real_neg (sin (g x))) m) x)"
+ by (import hollight DIFF_COMPOSITE)
+
+lemma REAL_EXP_0: "exp (real_of_num (0::nat)) = real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight REAL_EXP_0)
+
+lemma REAL_EXP_LE_X: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) x -->
+ real_le (real_add (real_of_num (NUMERAL_BIT1 (0::nat))) x) (exp x)"
+ by (import hollight REAL_EXP_LE_X)
+
+lemma REAL_EXP_LT_1: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x -->
+ real_lt (real_of_num (NUMERAL_BIT1 (0::nat))) (exp x)"
+ by (import hollight REAL_EXP_LT_1)
+
+lemma REAL_EXP_ADD_MUL: "ALL (x::hollight.real) y::hollight.real.
+ real_mul (exp (real_add x y)) (exp (real_neg x)) = exp y"
+ by (import hollight REAL_EXP_ADD_MUL)
+
+lemma REAL_EXP_NEG_MUL: "ALL x::hollight.real.
+ real_mul (exp x) (exp (real_neg x)) = real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight REAL_EXP_NEG_MUL)
+
+lemma REAL_EXP_NEG_MUL2: "ALL x::hollight.real.
+ real_mul (exp (real_neg x)) (exp x) = real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight REAL_EXP_NEG_MUL2)
+
+lemma REAL_EXP_NEG: "ALL x::hollight.real. exp (real_neg x) = real_inv (exp x)"
+ by (import hollight REAL_EXP_NEG)
+
+lemma REAL_EXP_ADD: "ALL (x::hollight.real) y::hollight.real.
+ exp (real_add x y) = real_mul (exp x) (exp y)"
+ by (import hollight REAL_EXP_ADD)
+
+lemma REAL_EXP_POS_LE: "ALL x::hollight.real. real_le (real_of_num (0::nat)) (exp x)"
+ by (import hollight REAL_EXP_POS_LE)
+
+lemma REAL_EXP_NZ: "ALL x::hollight.real. exp x ~= real_of_num (0::nat)"
+ by (import hollight REAL_EXP_NZ)
+
+lemma REAL_EXP_POS_LT: "ALL x::hollight.real. real_lt (real_of_num (0::nat)) (exp x)"
+ by (import hollight REAL_EXP_POS_LT)
+
+lemma REAL_EXP_N: "ALL (n::nat) x::hollight.real.
+ exp (real_mul (real_of_num n) x) = real_pow (exp x) n"
+ by (import hollight REAL_EXP_N)
+
+lemma REAL_EXP_SUB: "ALL (x::hollight.real) y::hollight.real.
+ exp (real_sub x y) = real_div (exp x) (exp y)"
+ by (import hollight REAL_EXP_SUB)
+
+lemma REAL_EXP_MONO_IMP: "ALL (x::hollight.real) y::hollight.real.
+ real_lt x y --> real_lt (exp x) (exp y)"
+ by (import hollight REAL_EXP_MONO_IMP)
+
+lemma REAL_EXP_MONO_LT: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (exp x) (exp y) = real_lt x y"
+ by (import hollight REAL_EXP_MONO_LT)
+
+lemma REAL_EXP_MONO_LE: "ALL (x::hollight.real) y::hollight.real.
+ real_le (exp x) (exp y) = real_le x y"
+ by (import hollight REAL_EXP_MONO_LE)
+
+lemma REAL_EXP_INJ: "ALL (x::hollight.real) y::hollight.real. (exp x = exp y) = (x = y)"
+ by (import hollight REAL_EXP_INJ)
+
+lemma REAL_EXP_TOTAL_LEMMA: "ALL y::hollight.real.
+ real_le (real_of_num (NUMERAL_BIT1 (0::nat))) y -->
+ (EX x::hollight.real.
+ real_le (real_of_num (0::nat)) x &
+ real_le x (real_sub y (real_of_num (NUMERAL_BIT1 (0::nat)))) &
+ exp x = y)"
+ by (import hollight REAL_EXP_TOTAL_LEMMA)
+
+lemma REAL_EXP_TOTAL: "ALL y::hollight.real.
+ real_lt (real_of_num (0::nat)) y --> (EX x::hollight.real. exp x = y)"
+ by (import hollight REAL_EXP_TOTAL)
+
+lemma REAL_EXP_BOUND_LEMMA: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) x &
+ real_le x
+ (real_inv (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) -->
+ real_le (exp x)
+ (real_add (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) x))"
+ by (import hollight REAL_EXP_BOUND_LEMMA)
+
+constdefs
+ ln :: "hollight.real => hollight.real"
+ "ln == %u::hollight.real. SOME ua::hollight.real. exp ua = u"
+
+lemma DEF_ln: "ln = (%u::hollight.real. SOME ua::hollight.real. exp ua = u)"
+ by (import hollight DEF_ln)
+
+lemma LN_EXP: "ALL x::hollight.real. ln (exp x) = x"
+ by (import hollight LN_EXP)
+
+lemma REAL_EXP_LN: "ALL x::hollight.real. (exp (ln x) = x) = real_lt (real_of_num (0::nat)) x"
+ by (import hollight REAL_EXP_LN)
+
+lemma LN_MUL: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_of_num (0::nat)) x & real_lt (real_of_num (0::nat)) y -->
+ ln (real_mul x y) = real_add (ln x) (ln y)"
+ by (import hollight LN_MUL)
+
+lemma LN_INJ: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_of_num (0::nat)) x & real_lt (real_of_num (0::nat)) y -->
+ (ln x = ln y) = (x = y)"
+ by (import hollight LN_INJ)
+
+lemma LN_1: "ln (real_of_num (NUMERAL_BIT1 (0::nat))) = real_of_num (0::nat)"
+ by (import hollight LN_1)
+
+lemma LN_INV: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x --> ln (real_inv x) = real_neg (ln x)"
+ by (import hollight LN_INV)
+
+lemma LN_DIV: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x &
+ real_lt (real_of_num (0::nat)) (y::hollight.real) -->
+ ln (real_div x y) = real_sub (ln x) (ln y)"
+ by (import hollight LN_DIV)
+
+lemma LN_MONO_LT: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_of_num (0::nat)) x & real_lt (real_of_num (0::nat)) y -->
+ real_lt (ln x) (ln y) = real_lt x y"
+ by (import hollight LN_MONO_LT)
+
+lemma LN_MONO_LE: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_of_num (0::nat)) x & real_lt (real_of_num (0::nat)) y -->
+ real_le (ln x) (ln y) = real_le x y"
+ by (import hollight LN_MONO_LE)
+
+lemma LN_POW: "ALL (n::nat) x::hollight.real.
+ real_lt (real_of_num (0::nat)) x -->
+ ln (real_pow x n) = real_mul (real_of_num n) (ln x)"
+ by (import hollight LN_POW)
+
+lemma LN_LE: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) x -->
+ real_le (ln (real_add (real_of_num (NUMERAL_BIT1 (0::nat))) x)) x"
+ by (import hollight LN_LE)
+
+lemma LN_LT_X: "ALL x::hollight.real. real_lt (real_of_num (0::nat)) x --> real_lt (ln x) x"
+ by (import hollight LN_LT_X)
+
+lemma LN_POS: "ALL x::hollight.real.
+ real_le (real_of_num (NUMERAL_BIT1 (0::nat))) x -->
+ real_le (real_of_num (0::nat)) (ln x)"
+ by (import hollight LN_POS)
+
+lemma LN_POS_LT: "ALL x::hollight.real.
+ real_lt (real_of_num (NUMERAL_BIT1 (0::nat))) x -->
+ real_lt (real_of_num (0::nat)) (ln x)"
+ by (import hollight LN_POS_LT)
+
+lemma DIFF_LN: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x --> diffl ln (real_inv x) x"
+ by (import hollight DIFF_LN)
+
+constdefs
+ root :: "nat => hollight.real => hollight.real"
+ "root ==
+%(u::nat) ua::hollight.real.
+ SOME ub::hollight.real.
+ (real_lt (real_of_num (0::nat)) ua -->
+ real_lt (real_of_num (0::nat)) ub) &
+ real_pow ub u = ua"
+
+lemma DEF_root: "root =
+(%(u::nat) ua::hollight.real.
+ SOME ub::hollight.real.
+ (real_lt (real_of_num (0::nat)) ua -->
+ real_lt (real_of_num (0::nat)) ub) &
+ real_pow ub u = ua)"
+ by (import hollight DEF_root)
+
+constdefs
+ sqrt :: "hollight.real => hollight.real"
+ "sqrt ==
+%u::hollight.real.
+ SOME y::hollight.real.
+ real_le (real_of_num (0::nat)) y &
+ real_pow y (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) = u"
+
+lemma DEF_sqrt: "sqrt =
+(%u::hollight.real.
+ SOME y::hollight.real.
+ real_le (real_of_num (0::nat)) y &
+ real_pow y (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) = u)"
+ by (import hollight DEF_sqrt)
+
+lemma sqrt: "sqrt (x::hollight.real) = root (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) x"
+ by (import hollight sqrt)
+
+lemma ROOT_LT_LEMMA: "ALL (n::nat) x::hollight.real.
+ real_lt (real_of_num (0::nat)) x -->
+ real_pow (exp (real_div (ln x) (real_of_num (Suc n)))) (Suc n) = x"
+ by (import hollight ROOT_LT_LEMMA)
+
+lemma ROOT_LN: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x -->
+ (ALL n::nat.
+ root (Suc n) x = exp (real_div (ln x) (real_of_num (Suc n))))"
+ by (import hollight ROOT_LN)
+
+lemma ROOT_0: "ALL n::nat. root (Suc n) (real_of_num (0::nat)) = real_of_num (0::nat)"
+ by (import hollight ROOT_0)
+
+lemma ROOT_1: "ALL n::nat.
+ root (Suc n) (real_of_num (NUMERAL_BIT1 (0::nat))) =
+ real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight ROOT_1)
+
+lemma ROOT_POW_POS: "ALL (n::nat) x::hollight.real.
+ real_le (real_of_num (0::nat)) x -->
+ real_pow (root (Suc n) x) (Suc n) = x"
+ by (import hollight ROOT_POW_POS)
+
+lemma POW_ROOT_POS: "ALL (n::nat) x::hollight.real.
+ real_le (real_of_num (0::nat)) x -->
+ root (Suc n) (real_pow x (Suc n)) = x"
+ by (import hollight POW_ROOT_POS)
+
+lemma ROOT_POS_POSITIVE: "ALL (x::hollight.real) n::nat.
+ real_le (real_of_num (0::nat)) x -->
+ real_le (real_of_num (0::nat)) (root (Suc n) x)"
+ by (import hollight ROOT_POS_POSITIVE)
+
+lemma ROOT_POS_UNIQ: "ALL (n::nat) (x::hollight.real) y::hollight.real.
+ real_le (real_of_num (0::nat)) x &
+ real_le (real_of_num (0::nat)) y & real_pow y (Suc n) = x -->
+ root (Suc n) x = y"
+ by (import hollight ROOT_POS_UNIQ)
+
+lemma ROOT_MUL: "ALL (n::nat) (x::hollight.real) y::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le (real_of_num (0::nat)) y -->
+ root (Suc n) (real_mul x y) = real_mul (root (Suc n) x) (root (Suc n) y)"
+ by (import hollight ROOT_MUL)
+
+lemma ROOT_INV: "ALL (n::nat) x::hollight.real.
+ real_le (real_of_num (0::nat)) x -->
+ root (Suc n) (real_inv x) = real_inv (root (Suc n) x)"
+ by (import hollight ROOT_INV)
+
+lemma ROOT_DIV: "ALL (x::nat) (xa::hollight.real) xb::hollight.real.
+ real_le (real_of_num (0::nat)) xa & real_le (real_of_num (0::nat)) xb -->
+ root (Suc x) (real_div xa xb) =
+ real_div (root (Suc x) xa) (root (Suc x) xb)"
+ by (import hollight ROOT_DIV)
+
+lemma ROOT_MONO_LT: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_lt x y -->
+ real_lt (root (Suc (n::nat)) x) (root (Suc n) y)"
+ by (import hollight ROOT_MONO_LT)
+
+lemma ROOT_MONO_LE: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le x y -->
+ real_le (root (Suc (n::nat)) x) (root (Suc n) y)"
+ by (import hollight ROOT_MONO_LE)
+
+lemma ROOT_MONO_LT_EQ: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le (real_of_num (0::nat)) y -->
+ real_lt (root (Suc (n::nat)) x) (root (Suc n) y) = real_lt x y"
+ by (import hollight ROOT_MONO_LT_EQ)
+
+lemma ROOT_MONO_LE_EQ: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le (real_of_num (0::nat)) y -->
+ real_le (root (Suc (n::nat)) x) (root (Suc n) y) = real_le x y"
+ by (import hollight ROOT_MONO_LE_EQ)
+
+lemma ROOT_INJ: "ALL (x::hollight.real) xa::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le (real_of_num (0::nat)) xa -->
+ (root (Suc (n::nat)) x = root (Suc n) xa) = (x = xa)"
+ by (import hollight ROOT_INJ)
+
+lemma SQRT_0: "sqrt (real_of_num (0::nat)) = real_of_num (0::nat)"
+ by (import hollight SQRT_0)
+
+lemma SQRT_1: "sqrt (real_of_num (NUMERAL_BIT1 (0::nat))) =
+real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight SQRT_1)
+
+lemma SQRT_POS_LT: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x -->
+ real_lt (real_of_num (0::nat)) (sqrt x)"
+ by (import hollight SQRT_POS_LT)
+
+lemma SQRT_POS_LE: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) x -->
+ real_le (real_of_num (0::nat)) (sqrt x)"
+ by (import hollight SQRT_POS_LE)
+
+lemma SQRT_POW2: "ALL x::hollight.real.
+ (real_pow (sqrt x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) = x) =
+ real_le (real_of_num (0::nat)) x"
+ by (import hollight SQRT_POW2)
+
+lemma SQRT_POW_2: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) x -->
+ real_pow (sqrt x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) = x"
+ by (import hollight SQRT_POW_2)
+
+lemma POW_2_SQRT: "real_le (real_of_num (0::nat)) (x::hollight.real) -->
+sqrt (real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) = x"
+ by (import hollight POW_2_SQRT)
+
+lemma SQRT_POS_UNIQ: "ALL (x::hollight.real) xa::hollight.real.
+ real_le (real_of_num (0::nat)) x &
+ real_le (real_of_num (0::nat)) xa &
+ real_pow xa (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))) = x -->
+ sqrt x = xa"
+ by (import hollight SQRT_POS_UNIQ)
+
+lemma SQRT_MUL: "ALL (x::hollight.real) xa::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le (real_of_num (0::nat)) xa -->
+ sqrt (real_mul x xa) = real_mul (sqrt x) (sqrt xa)"
+ by (import hollight SQRT_MUL)
+
+lemma SQRT_INV: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) x -->
+ sqrt (real_inv x) = real_inv (sqrt x)"
+ by (import hollight SQRT_INV)
+
+lemma SQRT_DIV: "ALL (x::hollight.real) xa::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le (real_of_num (0::nat)) xa -->
+ sqrt (real_div x xa) = real_div (sqrt x) (sqrt xa)"
+ by (import hollight SQRT_DIV)
+
+lemma SQRT_MONO_LT: "ALL (x::hollight.real) xa::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_lt x xa -->
+ real_lt (sqrt x) (sqrt xa)"
+ by (import hollight SQRT_MONO_LT)
+
+lemma SQRT_MONO_LE: "ALL (x::hollight.real) xa::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le x xa -->
+ real_le (sqrt x) (sqrt xa)"
+ by (import hollight SQRT_MONO_LE)
+
+lemma SQRT_MONO_LT_EQ: "ALL (x::hollight.real) xa::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le (real_of_num (0::nat)) xa -->
+ real_lt (sqrt x) (sqrt xa) = real_lt x xa"
+ by (import hollight SQRT_MONO_LT_EQ)
+
+lemma SQRT_MONO_LE_EQ: "ALL (x::hollight.real) xa::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le (real_of_num (0::nat)) xa -->
+ real_le (sqrt x) (sqrt xa) = real_le x xa"
+ by (import hollight SQRT_MONO_LE_EQ)
+
+lemma SQRT_INJ: "ALL (x::hollight.real) xa::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le (real_of_num (0::nat)) xa -->
+ (sqrt x = sqrt xa) = (x = xa)"
+ by (import hollight SQRT_INJ)
+
+lemma SQRT_EVEN_POW2: "ALL n::nat.
+ EVEN n -->
+ sqrt (real_pow (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) n) =
+ real_pow (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ (DIV n (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))"
+ by (import hollight SQRT_EVEN_POW2)
+
+lemma REAL_DIV_SQRT: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) x --> real_div x (sqrt x) = sqrt x"
+ by (import hollight REAL_DIV_SQRT)
+
+lemma POW_2_SQRT_ABS: "ALL x::hollight.real.
+ sqrt (real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) = real_abs x"
+ by (import hollight POW_2_SQRT_ABS)
+
+lemma SQRT_EQ_0: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) x -->
+ (sqrt x = real_of_num (0::nat)) = (x = real_of_num (0::nat))"
+ by (import hollight SQRT_EQ_0)
+
+lemma REAL_LE_LSQRT: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_of_num (0::nat)) x &
+ real_le (real_of_num (0::nat)) y &
+ real_le x (real_pow y (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) -->
+ real_le (sqrt x) y"
+ by (import hollight REAL_LE_LSQRT)
+
+lemma REAL_LE_POW_2: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat))
+ (real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))"
+ by (import hollight REAL_LE_POW_2)
+
+lemma REAL_LE_RSQRT: "ALL (x::hollight.real) y::hollight.real.
+ real_le (real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) y -->
+ real_le x (sqrt y)"
+ by (import hollight REAL_LE_RSQRT)
+
+lemma SIN_0: "sin (real_of_num (0::nat)) = real_of_num (0::nat)"
+ by (import hollight SIN_0)
+
+lemma COS_0: "cos (real_of_num (0::nat)) = real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight COS_0)
+
+lemma SIN_CIRCLE: "ALL x::hollight.real.
+ real_add (real_pow (sin x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ (real_pow (cos x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) =
+ real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight SIN_CIRCLE)
+
+lemma SIN_BOUND: "ALL x::hollight.real.
+ real_le (real_abs (sin x)) (real_of_num (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight SIN_BOUND)
+
+lemma SIN_BOUNDS: "ALL x::hollight.real.
+ real_le (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) (sin x) &
+ real_le (sin x) (real_of_num (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight SIN_BOUNDS)
+
+lemma COS_BOUND: "ALL x::hollight.real.
+ real_le (real_abs (cos x)) (real_of_num (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight COS_BOUND)
+
+lemma COS_BOUNDS: "ALL x::hollight.real.
+ real_le (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) (cos x) &
+ real_le (cos x) (real_of_num (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight COS_BOUNDS)
+
+lemma SIN_COS_ADD: "ALL (x::hollight.real) y::hollight.real.
+ real_add
+ (real_pow
+ (real_sub (sin (real_add x y))
+ (real_add (real_mul (sin x) (cos y)) (real_mul (cos x) (sin y))))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ (real_pow
+ (real_sub (cos (real_add x y))
+ (real_sub (real_mul (cos x) (cos y)) (real_mul (sin x) (sin y))))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) =
+ real_of_num (0::nat)"
+ by (import hollight SIN_COS_ADD)
+
+lemma SIN_COS_NEG: "ALL x::hollight.real.
+ real_add
+ (real_pow (real_add (sin (real_neg x)) (sin x))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ (real_pow (real_sub (cos (real_neg x)) (cos x))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) =
+ real_of_num (0::nat)"
+ by (import hollight SIN_COS_NEG)
+
+lemma SIN_ADD: "ALL (x::hollight.real) y::hollight.real.
+ sin (real_add x y) =
+ real_add (real_mul (sin x) (cos y)) (real_mul (cos x) (sin y))"
+ by (import hollight SIN_ADD)
+
+lemma COS_ADD: "ALL (x::hollight.real) y::hollight.real.
+ cos (real_add x y) =
+ real_sub (real_mul (cos x) (cos y)) (real_mul (sin x) (sin y))"
+ by (import hollight COS_ADD)
+
+lemma SIN_NEG: "ALL x::hollight.real. sin (real_neg x) = real_neg (sin x)"
+ by (import hollight SIN_NEG)
+
+lemma COS_NEG: "ALL x::hollight.real. cos (real_neg x) = cos x"
+ by (import hollight COS_NEG)
+
+lemma SIN_DOUBLE: "ALL x::hollight.real.
+ sin (real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) x) =
+ real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ (real_mul (sin x) (cos x))"
+ by (import hollight SIN_DOUBLE)
+
+lemma COS_DOUBLE: "ALL x::hollight.real.
+ cos (real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) x) =
+ real_sub (real_pow (cos x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ (real_pow (sin x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))"
+ by (import hollight COS_DOUBLE)
+
+lemma COS_ABS: "ALL x::hollight.real. cos (real_abs x) = cos x"
+ by (import hollight COS_ABS)
+
+lemma SIN_PAIRED: "ALL x::hollight.real.
+ sums
+ (%n::nat.
+ real_mul
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) n)
+ (real_of_num
+ (FACT
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * n +
+ NUMERAL_BIT1 (0::nat)))))
+ (real_pow x
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * n +
+ NUMERAL_BIT1 (0::nat))))
+ (sin x)"
+ by (import hollight SIN_PAIRED)
+
+lemma SIN_POS: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x &
+ real_lt x (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) -->
+ real_lt (real_of_num (0::nat)) (sin x)"
+ by (import hollight SIN_POS)
+
+lemma COS_PAIRED: "ALL x::hollight.real.
+ sums
+ (%n::nat.
+ real_mul
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) n)
+ (real_of_num (FACT (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * n))))
+ (real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)) * n)))
+ (cos x)"
+ by (import hollight COS_PAIRED)
+
+lemma COS_2: "real_lt (cos (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num (0::nat))"
+ by (import hollight COS_2)
+
+lemma COS_ISZERO: "EX! x::hollight.real.
+ real_le (real_of_num (0::nat)) x &
+ real_le x (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) &
+ cos x = real_of_num (0::nat)"
+ by (import hollight COS_ISZERO)
+
+constdefs
+ pi :: "hollight.real"
+ "pi ==
+real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ (SOME x::hollight.real.
+ real_le (real_of_num (0::nat)) x &
+ real_le x (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) &
+ cos x = real_of_num (0::nat))"
+
+lemma DEF_pi: "pi =
+real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ (SOME x::hollight.real.
+ real_le (real_of_num (0::nat)) x &
+ real_le x (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) &
+ cos x = real_of_num (0::nat))"
+ by (import hollight DEF_pi)
+
+lemma PI2: "real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) =
+(SOME x::hollight.real.
+ real_le (real_of_num (0::nat)) x &
+ real_le x (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) &
+ cos x = real_of_num (0::nat))"
+ by (import hollight PI2)
+
+lemma COS_PI2: "cos (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) =
+real_of_num (0::nat)"
+ by (import hollight COS_PI2)
+
+lemma PI2_BOUNDS: "real_lt (real_of_num (0::nat))
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) &
+real_lt (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))"
+ by (import hollight PI2_BOUNDS)
+
+lemma PI_POS: "real_lt (real_of_num (0::nat)) pi"
+ by (import hollight PI_POS)
+
+lemma SIN_PI2: "sin (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) =
+real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight SIN_PI2)
+
+lemma COS_PI: "cos pi = real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight COS_PI)
+
+lemma SIN_PI: "sin pi = real_of_num (0::nat)"
+ by (import hollight SIN_PI)
+
+lemma SIN_COS: "ALL x::hollight.real.
+ sin x =
+ cos (real_sub
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ x)"
+ by (import hollight SIN_COS)
+
+lemma COS_SIN: "ALL x::hollight.real.
+ cos x =
+ sin (real_sub
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ x)"
+ by (import hollight COS_SIN)
+
+lemma SIN_PERIODIC_PI: "ALL x::hollight.real. sin (real_add x pi) = real_neg (sin x)"
+ by (import hollight SIN_PERIODIC_PI)
+
+lemma COS_PERIODIC_PI: "ALL x::hollight.real. cos (real_add x pi) = real_neg (cos x)"
+ by (import hollight COS_PERIODIC_PI)
+
+lemma SIN_PERIODIC: "ALL x::hollight.real.
+ sin (real_add x
+ (real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ pi)) =
+ sin x"
+ by (import hollight SIN_PERIODIC)
+
+lemma COS_PERIODIC: "ALL x::hollight.real.
+ cos (real_add x
+ (real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ pi)) =
+ cos x"
+ by (import hollight COS_PERIODIC)
+
+lemma COS_NPI: "ALL n::nat.
+ cos (real_mul (real_of_num n) pi) =
+ real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) n"
+ by (import hollight COS_NPI)
+
+lemma SIN_NPI: "ALL n::nat. sin (real_mul (real_of_num n) pi) = real_of_num (0::nat)"
+ by (import hollight SIN_NPI)
+
+lemma SIN_POS_PI2: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x &
+ real_lt x
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) -->
+ real_lt (real_of_num (0::nat)) (sin x)"
+ by (import hollight SIN_POS_PI2)
+
+lemma COS_POS_PI2: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x &
+ real_lt x
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) -->
+ real_lt (real_of_num (0::nat)) (cos x)"
+ by (import hollight COS_POS_PI2)
+
+lemma COS_POS_PI: "ALL x::hollight.real.
+ real_lt
+ (real_neg
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ x &
+ real_lt x
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) -->
+ real_lt (real_of_num (0::nat)) (cos x)"
+ by (import hollight COS_POS_PI)
+
+lemma SIN_POS_PI: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x & real_lt x pi -->
+ real_lt (real_of_num (0::nat)) (sin x)"
+ by (import hollight SIN_POS_PI)
+
+lemma SIN_POS_PI_LE: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le x pi -->
+ real_le (real_of_num (0::nat)) (sin x)"
+ by (import hollight SIN_POS_PI_LE)
+
+lemma COS_TOTAL: "ALL y::hollight.real.
+ real_le (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) y &
+ real_le y (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ (EX! x::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le x pi & cos x = y)"
+ by (import hollight COS_TOTAL)
+
+lemma SIN_TOTAL: "ALL y::hollight.real.
+ real_le (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) y &
+ real_le y (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ (EX! x::hollight.real.
+ real_le
+ (real_neg
+ (real_div pi
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ x &
+ real_le x
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) &
+ sin x = y)"
+ by (import hollight SIN_TOTAL)
+
+lemma COS_ZERO_LEMMA: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) x & cos x = real_of_num (0::nat) -->
+ (EX n::nat.
+ ~ EVEN n &
+ x =
+ real_mul (real_of_num n)
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))"
+ by (import hollight COS_ZERO_LEMMA)
+
+lemma SIN_ZERO_LEMMA: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) x & sin x = real_of_num (0::nat) -->
+ (EX n::nat.
+ EVEN n &
+ x =
+ real_mul (real_of_num n)
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))"
+ by (import hollight SIN_ZERO_LEMMA)
+
+lemma COS_ZERO: "ALL x::hollight.real.
+ (cos x = real_of_num (0::nat)) =
+ ((EX n::nat.
+ ~ EVEN n &
+ x =
+ real_mul (real_of_num n)
+ (real_div pi
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))) |
+ (EX n::nat.
+ ~ EVEN n &
+ x =
+ real_neg
+ (real_mul (real_of_num n)
+ (real_div pi
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))))"
+ by (import hollight COS_ZERO)
+
+lemma SIN_ZERO: "ALL x::hollight.real.
+ (sin x = real_of_num (0::nat)) =
+ ((EX n::nat.
+ EVEN n &
+ x =
+ real_mul (real_of_num n)
+ (real_div pi
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))) |
+ (EX n::nat.
+ EVEN n &
+ x =
+ real_neg
+ (real_mul (real_of_num n)
+ (real_div pi
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))))"
+ by (import hollight SIN_ZERO)
+
+lemma SIN_ZERO_PI: "ALL x::hollight.real.
+ (sin x = real_of_num (0::nat)) =
+ ((EX n::nat. x = real_mul (real_of_num n) pi) |
+ (EX n::nat. x = real_neg (real_mul (real_of_num n) pi)))"
+ by (import hollight SIN_ZERO_PI)
+
+lemma COS_ONE_2PI: "ALL x::hollight.real.
+ (cos x = real_of_num (NUMERAL_BIT1 (0::nat))) =
+ ((EX n::nat.
+ x =
+ real_mul (real_of_num n)
+ (real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ pi)) |
+ (EX n::nat.
+ x =
+ real_neg
+ (real_mul (real_of_num n)
+ (real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ pi))))"
+ by (import hollight COS_ONE_2PI)
+
+constdefs
+ tan :: "hollight.real => hollight.real"
+ "tan == %u::hollight.real. real_div (sin u) (cos u)"
+
+lemma DEF_tan: "tan = (%u::hollight.real. real_div (sin u) (cos u))"
+ by (import hollight DEF_tan)
+
+lemma TAN_0: "tan (real_of_num (0::nat)) = real_of_num (0::nat)"
+ by (import hollight TAN_0)
+
+lemma TAN_PI: "tan pi = real_of_num (0::nat)"
+ by (import hollight TAN_PI)
+
+lemma TAN_NPI: "ALL n::nat. tan (real_mul (real_of_num n) pi) = real_of_num (0::nat)"
+ by (import hollight TAN_NPI)
+
+lemma TAN_NEG: "ALL x::hollight.real. tan (real_neg x) = real_neg (tan x)"
+ by (import hollight TAN_NEG)
+
+lemma TAN_PERIODIC: "ALL x::hollight.real.
+ tan (real_add x
+ (real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ pi)) =
+ tan x"
+ by (import hollight TAN_PERIODIC)
+
+lemma TAN_PERIODIC_PI: "ALL x::hollight.real. tan (real_add x pi) = tan x"
+ by (import hollight TAN_PERIODIC_PI)
+
+lemma TAN_PERIODIC_NPI: "ALL (x::hollight.real) n::nat.
+ tan (real_add x (real_mul (real_of_num n) pi)) = tan x"
+ by (import hollight TAN_PERIODIC_NPI)
+
+lemma TAN_ADD: "ALL (x::hollight.real) y::hollight.real.
+ cos x ~= real_of_num (0::nat) &
+ cos y ~= real_of_num (0::nat) &
+ cos (real_add x y) ~= real_of_num (0::nat) -->
+ tan (real_add x y) =
+ real_div (real_add (tan x) (tan y))
+ (real_sub (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_mul (tan x) (tan y)))"
+ by (import hollight TAN_ADD)
+
+lemma TAN_DOUBLE: "ALL x::hollight.real.
+ cos x ~= real_of_num (0::nat) &
+ cos (real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) x) ~=
+ real_of_num (0::nat) -->
+ tan (real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) x) =
+ real_div
+ (real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) (tan x))
+ (real_sub (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_pow (tan x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))"
+ by (import hollight TAN_DOUBLE)
+
+lemma TAN_POS_PI2: "ALL x::hollight.real.
+ real_lt (real_of_num (0::nat)) x &
+ real_lt x
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) -->
+ real_lt (real_of_num (0::nat)) (tan x)"
+ by (import hollight TAN_POS_PI2)
+
+lemma DIFF_TAN: "ALL x::hollight.real.
+ cos x ~= real_of_num (0::nat) -->
+ diffl tan
+ (real_inv (real_pow (cos x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) x"
+ by (import hollight DIFF_TAN)
+
+lemma DIFF_TAN_COMPOSITE: "diffl (g::hollight.real => hollight.real) (m::hollight.real)
+ (x::hollight.real) &
+cos (g x) ~= real_of_num (0::nat) -->
+diffl (%x::hollight.real. tan (g x))
+ (real_mul
+ (real_inv (real_pow (cos (g x)) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ m)
+ x"
+ by (import hollight DIFF_TAN_COMPOSITE)
+
+lemma TAN_TOTAL_LEMMA: "ALL y::hollight.real.
+ real_lt (real_of_num (0::nat)) y -->
+ (EX x::hollight.real.
+ real_lt (real_of_num (0::nat)) x &
+ real_lt x
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) &
+ real_lt y (tan x))"
+ by (import hollight TAN_TOTAL_LEMMA)
+
+lemma TAN_TOTAL_POS: "ALL y::hollight.real.
+ real_le (real_of_num (0::nat)) y -->
+ (EX x::hollight.real.
+ real_le (real_of_num (0::nat)) x &
+ real_lt x
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) &
+ tan x = y)"
+ by (import hollight TAN_TOTAL_POS)
+
+lemma TAN_TOTAL: "ALL y::hollight.real.
+ EX! x::hollight.real.
+ real_lt
+ (real_neg
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ x &
+ real_lt x
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) &
+ tan x = y"
+ by (import hollight TAN_TOTAL)
+
+lemma PI2_PI4: "real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) =
+real_mul (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ (real_div pi
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))"
+ by (import hollight PI2_PI4)
+
+lemma TAN_PI4: "tan (real_div pi
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))) =
+real_of_num (NUMERAL_BIT1 (0::nat))"
+ by (import hollight TAN_PI4)
+
+lemma TAN_COT: "ALL x::hollight.real.
+ tan (real_sub
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ x) =
+ real_inv (tan x)"
+ by (import hollight TAN_COT)
+
+lemma TAN_BOUND_PI2: "ALL x::hollight.real.
+ real_lt (real_abs x)
+ (real_div pi
+ (real_of_num
+ (NUMERAL_BIT0 (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))) -->
+ real_lt (real_abs (tan x)) (real_of_num (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight TAN_BOUND_PI2)
+
+lemma TAN_ABS_GE_X: "ALL x::hollight.real.
+ real_lt (real_abs x)
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) -->
+ real_le (real_abs x) (real_abs (tan x))"
+ by (import hollight TAN_ABS_GE_X)
+
+constdefs
+ asn :: "hollight.real => hollight.real"
+ "asn ==
+%u::hollight.real.
+ SOME x::hollight.real.
+ real_le
+ (real_neg
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ x &
+ real_le x
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) &
+ sin x = u"
+
+lemma DEF_asn: "asn =
+(%u::hollight.real.
+ SOME x::hollight.real.
+ real_le
+ (real_neg
+ (real_div pi
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ x &
+ real_le x
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) &
+ sin x = u)"
+ by (import hollight DEF_asn)
+
+constdefs
+ acs :: "hollight.real => hollight.real"
+ "acs ==
+%u::hollight.real.
+ SOME x::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le x pi & cos x = u"
+
+lemma DEF_acs: "acs =
+(%u::hollight.real.
+ SOME x::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le x pi & cos x = u)"
+ by (import hollight DEF_acs)
+
+constdefs
+ atn :: "hollight.real => hollight.real"
+ "atn ==
+%u::hollight.real.
+ SOME x::hollight.real.
+ real_lt
+ (real_neg
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ x &
+ real_lt x
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) &
+ tan x = u"
+
+lemma DEF_atn: "atn =
+(%u::hollight.real.
+ SOME x::hollight.real.
+ real_lt
+ (real_neg
+ (real_div pi
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ x &
+ real_lt x
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) &
+ tan x = u)"
+ by (import hollight DEF_atn)
+
+lemma ASN: "ALL y::hollight.real.
+ real_le (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) y &
+ real_le y (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ real_le
+ (real_neg
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ (asn y) &
+ real_le (asn y)
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) &
+ sin (asn y) = y"
+ by (import hollight ASN)
+
+lemma ASN_SIN: "ALL y::hollight.real.
+ real_le (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) y &
+ real_le y (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ sin (asn y) = y"
+ by (import hollight ASN_SIN)
+
+lemma ASN_BOUNDS: "ALL y::hollight.real.
+ real_le (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) y &
+ real_le y (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ real_le
+ (real_neg
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ (asn y) &
+ real_le (asn y)
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))"
+ by (import hollight ASN_BOUNDS)
+
+lemma ASN_BOUNDS_LT: "ALL y::hollight.real.
+ real_lt (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) y &
+ real_lt y (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ real_lt
+ (real_neg
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ (asn y) &
+ real_lt (asn y)
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))"
+ by (import hollight ASN_BOUNDS_LT)
+
+lemma SIN_ASN: "ALL x::hollight.real.
+ real_le
+ (real_neg
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ x &
+ real_le x
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) -->
+ asn (sin x) = x"
+ by (import hollight SIN_ASN)
+
+lemma ACS: "ALL y::hollight.real.
+ real_le (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) y &
+ real_le y (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ real_le (real_of_num (0::nat)) (acs y) &
+ real_le (acs y) pi & cos (acs y) = y"
+ by (import hollight ACS)
+
+lemma ACS_COS: "ALL y::hollight.real.
+ real_le (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) y &
+ real_le y (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ cos (acs y) = y"
+ by (import hollight ACS_COS)
+
+lemma ACS_BOUNDS: "ALL y::hollight.real.
+ real_le (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) y &
+ real_le y (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ real_le (real_of_num (0::nat)) (acs y) & real_le (acs y) pi"
+ by (import hollight ACS_BOUNDS)
+
+lemma ACS_BOUNDS_LT: "ALL y::hollight.real.
+ real_lt (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) y &
+ real_lt y (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ real_lt (real_of_num (0::nat)) (acs y) & real_lt (acs y) pi"
+ by (import hollight ACS_BOUNDS_LT)
+
+lemma COS_ACS: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) x & real_le x pi --> acs (cos x) = x"
+ by (import hollight COS_ACS)
+
+lemma ATN: "ALL y::hollight.real.
+ real_lt
+ (real_neg
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ (atn y) &
+ real_lt (atn y)
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) &
+ tan (atn y) = y"
+ by (import hollight ATN)
+
+lemma ATN_TAN: "ALL x::hollight.real. tan (atn x) = x"
+ by (import hollight ATN_TAN)
+
+lemma ATN_BOUNDS: "ALL x::hollight.real.
+ real_lt
+ (real_neg
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ (atn x) &
+ real_lt (atn x)
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))"
+ by (import hollight ATN_BOUNDS)
+
+lemma TAN_ATN: "ALL x::hollight.real.
+ real_lt
+ (real_neg
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ x &
+ real_lt x
+ (real_div pi (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))) -->
+ atn (tan x) = x"
+ by (import hollight TAN_ATN)
+
+lemma ATN_0: "atn (real_of_num (0::nat)) = real_of_num (0::nat)"
+ by (import hollight ATN_0)
+
+lemma ATN_1: "atn (real_of_num (NUMERAL_BIT1 (0::nat))) =
+real_div pi
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))"
+ by (import hollight ATN_1)
+
+lemma ATN_NEG: "ALL x::hollight.real. atn (real_neg x) = real_neg (atn x)"
+ by (import hollight ATN_NEG)
+
+lemma COS_ATN_NZ: "ALL x::hollight.real. cos (atn x) ~= real_of_num (0::nat)"
+ by (import hollight COS_ATN_NZ)
+
+lemma TAN_SEC: "ALL x::hollight.real.
+ cos x ~= real_of_num (0::nat) -->
+ real_add (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_pow (tan x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) =
+ real_pow (real_inv (cos x)) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))"
+ by (import hollight TAN_SEC)
+
+lemma DIFF_ATN: "ALL x::hollight.real.
+ diffl atn
+ (real_inv
+ (real_add (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ x"
+ by (import hollight DIFF_ATN)
+
+lemma DIFF_ATN_COMPOSITE: "diffl (g::hollight.real => hollight.real) (m::hollight.real)
+ (x::hollight.real) -->
+diffl (%x::hollight.real. atn (g x))
+ (real_mul
+ (real_inv
+ (real_add (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_pow (g x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ m)
+ x"
+ by (import hollight DIFF_ATN_COMPOSITE)
+
+lemma ATN_MONO_LT: "ALL (x::hollight.real) y::hollight.real.
+ real_lt x y --> real_lt (atn x) (atn y)"
+ by (import hollight ATN_MONO_LT)
+
+lemma ATN_MONO_LT_EQ: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (atn x) (atn y) = real_lt x y"
+ by (import hollight ATN_MONO_LT_EQ)
+
+lemma ATN_MONO_LE_EQ: "ALL (x::hollight.real) xa::hollight.real.
+ real_le (atn x) (atn xa) = real_le x xa"
+ by (import hollight ATN_MONO_LE_EQ)
+
+lemma ATN_INJ: "ALL (x::hollight.real) xa::hollight.real. (atn x = atn xa) = (x = xa)"
+ by (import hollight ATN_INJ)
+
+lemma ATN_POS_LT: "real_lt (real_of_num (0::nat)) (atn (x::hollight.real)) =
+real_lt (real_of_num (0::nat)) x"
+ by (import hollight ATN_POS_LT)
+
+lemma ATN_POS_LE: "real_le (real_of_num (0::nat)) (atn (x::hollight.real)) =
+real_le (real_of_num (0::nat)) x"
+ by (import hollight ATN_POS_LE)
+
+lemma ATN_LT_PI4_POS: "ALL x::hollight.real.
+ real_lt x (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ real_lt (atn x)
+ (real_div pi
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))"
+ by (import hollight ATN_LT_PI4_POS)
+
+lemma ATN_LT_PI4_NEG: "ALL x::hollight.real.
+ real_lt (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) x -->
+ real_lt
+ (real_neg
+ (real_div pi
+ (real_of_num
+ (NUMERAL_BIT0 (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))))
+ (atn x)"
+ by (import hollight ATN_LT_PI4_NEG)
+
+lemma ATN_LT_PI4: "ALL x::hollight.real.
+ real_lt (real_abs x) (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ real_lt (real_abs (atn x))
+ (real_div pi
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))"
+ by (import hollight ATN_LT_PI4)
+
+lemma ATN_LE_PI4: "ALL x::hollight.real.
+ real_le (real_abs x) (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ real_le (real_abs (atn x))
+ (real_div pi
+ (real_of_num (NUMERAL_BIT0 (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))"
+ by (import hollight ATN_LE_PI4)
+
+lemma COS_SIN_SQRT: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) (cos x) -->
+ cos x =
+ sqrt
+ (real_sub (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_pow (sin x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))"
+ by (import hollight COS_SIN_SQRT)
+
+lemma COS_ASN_NZ: "ALL x::hollight.real.
+ real_lt (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) x &
+ real_lt x (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ cos (asn x) ~= real_of_num (0::nat)"
+ by (import hollight COS_ASN_NZ)
+
+lemma DIFF_ASN_COS: "ALL x::hollight.real.
+ real_lt (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) x &
+ real_lt x (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ diffl asn (real_inv (cos (asn x))) x"
+ by (import hollight DIFF_ASN_COS)
+
+lemma DIFF_ASN: "ALL x::hollight.real.
+ real_lt (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) x &
+ real_lt x (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ diffl asn
+ (real_inv
+ (sqrt
+ (real_sub (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))))
+ x"
+ by (import hollight DIFF_ASN)
+
+lemma SIN_COS_SQRT: "ALL x::hollight.real.
+ real_le (real_of_num (0::nat)) (sin x) -->
+ sin x =
+ sqrt
+ (real_sub (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_pow (cos x) (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))"
+ by (import hollight SIN_COS_SQRT)
+
+lemma SIN_ACS_NZ: "ALL x::hollight.real.
+ real_lt (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) x &
+ real_lt x (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ sin (acs x) ~= real_of_num (0::nat)"
+ by (import hollight SIN_ACS_NZ)
+
+lemma DIFF_ACS_SIN: "ALL x::hollight.real.
+ real_lt (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) x &
+ real_lt x (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ diffl acs (real_inv (real_neg (sin (acs x)))) x"
+ by (import hollight DIFF_ACS_SIN)
+
+lemma DIFF_ACS: "ALL x::hollight.real.
+ real_lt (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) x &
+ real_lt x (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ diffl acs
+ (real_neg
+ (real_inv
+ (sqrt
+ (real_sub (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))))
+ x"
+ by (import hollight DIFF_ACS)
+
+lemma CIRCLE_SINCOS: "ALL (x::hollight.real) y::hollight.real.
+ real_add (real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))
+ (real_pow y (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))) =
+ real_of_num (NUMERAL_BIT1 (0::nat)) -->
+ (EX t::hollight.real. x = cos t & y = sin t)"
+ by (import hollight CIRCLE_SINCOS)
+
+lemma ACS_MONO_LT: "ALL (x::hollight.real) y::hollight.real.
+ real_lt (real_neg (real_of_num (NUMERAL_BIT1 (0::nat)))) x &
+ real_lt x y & real_lt y (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ real_lt (acs y) (acs x)"
+ by (import hollight ACS_MONO_LT)
+
+lemma LESS_SUC_EQ: "ALL (m::nat) n::nat. < m (Suc n) = <= m n"
+ by (import hollight LESS_SUC_EQ)
+
+lemma LESS_1: "ALL x::nat. < x (NUMERAL_BIT1 (0::nat)) = (x = (0::nat))"
+ by (import hollight LESS_1)
+
+constdefs
+ division :: "hollight.real * hollight.real => (nat => hollight.real) => bool"
+ "division ==
+%(u::hollight.real * hollight.real) ua::nat => hollight.real.
+ ua (0::nat) = fst u &
+ (EX N::nat.
+ (ALL n::nat. < n N --> real_lt (ua n) (ua (Suc n))) &
+ (ALL n::nat. >= n N --> ua n = snd u))"
+
+lemma DEF_division: "division =
+(%(u::hollight.real * hollight.real) ua::nat => hollight.real.
+ ua (0::nat) = fst u &
+ (EX N::nat.
+ (ALL n::nat. < n N --> real_lt (ua n) (ua (Suc n))) &
+ (ALL n::nat. >= n N --> ua n = snd u)))"
+ by (import hollight DEF_division)
+
+constdefs
+ dsize :: "(nat => hollight.real) => nat"
+ "dsize ==
+%u::nat => hollight.real.
+ SOME N::nat.
+ (ALL n::nat. < n N --> real_lt (u n) (u (Suc n))) &
+ (ALL n::nat. >= n N --> u n = u N)"
+
+lemma DEF_dsize: "dsize =
+(%u::nat => hollight.real.
+ SOME N::nat.
+ (ALL n::nat. < n N --> real_lt (u n) (u (Suc n))) &
+ (ALL n::nat. >= n N --> u n = u N))"
+ by (import hollight DEF_dsize)
+
+constdefs
+ tdiv :: "hollight.real * hollight.real
+=> (nat => hollight.real) * (nat => hollight.real) => bool"
+ "tdiv ==
+%(u::hollight.real * hollight.real)
+ ua::(nat => hollight.real) * (nat => hollight.real).
+ division (fst u, snd u) (fst ua) &
+ (ALL n::nat.
+ real_le (fst ua n) (snd ua n) & real_le (snd ua n) (fst ua (Suc n)))"
+
+lemma DEF_tdiv: "tdiv =
+(%(u::hollight.real * hollight.real)
+ ua::(nat => hollight.real) * (nat => hollight.real).
+ division (fst u, snd u) (fst ua) &
+ (ALL n::nat.
+ real_le (fst ua n) (snd ua n) &
+ real_le (snd ua n) (fst ua (Suc n))))"
+ by (import hollight DEF_tdiv)
+
+constdefs
+ gauge :: "(hollight.real => bool) => (hollight.real => hollight.real) => bool"
+ "gauge ==
+%(u::hollight.real => bool) ua::hollight.real => hollight.real.
+ ALL x::hollight.real. u x --> real_lt (real_of_num (0::nat)) (ua x)"
+
+lemma DEF_gauge: "gauge =
+(%(u::hollight.real => bool) ua::hollight.real => hollight.real.
+ ALL x::hollight.real. u x --> real_lt (real_of_num (0::nat)) (ua x))"
+ by (import hollight DEF_gauge)
+
+constdefs
+ fine :: "(hollight.real => hollight.real)
+=> (nat => hollight.real) * (nat => hollight.real) => bool"
+ "fine ==
+%(u::hollight.real => hollight.real)
+ ua::(nat => hollight.real) * (nat => hollight.real).
+ ALL n::nat.
+ < n (dsize (fst ua)) -->
+ real_lt (real_sub (fst ua (Suc n)) (fst ua n)) (u (snd ua n))"
+
+lemma DEF_fine: "fine =
+(%(u::hollight.real => hollight.real)
+ ua::(nat => hollight.real) * (nat => hollight.real).
+ ALL n::nat.
+ < n (dsize (fst ua)) -->
+ real_lt (real_sub (fst ua (Suc n)) (fst ua n)) (u (snd ua n)))"
+ by (import hollight DEF_fine)
+
+constdefs
+ rsum :: "(nat => hollight.real) * (nat => hollight.real)
+=> (hollight.real => hollight.real) => hollight.real"
+ "rsum ==
+%(u::(nat => hollight.real) * (nat => hollight.real))
+ ua::hollight.real => hollight.real.
+ psum (0::nat, dsize (fst u))
+ (%n::nat. real_mul (ua (snd u n)) (real_sub (fst u (Suc n)) (fst u n)))"
+
+lemma DEF_rsum: "rsum =
+(%(u::(nat => hollight.real) * (nat => hollight.real))
+ ua::hollight.real => hollight.real.
+ psum (0::nat, dsize (fst u))
+ (%n::nat.
+ real_mul (ua (snd u n)) (real_sub (fst u (Suc n)) (fst u n))))"
+ by (import hollight DEF_rsum)
+
+constdefs
+ defint :: "hollight.real * hollight.real
+=> (hollight.real => hollight.real) => hollight.real => bool"
+ "defint ==
+%(u::hollight.real * hollight.real) (ua::hollight.real => hollight.real)
+ ub::hollight.real.
+ ALL e::hollight.real.
+ real_lt (real_of_num (0::nat)) e -->
+ (EX g::hollight.real => hollight.real.
+ gauge (%x::hollight.real. real_le (fst u) x & real_le x (snd u))
+ g &
+ (ALL (D::nat => hollight.real) p::nat => hollight.real.
+ tdiv (fst u, snd u) (D, p) & fine g (D, p) -->
+ real_lt (real_abs (real_sub (rsum (D, p) ua) ub)) e))"
+
+lemma DEF_defint: "defint =
+(%(u::hollight.real * hollight.real) (ua::hollight.real => hollight.real)
+ ub::hollight.real.
+ ALL e::hollight.real.
+ real_lt (real_of_num (0::nat)) e -->
+ (EX g::hollight.real => hollight.real.
+ gauge (%x::hollight.real. real_le (fst u) x & real_le x (snd u))
+ g &
+ (ALL (D::nat => hollight.real) p::nat => hollight.real.
+ tdiv (fst u, snd u) (D, p) & fine g (D, p) -->
+ real_lt (real_abs (real_sub (rsum (D, p) ua) ub)) e)))"
+ by (import hollight DEF_defint)
+
+lemma DIVISION_0: "ALL (a::hollight.real) b::hollight.real.
+ a = b --> dsize (%n::nat. COND (n = (0::nat)) a b) = (0::nat)"
+ by (import hollight DIVISION_0)
+
+lemma DIVISION_1: "ALL (a::hollight.real) b::hollight.real.
+ real_lt a b -->
+ dsize (%n::nat. COND (n = (0::nat)) a b) = NUMERAL_BIT1 (0::nat)"
+ by (import hollight DIVISION_1)
+
+lemma DIVISION_SINGLE: "ALL (a::hollight.real) b::hollight.real.
+ real_le a b --> division (a, b) (%n::nat. COND (n = (0::nat)) a b)"
+ by (import hollight DIVISION_SINGLE)
+
+lemma DIVISION_LHS: "ALL (D::nat => hollight.real) (a::hollight.real) b::hollight.real.
+ division (a, b) D --> D (0::nat) = a"
+ by (import hollight DIVISION_LHS)
+
+lemma DIVISION_THM: "ALL (D::nat => hollight.real) (a::hollight.real) b::hollight.real.
+ division (a, b) D =
+ (D (0::nat) = a &
+ (ALL n::nat. < n (dsize D) --> real_lt (D n) (D (Suc n))) &
+ (ALL n::nat. >= n (dsize D) --> D n = b))"
+ by (import hollight DIVISION_THM)
+
+lemma DIVISION_RHS: "ALL (D::nat => hollight.real) (a::hollight.real) b::hollight.real.
+ division (a, b) D --> D (dsize D) = b"
+ by (import hollight DIVISION_RHS)
+
+lemma DIVISION_LT_GEN: "ALL (D::nat => hollight.real) (a::hollight.real) (b::hollight.real) (m::nat)
+ n::nat.
+ division (a, b) D & < m n & <= n (dsize D) --> real_lt (D m) (D n)"
+ by (import hollight DIVISION_LT_GEN)
+
+lemma DIVISION_LT: "ALL (D::nat => hollight.real) (a::hollight.real) b::hollight.real.
+ division (a, b) D -->
+ (ALL n::nat. < n (dsize D) --> real_lt (D (0::nat)) (D (Suc n)))"
+ by (import hollight DIVISION_LT)
+
+lemma DIVISION_LE: "ALL (D::nat => hollight.real) (a::hollight.real) b::hollight.real.
+ division (a, b) D --> real_le a b"
+ by (import hollight DIVISION_LE)
+
+lemma DIVISION_GT: "ALL (D::nat => hollight.real) (a::hollight.real) b::hollight.real.
+ division (a, b) D -->
+ (ALL n::nat. < n (dsize D) --> real_lt (D n) (D (dsize D)))"
+ by (import hollight DIVISION_GT)
+
+lemma DIVISION_EQ: "ALL (D::nat => hollight.real) (a::hollight.real) b::hollight.real.
+ division (a, b) D --> (a = b) = (dsize D = (0::nat))"
+ by (import hollight DIVISION_EQ)
+
+lemma DIVISION_LBOUND: "ALL (x::nat => hollight.real) (xa::hollight.real) (xb::hollight.real)
+ xc::nat. division (xa, xb) x --> real_le xa (x xc)"
+ by (import hollight DIVISION_LBOUND)
+
+lemma DIVISION_LBOUND_LT: "ALL (x::nat => hollight.real) (xa::hollight.real) (xb::hollight.real)
+ xc::nat.
+ division (xa, xb) x & dsize x ~= (0::nat) --> real_lt xa (x (Suc xc))"
+ by (import hollight DIVISION_LBOUND_LT)
+
+lemma DIVISION_UBOUND: "ALL (x::nat => hollight.real) (xa::hollight.real) (xb::hollight.real)
+ xc::nat. division (xa, xb) x --> real_le (x xc) xb"
+ by (import hollight DIVISION_UBOUND)
+
+lemma DIVISION_UBOUND_LT: "ALL (D::nat => hollight.real) (a::hollight.real) (b::hollight.real) n::nat.
+ division (a, b) D & < n (dsize D) --> real_lt (D n) b"
+ by (import hollight DIVISION_UBOUND_LT)
+
+lemma DIVISION_APPEND_LEMMA1: "ALL (a::hollight.real) (b::hollight.real) (c::hollight.real)
+ (D1::nat => hollight.real) D2::nat => hollight.real.
+ division (a, b) D1 & division (b, c) D2 -->
+ (ALL n::nat.
+ < n (dsize D1 + dsize D2) -->
+ real_lt (COND (< n (dsize D1)) (D1 n) (D2 (n - dsize D1)))
+ (COND (< (Suc n) (dsize D1)) (D1 (Suc n))
+ (D2 (Suc n - dsize D1)))) &
+ (ALL n::nat.
+ >= n (dsize D1 + dsize D2) -->
+ COND (< n (dsize D1)) (D1 n) (D2 (n - dsize D1)) =
+ COND (< (dsize D1 + dsize D2) (dsize D1)) (D1 (dsize D1 + dsize D2))
+ (D2 (dsize D1 + dsize D2 - dsize D1)))"
+ by (import hollight DIVISION_APPEND_LEMMA1)
+
+lemma DIVISION_APPEND_LEMMA2: "ALL (a::hollight.real) (b::hollight.real) (c::hollight.real)
+ (D1::nat => hollight.real) D2::nat => hollight.real.
+ division (a, b) D1 & division (b, c) D2 -->
+ dsize (%n::nat. COND (< n (dsize D1)) (D1 n) (D2 (n - dsize D1))) =
+ dsize D1 + dsize D2"
+ by (import hollight DIVISION_APPEND_LEMMA2)
+
+lemma DIVISION_APPEND: "ALL (a::hollight.real) (b::hollight.real) c::hollight.real.
+ (EX (D1::nat => hollight.real) p1::nat => hollight.real.
+ tdiv (a, b) (D1, p1) &
+ fine (g::hollight.real => hollight.real) (D1, p1)) &
+ (EX (D2::nat => hollight.real) p2::nat => hollight.real.
+ tdiv (b, c) (D2, p2) & fine g (D2, p2)) -->
+ (EX (x::nat => hollight.real) p::nat => hollight.real.
+ tdiv (a, c) (x, p) & fine g (x, p))"
+ by (import hollight DIVISION_APPEND)
+
+lemma DIVISION_EXISTS: "ALL (a::hollight.real) (b::hollight.real) g::hollight.real => hollight.real.
+ real_le a b & gauge (%x::hollight.real. real_le a x & real_le x b) g -->
+ (EX (D::nat => hollight.real) p::nat => hollight.real.
+ tdiv (a, b) (D, p) & fine g (D, p))"
+ by (import hollight DIVISION_EXISTS)
+
+lemma GAUGE_MIN: "ALL (E::hollight.real => bool) (g1::hollight.real => hollight.real)
+ g2::hollight.real => hollight.real.
+ gauge E g1 & gauge E g2 -->
+ gauge E (%x::hollight.real. COND (real_lt (g1 x) (g2 x)) (g1 x) (g2 x))"
+ by (import hollight GAUGE_MIN)
+
+lemma FINE_MIN: "ALL (g1::hollight.real => hollight.real)
+ (g2::hollight.real => hollight.real) (D::nat => hollight.real)
+ p::nat => hollight.real.
+ fine (%x::hollight.real. COND (real_lt (g1 x) (g2 x)) (g1 x) (g2 x))
+ (D, p) -->
+ fine g1 (D, p) & fine g2 (D, p)"
+ by (import hollight FINE_MIN)
+
+lemma DINT_UNIQ: "ALL (a::hollight.real) (b::hollight.real)
+ (f::hollight.real => hollight.real) (k1::hollight.real)
+ k2::hollight.real.
+ real_le a b & defint (a, b) f k1 & defint (a, b) f k2 --> k1 = k2"
+ by (import hollight DINT_UNIQ)
+
+lemma INTEGRAL_NULL: "ALL (f::hollight.real => hollight.real) a::hollight.real.
+ defint (a, a) f (real_of_num (0::nat))"
+ by (import hollight INTEGRAL_NULL)
+
+lemma STRADDLE_LEMMA: "ALL (f::hollight.real => hollight.real) (f'::hollight.real => hollight.real)
+ (a::hollight.real) (b::hollight.real) e::hollight.real.
+ (ALL x::hollight.real. real_le a x & real_le x b --> diffl f (f' x) x) &
+ real_lt (real_of_num (0::nat)) e -->
+ (EX x::hollight.real => hollight.real.
+ gauge (%x::hollight.real. real_le a x & real_le x b) x &
+ (ALL (xa::hollight.real) (u::hollight.real) v::hollight.real.
+ real_le a u &
+ real_le u xa &
+ real_le xa v & real_le v b & real_lt (real_sub v u) (x xa) -->
+ real_le
+ (real_abs
+ (real_sub (real_sub (f v) (f u))
+ (real_mul (f' xa) (real_sub v u))))
+ (real_mul e (real_sub v u))))"
+ by (import hollight STRADDLE_LEMMA)
+
+lemma FTC1: "ALL (f::hollight.real => hollight.real) (f'::hollight.real => hollight.real)
+ (a::hollight.real) b::hollight.real.
+ real_le a b &
+ (ALL x::hollight.real.
+ real_le a x & real_le x b --> diffl f (f' x) x) -->
+ defint (a, b) f' (real_sub (f b) (f a))"
+ by (import hollight FTC1)
+
+lemma MCLAURIN: "ALL (f::hollight.real => hollight.real)
+ (diff::nat => hollight.real => hollight.real) (h::hollight.real) n::nat.
+ real_lt (real_of_num (0::nat)) h &
+ < (0::nat) n &
+ diff (0::nat) = f &
+ (ALL (m::nat) t::hollight.real.
+ < m n & real_le (real_of_num (0::nat)) t & real_le t h -->
+ diffl (diff m) (diff (Suc m) t) t) -->
+ (EX t::hollight.real.
+ real_lt (real_of_num (0::nat)) t &
+ real_lt t h &
+ f h =
+ real_add
+ (psum (0::nat, n)
+ (%m::nat.
+ real_mul
+ (real_div (diff m (real_of_num (0::nat)))
+ (real_of_num (FACT m)))
+ (real_pow h m)))
+ (real_mul (real_div (diff n t) (real_of_num (FACT n)))
+ (real_pow h n)))"
+ by (import hollight MCLAURIN)
+
+lemma MCLAURIN_NEG: "ALL (f::hollight.real => hollight.real)
+ (diff::nat => hollight.real => hollight.real) (h::hollight.real) n::nat.
+ real_lt h (real_of_num (0::nat)) &
+ < (0::nat) n &
+ diff (0::nat) = f &
+ (ALL (m::nat) t::hollight.real.
+ < m n & real_le h t & real_le t (real_of_num (0::nat)) -->
+ diffl (diff m) (diff (Suc m) t) t) -->
+ (EX t::hollight.real.
+ real_lt h t &
+ real_lt t (real_of_num (0::nat)) &
+ f h =
+ real_add
+ (psum (0::nat, n)
+ (%m::nat.
+ real_mul
+ (real_div (diff m (real_of_num (0::nat)))
+ (real_of_num (FACT m)))
+ (real_pow h m)))
+ (real_mul (real_div (diff n t) (real_of_num (FACT n)))
+ (real_pow h n)))"
+ by (import hollight MCLAURIN_NEG)
+
+lemma MCLAURIN_BI_LE: "ALL (f::hollight.real => hollight.real)
+ (diff::nat => hollight.real => hollight.real) (x::hollight.real) n::nat.
+ diff (0::nat) = f &
+ (ALL (m::nat) t::hollight.real.
+ < m n & real_le (real_abs t) (real_abs x) -->
+ diffl (diff m) (diff (Suc m) t) t) -->
+ (EX xa::hollight.real.
+ real_le (real_abs xa) (real_abs x) &
+ f x =
+ real_add
+ (psum (0::nat, n)
+ (%m::nat.
+ real_mul
+ (real_div (diff m (real_of_num (0::nat)))
+ (real_of_num (FACT m)))
+ (real_pow x m)))
+ (real_mul (real_div (diff n xa) (real_of_num (FACT n)))
+ (real_pow x n)))"
+ by (import hollight MCLAURIN_BI_LE)
+
+lemma MCLAURIN_ALL_LT: "ALL (f::hollight.real => hollight.real)
+ diff::nat => hollight.real => hollight.real.
+ diff (0::nat) = f &
+ (ALL (m::nat) x::hollight.real. diffl (diff m) (diff (Suc m) x) x) -->
+ (ALL (x::hollight.real) n::nat.
+ x ~= real_of_num (0::nat) & < (0::nat) n -->
+ (EX t::hollight.real.
+ real_lt (real_of_num (0::nat)) (real_abs t) &
+ real_lt (real_abs t) (real_abs x) &
+ f x =
+ real_add
+ (psum (0::nat, n)
+ (%m::nat.
+ real_mul
+ (real_div (diff m (real_of_num (0::nat)))
+ (real_of_num (FACT m)))
+ (real_pow x m)))
+ (real_mul (real_div (diff n t) (real_of_num (FACT n)))
+ (real_pow x n))))"
+ by (import hollight MCLAURIN_ALL_LT)
+
+lemma MCLAURIN_ZERO: "ALL (diff::nat => hollight.real => hollight.real) (n::nat) x::hollight.real.
+ x = real_of_num (0::nat) & < (0::nat) n -->
+ psum (0::nat, n)
+ (%m::nat.
+ real_mul
+ (real_div (diff m (real_of_num (0::nat))) (real_of_num (FACT m)))
+ (real_pow x m)) =
+ diff (0::nat) (real_of_num (0::nat))"
+ by (import hollight MCLAURIN_ZERO)
+
+lemma MCLAURIN_ALL_LE: "ALL (f::hollight.real => hollight.real)
+ diff::nat => hollight.real => hollight.real.
+ diff (0::nat) = f &
+ (ALL (m::nat) x::hollight.real. diffl (diff m) (diff (Suc m) x) x) -->
+ (ALL (x::hollight.real) n::nat.
+ EX t::hollight.real.
+ real_le (real_abs t) (real_abs x) &
+ f x =
+ real_add
+ (psum (0::nat, n)
+ (%m::nat.
+ real_mul
+ (real_div (diff m (real_of_num (0::nat)))
+ (real_of_num (FACT m)))
+ (real_pow x m)))
+ (real_mul (real_div (diff n t) (real_of_num (FACT n)))
+ (real_pow x n)))"
+ by (import hollight MCLAURIN_ALL_LE)
+
+lemma MCLAURIN_EXP_LEMMA: "exp = exp & (ALL (x::nat) xa::hollight.real. diffl exp (exp xa) xa)"
+ by (import hollight MCLAURIN_EXP_LEMMA)
+
+lemma MCLAURIN_EXP_LT: "ALL (x::hollight.real) n::nat.
+ x ~= real_of_num (0::nat) & < (0::nat) n -->
+ (EX t::hollight.real.
+ real_lt (real_of_num (0::nat)) (real_abs t) &
+ real_lt (real_abs t) (real_abs x) &
+ exp x =
+ real_add
+ (psum (0::nat, n)
+ (%m::nat. real_div (real_pow x m) (real_of_num (FACT m))))
+ (real_mul (real_div (exp t) (real_of_num (FACT n))) (real_pow x n)))"
+ by (import hollight MCLAURIN_EXP_LT)
+
+lemma MCLAURIN_EXP_LE: "ALL (x::hollight.real) n::nat.
+ EX t::hollight.real.
+ real_le (real_abs t) (real_abs x) &
+ exp x =
+ real_add
+ (psum (0::nat, n)
+ (%m::nat. real_div (real_pow x m) (real_of_num (FACT m))))
+ (real_mul (real_div (exp t) (real_of_num (FACT n))) (real_pow x n))"
+ by (import hollight MCLAURIN_EXP_LE)
+
+lemma DIFF_LN_COMPOSITE: "ALL (g::hollight.real => hollight.real) (m::hollight.real) x::hollight.real.
+ diffl g m x & real_lt (real_of_num (0::nat)) (g x) -->
+ diffl (%x::hollight.real. ln (g x)) (real_mul (real_inv (g x)) m) x"
+ by (import hollight DIFF_LN_COMPOSITE)
+
+lemma MCLAURIN_LN_POS: "ALL (x::hollight.real) n::nat.
+ real_lt (real_of_num (0::nat)) x & < (0::nat) n -->
+ (EX t::hollight.real.
+ real_lt (real_of_num (0::nat)) t &
+ real_lt t x &
+ ln (real_add (real_of_num (NUMERAL_BIT1 (0::nat))) x) =
+ real_add
+ (psum (0::nat, n)
+ (%m::nat.
+ real_mul
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (Suc m))
+ (real_div (real_pow x m) (real_of_num m))))
+ (real_mul
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (Suc n))
+ (real_div (real_pow x n)
+ (real_mul (real_of_num n)
+ (real_pow (real_add (real_of_num (NUMERAL_BIT1 (0::nat))) t)
+ n)))))"
+ by (import hollight MCLAURIN_LN_POS)
+
+lemma MCLAURIN_LN_NEG: "ALL (x::hollight.real) n::nat.
+ real_lt (real_of_num (0::nat)) x &
+ real_lt x (real_of_num (NUMERAL_BIT1 (0::nat))) & < (0::nat) n -->
+ (EX t::hollight.real.
+ real_lt (real_of_num (0::nat)) t &
+ real_lt t x &
+ real_neg (ln (real_sub (real_of_num (NUMERAL_BIT1 (0::nat))) x)) =
+ real_add
+ (psum (0::nat, n)
+ (%m::nat. real_div (real_pow x m) (real_of_num m)))
+ (real_div (real_pow x n)
+ (real_mul (real_of_num n)
+ (real_pow (real_sub (real_of_num (NUMERAL_BIT1 (0::nat))) t)
+ n))))"
+ by (import hollight MCLAURIN_LN_NEG)
+
+lemma MCLAURIN_SIN: "ALL (x::hollight.real) n::nat.
+ real_le
+ (real_abs
+ (real_sub (sin x)
+ (psum (0::nat, n)
+ (%m::nat.
+ real_mul
+ (COND (EVEN m) (real_of_num (0::nat))
+ (real_div
+ (real_pow
+ (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV (m - NUMERAL_BIT1 (0::nat))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num (FACT m))))
+ (real_pow x m)))))
+ (real_mul (real_inv (real_of_num (FACT n))) (real_pow (real_abs x) n))"
+ by (import hollight MCLAURIN_SIN)
+
+lemma MCLAURIN_COS: "ALL (x::hollight.real) n::nat.
+ real_le
+ (real_abs
+ (real_sub (cos x)
+ (psum (0::nat, n)
+ (%m::nat.
+ real_mul
+ (COND (EVEN m)
+ (real_div
+ (real_pow
+ (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV m (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num (FACT m)))
+ (real_of_num (0::nat)))
+ (real_pow x m)))))
+ (real_mul (real_inv (real_of_num (FACT n))) (real_pow (real_abs x) n))"
+ by (import hollight MCLAURIN_COS)
+
+lemma REAL_ATN_POWSER_SUMMABLE: "ALL x::hollight.real.
+ real_lt (real_abs x) (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ summable
+ (%n::nat.
+ real_mul
+ (COND (EVEN n) (real_of_num (0::nat))
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV (n - NUMERAL_BIT1 (0::nat))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num n)))
+ (real_pow x n))"
+ by (import hollight REAL_ATN_POWSER_SUMMABLE)
+
+lemma REAL_ATN_POWSER_DIFFS_SUMMABLE: "ALL x::hollight.real.
+ real_lt (real_abs x) (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ summable
+ (%xa::nat.
+ real_mul
+ (diffs
+ (%n::nat.
+ COND (EVEN n) (real_of_num (0::nat))
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV (n - NUMERAL_BIT1 (0::nat))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num n)))
+ xa)
+ (real_pow x xa))"
+ by (import hollight REAL_ATN_POWSER_DIFFS_SUMMABLE)
+
+lemma REAL_ATN_POWSER_DIFFS_SUM: "ALL x::hollight.real.
+ real_lt (real_abs x) (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ sums
+ (%n::nat.
+ real_mul
+ (diffs
+ (%n::nat.
+ COND (EVEN n) (real_of_num (0::nat))
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV (n - NUMERAL_BIT1 (0::nat))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num n)))
+ n)
+ (real_pow x n))
+ (real_inv
+ (real_add (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))"
+ by (import hollight REAL_ATN_POWSER_DIFFS_SUM)
+
+lemma REAL_ATN_POWSER_DIFFS_DIFFS_SUMMABLE: "ALL x::hollight.real.
+ real_lt (real_abs x) (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ summable
+ (%xa::nat.
+ real_mul
+ (diffs
+ (diffs
+ (%n::nat.
+ COND (EVEN n) (real_of_num (0::nat))
+ (real_div
+ (real_pow
+ (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV (n - NUMERAL_BIT1 (0::nat))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num n))))
+ xa)
+ (real_pow x xa))"
+ by (import hollight REAL_ATN_POWSER_DIFFS_DIFFS_SUMMABLE)
+
+lemma REAL_ATN_POWSER_DIFFL: "ALL x::hollight.real.
+ real_lt (real_abs x) (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ diffl
+ (%x::hollight.real.
+ suminf
+ (%n::nat.
+ real_mul
+ (COND (EVEN n) (real_of_num (0::nat))
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV (n - NUMERAL_BIT1 (0::nat))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num n)))
+ (real_pow x n)))
+ (real_inv
+ (real_add (real_of_num (NUMERAL_BIT1 (0::nat)))
+ (real_pow x (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat))))))
+ x"
+ by (import hollight REAL_ATN_POWSER_DIFFL)
+
+lemma REAL_ATN_POWSER: "ALL x::hollight.real.
+ real_lt (real_abs x) (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ sums
+ (%n::nat.
+ real_mul
+ (COND (EVEN n) (real_of_num (0::nat))
+ (real_div
+ (real_pow (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV (n - NUMERAL_BIT1 (0::nat))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num n)))
+ (real_pow x n))
+ (atn x)"
+ by (import hollight REAL_ATN_POWSER)
+
+lemma MCLAURIN_ATN: "ALL (x::hollight.real) n::nat.
+ real_lt (real_abs x) (real_of_num (NUMERAL_BIT1 (0::nat))) -->
+ real_le
+ (real_abs
+ (real_sub (atn x)
+ (psum (0::nat, n)
+ (%m::nat.
+ real_mul
+ (COND (EVEN m) (real_of_num (0::nat))
+ (real_div
+ (real_pow
+ (real_neg (real_of_num (NUMERAL_BIT1 (0::nat))))
+ (DIV (m - NUMERAL_BIT1 (0::nat))
+ (NUMERAL_BIT0 (NUMERAL_BIT1 (0::nat)))))
+ (real_of_num m)))
+ (real_pow x m)))))
+ (real_div (real_pow (real_abs x) n)
+ (real_sub (real_of_num (NUMERAL_BIT1 (0::nat))) (real_abs x)))"
+ by (import hollight MCLAURIN_ATN)
+
+;end_setup
+
+end
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Import/HOLLight/hollight.imp Mon Sep 26 02:27:14 2005 +0200
@@ -0,0 +1,2980 @@
+import
+
+import_segment "hollight"
+
+def_maps
+ "two_2" > "two_2_def"
+ "two_1" > "two_1_def"
+ "treal_of_num" > "treal_of_num_def"
+ "treal_neg" > "treal_neg_def"
+ "treal_mul" > "treal_mul_def"
+ "treal_le" > "treal_le_def"
+ "treal_inv" > "treal_inv_def"
+ "treal_eq" > "treal_eq_def"
+ "treal_add" > "treal_add_def"
+ "three_3" > "three_3_def"
+ "three_2" > "three_2_def"
+ "three_1" > "three_1_def"
+ "tendsto" > "tendsto_def"
+ "tends_real_real" > "tends_real_real_def"
+ "tends_num_real" > "tends_num_real_def"
+ "tends" > "tends_def"
+ "tdiv" > "tdiv_def"
+ "tan" > "tan_def"
+ "tailadmissible" > "tailadmissible_def"
+ "support" > "support_def"
+ "superadmissible" > "superadmissible_def"
+ "sup" > "sup_def"
+ "sums" > "sums_def"
+ "summable" > "summable_def"
+ "suminf" > "suminf_def"
+ "sum" > "sum_def"
+ "subseq" > "subseq_def"
+ "sqrt" > "sqrt_def"
+ "sndcart" > "sndcart_def"
+ "sin" > "sin_def"
+ "set_of_list" > "set_of_list_def"
+ "rsum" > "rsum_def"
+ "root" > "root_def"
+ "real_sub" > "real_sub_def"
+ "real_pow" > "real_pow_def"
+ "real_of_num" > "real_of_num_def"
+ "real_neg" > "real_neg_def"
+ "real_mul" > "real_mul_def"
+ "real_min" > "real_min_def"
+ "real_max" > "real_max_def"
+ "real_lt" > "real_lt_def"
+ "real_le" > "real_le_def"
+ "real_inv" > "real_inv_def"
+ "real_gt" > "real_gt_def"
+ "real_ge" > "real_ge_def"
+ "real_div" > "real_div_def"
+ "real_add" > "real_add_def"
+ "real_abs" > "real_abs_def"
+ "re_universe" > "re_universe_def"
+ "re_union" > "re_union_def"
+ "re_subset" > "re_subset_def"
+ "re_null" > "re_null_def"
+ "re_intersect" > "re_intersect_def"
+ "re_compl" > "re_compl_def"
+ "re_Union" > "re_Union_def"
+ "psum" > "psum_def"
+ "pi" > "pi_def"
+ "pastecart" > "pastecart_def"
+ "pairwise" > "pairwise_def"
+ "nsum" > "nsum_def"
+ "neutral" > "neutral_def"
+ "neigh" > "neigh_def"
+ "nadd_rinv" > "nadd_rinv_def"
+ "nadd_of_num" > "nadd_of_num_def"
+ "nadd_mul" > "nadd_mul_def"
+ "nadd_le" > "nadd_le_def"
+ "nadd_inv" > "nadd_inv_def"
+ "nadd_eq" > "nadd_eq_def"
+ "nadd_add" > "nadd_add_def"
+ "mtop" > "mtop_def"
+ "mr1" > "mr1_def"
+ "monoidal" > "monoidal_def"
+ "mono" > "mono_def"
+ "mod_real" > "mod_real_def"
+ "mod_nat" > "mod_nat_def"
+ "mod_int" > "mod_int_def"
+ "minimal" > "minimal_def"
+ "measure" > "measure_def"
+ "ln" > "ln_def"
+ "list_of_set" > "list_of_set_def"
+ "limpt" > "limpt_def"
+ "lim" > "lim_def"
+ "lambda" > "lambda_def"
+ "iterate" > "iterate_def"
+ "istopology" > "istopology_def"
+ "ismet" > "ismet_def"
+ "is_nadd" > "is_nadd_def"
+ "is_int" > "is_int_def"
+ "int_sub" > "int_sub_def"
+ "int_pow" > "int_pow_def"
+ "int_of_num" > "int_of_num_def"
+ "int_neg" > "int_neg_def"
+ "int_mul" > "int_mul_def"
+ "int_min" > "int_min_def"
+ "int_max" > "int_max_def"
+ "int_lt" > "int_lt_def"
+ "int_le" > "int_le_def"
+ "int_gt" > "int_gt_def"
+ "int_ge" > "int_ge_def"
+ "int_add" > "int_add_def"
+ "int_abs" > "int_abs_def"
+ "hreal_of_num" > "hreal_of_num_def"
+ "hreal_mul" > "hreal_mul_def"
+ "hreal_le" > "hreal_le_def"
+ "hreal_inv" > "hreal_inv_def"
+ "hreal_add" > "hreal_add_def"
+ "gauge" > "gauge_def"
+ "fstcart" > "fstcart_def"
+ "finite_index" > "finite_index_def"
+ "fine" > "fine_def"
+ "exp" > "exp_def"
+ "eqeq" > "eqeq_def"
+ "dsize" > "dsize_def"
+ "dotdot" > "dotdot_def"
+ "dorder" > "dorder_def"
+ "division" > "division_def"
+ "dist" > "dist_def"
+ "dimindex" > "dimindex_def"
+ "diffs" > "diffs_def"
+ "diffl" > "diffl_def"
+ "differentiable" > "differentiable_def"
+ "defint" > "defint_def"
+ "cos" > "cos_def"
+ "convergent" > "convergent_def"
+ "contl" > "contl_def"
+ "closed" > "closed_def"
+ "cauchy" > "cauchy_def"
+ "bounded" > "bounded_def"
+ "ball" > "ball_def"
+ "atn" > "atn_def"
+ "asn" > "asn_def"
+ "admissible" > "admissible_def"
+ "acs" > "acs_def"
+ "_FALSITY_" > "_FALSITY__def"
+ "_10314" > "_10314_def"
+ "_10313" > "_10313_def"
+ "_10312" > "_10312_def"
+ "_10289" > "_10289_def"
+ "_10288" > "_10288_def"
+ "ZRECSPACE" > "ZRECSPACE_def"
+ "ZIP" > "ZIP_def"
+ "ZCONSTR" > "ZCONSTR_def"
+ "ZBOT" > "ZBOT_def"
+ "WF" > "WF_def"
+ "UNIV" > "UNIV_def"
+ "UNIONS" > "UNIONS_def"
+ "UNION" > "UNION_def"
+ "UNCURRY" > "UNCURRY_def"
+ "TL" > "TL_def"
+ "SURJ" > "SURJ_def"
+ "SUBSET" > "SUBSET_def"
+ "SOME" > "SOME_def"
+ "SING" > "SING_def"
+ "SETSPEC" > "SETSPEC_def"
+ "REVERSE" > "REVERSE_def"
+ "REST" > "REST_def"
+ "REPLICATE" > "REPLICATE_def"
+ "PSUBSET" > "PSUBSET_def"
+ "PASSOC" > "PASSOC_def"
+ "PAIRWISE" > "PAIRWISE_def"
+ "OUTR" > "OUTR_def"
+ "OUTL" > "OUTL_def"
+ "ODD" > "ODD_def"
+ "NUMSUM" > "NUMSUM_def"
+ "NUMSND" > "NUMSND_def"
+ "NUMRIGHT" > "NUMRIGHT_def"
+ "NUMPAIR" > "NUMPAIR_def"
+ "NUMLEFT" > "NUMLEFT_def"
+ "NUMFST" > "NUMFST_def"
+ "NULL" > "NULL_def"
+ "NONE" > "NONE_def"
+ "NIL" > "NIL_def"
+ "MOD" > "MOD_def"
+ "MEM" > "MEM_def"
+ "MAP2" > "MAP2_def"
+ "MAP" > "MAP_def"
+ "LET_END" > "LET_END_def"
+ "LENGTH" > "LENGTH_def"
+ "LAST" > "LAST_def"
+ "ITSET" > "ITSET_def"
+ "ITLIST2" > "ITLIST2_def"
+ "ITLIST" > "ITLIST_def"
+ "ISO" > "ISO_def"
+ "INTERS" > "INTERS_def"
+ "INTER" > "INTER_def"
+ "INSERT" > "INSERT_def"
+ "INR" > "INR_def"
+ "INL" > "INL_def"
+ "INJP" > "INJP_def"
+ "INJN" > "INJN_def"
+ "INJF" > "INJF_def"
+ "INJA" > "INJA_def"
+ "INJ" > "INJ_def"
+ "INFINITE" > "INFINITE_def"
+ "IN" > "IN_def"
+ "IMAGE" > "IMAGE_def"
+ "HD" > "HD_def"
+ "HAS_SIZE" > "HAS_SIZE_def"
+ "GSPEC" > "GSPEC_def"
+ "GEQ" > "GEQ_def"
+ "GABS" > "GABS_def"
+ "FNIL" > "FNIL_def"
+ "FINREC" > "FINREC_def"
+ "FINITE" > "FINITE_def"
+ "FILTER" > "FILTER_def"
+ "FCONS" > "FCONS_def"
+ "FACT" > "FACT_def"
+ "EXP" > "EXP_def"
+ "EX" > "EX_def"
+ "EVEN" > "EVEN_def"
+ "EMPTY" > "EMPTY_def"
+ "EL" > "EL_def"
+ "DIV" > "DIV_def"
+ "DISJOINT" > "DISJOINT_def"
+ "DIFF" > "DIFF_def"
+ "DELETE" > "DELETE_def"
+ "DECIMAL" > "DECIMAL_def"
+ "CURRY" > "CURRY_def"
+ "COUNTABLE" > "COUNTABLE_def"
+ "CONSTR" > "CONSTR_def"
+ "CONS" > "CONS_def"
+ "COND" > "COND_def"
+ "CHOICE" > "CHOICE_def"
+ "CASEWISE" > "CASEWISE_def"
+ "CARD_LT" > "CARD_LT_def"
+ "CARD_LE" > "CARD_LE_def"
+ "CARD_GT" > "CARD_GT_def"
+ "CARD_GE" > "CARD_GE_def"
+ "CARD_EQ" > "CARD_EQ_def"
+ "CARD" > "CARD_def"
+ "BOTTOM" > "BOTTOM_def"
+ "BIJ" > "BIJ_def"
+ "ASSOC" > "ASSOC_def"
+ "APPEND" > "APPEND_def"
+ "ALL_list" > "ALL_list_def"
+ "ALL2" > "ALL2_def"
+ ">=" > ">=_def"
+ ">" > ">_def"
+ "<=" > "<=_def"
+ "<" > "<_def"
+ "$" > "$_def"
+
+type_maps
+ "topology" > "HOLLight.hollight.topology"
+ "sum" > "HOLLight.hollight.sum"
+ "recspace" > "HOLLight.hollight.recspace"
+ "real" > "HOLLight.hollight.real"
+ "prod" > "*"
+ "option" > "HOLLight.hollight.option"
+ "num" > "nat"
+ "nadd" > "HOLLight.hollight.nadd"
+ "metric" > "HOLLight.hollight.metric"
+ "list" > "HOLLight.hollight.list"
+ "int" > "HOLLight.hollight.int"
+ "ind" > "Nat.ind"
+ "hreal" > "HOLLight.hollight.hreal"
+ "fun" > "fun"
+ "finite_sum" > "HOLLight.hollight.finite_sum"
+ "finite_image" > "HOLLight.hollight.finite_image"
+ "cart" > "HOLLight.hollight.cart"
+ "bool" > "bool"
+ "N_3" > "HOLLight.hollight.N_3"
+ "N_2" > "HOLLight.hollight.N_2"
+ "N_1" > "Product_Type.unit"
+
+const_maps
+ "~" > "Not"
+ "two_2" > "HOLLight.hollight.two_2"
+ "two_1" > "HOLLight.hollight.two_1"
+ "treal_of_num" > "HOLLight.hollight.treal_of_num"
+ "treal_neg" > "HOLLight.hollight.treal_neg"
+ "treal_mul" > "HOLLight.hollight.treal_mul"
+ "treal_le" > "HOLLight.hollight.treal_le"
+ "treal_inv" > "HOLLight.hollight.treal_inv"
+ "treal_eq" > "HOLLight.hollight.treal_eq"
+ "treal_add" > "HOLLight.hollight.treal_add"
+ "three_3" > "HOLLight.hollight.three_3"
+ "three_2" > "HOLLight.hollight.three_2"
+ "three_1" > "HOLLight.hollight.three_1"
+ "tendsto" > "HOLLight.hollight.tendsto"
+ "tends_real_real" > "HOLLight.hollight.tends_real_real"
+ "tends_num_real" > "HOLLight.hollight.tends_num_real"
+ "tends" > "HOLLight.hollight.tends"
+ "tdiv" > "HOLLight.hollight.tdiv"
+ "tan" > "HOLLight.hollight.tan"
+ "tailadmissible" > "HOLLight.hollight.tailadmissible"
+ "support" > "HOLLight.hollight.support"
+ "superadmissible" > "HOLLight.hollight.superadmissible"
+ "sup" > "HOLLight.hollight.sup"
+ "sums" > "HOLLight.hollight.sums"
+ "summable" > "HOLLight.hollight.summable"
+ "suminf" > "HOLLight.hollight.suminf"
+ "sum" > "HOLLight.hollight.sum"
+ "subseq" > "HOLLight.hollight.subseq"
+ "sqrt" > "HOLLight.hollight.sqrt"
+ "sndcart" > "HOLLight.hollight.sndcart"
+ "sin" > "HOLLight.hollight.sin"
+ "set_of_list" > "HOLLight.hollight.set_of_list"
+ "rsum" > "HOLLight.hollight.rsum"
+ "root" > "HOLLight.hollight.root"
+ "real_sub" > "HOLLight.hollight.real_sub"
+ "real_pow" > "HOLLight.hollight.real_pow"
+ "real_of_num" > "HOLLight.hollight.real_of_num"
+ "real_neg" > "HOLLight.hollight.real_neg"
+ "real_mul" > "HOLLight.hollight.real_mul"
+ "real_min" > "HOLLight.hollight.real_min"
+ "real_max" > "HOLLight.hollight.real_max"
+ "real_lt" > "HOLLight.hollight.real_lt"
+ "real_le" > "HOLLight.hollight.real_le"
+ "real_inv" > "HOLLight.hollight.real_inv"
+ "real_gt" > "HOLLight.hollight.real_gt"
+ "real_ge" > "HOLLight.hollight.real_ge"
+ "real_div" > "HOLLight.hollight.real_div"
+ "real_add" > "HOLLight.hollight.real_add"
+ "real_abs" > "HOLLight.hollight.real_abs"
+ "re_universe" > "HOLLight.hollight.re_universe"
+ "re_union" > "HOLLight.hollight.re_union"
+ "re_subset" > "HOLLight.hollight.re_subset"
+ "re_null" > "HOLLight.hollight.re_null"
+ "re_intersect" > "HOLLight.hollight.re_intersect"
+ "re_compl" > "HOLLight.hollight.re_compl"
+ "re_Union" > "HOLLight.hollight.re_Union"
+ "psum" > "HOLLight.hollight.psum"
+ "pi" > "HOLLight.hollight.pi"
+ "pastecart" > "HOLLight.hollight.pastecart"
+ "pairwise" > "HOLLight.hollight.pairwise"
+ "one" > "Product_Type.Unity"
+ "o" > "Fun.comp"
+ "nsum" > "HOLLight.hollight.nsum"
+ "neutral" > "HOLLight.hollight.neutral"
+ "neigh" > "HOLLight.hollight.neigh"
+ "nadd_rinv" > "HOLLight.hollight.nadd_rinv"
+ "nadd_of_num" > "HOLLight.hollight.nadd_of_num"
+ "nadd_mul" > "HOLLight.hollight.nadd_mul"
+ "nadd_le" > "HOLLight.hollight.nadd_le"
+ "nadd_inv" > "HOLLight.hollight.nadd_inv"
+ "nadd_eq" > "HOLLight.hollight.nadd_eq"
+ "nadd_add" > "HOLLight.hollight.nadd_add"
+ "mtop" > "HOLLight.hollight.mtop"
+ "mr1" > "HOLLight.hollight.mr1"
+ "monoidal" > "HOLLight.hollight.monoidal"
+ "mono" > "HOLLight.hollight.mono"
+ "mod_real" > "HOLLight.hollight.mod_real"
+ "mod_nat" > "HOLLight.hollight.mod_nat"
+ "mod_int" > "HOLLight.hollight.mod_int"
+ "mk_pair" > "Product_Type.Pair_Rep"
+ "minimal" > "HOLLight.hollight.minimal"
+ "measure" > "HOLLight.hollight.measure"
+ "ln" > "HOLLight.hollight.ln"
+ "list_of_set" > "HOLLight.hollight.list_of_set"
+ "limpt" > "HOLLight.hollight.limpt"
+ "lim" > "HOLLight.hollight.lim"
+ "lambda" > "HOLLight.hollight.lambda"
+ "iterate" > "HOLLight.hollight.iterate"
+ "istopology" > "HOLLight.hollight.istopology"
+ "ismet" > "HOLLight.hollight.ismet"
+ "is_nadd" > "HOLLight.hollight.is_nadd"
+ "is_int" > "HOLLight.hollight.is_int"
+ "int_sub" > "HOLLight.hollight.int_sub"
+ "int_pow" > "HOLLight.hollight.int_pow"
+ "int_of_num" > "HOLLight.hollight.int_of_num"
+ "int_neg" > "HOLLight.hollight.int_neg"
+ "int_mul" > "HOLLight.hollight.int_mul"
+ "int_min" > "HOLLight.hollight.int_min"
+ "int_max" > "HOLLight.hollight.int_max"
+ "int_lt" > "HOLLight.hollight.int_lt"
+ "int_le" > "HOLLight.hollight.int_le"
+ "int_gt" > "HOLLight.hollight.int_gt"
+ "int_ge" > "HOLLight.hollight.int_ge"
+ "int_add" > "HOLLight.hollight.int_add"
+ "int_abs" > "HOLLight.hollight.int_abs"
+ "hreal_of_num" > "HOLLight.hollight.hreal_of_num"
+ "hreal_mul" > "HOLLight.hollight.hreal_mul"
+ "hreal_le" > "HOLLight.hollight.hreal_le"
+ "hreal_inv" > "HOLLight.hollight.hreal_inv"
+ "hreal_add" > "HOLLight.hollight.hreal_add"
+ "gauge" > "HOLLight.hollight.gauge"
+ "fstcart" > "HOLLight.hollight.fstcart"
+ "finite_index" > "HOLLight.hollight.finite_index"
+ "fine" > "HOLLight.hollight.fine"
+ "exp" > "HOLLight.hollight.exp"
+ "eqeq" > "HOLLight.hollight.eqeq"
+ "dsize" > "HOLLight.hollight.dsize"
+ "dotdot" > "HOLLight.hollight.dotdot"
+ "dorder" > "HOLLight.hollight.dorder"
+ "division" > "HOLLight.hollight.division"
+ "dist" > "HOLLight.hollight.dist"
+ "dimindex" > "HOLLight.hollight.dimindex"
+ "diffs" > "HOLLight.hollight.diffs"
+ "diffl" > "HOLLight.hollight.diffl"
+ "differentiable" > "HOLLight.hollight.differentiable"
+ "defint" > "HOLLight.hollight.defint"
+ "cos" > "HOLLight.hollight.cos"
+ "convergent" > "HOLLight.hollight.convergent"
+ "contl" > "HOLLight.hollight.contl"
+ "closed" > "HOLLight.hollight.closed"
+ "cauchy" > "HOLLight.hollight.cauchy"
+ "bounded" > "HOLLight.hollight.bounded"
+ "ball" > "HOLLight.hollight.ball"
+ "atn" > "HOLLight.hollight.atn"
+ "asn" > "HOLLight.hollight.asn"
+ "admissible" > "HOLLight.hollight.admissible"
+ "acs" > "HOLLight.hollight.acs"
+ "_FALSITY_" > "HOLLight.hollight._FALSITY_"
+ "_10314" > "HOLLight.hollight._10314"
+ "_10313" > "HOLLight.hollight._10313"
+ "_10312" > "HOLLight.hollight._10312"
+ "_10289" > "HOLLight.hollight._10289"
+ "_10288" > "HOLLight.hollight._10288"
+ "_0" > "0" :: "nat"
+ "\\/" > "op |"
+ "ZRECSPACE" > "HOLLight.hollight.ZRECSPACE"
+ "ZIP" > "HOLLight.hollight.ZIP"
+ "ZCONSTR" > "HOLLight.hollight.ZCONSTR"
+ "ZBOT" > "HOLLight.hollight.ZBOT"
+ "WF" > "HOLLight.hollight.WF"
+ "UNIV" > "HOLLight.hollight.UNIV"
+ "UNIONS" > "HOLLight.hollight.UNIONS"
+ "UNION" > "HOLLight.hollight.UNION"
+ "UNCURRY" > "HOLLight.hollight.UNCURRY"
+ "TL" > "HOLLight.hollight.TL"
+ "T" > "True"
+ "SURJ" > "HOLLight.hollight.SURJ"
+ "SUC" > "Suc"
+ "SUBSET" > "HOLLight.hollight.SUBSET"
+ "SOME" > "HOLLight.hollight.SOME"
+ "SND" > "snd"
+ "SING" > "HOLLight.hollight.SING"
+ "SETSPEC" > "HOLLight.hollight.SETSPEC"
+ "REVERSE" > "HOLLight.hollight.REVERSE"
+ "REST" > "HOLLight.hollight.REST"
+ "REP_prod" > "Rep_Prod"
+ "REPLICATE" > "HOLLight.hollight.REPLICATE"
+ "PSUBSET" > "HOLLight.hollight.PSUBSET"
+ "PRE" > "HOLLightCompat.Pred"
+ "PASSOC" > "HOLLight.hollight.PASSOC"
+ "PAIRWISE" > "HOLLight.hollight.PAIRWISE"
+ "OUTR" > "HOLLight.hollight.OUTR"
+ "OUTL" > "HOLLight.hollight.OUTL"
+ "ONTO" > "Fun.surj"
+ "ONE_ONE" > "HOL4Setup.ONE_ONE"
+ "ODD" > "HOLLight.hollight.ODD"
+ "NUMSUM" > "HOLLight.hollight.NUMSUM"
+ "NUMSND" > "HOLLight.hollight.NUMSND"
+ "NUMRIGHT" > "HOLLight.hollight.NUMRIGHT"
+ "NUMPAIR" > "HOLLight.hollight.NUMPAIR"
+ "NUMLEFT" > "HOLLight.hollight.NUMLEFT"
+ "NUMFST" > "HOLLight.hollight.NUMFST"
+ "NUMERAL" > "HOL4Compat.NUMERAL"
+ "NULL" > "HOLLight.hollight.NULL"
+ "NONE" > "HOLLight.hollight.NONE"
+ "NIL" > "HOLLight.hollight.NIL"
+ "MOD" > "HOLLight.hollight.MOD"
+ "MEM" > "HOLLight.hollight.MEM"
+ "MAP2" > "HOLLight.hollight.MAP2"
+ "MAP" > "HOLLight.hollight.MAP"
+ "LET_END" > "HOLLight.hollight.LET_END"
+ "LET" > "HOL4Compat.LET"
+ "LENGTH" > "HOLLight.hollight.LENGTH"
+ "LAST" > "HOLLight.hollight.LAST"
+ "ITSET" > "HOLLight.hollight.ITSET"
+ "ITLIST2" > "HOLLight.hollight.ITLIST2"
+ "ITLIST" > "HOLLight.hollight.ITLIST"
+ "ISO" > "HOLLight.hollight.ISO"
+ "INTERS" > "HOLLight.hollight.INTERS"
+ "INTER" > "HOLLight.hollight.INTER"
+ "INSERT" > "HOLLight.hollight.INSERT"
+ "INR" > "HOLLight.hollight.INR"
+ "INL" > "HOLLight.hollight.INL"
+ "INJP" > "HOLLight.hollight.INJP"
+ "INJN" > "HOLLight.hollight.INJN"
+ "INJF" > "HOLLight.hollight.INJF"
+ "INJA" > "HOLLight.hollight.INJA"
+ "INJ" > "HOLLight.hollight.INJ"
+ "INFINITE" > "HOLLight.hollight.INFINITE"
+ "IN" > "HOLLight.hollight.IN"
+ "IMAGE" > "HOLLight.hollight.IMAGE"
+ "I" > "Fun.id"
+ "HD" > "HOLLight.hollight.HD"
+ "HAS_SIZE" > "HOLLight.hollight.HAS_SIZE"
+ "GSPEC" > "HOLLight.hollight.GSPEC"
+ "GEQ" > "HOLLight.hollight.GEQ"
+ "GABS" > "HOLLight.hollight.GABS"
+ "FST" > "fst"
+ "FNIL" > "HOLLight.hollight.FNIL"
+ "FINREC" > "HOLLight.hollight.FINREC"
+ "FINITE" > "HOLLight.hollight.FINITE"
+ "FILTER" > "HOLLight.hollight.FILTER"
+ "FCONS" > "HOLLight.hollight.FCONS"
+ "FACT" > "HOLLight.hollight.FACT"
+ "F" > "False"
+ "EXP" > "HOLLight.hollight.EXP"
+ "EX" > "HOLLight.hollight.EX"
+ "EVEN" > "HOLLight.hollight.EVEN"
+ "EMPTY" > "HOLLight.hollight.EMPTY"
+ "EL" > "HOLLight.hollight.EL"
+ "DIV" > "HOLLight.hollight.DIV"
+ "DISJOINT" > "HOLLight.hollight.DISJOINT"
+ "DIFF" > "HOLLight.hollight.DIFF"
+ "DELETE" > "HOLLight.hollight.DELETE"
+ "DECIMAL" > "HOLLight.hollight.DECIMAL"
+ "CURRY" > "HOLLight.hollight.CURRY"
+ "COUNTABLE" > "HOLLight.hollight.COUNTABLE"
+ "CONSTR" > "HOLLight.hollight.CONSTR"
+ "CONS" > "HOLLight.hollight.CONS"
+ "COND" > "HOLLight.hollight.COND"
+ "CHOICE" > "HOLLight.hollight.CHOICE"
+ "CASEWISE" > "HOLLight.hollight.CASEWISE"
+ "CARD_LT" > "HOLLight.hollight.CARD_LT"
+ "CARD_LE" > "HOLLight.hollight.CARD_LE"
+ "CARD_GT" > "HOLLight.hollight.CARD_GT"
+ "CARD_GE" > "HOLLight.hollight.CARD_GE"
+ "CARD_EQ" > "HOLLight.hollight.CARD_EQ"
+ "CARD" > "HOLLight.hollight.CARD"
+ "BOTTOM" > "HOLLight.hollight.BOTTOM"
+ "BIT1" > "HOL4Compat.NUMERAL_BIT1"
+ "BIT0" > "HOLLightCompat.NUMERAL_BIT0"
+ "BIJ" > "HOLLight.hollight.BIJ"
+ "ASSOC" > "HOLLight.hollight.ASSOC"
+ "APPEND" > "HOLLight.hollight.APPEND"
+ "ALL_list" > "HOLLight.hollight.ALL_list"
+ "ALL2" > "HOLLight.hollight.ALL2"
+ "ABS_prod" > "Abs_Prod"
+ "@" > "Hilbert_Choice.Eps"
+ "?!" > "Ex1"
+ "?" > "Ex"
+ ">=" > "HOLLight.hollight.>="
+ ">" > "HOLLight.hollight.>"
+ "==>" > "op -->"
+ "=" > "op ="
+ "<=" > "HOLLight.hollight.<="
+ "<" > "HOLLight.hollight.<"
+ "/\\" > "op &"
+ "-" > "op -" :: "nat => nat => nat"
+ "," > "Pair"
+ "+" > "op +" :: "nat => nat => nat"
+ "*" > "op *" :: "nat => nat => nat"
+ "$" > "HOLLight.hollight.$"
+ "!" > "All"
+
+const_renames
+ "ALL" > "ALL_list"
+ "==" > "eqeq"
+ ".." > "dotdot"
+
+thm_maps
+ "two_2_def" > "HOLLight.hollight.two_2_def"
+ "two_1_def" > "HOLLight.hollight.two_1_def"
+ "treal_of_num_def" > "HOLLight.hollight.treal_of_num_def"
+ "treal_neg_def" > "HOLLight.hollight.treal_neg_def"
+ "treal_mul_def" > "HOLLight.hollight.treal_mul_def"
+ "treal_le_def" > "HOLLight.hollight.treal_le_def"
+ "treal_inv_def" > "HOLLight.hollight.treal_inv_def"
+ "treal_eq_def" > "HOLLight.hollight.treal_eq_def"
+ "treal_add_def" > "HOLLight.hollight.treal_add_def"
+ "three_3_def" > "HOLLight.hollight.three_3_def"
+ "three_2_def" > "HOLLight.hollight.three_2_def"
+ "three_1_def" > "HOLLight.hollight.three_1_def"
+ "th_cond" > "HOLLight.hollight.th_cond"
+ "th" > "HOLLight.hollight.th"
+ "tendsto_def" > "HOLLight.hollight.tendsto_def"
+ "tends_real_real_def" > "HOLLight.hollight.tends_real_real_def"
+ "tends_num_real_def" > "HOLLight.hollight.tends_num_real_def"
+ "tends_def" > "HOLLight.hollight.tends_def"
+ "tdiv_def" > "HOLLight.hollight.tdiv_def"
+ "tan_def" > "HOLLight.hollight.tan_def"
+ "tailadmissible_def" > "HOLLight.hollight.tailadmissible_def"
+ "support_def" > "HOLLight.hollight.support_def"
+ "superadmissible_def" > "HOLLight.hollight.superadmissible_def"
+ "sup_def" > "HOLLight.hollight.sup_def"
+ "sup" > "HOLLight.hollight.sup"
+ "sums_def" > "HOLLight.hollight.sums_def"
+ "summable_def" > "HOLLight.hollight.summable_def"
+ "suminf_def" > "HOLLight.hollight.suminf_def"
+ "sum_def" > "HOLLight.hollight.sum_def"
+ "sum_EXISTS" > "HOLLight.hollight.sum_EXISTS"
+ "sum" > "HOLLight.hollight.sum"
+ "subseq_def" > "HOLLight.hollight.subseq_def"
+ "sth" > "HOLLight.hollight.sth"
+ "sqrt_def" > "HOLLight.hollight.sqrt_def"
+ "sqrt" > "HOLLight.hollight.sqrt"
+ "sndcart_def" > "HOLLight.hollight.sndcart_def"
+ "sin_def" > "HOLLight.hollight.sin_def"
+ "set_of_list_def" > "HOLLight.hollight.set_of_list_def"
+ "rsum_def" > "HOLLight.hollight.rsum_def"
+ "root_def" > "HOLLight.hollight.root_def"
+ "right_th" > "HOLLight.hollight.right_th"
+ "real_sub_def" > "HOLLight.hollight.real_sub_def"
+ "real_pow_def" > "HOLLight.hollight.real_pow_def"
+ "real_of_num_def" > "HOLLight.hollight.real_of_num_def"
+ "real_neg_def" > "HOLLight.hollight.real_neg_def"
+ "real_mul_def" > "HOLLight.hollight.real_mul_def"
+ "real_min_def" > "HOLLight.hollight.real_min_def"
+ "real_max_def" > "HOLLight.hollight.real_max_def"
+ "real_lt_def" > "HOLLight.hollight.real_lt_def"
+ "real_le_def" > "HOLLight.hollight.real_le_def"
+ "real_le" > "HOLLight.hollight.real_le"
+ "real_inv_def" > "HOLLight.hollight.real_inv_def"
+ "real_gt_def" > "HOLLight.hollight.real_gt_def"
+ "real_ge_def" > "HOLLight.hollight.real_ge_def"
+ "real_div_def" > "HOLLight.hollight.real_div_def"
+ "real_add_def" > "HOLLight.hollight.real_add_def"
+ "real_abs_def" > "HOLLight.hollight.real_abs_def"
+ "re_universe_def" > "HOLLight.hollight.re_universe_def"
+ "re_union_def" > "HOLLight.hollight.re_union_def"
+ "re_subset_def" > "HOLLight.hollight.re_subset_def"
+ "re_null_def" > "HOLLight.hollight.re_null_def"
+ "re_intersect_def" > "HOLLight.hollight.re_intersect_def"
+ "re_compl_def" > "HOLLight.hollight.re_compl_def"
+ "re_Union_def" > "HOLLight.hollight.re_Union_def"
+ "psum_def" > "HOLLight.hollight.psum_def"
+ "pi_def" > "HOLLight.hollight.pi_def"
+ "pastecart_def" > "HOLLight.hollight.pastecart_def"
+ "pairwise_def" > "HOLLight.hollight.pairwise_def"
+ "pair_RECURSION" > "HOLLight.hollight.pair_RECURSION"
+ "pair_INDUCT" > "Datatype.prod.induct"
+ "one_axiom" > "HOLLight.hollight.one_axiom"
+ "one_RECURSION" > "HOLLight.hollight.one_RECURSION"
+ "one_INDUCT" > "Datatype.unit.induct"
+ "one_Axiom" > "HOLLight.hollight.one_Axiom"
+ "one" > "HOL4Compat.one"
+ "o_THM" > "Fun.o_apply"
+ "o_ASSOC" > "HOLLight.hollight.o_ASSOC"
+ "num_WOP" > "HOLLight.hollight.num_WOP"
+ "num_WF" > "HOLLight.hollight.num_WF"
+ "num_RECURSION_STD" > "HOLLight.hollight.num_RECURSION_STD"
+ "num_MAX" > "HOLLight.hollight.num_MAX"
+ "num_INFINITE" > "HOLLight.hollight.num_INFINITE"
+ "num_INDUCTION" > "List.lexn.induct"
+ "num_FINITE_AVOID" > "HOLLight.hollight.num_FINITE_AVOID"
+ "num_FINITE" > "HOLLight.hollight.num_FINITE"
+ "num_CASES" > "Nat.nat.nchotomy"
+ "num_Axiom" > "HOLLight.hollight.num_Axiom"
+ "nsum_def" > "HOLLight.hollight.nsum_def"
+ "neutral_def" > "HOLLight.hollight.neutral_def"
+ "neigh_def" > "HOLLight.hollight.neigh_def"
+ "nadd_rinv_def" > "HOLLight.hollight.nadd_rinv_def"
+ "nadd_of_num_def" > "HOLLight.hollight.nadd_of_num_def"
+ "nadd_mul_def" > "HOLLight.hollight.nadd_mul_def"
+ "nadd_le_def" > "HOLLight.hollight.nadd_le_def"
+ "nadd_inv_def" > "HOLLight.hollight.nadd_inv_def"
+ "nadd_eq_def" > "HOLLight.hollight.nadd_eq_def"
+ "nadd_add_def" > "HOLLight.hollight.nadd_add_def"
+ "mtop_istopology" > "HOLLight.hollight.mtop_istopology"
+ "mtop_def" > "HOLLight.hollight.mtop_def"
+ "mr1_def" > "HOLLight.hollight.mr1_def"
+ "monoidal_def" > "HOLLight.hollight.monoidal_def"
+ "mono_def" > "HOLLight.hollight.mono_def"
+ "mod_real_def" > "HOLLight.hollight.mod_real_def"
+ "mod_nat_def" > "HOLLight.hollight.mod_nat_def"
+ "mod_int_def" > "HOLLight.hollight.mod_int_def"
+ "minimal_def" > "HOLLight.hollight.minimal_def"
+ "measure_def" > "HOLLight.hollight.measure_def"
+ "ln_def" > "HOLLight.hollight.ln_def"
+ "list_of_set_def" > "HOLLight.hollight.list_of_set_def"
+ "list_INDUCT" > "HOLLight.hollight.list_INDUCT"
+ "list_CASES" > "HOLLight.hollight.list_CASES"
+ "limpt_def" > "HOLLight.hollight.limpt_def"
+ "lim_def" > "HOLLight.hollight.lim_def"
+ "lambda_def" > "HOLLight.hollight.lambda_def"
+ "iterate_def" > "HOLLight.hollight.iterate_def"
+ "istopology_def" > "HOLLight.hollight.istopology_def"
+ "ismet_def" > "HOLLight.hollight.ismet_def"
+ "is_nadd_def" > "HOLLight.hollight.is_nadd_def"
+ "is_nadd_0" > "HOLLight.hollight.is_nadd_0"
+ "is_int_def" > "HOLLight.hollight.is_int_def"
+ "int_sub_th" > "HOLLight.hollight.int_sub_th"
+ "int_sub_def" > "HOLLight.hollight.int_sub_def"
+ "int_pow_th" > "HOLLight.hollight.int_pow_th"
+ "int_pow_def" > "HOLLight.hollight.int_pow_def"
+ "int_of_num_th" > "HOLLight.hollight.int_of_num_th"
+ "int_of_num_def" > "HOLLight.hollight.int_of_num_def"
+ "int_neg_th" > "HOLLight.hollight.int_neg_th"
+ "int_neg_def" > "HOLLight.hollight.int_neg_def"
+ "int_mul_th" > "HOLLight.hollight.int_mul_th"
+ "int_mul_def" > "HOLLight.hollight.int_mul_def"
+ "int_min_th" > "HOLLight.hollight.int_min_th"
+ "int_min_def" > "HOLLight.hollight.int_min_def"
+ "int_max_th" > "HOLLight.hollight.int_max_th"
+ "int_max_def" > "HOLLight.hollight.int_max_def"
+ "int_lt_def" > "HOLLight.hollight.int_lt_def"
+ "int_le_def" > "HOLLight.hollight.int_le_def"
+ "int_gt_def" > "HOLLight.hollight.int_gt_def"
+ "int_ge_def" > "HOLLight.hollight.int_ge_def"
+ "int_eq" > "HOLLight.hollight.int.dest_int_inject"
+ "int_add_th" > "HOLLight.hollight.int_add_th"
+ "int_add_def" > "HOLLight.hollight.int_add_def"
+ "int_abs_th" > "HOLLight.hollight.int_abs_th"
+ "int_abs_def" > "HOLLight.hollight.int_abs_def"
+ "hreal_of_num_def" > "HOLLight.hollight.hreal_of_num_def"
+ "hreal_mul_def" > "HOLLight.hollight.hreal_mul_def"
+ "hreal_le_def" > "HOLLight.hollight.hreal_le_def"
+ "hreal_inv_def" > "HOLLight.hollight.hreal_inv_def"
+ "hreal_add_def" > "HOLLight.hollight.hreal_add_def"
+ "gauge_def" > "HOLLight.hollight.gauge_def"
+ "fstcart_def" > "HOLLight.hollight.fstcart_def"
+ "finite_index_def" > "HOLLight.hollight.finite_index_def"
+ "fine_def" > "HOLLight.hollight.fine_def"
+ "exp_def" > "HOLLight.hollight.exp_def"
+ "eqeq_def" > "HOLLight.hollight.eqeq_def"
+ "dsize_def" > "HOLLight.hollight.dsize_def"
+ "dotdot_def" > "HOLLight.hollight.dotdot_def"
+ "dorder_def" > "HOLLight.hollight.dorder_def"
+ "division_def" > "HOLLight.hollight.division_def"
+ "dist_def" > "HOLLight.hollight.dist_def"
+ "dimindex_def" > "HOLLight.hollight.dimindex_def"
+ "diffs_def" > "HOLLight.hollight.diffs_def"
+ "diffl_def" > "HOLLight.hollight.diffl_def"
+ "differentiable_def" > "HOLLight.hollight.differentiable_def"
+ "dest_int_rep" > "HOLLight.hollight.dest_int_rep"
+ "defint_def" > "HOLLight.hollight.defint_def"
+ "cth" > "HOLLight.hollight.cth"
+ "cos_def" > "HOLLight.hollight.cos_def"
+ "convergent_def" > "HOLLight.hollight.convergent_def"
+ "contl_def" > "HOLLight.hollight.contl_def"
+ "closed_def" > "HOLLight.hollight.closed_def"
+ "cauchy_def" > "HOLLight.hollight.cauchy_def"
+ "bounded_def" > "HOLLight.hollight.bounded_def"
+ "ball_def" > "HOLLight.hollight.ball_def"
+ "ax__3" > "HOL4Setup.INFINITY_AX"
+ "ax__2" > "Hilbert_Choice.tfl_some"
+ "ax__1" > "Presburger.fm_modd_pinf"
+ "atn_def" > "HOLLight.hollight.atn_def"
+ "asn_def" > "HOLLight.hollight.asn_def"
+ "admissible_def" > "HOLLight.hollight.admissible_def"
+ "acs_def" > "HOLLight.hollight.acs_def"
+ "_FALSITY__def" > "HOLLight.hollight._FALSITY__def"
+ "_10314_def" > "HOLLight.hollight._10314_def"
+ "_10313_def" > "HOLLight.hollight._10313_def"
+ "_10312_def" > "HOLLight.hollight._10312_def"
+ "_10289_def" > "HOLLight.hollight._10289_def"
+ "_10288_def" > "HOLLight.hollight._10288_def"
+ "ZRECSPACE_def" > "HOLLight.hollight.ZRECSPACE_def"
+ "ZIP_def" > "HOLLight.hollight.ZIP_def"
+ "ZIP" > "HOLLight.hollight.ZIP"
+ "ZCONSTR_def" > "HOLLight.hollight.ZCONSTR_def"
+ "ZCONSTR_ZBOT" > "HOLLight.hollight.ZCONSTR_ZBOT"
+ "ZBOT_def" > "HOLLight.hollight.ZBOT_def"
+ "WLOG_LT" > "HOLLight.hollight.WLOG_LT"
+ "WLOG_LE" > "HOLLight.hollight.WLOG_LE"
+ "WF_num" > "HOLLight.hollight.WF_num"
+ "WF_def" > "HOLLight.hollight.WF_def"
+ "WF_UREC_WF" > "HOLLight.hollight.WF_UREC_WF"
+ "WF_UREC" > "HOLLight.hollight.WF_UREC"
+ "WF_SUBSET" > "HOLLight.hollight.WF_SUBSET"
+ "WF_REFL" > "HOLLight.hollight.WF_REFL"
+ "WF_REC_num" > "HOLLight.hollight.WF_REC_num"
+ "WF_REC_WF" > "HOLLight.hollight.WF_REC_WF"
+ "WF_REC_TAIL_GENERAL" > "HOLLight.hollight.WF_REC_TAIL_GENERAL"
+ "WF_REC_TAIL" > "HOLLight.hollight.WF_REC_TAIL"
+ "WF_REC_INVARIANT" > "HOLLight.hollight.WF_REC_INVARIANT"
+ "WF_REC_CASES" > "HOLLight.hollight.WF_REC_CASES"
+ "WF_REC" > "HOLLight.hollight.WF_REC"
+ "WF_POINTWISE" > "HOLLight.hollight.WF_POINTWISE"
+ "WF_MEASURE_GEN" > "HOLLight.hollight.WF_MEASURE_GEN"
+ "WF_MEASURE" > "HOLLight.hollight.WF_MEASURE"
+ "WF_LEX_DEPENDENT" > "HOLLight.hollight.WF_LEX_DEPENDENT"
+ "WF_LEX" > "HOLLight.hollight.WF_LEX"
+ "WF_IND" > "HOLLight.hollight.WF_IND"
+ "WF_FALSE" > "HOLLight.hollight.WF_FALSE"
+ "WF_EREC" > "HOLLight.hollight.WF_EREC"
+ "WF_EQ" > "HOLLight.hollight.WF_EQ"
+ "WF_DCHAIN" > "HOLLight.hollight.WF_DCHAIN"
+ "UNWIND_THM2" > "HOL.simp_thms_39"
+ "UNWIND_THM1" > "HOL.simp_thms_40"
+ "UNIV_def" > "HOLLight.hollight.UNIV_def"
+ "UNIV_SUBSET" > "HOLLight.hollight.UNIV_SUBSET"
+ "UNIV_NOT_EMPTY" > "HOLLight.hollight.UNIV_NOT_EMPTY"
+ "UNIQUE_SKOLEM_THM" > "HOL.choice_eq"
+ "UNIQUE_SKOLEM_ALT" > "HOLLight.hollight.UNIQUE_SKOLEM_ALT"
+ "UNION_def" > "HOLLight.hollight.UNION_def"
+ "UNION_UNIV" > "HOLLight.hollight.UNION_UNIV"
+ "UNION_SUBSET" > "HOLLight.hollight.UNION_SUBSET"
+ "UNION_OVER_INTER" > "HOLLight.hollight.UNION_OVER_INTER"
+ "UNION_IDEMPOT" > "HOLLight.hollight.UNION_IDEMPOT"
+ "UNION_EMPTY" > "HOLLight.hollight.UNION_EMPTY"
+ "UNION_COMM" > "HOLLight.hollight.UNION_COMM"
+ "UNION_ASSOC" > "HOLLight.hollight.UNION_ASSOC"
+ "UNION_ACI" > "HOLLight.hollight.UNION_ACI"
+ "UNIONS_def" > "HOLLight.hollight.UNIONS_def"
+ "UNIONS_INSERT" > "HOLLight.hollight.UNIONS_INSERT"
+ "UNIONS_2" > "HOLLight.hollight.UNIONS_2"
+ "UNIONS_1" > "HOLLight.hollight.UNIONS_1"
+ "UNIONS_0" > "HOLLight.hollight.UNIONS_0"
+ "UNCURRY_def" > "HOLLight.hollight.UNCURRY_def"
+ "TYDEF_topology" > "HOLLight.hollight.TYDEF_topology"
+ "TYDEF_sum" > "HOLLight.hollight.TYDEF_sum"
+ "TYDEF_recspace" > "HOLLight.hollight.TYDEF_recspace"
+ "TYDEF_real" > "HOLLight.hollight.TYDEF_real"
+ "TYDEF_option" > "HOLLight.hollight.TYDEF_option"
+ "TYDEF_nadd" > "HOLLight.hollight.TYDEF_nadd"
+ "TYDEF_metric" > "HOLLight.hollight.TYDEF_metric"
+ "TYDEF_list" > "HOLLight.hollight.TYDEF_list"
+ "TYDEF_int" > "HOLLight.hollight.TYDEF_int"
+ "TYDEF_hreal" > "HOLLight.hollight.TYDEF_hreal"
+ "TYDEF_finite_sum" > "HOLLight.hollight.TYDEF_finite_sum"
+ "TYDEF_finite_image" > "HOLLight.hollight.TYDEF_finite_image"
+ "TYDEF_cart" > "HOLLight.hollight.TYDEF_cart"
+ "TYDEF_3" > "HOLLight.hollight.TYDEF_3"
+ "TYDEF_2" > "HOLLight.hollight.TYDEF_2"
+ "TWO" > "HOLLight.hollight.TWO"
+ "TRIV_OR_FORALL_THM" > "HOLLight.hollight.TRIV_OR_FORALL_THM"
+ "TRIV_FORALL_OR_THM" > "HOLLight.hollight.TRIV_FORALL_OR_THM"
+ "TRIV_FORALL_IMP_THM" > "HOLLight.hollight.TRIV_FORALL_IMP_THM"
+ "TRIV_EXISTS_IMP_THM" > "HOLLight.hollight.TRIV_EXISTS_IMP_THM"
+ "TRIV_EXISTS_AND_THM" > "HOLLight.hollight.TRIV_EXISTS_AND_THM"
+ "TRIV_AND_EXISTS_THM" > "HOLLight.hollight.TRIV_AND_EXISTS_THM"
+ "TREAL_OF_NUM_WELLDEF" > "HOLLight.hollight.TREAL_OF_NUM_WELLDEF"
+ "TREAL_OF_NUM_MUL" > "HOLLight.hollight.TREAL_OF_NUM_MUL"
+ "TREAL_OF_NUM_LE" > "HOLLight.hollight.TREAL_OF_NUM_LE"
+ "TREAL_OF_NUM_EQ" > "HOLLight.hollight.TREAL_OF_NUM_EQ"
+ "TREAL_OF_NUM_ADD" > "HOLLight.hollight.TREAL_OF_NUM_ADD"
+ "TREAL_NEG_WELLDEF" > "HOLLight.hollight.TREAL_NEG_WELLDEF"
+ "TREAL_MUL_WELLDEFR" > "HOLLight.hollight.TREAL_MUL_WELLDEFR"
+ "TREAL_MUL_WELLDEF" > "HOLLight.hollight.TREAL_MUL_WELLDEF"
+ "TREAL_MUL_SYM_EQ" > "HOLLight.hollight.TREAL_MUL_SYM_EQ"
+ "TREAL_MUL_SYM" > "HOLLight.hollight.TREAL_MUL_SYM"
+ "TREAL_MUL_LINV" > "HOLLight.hollight.TREAL_MUL_LINV"
+ "TREAL_MUL_LID" > "HOLLight.hollight.TREAL_MUL_LID"
+ "TREAL_MUL_ASSOC" > "HOLLight.hollight.TREAL_MUL_ASSOC"
+ "TREAL_LE_WELLDEF" > "HOLLight.hollight.TREAL_LE_WELLDEF"
+ "TREAL_LE_TRANS" > "HOLLight.hollight.TREAL_LE_TRANS"
+ "TREAL_LE_TOTAL" > "HOLLight.hollight.TREAL_LE_TOTAL"
+ "TREAL_LE_REFL" > "HOLLight.hollight.TREAL_LE_REFL"
+ "TREAL_LE_MUL" > "HOLLight.hollight.TREAL_LE_MUL"
+ "TREAL_LE_LADD_IMP" > "HOLLight.hollight.TREAL_LE_LADD_IMP"
+ "TREAL_LE_ANTISYM" > "HOLLight.hollight.TREAL_LE_ANTISYM"
+ "TREAL_INV_WELLDEF" > "HOLLight.hollight.TREAL_INV_WELLDEF"
+ "TREAL_INV_0" > "HOLLight.hollight.TREAL_INV_0"
+ "TREAL_EQ_TRANS" > "HOLLight.hollight.TREAL_EQ_TRANS"
+ "TREAL_EQ_SYM" > "HOLLight.hollight.TREAL_EQ_SYM"
+ "TREAL_EQ_REFL" > "HOLLight.hollight.TREAL_EQ_REFL"
+ "TREAL_EQ_IMP_LE" > "HOLLight.hollight.TREAL_EQ_IMP_LE"
+ "TREAL_EQ_AP" > "HOLLight.hollight.TREAL_EQ_AP"
+ "TREAL_ADD_WELLDEFR" > "HOLLight.hollight.TREAL_ADD_WELLDEFR"
+ "TREAL_ADD_WELLDEF" > "HOLLight.hollight.TREAL_ADD_WELLDEF"
+ "TREAL_ADD_SYM_EQ" > "HOLLight.hollight.TREAL_ADD_SYM_EQ"
+ "TREAL_ADD_SYM" > "HOLLight.hollight.TREAL_ADD_SYM"
+ "TREAL_ADD_LINV" > "HOLLight.hollight.TREAL_ADD_LINV"
+ "TREAL_ADD_LID" > "HOLLight.hollight.TREAL_ADD_LID"
+ "TREAL_ADD_LDISTRIB" > "HOLLight.hollight.TREAL_ADD_LDISTRIB"
+ "TREAL_ADD_ASSOC" > "HOLLight.hollight.TREAL_ADD_ASSOC"
+ "TOPOLOGY_UNION" > "HOLLight.hollight.TOPOLOGY_UNION"
+ "TOPOLOGY" > "HOLLight.hollight.TOPOLOGY"
+ "TL_def" > "HOLLight.hollight.TL_def"
+ "TERMDIFF_STRONG" > "HOLLight.hollight.TERMDIFF_STRONG"
+ "TERMDIFF_LEMMA5" > "HOLLight.hollight.TERMDIFF_LEMMA5"
+ "TERMDIFF_LEMMA4" > "HOLLight.hollight.TERMDIFF_LEMMA4"
+ "TERMDIFF_LEMMA3" > "HOLLight.hollight.TERMDIFF_LEMMA3"
+ "TERMDIFF_LEMMA2" > "HOLLight.hollight.TERMDIFF_LEMMA2"
+ "TERMDIFF_LEMMA1" > "HOLLight.hollight.TERMDIFF_LEMMA1"
+ "TERMDIFF_CONVERGES" > "HOLLight.hollight.TERMDIFF_CONVERGES"
+ "TERMDIFF" > "HOLLight.hollight.TERMDIFF"
+ "TAN_TOTAL_POS" > "HOLLight.hollight.TAN_TOTAL_POS"
+ "TAN_TOTAL_LEMMA" > "HOLLight.hollight.TAN_TOTAL_LEMMA"
+ "TAN_TOTAL" > "HOLLight.hollight.TAN_TOTAL"
+ "TAN_SEC" > "HOLLight.hollight.TAN_SEC"
+ "TAN_POS_PI2" > "HOLLight.hollight.TAN_POS_PI2"
+ "TAN_PI4" > "HOLLight.hollight.TAN_PI4"
+ "TAN_PI" > "HOLLight.hollight.TAN_PI"
+ "TAN_PERIODIC_PI" > "HOLLight.hollight.TAN_PERIODIC_PI"
+ "TAN_PERIODIC_NPI" > "HOLLight.hollight.TAN_PERIODIC_NPI"
+ "TAN_PERIODIC" > "HOLLight.hollight.TAN_PERIODIC"
+ "TAN_NPI" > "HOLLight.hollight.TAN_NPI"
+ "TAN_NEG" > "HOLLight.hollight.TAN_NEG"
+ "TAN_DOUBLE" > "HOLLight.hollight.TAN_DOUBLE"
+ "TAN_COT" > "HOLLight.hollight.TAN_COT"
+ "TAN_BOUND_PI2" > "HOLLight.hollight.TAN_BOUND_PI2"
+ "TAN_ATN" > "HOLLight.hollight.TAN_ATN"
+ "TAN_ADD" > "HOLLight.hollight.TAN_ADD"
+ "TAN_ABS_GE_X" > "HOLLight.hollight.TAN_ABS_GE_X"
+ "TAN_0" > "HOLLight.hollight.TAN_0"
+ "TAIL_IMP_SUPERADMISSIBLE" > "HOLLight.hollight.TAIL_IMP_SUPERADMISSIBLE"
+ "SWAP_FORALL_THM" > "HOLLight.hollight.SWAP_FORALL_THM"
+ "SWAP_EXISTS_THM" > "HOLLight.hollight.SWAP_EXISTS_THM"
+ "SURJ_def" > "HOLLight.hollight.SURJ_def"
+ "SURJECTIVE_RIGHT_INVERSE" > "HOLLight.hollight.SURJECTIVE_RIGHT_INVERSE"
+ "SURJECTIVE_ON_RIGHT_INVERSE" > "HOLLight.hollight.SURJECTIVE_ON_RIGHT_INVERSE"
+ "SURJECTIVE_IFF_INJECTIVE_GEN" > "HOLLight.hollight.SURJECTIVE_IFF_INJECTIVE_GEN"
+ "SURJECTIVE_IFF_INJECTIVE" > "HOLLight.hollight.SURJECTIVE_IFF_INJECTIVE"
+ "SUPPORT_SUPPORT" > "HOLLight.hollight.SUPPORT_SUPPORT"
+ "SUPPORT_SUBSET" > "HOLLight.hollight.SUPPORT_SUBSET"
+ "SUPPORT_EMPTY" > "HOLLight.hollight.SUPPORT_EMPTY"
+ "SUPPORT_DELTA" > "HOLLight.hollight.SUPPORT_DELTA"
+ "SUPPORT_CLAUSES" > "HOLLight.hollight.SUPPORT_CLAUSES"
+ "SUPERADMISSIBLE_T" > "HOLLight.hollight.SUPERADMISSIBLE_T"
+ "SUPERADMISSIBLE_COND" > "HOLLight.hollight.SUPERADMISSIBLE_COND"
+ "SUM_ZERO" > "HOLLight.hollight.SUM_ZERO"
+ "SUM_UNIQ" > "HOLLight.hollight.SUM_UNIQ"
+ "SUM_UNION_RZERO" > "HOLLight.hollight.SUM_UNION_RZERO"
+ "SUM_UNION_LZERO" > "HOLLight.hollight.SUM_UNION_LZERO"
+ "SUM_UNION_EQ" > "HOLLight.hollight.SUM_UNION_EQ"
+ "SUM_UNION" > "HOLLight.hollight.SUM_UNION"
+ "SUM_TWO" > "HOLLight.hollight.SUM_TWO"
+ "SUM_TRIV_NUMSEG" > "HOLLight.hollight.SUM_TRIV_NUMSEG"
+ "SUM_SWAP_NUMSEG" > "HOLLight.hollight.SUM_SWAP_NUMSEG"
+ "SUM_SWAP" > "HOLLight.hollight.SUM_SWAP"
+ "SUM_SUPPORT" > "HOLLight.hollight.SUM_SUPPORT"
+ "SUM_SUPERSET" > "HOLLight.hollight.SUM_SUPERSET"
+ "SUM_SUM_RESTRICT" > "HOLLight.hollight.SUM_SUM_RESTRICT"
+ "SUM_SUMMABLE" > "HOLLight.hollight.SUM_SUMMABLE"
+ "SUM_SUB_NUMSEG" > "HOLLight.hollight.SUM_SUB_NUMSEG"
+ "SUM_SUBST" > "HOLLight.hollight.SUM_SUBST"
+ "SUM_SUBSET_SIMPLE" > "HOLLight.hollight.SUM_SUBSET_SIMPLE"
+ "SUM_SUBSET" > "HOLLight.hollight.SUM_SUBSET"
+ "SUM_SUB" > "HOLLight.hollight.SUM_SUB"
+ "SUM_SPLIT" > "HOLLight.hollight.SUM_SPLIT"
+ "SUM_SING_NUMSEG" > "HOLLight.hollight.SUM_SING_NUMSEG"
+ "SUM_SING" > "HOLLight.hollight.SUM_SING"
+ "SUM_RESTRICT_SET" > "HOLLight.hollight.SUM_RESTRICT_SET"
+ "SUM_RESTRICT" > "HOLLight.hollight.SUM_RESTRICT"
+ "SUM_REINDEX" > "HOLLight.hollight.SUM_REINDEX"
+ "SUM_POS_LE_NUMSEG" > "HOLLight.hollight.SUM_POS_LE_NUMSEG"
+ "SUM_POS_LE" > "HOLLight.hollight.SUM_POS_LE"
+ "SUM_POS_GEN" > "HOLLight.hollight.SUM_POS_GEN"
+ "SUM_POS_EQ_0_NUMSEG" > "HOLLight.hollight.SUM_POS_EQ_0_NUMSEG"
+ "SUM_POS_EQ_0" > "HOLLight.hollight.SUM_POS_EQ_0"
+ "SUM_POS_BOUND" > "HOLLight.hollight.SUM_POS_BOUND"
+ "SUM_POS" > "HOLLight.hollight.SUM_POS"
+ "SUM_OFFSET_0" > "HOLLight.hollight.SUM_OFFSET_0"
+ "SUM_OFFSET" > "HOLLight.hollight.SUM_OFFSET"
+ "SUM_NSUB" > "HOLLight.hollight.SUM_NSUB"
+ "SUM_NEG_NUMSEG" > "HOLLight.hollight.SUM_NEG_NUMSEG"
+ "SUM_NEG" > "HOLLight.hollight.SUM_NEG"
+ "SUM_MULTICOUNT_GEN" > "HOLLight.hollight.SUM_MULTICOUNT_GEN"
+ "SUM_MULTICOUNT" > "HOLLight.hollight.SUM_MULTICOUNT"
+ "SUM_MORETERMS_EQ" > "HOLLight.hollight.SUM_MORETERMS_EQ"
+ "SUM_LT_ALL" > "HOLLight.hollight.SUM_LT_ALL"
+ "SUM_LT" > "HOLLight.hollight.SUM_LT"
+ "SUM_LE_NUMSEG" > "HOLLight.hollight.SUM_LE_NUMSEG"
+ "SUM_LE" > "HOLLight.hollight.SUM_LE"
+ "SUM_IMAGE_GEN" > "HOLLight.hollight.SUM_IMAGE_GEN"
+ "SUM_IMAGE" > "HOLLight.hollight.SUM_IMAGE"
+ "SUM_HORNER" > "HOLLight.hollight.SUM_HORNER"
+ "SUM_GROUP" > "HOLLight.hollight.SUM_GROUP"
+ "SUM_EQ_SUPERSET" > "HOLLight.hollight.SUM_EQ_SUPERSET"
+ "SUM_EQ_NUMSEG" > "HOLLight.hollight.SUM_EQ_NUMSEG"
+ "SUM_EQ_0_NUMSEG" > "HOLLight.hollight.SUM_EQ_0_NUMSEG"
+ "SUM_EQ_0" > "HOLLight.hollight.SUM_EQ_0"
+ "SUM_EQ" > "HOLLight.hollight.SUM_EQ"
+ "SUM_DIFFERENCES_EQ" > "HOLLight.hollight.SUM_DIFFERENCES_EQ"
+ "SUM_DIFF" > "HOLLight.hollight.SUM_DIFF"
+ "SUM_DELTA" > "HOLLight.hollight.SUM_DELTA"
+ "SUM_CONST_NUMSEG" > "HOLLight.hollight.SUM_CONST_NUMSEG"
+ "SUM_CONST" > "HOLLight.hollight.SUM_CONST"
+ "SUM_CMUL_NUMSEG" > "HOLLight.hollight.SUM_CMUL_NUMSEG"
+ "SUM_CMUL" > "HOLLight.hollight.SUM_CMUL"
+ "SUM_CLAUSES_RIGHT" > "HOLLight.hollight.SUM_CLAUSES_RIGHT"
+ "SUM_CLAUSES_NUMSEG" > "HOLLight.hollight.SUM_CLAUSES_NUMSEG"
+ "SUM_CLAUSES_LEFT" > "HOLLight.hollight.SUM_CLAUSES_LEFT"
+ "SUM_CLAUSES" > "HOLLight.hollight.SUM_CLAUSES"
+ "SUM_CANCEL" > "HOLLight.hollight.SUM_CANCEL"
+ "SUM_BOUND_LT_GEN" > "HOLLight.hollight.SUM_BOUND_LT_GEN"
+ "SUM_BOUND_LT_ALL" > "HOLLight.hollight.SUM_BOUND_LT_ALL"
+ "SUM_BOUND_LT" > "HOLLight.hollight.SUM_BOUND_LT"
+ "SUM_BOUND_GEN" > "HOLLight.hollight.SUM_BOUND_GEN"
+ "SUM_BOUND" > "HOLLight.hollight.SUM_BOUND"
+ "SUM_ADD_SPLIT" > "HOLLight.hollight.SUM_ADD_SPLIT"
+ "SUM_ADD_NUMSEG" > "HOLLight.hollight.SUM_ADD_NUMSEG"
+ "SUM_ADD" > "HOLLight.hollight.SUM_ADD"
+ "SUM_ABS_NUMSEG" > "HOLLight.hollight.SUM_ABS_NUMSEG"
+ "SUM_ABS_LE" > "HOLLight.hollight.SUM_ABS_LE"
+ "SUM_ABS_BOUND" > "HOLLight.hollight.SUM_ABS_BOUND"
+ "SUM_ABS" > "HOLLight.hollight.SUM_ABS"
+ "SUM_2" > "HOLLight.hollight.SUM_2"
+ "SUM_1" > "HOLLight.hollight.SUM_1"
+ "SUM_0" > "HOLLight.hollight.SUM_0"
+ "SUMMABLE_SUM" > "HOLLight.hollight.SUMMABLE_SUM"
+ "SUC_SUB1" > "HOLLight.hollight.SUC_SUB1"
+ "SUC_INJ" > "Nat.nat.simps_3"
+ "SUB_SUC" > "Nat.diff_Suc_Suc"
+ "SUB_SUB" > "HOLLight.hollight.SUB_SUB"
+ "SUB_REFL" > "Nat.diff_self_eq_0"
+ "SUB_PRESUC" > "HOLLight.hollight.SUB_PRESUC"
+ "SUB_OLD" > "HOLLight.hollight.SUB_OLD"
+ "SUB_EQ_0" > "HOLLight.hollight.SUB_EQ_0"
+ "SUB_ELIM_THM" > "HOLLight.hollight.SUB_ELIM_THM"
+ "SUB_ADD_RCANCEL" > "Nat.diff_cancel2"
+ "SUB_ADD_LCANCEL" > "Nat.diff_cancel"
+ "SUB_ADD" > "HOLLight.hollight.SUB_ADD"
+ "SUB_0" > "HOLLight.hollight.SUB_0"
+ "SUBSET_def" > "HOLLight.hollight.SUBSET_def"
+ "SUBSET_UNIV" > "HOLLight.hollight.SUBSET_UNIV"
+ "SUBSET_UNION_ABSORPTION" > "HOLLight.hollight.SUBSET_UNION_ABSORPTION"
+ "SUBSET_UNION" > "HOLLight.hollight.SUBSET_UNION"
+ "SUBSET_TRANS" > "HOLLight.hollight.SUBSET_TRANS"
+ "SUBSET_RESTRICT" > "HOLLight.hollight.SUBSET_RESTRICT"
+ "SUBSET_REFL" > "HOLLight.hollight.SUBSET_REFL"
+ "SUBSET_PSUBSET_TRANS" > "HOLLight.hollight.SUBSET_PSUBSET_TRANS"
+ "SUBSET_NUMSEG" > "HOLLight.hollight.SUBSET_NUMSEG"
+ "SUBSET_INTER_ABSORPTION" > "HOLLight.hollight.SUBSET_INTER_ABSORPTION"
+ "SUBSET_INSERT_DELETE" > "HOLLight.hollight.SUBSET_INSERT_DELETE"
+ "SUBSET_INSERT" > "HOLLight.hollight.SUBSET_INSERT"
+ "SUBSET_IMAGE" > "HOLLight.hollight.SUBSET_IMAGE"
+ "SUBSET_EMPTY" > "HOLLight.hollight.SUBSET_EMPTY"
+ "SUBSET_DIFF" > "HOLLight.hollight.SUBSET_DIFF"
+ "SUBSET_DELETE" > "HOLLight.hollight.SUBSET_DELETE"
+ "SUBSET_ANTISYM" > "HOLLight.hollight.SUBSET_ANTISYM"
+ "SUBSETA_TRANS" > "HOLLight.hollight.SUBSETA_TRANS"
+ "SUBSETA_REFL" > "HOLLight.hollight.SUBSETA_REFL"
+ "SUBSETA_ANTISYM" > "HOLLight.hollight.SUBSETA_ANTISYM"
+ "SUBSEQ_SUC" > "HOLLight.hollight.SUBSEQ_SUC"
+ "STRADDLE_LEMMA" > "HOLLight.hollight.STRADDLE_LEMMA"
+ "SQRT_POW_2" > "HOLLight.hollight.SQRT_POW_2"
+ "SQRT_POW2" > "HOLLight.hollight.SQRT_POW2"
+ "SQRT_POS_UNIQ" > "HOLLight.hollight.SQRT_POS_UNIQ"
+ "SQRT_POS_LT" > "HOLLight.hollight.SQRT_POS_LT"
+ "SQRT_POS_LE" > "HOLLight.hollight.SQRT_POS_LE"
+ "SQRT_MUL" > "HOLLight.hollight.SQRT_MUL"
+ "SQRT_MONO_LT_EQ" > "HOLLight.hollight.SQRT_MONO_LT_EQ"
+ "SQRT_MONO_LT" > "HOLLight.hollight.SQRT_MONO_LT"
+ "SQRT_MONO_LE_EQ" > "HOLLight.hollight.SQRT_MONO_LE_EQ"
+ "SQRT_MONO_LE" > "HOLLight.hollight.SQRT_MONO_LE"
+ "SQRT_INV" > "HOLLight.hollight.SQRT_INV"
+ "SQRT_INJ" > "HOLLight.hollight.SQRT_INJ"
+ "SQRT_EVEN_POW2" > "HOLLight.hollight.SQRT_EVEN_POW2"
+ "SQRT_EQ_0" > "HOLLight.hollight.SQRT_EQ_0"
+ "SQRT_DIV" > "HOLLight.hollight.SQRT_DIV"
+ "SQRT_1" > "HOLLight.hollight.SQRT_1"
+ "SQRT_0" > "HOLLight.hollight.SQRT_0"
+ "SOME_def" > "HOLLight.hollight.SOME_def"
+ "SNDCART_PASTECART" > "HOLLight.hollight.SNDCART_PASTECART"
+ "SND" > "Product_Type.snd_conv"
+ "SKOLEM_THM" > "HOLLight.hollight.SKOLEM_THM"
+ "SIN_ZERO_PI" > "HOLLight.hollight.SIN_ZERO_PI"
+ "SIN_ZERO_LEMMA" > "HOLLight.hollight.SIN_ZERO_LEMMA"
+ "SIN_ZERO" > "HOLLight.hollight.SIN_ZERO"
+ "SIN_TOTAL" > "HOLLight.hollight.SIN_TOTAL"
+ "SIN_POS_PI_LE" > "HOLLight.hollight.SIN_POS_PI_LE"
+ "SIN_POS_PI2" > "HOLLight.hollight.SIN_POS_PI2"
+ "SIN_POS_PI" > "HOLLight.hollight.SIN_POS_PI"
+ "SIN_POS" > "HOLLight.hollight.SIN_POS"
+ "SIN_PI2" > "HOLLight.hollight.SIN_PI2"
+ "SIN_PI" > "HOLLight.hollight.SIN_PI"
+ "SIN_PERIODIC_PI" > "HOLLight.hollight.SIN_PERIODIC_PI"
+ "SIN_PERIODIC" > "HOLLight.hollight.SIN_PERIODIC"
+ "SIN_PAIRED" > "HOLLight.hollight.SIN_PAIRED"
+ "SIN_NPI" > "HOLLight.hollight.SIN_NPI"
+ "SIN_NEGLEMMA" > "HOLLight.hollight.SIN_NEGLEMMA"
+ "SIN_NEG" > "HOLLight.hollight.SIN_NEG"
+ "SIN_FDIFF" > "HOLLight.hollight.SIN_FDIFF"
+ "SIN_DOUBLE" > "HOLLight.hollight.SIN_DOUBLE"
+ "SIN_COS_SQRT" > "HOLLight.hollight.SIN_COS_SQRT"
+ "SIN_COS_NEG" > "HOLLight.hollight.SIN_COS_NEG"
+ "SIN_COS_ADD" > "HOLLight.hollight.SIN_COS_ADD"
+ "SIN_COS" > "HOLLight.hollight.SIN_COS"
+ "SIN_CONVERGES" > "HOLLight.hollight.SIN_CONVERGES"
+ "SIN_CIRCLE" > "HOLLight.hollight.SIN_CIRCLE"
+ "SIN_BOUNDS" > "HOLLight.hollight.SIN_BOUNDS"
+ "SIN_BOUND" > "HOLLight.hollight.SIN_BOUND"
+ "SIN_ASN" > "HOLLight.hollight.SIN_ASN"
+ "SIN_ADD" > "HOLLight.hollight.SIN_ADD"
+ "SIN_ACS_NZ" > "HOLLight.hollight.SIN_ACS_NZ"
+ "SIN_0" > "HOLLight.hollight.SIN_0"
+ "SING_def" > "HOLLight.hollight.SING_def"
+ "SIMPLE_IMAGE" > "HOLLight.hollight.SIMPLE_IMAGE"
+ "SET_RECURSION_LEMMA" > "HOLLight.hollight.SET_RECURSION_LEMMA"
+ "SET_OF_LIST_OF_SET" > "HOLLight.hollight.SET_OF_LIST_OF_SET"
+ "SET_OF_LIST_APPEND" > "HOLLight.hollight.SET_OF_LIST_APPEND"
+ "SET_CASES" > "HOLLight.hollight.SET_CASES"
+ "SETSPEC_def" > "HOLLight.hollight.SETSPEC_def"
+ "SETOK_LE_LT" > "HOLLight.hollight.SETOK_LE_LT"
+ "SER_ZERO" > "HOLLight.hollight.SER_ZERO"
+ "SER_UNIQ" > "HOLLight.hollight.SER_UNIQ"
+ "SER_SUB" > "HOLLight.hollight.SER_SUB"
+ "SER_RATIO" > "HOLLight.hollight.SER_RATIO"
+ "SER_POS_LT_PAIR" > "HOLLight.hollight.SER_POS_LT_PAIR"
+ "SER_POS_LT" > "HOLLight.hollight.SER_POS_LT"
+ "SER_POS_LE" > "HOLLight.hollight.SER_POS_LE"
+ "SER_PAIR" > "HOLLight.hollight.SER_PAIR"
+ "SER_OFFSET_REV" > "HOLLight.hollight.SER_OFFSET_REV"
+ "SER_OFFSET" > "HOLLight.hollight.SER_OFFSET"
+ "SER_NEG" > "HOLLight.hollight.SER_NEG"
+ "SER_LE2" > "HOLLight.hollight.SER_LE2"
+ "SER_LE" > "HOLLight.hollight.SER_LE"
+ "SER_GROUP" > "HOLLight.hollight.SER_GROUP"
+ "SER_COMPARA_UNIFORM_WEAK" > "HOLLight.hollight.SER_COMPARA_UNIFORM_WEAK"
+ "SER_COMPARA_UNIFORM" > "HOLLight.hollight.SER_COMPARA_UNIFORM"
+ "SER_COMPARA" > "HOLLight.hollight.SER_COMPARA"
+ "SER_COMPAR" > "HOLLight.hollight.SER_COMPAR"
+ "SER_CMUL" > "HOLLight.hollight.SER_CMUL"
+ "SER_CDIV" > "HOLLight.hollight.SER_CDIV"
+ "SER_CAUCHY" > "HOLLight.hollight.SER_CAUCHY"
+ "SER_ADD" > "HOLLight.hollight.SER_ADD"
+ "SER_ACONV" > "HOLLight.hollight.SER_ACONV"
+ "SER_ABS" > "HOLLight.hollight.SER_ABS"
+ "SER_0" > "HOLLight.hollight.SER_0"
+ "SEQ_UNIQ" > "HOLLight.hollight.SEQ_UNIQ"
+ "SEQ_TRUNCATION" > "HOLLight.hollight.SEQ_TRUNCATION"
+ "SEQ_TRANSFORM" > "HOLLight.hollight.SEQ_TRANSFORM"
+ "SEQ_TENDS" > "HOLLight.hollight.SEQ_TENDS"
+ "SEQ_SUM" > "HOLLight.hollight.SEQ_SUM"
+ "SEQ_SUC" > "HOLLight.hollight.SEQ_SUC"
+ "SEQ_SUBLE" > "HOLLight.hollight.SEQ_SUBLE"
+ "SEQ_SUB" > "HOLLight.hollight.SEQ_SUB"
+ "SEQ_SBOUNDED" > "HOLLight.hollight.SEQ_SBOUNDED"
+ "SEQ_POWER_ABS" > "HOLLight.hollight.SEQ_POWER_ABS"
+ "SEQ_POWER" > "HOLLight.hollight.SEQ_POWER"
+ "SEQ_NULL" > "HOLLight.hollight.SEQ_NULL"
+ "SEQ_NPOW" > "HOLLight.hollight.SEQ_NPOW"
+ "SEQ_NEG_CONV" > "HOLLight.hollight.SEQ_NEG_CONV"
+ "SEQ_NEG_BOUNDED" > "HOLLight.hollight.SEQ_NEG_BOUNDED"
+ "SEQ_NEG" > "HOLLight.hollight.SEQ_NEG"
+ "SEQ_MUL" > "HOLLight.hollight.SEQ_MUL"
+ "SEQ_MONOSUB" > "HOLLight.hollight.SEQ_MONOSUB"
+ "SEQ_LIM" > "HOLLight.hollight.SEQ_LIM"
+ "SEQ_LE_0" > "HOLLight.hollight.SEQ_LE_0"
+ "SEQ_LE" > "HOLLight.hollight.SEQ_LE"
+ "SEQ_INV0" > "HOLLight.hollight.SEQ_INV0"
+ "SEQ_INV" > "HOLLight.hollight.SEQ_INV"
+ "SEQ_ICONV" > "HOLLight.hollight.SEQ_ICONV"
+ "SEQ_DIV" > "HOLLight.hollight.SEQ_DIV"
+ "SEQ_DIRECT" > "HOLLight.hollight.SEQ_DIRECT"
+ "SEQ_CONT_UNIFORM" > "HOLLight.hollight.SEQ_CONT_UNIFORM"
+ "SEQ_CONST" > "HOLLight.hollight.SEQ_CONST"
+ "SEQ_CBOUNDED" > "HOLLight.hollight.SEQ_CBOUNDED"
+ "SEQ_CAUCHY" > "HOLLight.hollight.SEQ_CAUCHY"
+ "SEQ_BOUNDED_2" > "HOLLight.hollight.SEQ_BOUNDED_2"
+ "SEQ_BOUNDED" > "HOLLight.hollight.SEQ_BOUNDED"
+ "SEQ_BCONV" > "HOLLight.hollight.SEQ_BCONV"
+ "SEQ_ADD" > "HOLLight.hollight.SEQ_ADD"
+ "SEQ_ABS_IMP" > "HOLLight.hollight.SEQ_ABS_IMP"
+ "SEQ_ABS" > "HOLLight.hollight.SEQ_ABS"
+ "SEQ" > "HOLLight.hollight.SEQ"
+ "SEMIRING_PTHS" > "HOLLight.hollight.SEMIRING_PTHS"
+ "SELECT_UNIQUE" > "HOLLight.hollight.SELECT_UNIQUE"
+ "SELECT_REFL" > "Hilbert_Choice.some_eq_trivial"
+ "SELECT_LEMMA" > "Hilbert_Choice.some_sym_eq_trivial"
+ "ROOT_POW_POS" > "HOLLight.hollight.ROOT_POW_POS"
+ "ROOT_POS_UNIQ" > "HOLLight.hollight.ROOT_POS_UNIQ"
+ "ROOT_POS_POSITIVE" > "HOLLight.hollight.ROOT_POS_POSITIVE"
+ "ROOT_MUL" > "HOLLight.hollight.ROOT_MUL"
+ "ROOT_MONO_LT_EQ" > "HOLLight.hollight.ROOT_MONO_LT_EQ"
+ "ROOT_MONO_LT" > "HOLLight.hollight.ROOT_MONO_LT"
+ "ROOT_MONO_LE_EQ" > "HOLLight.hollight.ROOT_MONO_LE_EQ"
+ "ROOT_MONO_LE" > "HOLLight.hollight.ROOT_MONO_LE"
+ "ROOT_LT_LEMMA" > "HOLLight.hollight.ROOT_LT_LEMMA"
+ "ROOT_LN" > "HOLLight.hollight.ROOT_LN"
+ "ROOT_INV" > "HOLLight.hollight.ROOT_INV"
+ "ROOT_INJ" > "HOLLight.hollight.ROOT_INJ"
+ "ROOT_DIV" > "HOLLight.hollight.ROOT_DIV"
+ "ROOT_1" > "HOLLight.hollight.ROOT_1"
+ "ROOT_0" > "HOLLight.hollight.ROOT_0"
+ "ROLLE" > "HOLLight.hollight.ROLLE"
+ "RIGHT_SUB_DISTRIB" > "Nat.nat_distrib_3"
+ "RIGHT_OR_FORALL_THM" > "HOL.all_simps_4"
+ "RIGHT_OR_EXISTS_THM" > "HOL.ex_simps_4"
+ "RIGHT_OR_DISTRIB" > "HOL.conj_disj_distribR"
+ "RIGHT_IMP_FORALL_THM" > "HOL.all_simps_6"
+ "RIGHT_IMP_EXISTS_THM" > "HOL.ex_simps_6"
+ "RIGHT_FORALL_OR_THM" > "HOL.all_simps_4"
+ "RIGHT_FORALL_IMP_THM" > "HOL.all_simps_6"
+ "RIGHT_EXISTS_IMP_THM" > "HOL.ex_simps_6"
+ "RIGHT_EXISTS_AND_THM" > "HOL.ex_simps_2"
+ "RIGHT_AND_FORALL_THM" > "HOL.all_simps_2"
+ "RIGHT_AND_EXISTS_THM" > "HOL.ex_simps_2"
+ "RIGHT_ADD_DISTRIB" > "Nat.nat_distrib_1"
+ "REVERSE_def" > "HOLLight.hollight.REVERSE_def"
+ "REVERSE_REVERSE" > "HOLLight.hollight.REVERSE_REVERSE"
+ "REVERSE_APPEND" > "HOLLight.hollight.REVERSE_APPEND"
+ "REST_def" > "HOLLight.hollight.REST_def"
+ "REP_ABS_PAIR" > "HOLLightCompat.REP_ABS_PAIR"
+ "REPLICATE_def" > "HOLLight.hollight.REPLICATE_def"
+ "REFL_CLAUSE" > "HOL.simp_thms_6"
+ "RECURSION_CASEWISE_PAIRWISE" > "HOLLight.hollight.RECURSION_CASEWISE_PAIRWISE"
+ "RECURSION_CASEWISE" > "HOLLight.hollight.RECURSION_CASEWISE"
+ "REAL_WLOG_LT" > "HOLLight.hollight.REAL_WLOG_LT"
+ "REAL_WLOG_LE" > "HOLLight.hollight.REAL_WLOG_LE"
+ "REAL_SUP_UBOUND_LE" > "HOLLight.hollight.REAL_SUP_UBOUND_LE"
+ "REAL_SUP_UBOUND" > "HOLLight.hollight.REAL_SUP_UBOUND"
+ "REAL_SUP_LE" > "HOLLight.hollight.REAL_SUP_LE"
+ "REAL_SUP_EXISTS" > "HOLLight.hollight.REAL_SUP_EXISTS"
+ "REAL_SUP" > "HOLLight.hollight.REAL_SUP"
+ "REAL_SUMSQ" > "HOLLight.hollight.REAL_SUMSQ"
+ "REAL_SUB_TRIANGLE" > "HOLLight.hollight.REAL_SUB_TRIANGLE"
+ "REAL_SUB_SUB2" > "HOLLight.hollight.REAL_SUB_SUB2"
+ "REAL_SUB_SUB" > "HOLLight.hollight.REAL_SUB_SUB"
+ "REAL_SUB_RZERO" > "HOLLight.hollight.REAL_SUB_RZERO"
+ "REAL_SUB_RNEG" > "HOLLight.hollight.REAL_SUB_RNEG"
+ "REAL_SUB_REFL" > "HOLLight.hollight.REAL_SUB_REFL"
+ "REAL_SUB_RDISTRIB" > "HOLLight.hollight.REAL_SUB_RDISTRIB"
+ "REAL_SUB_NEG2" > "HOLLight.hollight.REAL_SUB_NEG2"
+ "REAL_SUB_LZERO" > "HOLLight.hollight.REAL_SUB_LZERO"
+ "REAL_SUB_LT" > "HOLLight.hollight.REAL_SUB_LT"
+ "REAL_SUB_LNEG" > "HOLLight.hollight.REAL_SUB_LNEG"
+ "REAL_SUB_LE" > "HOLLight.hollight.REAL_SUB_LE"
+ "REAL_SUB_LDISTRIB" > "HOLLight.hollight.REAL_SUB_LDISTRIB"
+ "REAL_SUB_INV2" > "HOLLight.hollight.REAL_SUB_INV2"
+ "REAL_SUB_INV" > "HOLLight.hollight.REAL_SUB_INV"
+ "REAL_SUB_ADD2" > "HOLLight.hollight.REAL_SUB_ADD2"
+ "REAL_SUB_ADD" > "HOLLight.hollight.REAL_SUB_ADD"
+ "REAL_SUB_ABS" > "HOLLight.hollight.REAL_SUB_ABS"
+ "REAL_SUB_0" > "HOLLight.hollight.REAL_SUB_0"
+ "REAL_RNEG_UNIQ" > "HOLLight.hollight.REAL_RNEG_UNIQ"
+ "REAL_RINV_UNIQ" > "HOLLight.hollight.REAL_RINV_UNIQ"
+ "REAL_RDISTRIB" > "HOLLight.hollight.REAL_RDISTRIB"
+ "REAL_POW_SUB" > "HOLLight.hollight.REAL_POW_SUB"
+ "REAL_POW_POW" > "HOLLight.hollight.REAL_POW_POW"
+ "REAL_POW_ONE" > "HOLLight.hollight.REAL_POW_ONE"
+ "REAL_POW_NZ" > "HOLLight.hollight.REAL_POW_NZ"
+ "REAL_POW_NEG" > "HOLLight.hollight.REAL_POW_NEG"
+ "REAL_POW_MUL" > "HOLLight.hollight.REAL_POW_MUL"
+ "REAL_POW_MONO_LT" > "HOLLight.hollight.REAL_POW_MONO_LT"
+ "REAL_POW_MONO" > "HOLLight.hollight.REAL_POW_MONO"
+ "REAL_POW_LT2" > "HOLLight.hollight.REAL_POW_LT2"
+ "REAL_POW_LT" > "HOLLight.hollight.REAL_POW_LT"
+ "REAL_POW_LE_1" > "HOLLight.hollight.REAL_POW_LE_1"
+ "REAL_POW_LE2" > "HOLLight.hollight.REAL_POW_LE2"
+ "REAL_POW_LE" > "HOLLight.hollight.REAL_POW_LE"
+ "REAL_POW_INV" > "HOLLight.hollight.REAL_POW_INV"
+ "REAL_POW_EQ_0" > "HOLLight.hollight.REAL_POW_EQ_0"
+ "REAL_POW_DIV" > "HOLLight.hollight.REAL_POW_DIV"
+ "REAL_POW_ADD" > "HOLLight.hollight.REAL_POW_ADD"
+ "REAL_POW_2" > "HOLLight.hollight.REAL_POW_2"
+ "REAL_POW_1_LE" > "HOLLight.hollight.REAL_POW_1_LE"
+ "REAL_POW_1" > "HOLLight.hollight.REAL_POW_1"
+ "REAL_POW2_ABS" > "HOLLight.hollight.REAL_POW2_ABS"
+ "REAL_POS_NZ" > "HOLLight.hollight.REAL_POS_NZ"
+ "REAL_POSSQ" > "HOLLight.hollight.REAL_POSSQ"
+ "REAL_POS" > "HOLLight.hollight.REAL_POS"
+ "REAL_POLY_NEG_CLAUSES" > "HOLLight.hollight.REAL_POLY_NEG_CLAUSES"
+ "REAL_POLY_CLAUSES" > "HOLLight.hollight.REAL_POLY_CLAUSES"
+ "REAL_OF_NUM_SUM_NUMSEG" > "HOLLight.hollight.REAL_OF_NUM_SUM_NUMSEG"
+ "REAL_OF_NUM_SUM" > "HOLLight.hollight.REAL_OF_NUM_SUM"
+ "REAL_OF_NUM_SUC" > "HOLLight.hollight.REAL_OF_NUM_SUC"
+ "REAL_OF_NUM_SUB" > "HOLLight.hollight.REAL_OF_NUM_SUB"
+ "REAL_OF_NUM_POW" > "HOLLight.hollight.REAL_OF_NUM_POW"
+ "REAL_OF_NUM_LT" > "HOLLight.hollight.REAL_OF_NUM_LT"
+ "REAL_OF_NUM_GT" > "HOLLight.hollight.REAL_OF_NUM_GT"
+ "REAL_OF_NUM_GE" > "HOLLight.hollight.REAL_OF_NUM_GE"
+ "REAL_NZ_IMP_LT" > "HOLLight.hollight.REAL_NZ_IMP_LT"
+ "REAL_NOT_LT" > "HOLLight.hollight.REAL_NOT_LT"
+ "REAL_NOT_LE" > "HOLLight.hollight.real_lt_def"
+ "REAL_NOT_EQ" > "HOLLight.hollight.REAL_NOT_EQ"
+ "REAL_NEG_SUB" > "HOLLight.hollight.REAL_NEG_SUB"
+ "REAL_NEG_RMUL" > "HOLLight.hollight.REAL_NEG_RMUL"
+ "REAL_NEG_NEG" > "HOLLight.hollight.REAL_NEG_NEG"
+ "REAL_NEG_MUL2" > "HOLLight.hollight.REAL_NEG_MUL2"
+ "REAL_NEG_MINUS1" > "HOLLight.hollight.REAL_NEG_MINUS1"
+ "REAL_NEG_LT0" > "HOLLight.hollight.REAL_NEG_LT0"
+ "REAL_NEG_LMUL" > "HOLLight.hollight.REAL_NEG_LMUL"
+ "REAL_NEG_LE0" > "HOLLight.hollight.REAL_NEG_LE0"
+ "REAL_NEG_INV" > "HOLLight.hollight.REAL_NEG_INV"
+ "REAL_NEG_GT0" > "HOLLight.hollight.REAL_NEG_GT0"
+ "REAL_NEG_GE0" > "HOLLight.hollight.REAL_NEG_GE0"
+ "REAL_NEG_EQ_0" > "HOLLight.hollight.REAL_NEG_EQ_0"
+ "REAL_NEG_EQ0" > "HOLLight.hollight.REAL_NEG_EQ0"
+ "REAL_NEG_EQ" > "HOLLight.hollight.REAL_NEG_EQ"
+ "REAL_NEG_ADD" > "HOLLight.hollight.REAL_NEG_ADD"
+ "REAL_NEG_0" > "HOLLight.hollight.REAL_NEG_0"
+ "REAL_NEGNEG" > "HOLLight.hollight.REAL_NEGNEG"
+ "REAL_MUL_RZERO" > "HOLLight.hollight.REAL_MUL_RZERO"
+ "REAL_MUL_RNEG" > "HOLLight.hollight.REAL_MUL_RNEG"
+ "REAL_MUL_RINV_UNIQ" > "HOLLight.hollight.REAL_MUL_RINV_UNIQ"
+ "REAL_MUL_RINV" > "HOLLight.hollight.REAL_MUL_RINV"
+ "REAL_MUL_RID" > "HOLLight.hollight.REAL_MUL_RID"
+ "REAL_MUL_LZERO" > "HOLLight.hollight.REAL_MUL_LZERO"
+ "REAL_MUL_LNEG" > "HOLLight.hollight.REAL_MUL_LNEG"
+ "REAL_MUL_LINV_UNIQ" > "HOLLight.hollight.REAL_MUL_LINV_UNIQ"
+ "REAL_MUL_AC" > "HOLLight.hollight.REAL_MUL_AC"
+ "REAL_MUL_2" > "HOLLight.hollight.REAL_MUL_2"
+ "REAL_MUL" > "HOLLight.hollight.REAL_MUL"
+ "REAL_MIN_SYM" > "HOLLight.hollight.REAL_MIN_SYM"
+ "REAL_MIN_MIN" > "HOLLight.hollight.REAL_MIN_MIN"
+ "REAL_MIN_MAX" > "HOLLight.hollight.REAL_MIN_MAX"
+ "REAL_MIN_LT" > "HOLLight.hollight.REAL_MIN_LT"
+ "REAL_MIN_LE" > "HOLLight.hollight.REAL_MIN_LE"
+ "REAL_MIN_ASSOC" > "HOLLight.hollight.REAL_MIN_ASSOC"
+ "REAL_MIN_ACI" > "HOLLight.hollight.REAL_MIN_ACI"
+ "REAL_MIDDLE2" > "HOLLight.hollight.REAL_MIDDLE2"
+ "REAL_MIDDLE1" > "HOLLight.hollight.REAL_MIDDLE1"
+ "REAL_MEAN" > "HOLLight.hollight.REAL_MEAN"
+ "REAL_MAX_SYM" > "HOLLight.hollight.REAL_MAX_SYM"
+ "REAL_MAX_MIN" > "HOLLight.hollight.REAL_MAX_MIN"
+ "REAL_MAX_MAX" > "HOLLight.hollight.REAL_MAX_MAX"
+ "REAL_MAX_LT" > "HOLLight.hollight.REAL_MAX_LT"
+ "REAL_MAX_LE" > "HOLLight.hollight.REAL_MAX_LE"
+ "REAL_MAX_ASSOC" > "HOLLight.hollight.REAL_MAX_ASSOC"
+ "REAL_MAX_ACI" > "HOLLight.hollight.REAL_MAX_ACI"
+ "REAL_LT_TRANS" > "HOLLight.hollight.REAL_LT_TRANS"
+ "REAL_LT_TOTAL" > "HOLLight.hollight.REAL_LT_TOTAL"
+ "REAL_LT_SUB_RADD" > "HOLLight.hollight.REAL_LT_SUB_RADD"
+ "REAL_LT_SUB_LADD" > "HOLLight.hollight.REAL_LT_SUB_LADD"
+ "REAL_LT_SQUARE" > "HOLLight.hollight.REAL_LT_SQUARE"
+ "REAL_LT_RNEG" > "HOLLight.hollight.REAL_LT_RNEG"
+ "REAL_LT_RMUL_IMP" > "HOLLight.hollight.REAL_LT_RMUL_IMP"
+ "REAL_LT_RMUL_EQ" > "HOLLight.hollight.REAL_LT_RMUL_EQ"
+ "REAL_LT_RMUL_0" > "HOLLight.hollight.REAL_LT_RMUL_0"
+ "REAL_LT_RMUL" > "HOLLight.hollight.REAL_LT_RMUL"
+ "REAL_LT_REFL" > "HOLLight.hollight.REAL_LT_REFL"
+ "REAL_LT_RDIV_EQ" > "HOLLight.hollight.REAL_LT_RDIV_EQ"
+ "REAL_LT_RDIV_0" > "HOLLight.hollight.REAL_LT_RDIV_0"
+ "REAL_LT_RDIV" > "HOLLight.hollight.REAL_LT_RDIV"
+ "REAL_LT_RCANCEL_IMP" > "HOLLight.hollight.REAL_LT_RCANCEL_IMP"
+ "REAL_LT_RADD" > "HOLLight.hollight.REAL_LT_RADD"
+ "REAL_LT_POW2" > "HOLLight.hollight.REAL_LT_POW2"
+ "REAL_LT_NZ" > "HOLLight.hollight.REAL_LT_NZ"
+ "REAL_LT_NEGTOTAL" > "HOLLight.hollight.REAL_LT_NEGTOTAL"
+ "REAL_LT_NEG2" > "HOLLight.hollight.REAL_LT_NEG2"
+ "REAL_LT_NEG" > "HOLLight.hollight.REAL_LT_NEG"
+ "REAL_LT_MULTIPLE" > "HOLLight.hollight.REAL_LT_MULTIPLE"
+ "REAL_LT_MUL2_ALT" > "HOLLight.hollight.REAL_LT_MUL2_ALT"
+ "REAL_LT_MUL2" > "HOLLight.hollight.REAL_LT_MUL2"
+ "REAL_LT_MUL" > "HOLLight.hollight.REAL_LT_MUL"
+ "REAL_LT_MIN" > "HOLLight.hollight.REAL_LT_MIN"
+ "REAL_LT_MAX" > "HOLLight.hollight.REAL_LT_MAX"
+ "REAL_LT_LNEG" > "HOLLight.hollight.REAL_LT_LNEG"
+ "REAL_LT_LMUL_IMP" > "HOLLight.hollight.REAL_LT_LMUL_IMP"
+ "REAL_LT_LMUL_EQ" > "HOLLight.hollight.REAL_LT_LMUL_EQ"
+ "REAL_LT_LMUL_0" > "HOLLight.hollight.REAL_LT_LMUL_0"
+ "REAL_LT_LMUL" > "HOLLight.hollight.REAL_LT_LMUL"
+ "REAL_LT_LE" > "HOLLight.hollight.REAL_LT_LE"
+ "REAL_LT_LDIV_EQ" > "HOLLight.hollight.REAL_LT_LDIV_EQ"
+ "REAL_LT_LCANCEL_IMP" > "HOLLight.hollight.REAL_LT_LCANCEL_IMP"
+ "REAL_LT_LADD_IMP" > "HOLLight.hollight.REAL_LT_LADD_IMP"
+ "REAL_LT_LADD" > "HOLLight.hollight.REAL_LT_LADD"
+ "REAL_LT_INV_EQ" > "HOLLight.hollight.REAL_LT_INV_EQ"
+ "REAL_LT_INV2" > "HOLLight.hollight.REAL_LT_INV2"
+ "REAL_LT_INV" > "HOLLight.hollight.REAL_LT_INV"
+ "REAL_LT_IMP_NZ" > "HOLLight.hollight.REAL_LT_IMP_NZ"
+ "REAL_LT_IMP_NE" > "HOLLight.hollight.REAL_LT_IMP_NE"
+ "REAL_LT_IMP_LE" > "HOLLight.hollight.REAL_LT_IMP_LE"
+ "REAL_LT_HALF2" > "HOLLight.hollight.REAL_LT_HALF2"
+ "REAL_LT_HALF1" > "HOLLight.hollight.REAL_LT_HALF1"
+ "REAL_LT_GT" > "HOLLight.hollight.REAL_LT_GT"
+ "REAL_LT_FRACTION_0" > "HOLLight.hollight.REAL_LT_FRACTION_0"
+ "REAL_LT_FRACTION" > "HOLLight.hollight.REAL_LT_FRACTION"
+ "REAL_LT_DIV2_EQ" > "HOLLight.hollight.REAL_LT_DIV2_EQ"
+ "REAL_LT_DIV" > "HOLLight.hollight.REAL_LT_DIV"
+ "REAL_LT_ANTISYM" > "HOLLight.hollight.REAL_LT_ANTISYM"
+ "REAL_LT_ADD_SUB" > "HOLLight.hollight.REAL_LT_ADD_SUB"
+ "REAL_LT_ADDR" > "HOLLight.hollight.REAL_LT_ADDR"
+ "REAL_LT_ADDNEG2" > "HOLLight.hollight.REAL_LT_ADDNEG2"
+ "REAL_LT_ADDNEG" > "HOLLight.hollight.REAL_LT_ADDNEG"
+ "REAL_LT_ADDL" > "HOLLight.hollight.REAL_LT_ADDL"
+ "REAL_LT_ADD2" > "HOLLight.hollight.REAL_LT_ADD2"
+ "REAL_LT_ADD1" > "HOLLight.hollight.REAL_LT_ADD1"
+ "REAL_LT_ADD" > "HOLLight.hollight.REAL_LT_ADD"
+ "REAL_LT_1" > "HOLLight.hollight.REAL_LT_1"
+ "REAL_LT_01" > "HOLLight.hollight.REAL_LT_01"
+ "REAL_LTE_TRANS" > "HOLLight.hollight.REAL_LTE_TRANS"
+ "REAL_LTE_TOTAL" > "HOLLight.hollight.REAL_LTE_TOTAL"
+ "REAL_LTE_ANTISYM" > "HOLLight.hollight.REAL_LTE_ANTISYM"
+ "REAL_LTE_ADD2" > "HOLLight.hollight.REAL_LTE_ADD2"
+ "REAL_LTE_ADD" > "HOLLight.hollight.REAL_LTE_ADD"
+ "REAL_LT1_POW2" > "HOLLight.hollight.REAL_LT1_POW2"
+ "REAL_LT" > "HOLLight.hollight.REAL_LT"
+ "REAL_LNEG_UNIQ" > "HOLLight.hollight.REAL_LNEG_UNIQ"
+ "REAL_LINV_UNIQ" > "HOLLight.hollight.REAL_LINV_UNIQ"
+ "REAL_LE_TRANS" > "HOLLight.hollight.REAL_LE_TRANS"
+ "REAL_LE_TOTAL" > "HOLLight.hollight.REAL_LE_TOTAL"
+ "REAL_LE_SUB_RADD" > "HOLLight.hollight.REAL_LE_SUB_RADD"
+ "REAL_LE_SUB_LADD" > "HOLLight.hollight.REAL_LE_SUB_LADD"
+ "REAL_LE_SQUARE_POW" > "HOLLight.hollight.REAL_LE_SQUARE_POW"
+ "REAL_LE_SQUARE_ABS" > "HOLLight.hollight.REAL_LE_SQUARE_ABS"
+ "REAL_LE_SQUARE" > "HOLLight.hollight.REAL_LE_SQUARE"
+ "REAL_LE_RSQRT" > "HOLLight.hollight.REAL_LE_RSQRT"
+ "REAL_LE_RNEG" > "HOLLight.hollight.REAL_LE_RNEG"
+ "REAL_LE_RMUL_IMP" > "HOLLight.hollight.REAL_LE_RMUL_IMP"
+ "REAL_LE_RMUL_EQ" > "HOLLight.hollight.REAL_LE_RMUL_EQ"
+ "REAL_LE_RMUL" > "HOLLight.hollight.REAL_LE_RMUL"
+ "REAL_LE_REFL" > "HOLLight.hollight.REAL_LE_REFL"
+ "REAL_LE_RDIV_EQ" > "HOLLight.hollight.REAL_LE_RDIV_EQ"
+ "REAL_LE_RDIV" > "HOLLight.hollight.REAL_LE_RDIV"
+ "REAL_LE_RCANCEL_IMP" > "HOLLight.hollight.REAL_LE_RCANCEL_IMP"
+ "REAL_LE_RADD" > "HOLLight.hollight.REAL_LE_RADD"
+ "REAL_LE_POW_2" > "HOLLight.hollight.REAL_LE_POW_2"
+ "REAL_LE_POW2" > "HOLLight.hollight.REAL_LE_POW2"
+ "REAL_LE_NEGTOTAL" > "HOLLight.hollight.REAL_LE_NEGTOTAL"
+ "REAL_LE_NEGR" > "HOLLight.hollight.REAL_LE_NEGR"
+ "REAL_LE_NEGL" > "HOLLight.hollight.REAL_LE_NEGL"
+ "REAL_LE_NEG2" > "HOLLight.hollight.REAL_LE_NEG2"
+ "REAL_LE_NEG" > "HOLLight.hollight.REAL_LE_NEG"
+ "REAL_LE_MUL2V" > "HOLLight.hollight.REAL_LE_MUL2V"
+ "REAL_LE_MUL2" > "HOLLight.hollight.REAL_LE_MUL2"
+ "REAL_LE_MUL" > "HOLLight.hollight.REAL_LE_MUL"
+ "REAL_LE_MIN" > "HOLLight.hollight.REAL_LE_MIN"
+ "REAL_LE_MAX" > "HOLLight.hollight.REAL_LE_MAX"
+ "REAL_LE_LT" > "HOLLight.hollight.REAL_LE_LT"
+ "REAL_LE_LSQRT" > "HOLLight.hollight.REAL_LE_LSQRT"
+ "REAL_LE_LNEG" > "HOLLight.hollight.REAL_LE_LNEG"
+ "REAL_LE_LMUL_LOCAL" > "HOLLight.hollight.REAL_LE_LMUL_LOCAL"
+ "REAL_LE_LMUL_IMP" > "HOLLight.hollight.REAL_LE_LMUL_IMP"
+ "REAL_LE_LMUL_EQ" > "HOLLight.hollight.REAL_LE_LMUL_EQ"
+ "REAL_LE_LMUL" > "HOLLight.hollight.REAL_LE_LMUL"
+ "REAL_LE_LDIV_EQ" > "HOLLight.hollight.REAL_LE_LDIV_EQ"
+ "REAL_LE_LDIV" > "HOLLight.hollight.REAL_LE_LDIV"
+ "REAL_LE_LCANCEL_IMP" > "HOLLight.hollight.REAL_LE_LCANCEL_IMP"
+ "REAL_LE_LADD" > "HOLLight.hollight.REAL_LE_LADD"
+ "REAL_LE_INV_EQ" > "HOLLight.hollight.REAL_LE_INV_EQ"
+ "REAL_LE_INV2" > "HOLLight.hollight.REAL_LE_INV2"
+ "REAL_LE_INV" > "HOLLight.hollight.REAL_LE_INV"
+ "REAL_LE_DOUBLE" > "HOLLight.hollight.REAL_LE_DOUBLE"
+ "REAL_LE_DIV2_EQ" > "HOLLight.hollight.REAL_LE_DIV2_EQ"
+ "REAL_LE_DIV" > "HOLLight.hollight.REAL_LE_DIV"
+ "REAL_LE_ANTISYM" > "HOLLight.hollight.REAL_LE_ANTISYM"
+ "REAL_LE_ADDR" > "HOLLight.hollight.REAL_LE_ADDR"
+ "REAL_LE_ADDL" > "HOLLight.hollight.REAL_LE_ADDL"
+ "REAL_LE_ADD2" > "HOLLight.hollight.REAL_LE_ADD2"
+ "REAL_LE_ADD" > "HOLLight.hollight.REAL_LE_ADD"
+ "REAL_LE_01" > "HOLLight.hollight.REAL_LE_01"
+ "REAL_LET_TRANS" > "HOLLight.hollight.REAL_LET_TRANS"
+ "REAL_LET_TOTAL" > "HOLLight.hollight.REAL_LET_TOTAL"
+ "REAL_LET_ANTISYM" > "HOLLight.hollight.REAL_LET_ANTISYM"
+ "REAL_LET_ADD2" > "HOLLight.hollight.REAL_LET_ADD2"
+ "REAL_LET_ADD" > "HOLLight.hollight.REAL_LET_ADD"
+ "REAL_LE1_POW2" > "HOLLight.hollight.REAL_LE1_POW2"
+ "REAL_LE" > "HOLLight.hollight.REAL_LE"
+ "REAL_INV_POS" > "HOLLight.hollight.REAL_INV_POS"
+ "REAL_INV_NZ" > "HOLLight.hollight.REAL_INV_NZ"
+ "REAL_INV_NEG" > "HOLLight.hollight.REAL_INV_NEG"
+ "REAL_INV_MUL_WEAK" > "HOLLight.hollight.REAL_INV_MUL_WEAK"
+ "REAL_INV_MUL" > "HOLLight.hollight.REAL_INV_MUL"
+ "REAL_INV_LT1" > "HOLLight.hollight.REAL_INV_LT1"
+ "REAL_INV_LE_1" > "HOLLight.hollight.REAL_INV_LE_1"
+ "REAL_INV_INV" > "HOLLight.hollight.REAL_INV_INV"
+ "REAL_INV_EQ_0" > "HOLLight.hollight.REAL_INV_EQ_0"
+ "REAL_INV_DIV" > "HOLLight.hollight.REAL_INV_DIV"
+ "REAL_INV_1_LE" > "HOLLight.hollight.REAL_INV_1_LE"
+ "REAL_INV_1OVER" > "HOLLight.hollight.REAL_INV_1OVER"
+ "REAL_INV_1" > "HOLLight.hollight.REAL_INV_1"
+ "REAL_INVINV" > "HOLLight.hollight.REAL_INVINV"
+ "REAL_INV1" > "HOLLight.hollight.REAL_INV1"
+ "REAL_INJ" > "HOLLight.hollight.REAL_INJ"
+ "REAL_HREAL_LEMMA2" > "HOLLight.hollight.REAL_HREAL_LEMMA2"
+ "REAL_HREAL_LEMMA1" > "HOLLight.hollight.REAL_HREAL_LEMMA1"
+ "REAL_HALF_DOUBLE" > "HOLLight.hollight.REAL_HALF_DOUBLE"
+ "REAL_FACT_NZ" > "HOLLight.hollight.REAL_FACT_NZ"
+ "REAL_EXP_TOTAL_LEMMA" > "HOLLight.hollight.REAL_EXP_TOTAL_LEMMA"
+ "REAL_EXP_TOTAL" > "HOLLight.hollight.REAL_EXP_TOTAL"
+ "REAL_EXP_SUB" > "HOLLight.hollight.REAL_EXP_SUB"
+ "REAL_EXP_POS_LT" > "HOLLight.hollight.REAL_EXP_POS_LT"
+ "REAL_EXP_POS_LE" > "HOLLight.hollight.REAL_EXP_POS_LE"
+ "REAL_EXP_NZ" > "HOLLight.hollight.REAL_EXP_NZ"
+ "REAL_EXP_NEG_MUL2" > "HOLLight.hollight.REAL_EXP_NEG_MUL2"
+ "REAL_EXP_NEG_MUL" > "HOLLight.hollight.REAL_EXP_NEG_MUL"
+ "REAL_EXP_NEG" > "HOLLight.hollight.REAL_EXP_NEG"
+ "REAL_EXP_N" > "HOLLight.hollight.REAL_EXP_N"
+ "REAL_EXP_MONO_LT" > "HOLLight.hollight.REAL_EXP_MONO_LT"
+ "REAL_EXP_MONO_LE" > "HOLLight.hollight.REAL_EXP_MONO_LE"
+ "REAL_EXP_MONO_IMP" > "HOLLight.hollight.REAL_EXP_MONO_IMP"
+ "REAL_EXP_LT_1" > "HOLLight.hollight.REAL_EXP_LT_1"
+ "REAL_EXP_LN" > "HOLLight.hollight.REAL_EXP_LN"
+ "REAL_EXP_LE_X" > "HOLLight.hollight.REAL_EXP_LE_X"
+ "REAL_EXP_INJ" > "HOLLight.hollight.REAL_EXP_INJ"
+ "REAL_EXP_FDIFF" > "HOLLight.hollight.REAL_EXP_FDIFF"
+ "REAL_EXP_CONVERGES" > "HOLLight.hollight.REAL_EXP_CONVERGES"
+ "REAL_EXP_BOUND_LEMMA" > "HOLLight.hollight.REAL_EXP_BOUND_LEMMA"
+ "REAL_EXP_ADD_MUL" > "HOLLight.hollight.REAL_EXP_ADD_MUL"
+ "REAL_EXP_ADD" > "HOLLight.hollight.REAL_EXP_ADD"
+ "REAL_EXP_0" > "HOLLight.hollight.REAL_EXP_0"
+ "REAL_EQ_SUB_RADD" > "HOLLight.hollight.REAL_EQ_SUB_RADD"
+ "REAL_EQ_SUB_LADD" > "HOLLight.hollight.REAL_EQ_SUB_LADD"
+ "REAL_EQ_RMUL_IMP" > "HOLLight.hollight.REAL_EQ_RMUL_IMP"
+ "REAL_EQ_RMUL" > "HOLLight.hollight.REAL_EQ_RMUL"
+ "REAL_EQ_RDIV_EQ" > "HOLLight.hollight.REAL_EQ_RDIV_EQ"
+ "REAL_EQ_RCANCEL_IMP" > "HOLLight.hollight.REAL_EQ_RCANCEL_IMP"
+ "REAL_EQ_RADD" > "HOLLight.hollight.REAL_EQ_RADD"
+ "REAL_EQ_NEG2" > "HOLLight.hollight.REAL_EQ_NEG2"
+ "REAL_EQ_NEG" > "HOLLight.hollight.REAL_EQ_NEG"
+ "REAL_EQ_MUL_RCANCEL" > "HOLLight.hollight.REAL_EQ_MUL_RCANCEL"
+ "REAL_EQ_MUL_LCANCEL" > "HOLLight.hollight.REAL_EQ_MUL_LCANCEL"
+ "REAL_EQ_LMUL_IMP" > "HOLLight.hollight.REAL_EQ_LMUL_IMP"
+ "REAL_EQ_LMUL2" > "HOLLight.hollight.REAL_EQ_LMUL2"
+ "REAL_EQ_LMUL" > "HOLLight.hollight.REAL_EQ_LMUL"
+ "REAL_EQ_LDIV_EQ" > "HOLLight.hollight.REAL_EQ_LDIV_EQ"
+ "REAL_EQ_LCANCEL_IMP" > "HOLLight.hollight.REAL_EQ_LCANCEL_IMP"
+ "REAL_EQ_LADD" > "HOLLight.hollight.REAL_EQ_LADD"
+ "REAL_EQ_IMP_LE" > "HOLLight.hollight.REAL_EQ_IMP_LE"
+ "REAL_EQ_ADD_RCANCEL_0" > "HOLLight.hollight.REAL_EQ_ADD_RCANCEL_0"
+ "REAL_EQ_ADD_RCANCEL" > "HOLLight.hollight.REAL_EQ_ADD_RCANCEL"
+ "REAL_EQ_ADD_LCANCEL_0" > "HOLLight.hollight.REAL_EQ_ADD_LCANCEL_0"
+ "REAL_EQ_ADD_LCANCEL" > "HOLLight.hollight.REAL_EQ_ADD_LCANCEL"
+ "REAL_ENTIRE" > "HOLLight.hollight.REAL_ENTIRE"
+ "REAL_DOWN2" > "HOLLight.hollight.REAL_DOWN2"
+ "REAL_DOWN" > "HOLLight.hollight.REAL_DOWN"
+ "REAL_DOUBLE" > "HOLLight.hollight.REAL_DOUBLE"
+ "REAL_DIV_SQRT" > "HOLLight.hollight.REAL_DIV_SQRT"
+ "REAL_DIV_RMUL" > "HOLLight.hollight.REAL_DIV_RMUL"
+ "REAL_DIV_REFL" > "HOLLight.hollight.REAL_DIV_REFL"
+ "REAL_DIV_POW2_ALT" > "HOLLight.hollight.REAL_DIV_POW2_ALT"
+ "REAL_DIV_POW2" > "HOLLight.hollight.REAL_DIV_POW2"
+ "REAL_DIV_MUL2" > "HOLLight.hollight.REAL_DIV_MUL2"
+ "REAL_DIV_LZERO" > "HOLLight.hollight.REAL_DIV_LZERO"
+ "REAL_DIV_LMUL" > "HOLLight.hollight.REAL_DIV_LMUL"
+ "REAL_DIV_1" > "HOLLight.hollight.REAL_DIV_1"
+ "REAL_DIFFSQ" > "HOLLight.hollight.REAL_DIFFSQ"
+ "REAL_COMPLETE_SOMEPOS" > "HOLLight.hollight.REAL_COMPLETE_SOMEPOS"
+ "REAL_COMPLETE" > "HOLLight.hollight.REAL_COMPLETE"
+ "REAL_ATN_POWSER_SUMMABLE" > "HOLLight.hollight.REAL_ATN_POWSER_SUMMABLE"
+ "REAL_ATN_POWSER_DIFFS_SUMMABLE" > "HOLLight.hollight.REAL_ATN_POWSER_DIFFS_SUMMABLE"
+ "REAL_ATN_POWSER_DIFFS_SUM" > "HOLLight.hollight.REAL_ATN_POWSER_DIFFS_SUM"
+ "REAL_ATN_POWSER_DIFFS_DIFFS_SUMMABLE" > "HOLLight.hollight.REAL_ATN_POWSER_DIFFS_DIFFS_SUMMABLE"
+ "REAL_ATN_POWSER_DIFFL" > "HOLLight.hollight.REAL_ATN_POWSER_DIFFL"
+ "REAL_ATN_POWSER" > "HOLLight.hollight.REAL_ATN_POWSER"
+ "REAL_ARCH_SIMPLE" > "HOLLight.hollight.REAL_ARCH_SIMPLE"
+ "REAL_ARCH_LEAST" > "HOLLight.hollight.REAL_ARCH_LEAST"
+ "REAL_ARCH" > "HOLLight.hollight.REAL_ARCH"
+ "REAL_ADD_SUB2" > "HOLLight.hollight.REAL_ADD_SUB2"
+ "REAL_ADD_SUB" > "HOLLight.hollight.REAL_ADD_SUB"
+ "REAL_ADD_RINV" > "HOLLight.hollight.REAL_ADD_RINV"
+ "REAL_ADD_RID_UNIQ" > "HOLLight.hollight.REAL_ADD_RID_UNIQ"
+ "REAL_ADD_RID" > "HOLLight.hollight.REAL_ADD_RID"
+ "REAL_ADD_RDISTRIB" > "HOLLight.hollight.REAL_ADD_RDISTRIB"
+ "REAL_ADD_LID_UNIQ" > "HOLLight.hollight.REAL_ADD_LID_UNIQ"
+ "REAL_ADD_AC" > "HOLLight.hollight.REAL_ADD_AC"
+ "REAL_ADD2_SUB2" > "HOLLight.hollight.REAL_ADD2_SUB2"
+ "REAL_ADD" > "HOLLight.hollight.REAL_ADD"
+ "REAL_ABS_ZERO" > "HOLLight.hollight.REAL_ABS_ZERO"
+ "REAL_ABS_TRIANGLE_LT" > "HOLLight.hollight.REAL_ABS_TRIANGLE_LT"
+ "REAL_ABS_TRIANGLE_LE" > "HOLLight.hollight.REAL_ABS_TRIANGLE_LE"
+ "REAL_ABS_TRIANGLE" > "HOLLight.hollight.REAL_ABS_TRIANGLE"
+ "REAL_ABS_SUB_ABS" > "HOLLight.hollight.REAL_ABS_SUB_ABS"
+ "REAL_ABS_SUB" > "HOLLight.hollight.REAL_ABS_SUB"
+ "REAL_ABS_STILLNZ" > "HOLLight.hollight.REAL_ABS_STILLNZ"
+ "REAL_ABS_SIGN2" > "HOLLight.hollight.REAL_ABS_SIGN2"
+ "REAL_ABS_SIGN" > "HOLLight.hollight.REAL_ABS_SIGN"
+ "REAL_ABS_REFL" > "HOLLight.hollight.REAL_ABS_REFL"
+ "REAL_ABS_POW" > "HOLLight.hollight.REAL_ABS_POW"
+ "REAL_ABS_POS" > "HOLLight.hollight.REAL_ABS_POS"
+ "REAL_ABS_NZ" > "HOLLight.hollight.REAL_ABS_NZ"
+ "REAL_ABS_NUM" > "HOLLight.hollight.REAL_ABS_NUM"
+ "REAL_ABS_NEG" > "HOLLight.hollight.REAL_ABS_NEG"
+ "REAL_ABS_MUL" > "HOLLight.hollight.REAL_ABS_MUL"
+ "REAL_ABS_LE" > "HOLLight.hollight.REAL_ABS_LE"
+ "REAL_ABS_INV" > "HOLLight.hollight.REAL_ABS_INV"
+ "REAL_ABS_DIV" > "HOLLight.hollight.REAL_ABS_DIV"
+ "REAL_ABS_CIRCLE" > "HOLLight.hollight.REAL_ABS_CIRCLE"
+ "REAL_ABS_CASES" > "HOLLight.hollight.REAL_ABS_CASES"
+ "REAL_ABS_BOUNDS" > "HOLLight.hollight.REAL_ABS_BOUNDS"
+ "REAL_ABS_BOUND" > "HOLLight.hollight.REAL_ABS_BOUND"
+ "REAL_ABS_BETWEEN2" > "HOLLight.hollight.REAL_ABS_BETWEEN2"
+ "REAL_ABS_BETWEEN1" > "HOLLight.hollight.REAL_ABS_BETWEEN1"
+ "REAL_ABS_BETWEEN" > "HOLLight.hollight.REAL_ABS_BETWEEN"
+ "REAL_ABS_ABS" > "HOLLight.hollight.REAL_ABS_ABS"
+ "REAL_ABS_1" > "HOLLight.hollight.REAL_ABS_1"
+ "REAL_ABS_0" > "HOLLight.hollight.REAL_ABS_0"
+ "REAL" > "HOLLight.hollight.REAL"
+ "RAT_LEMMA5" > "HOLLight.hollight.RAT_LEMMA5"
+ "RAT_LEMMA4" > "HOLLight.hollight.RAT_LEMMA4"
+ "RAT_LEMMA3" > "HOLLight.hollight.RAT_LEMMA3"
+ "RAT_LEMMA2" > "HOLLight.hollight.RAT_LEMMA2"
+ "RAT_LEMMA1" > "HOLLight.hollight.RAT_LEMMA1"
+ "PSUM_SUM_NUMSEG" > "HOLLight.hollight.PSUM_SUM_NUMSEG"
+ "PSUM_SUM" > "HOLLight.hollight.PSUM_SUM"
+ "PSUBSET_def" > "HOLLight.hollight.PSUBSET_def"
+ "PSUBSET_UNIV" > "HOLLight.hollight.PSUBSET_UNIV"
+ "PSUBSET_TRANS" > "HOLLight.hollight.PSUBSET_TRANS"
+ "PSUBSET_SUBSET_TRANS" > "HOLLight.hollight.PSUBSET_SUBSET_TRANS"
+ "PSUBSET_MEMBER" > "HOLLight.hollight.PSUBSET_MEMBER"
+ "PSUBSET_IRREFL" > "HOLLight.hollight.PSUBSET_IRREFL"
+ "PSUBSET_INSERT_SUBSET" > "HOLLight.hollight.PSUBSET_INSERT_SUBSET"
+ "PRE_ELIM_THM" > "HOLLight.hollight.PRE_ELIM_THM"
+ "POW_ZERO_EQ" > "HOLLight.hollight.POW_ZERO_EQ"
+ "POW_ZERO" > "HOLLight.hollight.POW_ZERO"
+ "POW_ROOT_POS" > "HOLLight.hollight.POW_ROOT_POS"
+ "POW_POS_LT" > "HOLLight.hollight.POW_POS_LT"
+ "POW_POS" > "HOLLight.hollight.POW_POS"
+ "POW_PLUS1" > "HOLLight.hollight.POW_PLUS1"
+ "POW_NZ" > "HOLLight.hollight.POW_NZ"
+ "POW_MUL" > "HOLLight.hollight.POW_MUL"
+ "POW_MINUS1" > "HOLLight.hollight.POW_MINUS1"
+ "POW_M1" > "HOLLight.hollight.POW_M1"
+ "POW_LT" > "HOLLight.hollight.POW_LT"
+ "POW_LE" > "HOLLight.hollight.POW_LE"
+ "POW_INV" > "HOLLight.hollight.POW_INV"
+ "POW_EQ" > "HOLLight.hollight.POW_EQ"
+ "POW_ADD" > "HOLLight.hollight.POW_ADD"
+ "POW_ABS" > "HOLLight.hollight.POW_ABS"
+ "POW_2_SQRT_ABS" > "HOLLight.hollight.POW_2_SQRT_ABS"
+ "POW_2_SQRT" > "HOLLight.hollight.POW_2_SQRT"
+ "POW_2_LT" > "HOLLight.hollight.POW_2_LT"
+ "POW_2_LE1" > "HOLLight.hollight.POW_2_LE1"
+ "POW_2" > "HOLLight.hollight.POW_2"
+ "POW_1" > "HOLLight.hollight.POW_1"
+ "POW_0" > "HOLLight.hollight.POW_0"
+ "POWSER_LIMIT_0_STRONG" > "HOLLight.hollight.POWSER_LIMIT_0_STRONG"
+ "POWSER_LIMIT_0" > "HOLLight.hollight.POWSER_LIMIT_0"
+ "POWSER_INSIDEA" > "HOLLight.hollight.POWSER_INSIDEA"
+ "POWSER_INSIDE" > "HOLLight.hollight.POWSER_INSIDE"
+ "POWSER_EQUAL_0" > "HOLLight.hollight.POWSER_EQUAL_0"
+ "POWSER_EQUAL" > "HOLLight.hollight.POWSER_EQUAL"
+ "POWSER_0" > "HOLLight.hollight.POWSER_0"
+ "POWREV" > "HOLLight.hollight.POWREV"
+ "POWDIFF_LEMMA" > "HOLLight.hollight.POWDIFF_LEMMA"
+ "POWDIFF" > "HOLLight.hollight.POWDIFF"
+ "PI_POS" > "HOLLight.hollight.PI_POS"
+ "PI2_PI4" > "HOLLight.hollight.PI2_PI4"
+ "PI2_BOUNDS" > "HOLLight.hollight.PI2_BOUNDS"
+ "PI2" > "HOLLight.hollight.PI2"
+ "PASTECART_FST_SND" > "HOLLight.hollight.PASTECART_FST_SND"
+ "PASTECART_EQ" > "HOLLight.hollight.PASTECART_EQ"
+ "PASSOC_def" > "HOLLight.hollight.PASSOC_def"
+ "PAIR_SURJECTIVE" > "Datatype.prod.nchotomy"
+ "PAIR_EXISTS_THM" > "HOLLight.hollight.PAIR_EXISTS_THM"
+ "PAIR_EQ" > "Datatype.prod.simps_1"
+ "PAIRWISE_def" > "HOLLight.hollight.PAIRWISE_def"
+ "PAIR" > "HOL4Compat.PAIR"
+ "OUTR_def" > "HOLLight.hollight.OUTR_def"
+ "OUTL_def" > "HOLLight.hollight.OUTL_def"
+ "OR_EXISTS_THM" > "HOL.ex_disj_distrib"
+ "OR_CLAUSES" > "HOLLight.hollight.OR_CLAUSES"
+ "OPEN_UNOPEN" > "HOLLight.hollight.OPEN_UNOPEN"
+ "OPEN_SUBOPEN" > "HOLLight.hollight.OPEN_SUBOPEN"
+ "OPEN_OWN_NEIGH" > "HOLLight.hollight.OPEN_OWN_NEIGH"
+ "OPEN_NEIGH" > "HOLLight.hollight.OPEN_NEIGH"
+ "ONE" > "HOLLight.hollight.ONE"
+ "ODD_def" > "HOLLight.hollight.ODD_def"
+ "ODD_MULT" > "HOLLight.hollight.ODD_MULT"
+ "ODD_MOD" > "HOLLight.hollight.ODD_MOD"
+ "ODD_EXP" > "HOLLight.hollight.ODD_EXP"
+ "ODD_EXISTS" > "HOLLight.hollight.ODD_EXISTS"
+ "ODD_DOUBLE" > "HOLLight.hollight.ODD_DOUBLE"
+ "ODD_ADD" > "HOLLight.hollight.ODD_ADD"
+ "NUM_INTEGRAL_LEMMA" > "HOLLight.hollight.NUM_INTEGRAL_LEMMA"
+ "NUM_INTEGRAL" > "HOLLight.hollight.NUM_INTEGRAL"
+ "NUMSUM_def" > "HOLLight.hollight.NUMSUM_def"
+ "NUMSUM_INJ" > "HOLLight.hollight.NUMSUM_INJ"
+ "NUMSND_def" > "HOLLight.hollight.NUMSND_def"
+ "NUMSEG_SING" > "HOLLight.hollight.NUMSEG_SING"
+ "NUMSEG_RREC" > "HOLLight.hollight.NUMSEG_RREC"
+ "NUMSEG_REC" > "HOLLight.hollight.NUMSEG_REC"
+ "NUMSEG_OFFSET_IMAGE" > "HOLLight.hollight.NUMSEG_OFFSET_IMAGE"
+ "NUMSEG_LREC" > "HOLLight.hollight.NUMSEG_LREC"
+ "NUMSEG_EMPTY" > "HOLLight.hollight.NUMSEG_EMPTY"
+ "NUMSEG_COMBINE_R" > "HOLLight.hollight.NUMSEG_COMBINE_R"
+ "NUMSEG_COMBINE_L" > "HOLLight.hollight.NUMSEG_COMBINE_L"
+ "NUMSEG_CLAUSES" > "HOLLight.hollight.NUMSEG_CLAUSES"
+ "NUMSEG_ADD_SPLIT" > "HOLLight.hollight.NUMSEG_ADD_SPLIT"
+ "NUMRIGHT_def" > "HOLLight.hollight.NUMRIGHT_def"
+ "NUMPAIR_def" > "HOLLight.hollight.NUMPAIR_def"
+ "NUMPAIR_INJ_LEMMA" > "HOLLight.hollight.NUMPAIR_INJ_LEMMA"
+ "NUMPAIR_INJ" > "HOLLight.hollight.NUMPAIR_INJ"
+ "NUMLEFT_def" > "HOLLight.hollight.NUMLEFT_def"
+ "NUMFST_def" > "HOLLight.hollight.NUMFST_def"
+ "NULL_def" > "HOLLight.hollight.NULL_def"
+ "NSUM_UNION_RZERO" > "HOLLight.hollight.NSUM_UNION_RZERO"
+ "NSUM_UNION_LZERO" > "HOLLight.hollight.NSUM_UNION_LZERO"
+ "NSUM_UNION_EQ" > "HOLLight.hollight.NSUM_UNION_EQ"
+ "NSUM_UNION" > "HOLLight.hollight.NSUM_UNION"
+ "NSUM_TRIV_NUMSEG" > "HOLLight.hollight.NSUM_TRIV_NUMSEG"
+ "NSUM_SWAP_NUMSEG" > "HOLLight.hollight.NSUM_SWAP_NUMSEG"
+ "NSUM_SWAP" > "HOLLight.hollight.NSUM_SWAP"
+ "NSUM_SUPPORT" > "HOLLight.hollight.NSUM_SUPPORT"
+ "NSUM_SUPERSET" > "HOLLight.hollight.NSUM_SUPERSET"
+ "NSUM_SUBSET_SIMPLE" > "HOLLight.hollight.NSUM_SUBSET_SIMPLE"
+ "NSUM_SUBSET" > "HOLLight.hollight.NSUM_SUBSET"
+ "NSUM_SING_NUMSEG" > "HOLLight.hollight.NSUM_SING_NUMSEG"
+ "NSUM_SING" > "HOLLight.hollight.NSUM_SING"
+ "NSUM_RESTRICT_SET" > "HOLLight.hollight.NSUM_RESTRICT_SET"
+ "NSUM_RESTRICT" > "HOLLight.hollight.NSUM_RESTRICT"
+ "NSUM_POS_LE_NUMSEG" > "HOLLight.hollight.NSUM_POS_LE_NUMSEG"
+ "NSUM_POS_LE" > "HOLLight.hollight.NSUM_POS_LE"
+ "NSUM_POS_EQ_0_NUMSEG" > "HOLLight.hollight.NSUM_POS_EQ_0_NUMSEG"
+ "NSUM_POS_EQ_0" > "HOLLight.hollight.NSUM_POS_EQ_0"
+ "NSUM_POS_BOUND" > "HOLLight.hollight.NSUM_POS_BOUND"
+ "NSUM_OFFSET_0" > "HOLLight.hollight.NSUM_OFFSET_0"
+ "NSUM_OFFSET" > "HOLLight.hollight.NSUM_OFFSET"
+ "NSUM_NSUM_RESTRICT" > "HOLLight.hollight.NSUM_NSUM_RESTRICT"
+ "NSUM_MULTICOUNT_GEN" > "HOLLight.hollight.NSUM_MULTICOUNT_GEN"
+ "NSUM_MULTICOUNT" > "HOLLight.hollight.NSUM_MULTICOUNT"
+ "NSUM_LT_ALL" > "HOLLight.hollight.NSUM_LT_ALL"
+ "NSUM_LT" > "HOLLight.hollight.NSUM_LT"
+ "NSUM_LE_NUMSEG" > "HOLLight.hollight.NSUM_LE_NUMSEG"
+ "NSUM_LE" > "HOLLight.hollight.NSUM_LE"
+ "NSUM_IMAGE_GEN" > "HOLLight.hollight.NSUM_IMAGE_GEN"
+ "NSUM_IMAGE" > "HOLLight.hollight.NSUM_IMAGE"
+ "NSUM_EQ_SUPERSET" > "HOLLight.hollight.NSUM_EQ_SUPERSET"
+ "NSUM_EQ_NUMSEG" > "HOLLight.hollight.NSUM_EQ_NUMSEG"
+ "NSUM_EQ_0_NUMSEG" > "HOLLight.hollight.NSUM_EQ_0_NUMSEG"
+ "NSUM_EQ_0" > "HOLLight.hollight.NSUM_EQ_0"
+ "NSUM_EQ" > "HOLLight.hollight.NSUM_EQ"
+ "NSUM_DIFF" > "HOLLight.hollight.NSUM_DIFF"
+ "NSUM_DELTA" > "HOLLight.hollight.NSUM_DELTA"
+ "NSUM_CONST_NUMSEG" > "HOLLight.hollight.NSUM_CONST_NUMSEG"
+ "NSUM_CONST" > "HOLLight.hollight.NSUM_CONST"
+ "NSUM_CMUL_NUMSEG" > "HOLLight.hollight.NSUM_CMUL_NUMSEG"
+ "NSUM_CMUL" > "HOLLight.hollight.NSUM_CMUL"
+ "NSUM_CLAUSES_RIGHT" > "HOLLight.hollight.NSUM_CLAUSES_RIGHT"
+ "NSUM_CLAUSES_NUMSEG" > "HOLLight.hollight.NSUM_CLAUSES_NUMSEG"
+ "NSUM_CLAUSES_LEFT" > "HOLLight.hollight.NSUM_CLAUSES_LEFT"
+ "NSUM_CLAUSES" > "HOLLight.hollight.NSUM_CLAUSES"
+ "NSUM_BOUND_LT_GEN" > "HOLLight.hollight.NSUM_BOUND_LT_GEN"
+ "NSUM_BOUND_LT_ALL" > "HOLLight.hollight.NSUM_BOUND_LT_ALL"
+ "NSUM_BOUND_LT" > "HOLLight.hollight.NSUM_BOUND_LT"
+ "NSUM_BOUND_GEN" > "HOLLight.hollight.NSUM_BOUND_GEN"
+ "NSUM_BOUND" > "HOLLight.hollight.NSUM_BOUND"
+ "NSUM_ADD_SPLIT" > "HOLLight.hollight.NSUM_ADD_SPLIT"
+ "NSUM_ADD_NUMSEG" > "HOLLight.hollight.NSUM_ADD_NUMSEG"
+ "NSUM_ADD" > "HOLLight.hollight.NSUM_ADD"
+ "NSUM_0" > "HOLLight.hollight.NSUM_0"
+ "NOT_UNIV_PSUBSET" > "HOLLight.hollight.NOT_UNIV_PSUBSET"
+ "NOT_SUC" > "Nat.nat.simps_1"
+ "NOT_PSUBSET_EMPTY" > "HOLLight.hollight.NOT_PSUBSET_EMPTY"
+ "NOT_ODD" > "HOLLight.hollight.NOT_ODD"
+ "NOT_LT" > "HOLLight.hollight.NOT_LT"
+ "NOT_LE" > "HOLLight.hollight.NOT_LE"
+ "NOT_IN_EMPTY" > "HOLLight.hollight.NOT_IN_EMPTY"
+ "NOT_INSERT_EMPTY" > "HOLLight.hollight.NOT_INSERT_EMPTY"
+ "NOT_FORALL_THM" > "Inductive.basic_monos_15"
+ "NOT_EXISTS_THM" > "Inductive.basic_monos_16"
+ "NOT_EX" > "HOLLight.hollight.NOT_EX"
+ "NOT_EVEN" > "HOLLight.hollight.NOT_EVEN"
+ "NOT_EQUAL_SETS" > "HOLLight.hollight.NOT_EQUAL_SETS"
+ "NOT_EMPTY_INSERT" > "HOLLight.hollight.NOT_EMPTY_INSERT"
+ "NOT_CONS_NIL" > "HOLLight.hollight.NOT_CONS_NIL"
+ "NOT_CLAUSES_WEAK" > "HOLLight.hollight.NOT_CLAUSES_WEAK"
+ "NOT_ALL" > "HOLLight.hollight.NOT_ALL"
+ "NONE_def" > "HOLLight.hollight.NONE_def"
+ "NIL_def" > "HOLLight.hollight.NIL_def"
+ "NEUTRAL_REAL_MUL" > "HOLLight.hollight.NEUTRAL_REAL_MUL"
+ "NEUTRAL_REAL_ADD" > "HOLLight.hollight.NEUTRAL_REAL_ADD"
+ "NEUTRAL_MUL" > "HOLLight.hollight.NEUTRAL_MUL"
+ "NEUTRAL_ADD" > "HOLLight.hollight.NEUTRAL_ADD"
+ "NET_SUM" > "HOLLight.hollight.NET_SUM"
+ "NET_SUB" > "HOLLight.hollight.NET_SUB"
+ "NET_NULL_MUL" > "HOLLight.hollight.NET_NULL_MUL"
+ "NET_NULL_CMUL" > "HOLLight.hollight.NET_NULL_CMUL"
+ "NET_NULL_ADD" > "HOLLight.hollight.NET_NULL_ADD"
+ "NET_NULL" > "HOLLight.hollight.NET_NULL"
+ "NET_NEG" > "HOLLight.hollight.NET_NEG"
+ "NET_MUL" > "HOLLight.hollight.NET_MUL"
+ "NET_LE" > "HOLLight.hollight.NET_LE"
+ "NET_INV" > "HOLLight.hollight.NET_INV"
+ "NET_DIV" > "HOLLight.hollight.NET_DIV"
+ "NET_CONV_NZ" > "HOLLight.hollight.NET_CONV_NZ"
+ "NET_CONV_IBOUNDED" > "HOLLight.hollight.NET_CONV_IBOUNDED"
+ "NET_CONV_BOUNDED" > "HOLLight.hollight.NET_CONV_BOUNDED"
+ "NET_ADD" > "HOLLight.hollight.NET_ADD"
+ "NET_ABS" > "HOLLight.hollight.NET_ABS"
+ "NEST_LEMMA_UNIQ" > "HOLLight.hollight.NEST_LEMMA_UNIQ"
+ "NEST_LEMMA" > "HOLLight.hollight.NEST_LEMMA"
+ "NADD_UBOUND" > "HOLLight.hollight.NADD_UBOUND"
+ "NADD_SUC" > "HOLLight.hollight.NADD_SUC"
+ "NADD_RDISTRIB" > "HOLLight.hollight.NADD_RDISTRIB"
+ "NADD_OF_NUM_WELLDEF" > "HOLLight.hollight.NADD_OF_NUM_WELLDEF"
+ "NADD_OF_NUM_MUL" > "HOLLight.hollight.NADD_OF_NUM_MUL"
+ "NADD_OF_NUM_LE" > "HOLLight.hollight.NADD_OF_NUM_LE"
+ "NADD_OF_NUM_EQ" > "HOLLight.hollight.NADD_OF_NUM_EQ"
+ "NADD_OF_NUM_ADD" > "HOLLight.hollight.NADD_OF_NUM_ADD"
+ "NADD_OF_NUM" > "HOLLight.hollight.NADD_OF_NUM"
+ "NADD_NONZERO" > "HOLLight.hollight.NADD_NONZERO"
+ "NADD_MUL_WELLDEF_LEMMA" > "HOLLight.hollight.NADD_MUL_WELLDEF_LEMMA"
+ "NADD_MUL_WELLDEF" > "HOLLight.hollight.NADD_MUL_WELLDEF"
+ "NADD_MUL_SYM" > "HOLLight.hollight.NADD_MUL_SYM"
+ "NADD_MUL_LINV_LEMMA8" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA8"
+ "NADD_MUL_LINV_LEMMA7a" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA7a"
+ "NADD_MUL_LINV_LEMMA7" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA7"
+ "NADD_MUL_LINV_LEMMA6" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA6"
+ "NADD_MUL_LINV_LEMMA5" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA5"
+ "NADD_MUL_LINV_LEMMA4" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA4"
+ "NADD_MUL_LINV_LEMMA3" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA3"
+ "NADD_MUL_LINV_LEMMA2" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA2"
+ "NADD_MUL_LINV_LEMMA1" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA1"
+ "NADD_MUL_LINV_LEMMA0" > "HOLLight.hollight.NADD_MUL_LINV_LEMMA0"
+ "NADD_MUL_LINV" > "HOLLight.hollight.NADD_MUL_LINV"
+ "NADD_MUL_LID" > "HOLLight.hollight.NADD_MUL_LID"
+ "NADD_MUL_ASSOC" > "HOLLight.hollight.NADD_MUL_ASSOC"
+ "NADD_MULTIPLICATIVE" > "HOLLight.hollight.NADD_MULTIPLICATIVE"
+ "NADD_MUL" > "HOLLight.hollight.NADD_MUL"
+ "NADD_LE_WELLDEF_LEMMA" > "HOLLight.hollight.NADD_LE_WELLDEF_LEMMA"
+ "NADD_LE_WELLDEF" > "HOLLight.hollight.NADD_LE_WELLDEF"
+ "NADD_LE_TRANS" > "HOLLight.hollight.NADD_LE_TRANS"
+ "NADD_LE_TOTAL_LEMMA" > "HOLLight.hollight.NADD_LE_TOTAL_LEMMA"
+ "NADD_LE_TOTAL" > "HOLLight.hollight.NADD_LE_TOTAL"
+ "NADD_LE_RMUL" > "HOLLight.hollight.NADD_LE_RMUL"
+ "NADD_LE_REFL" > "HOLLight.hollight.NADD_LE_REFL"
+ "NADD_LE_RADD" > "HOLLight.hollight.NADD_LE_RADD"
+ "NADD_LE_LMUL" > "HOLLight.hollight.NADD_LE_LMUL"
+ "NADD_LE_LADD" > "HOLLight.hollight.NADD_LE_LADD"
+ "NADD_LE_EXISTS" > "HOLLight.hollight.NADD_LE_EXISTS"
+ "NADD_LE_ANTISYM" > "HOLLight.hollight.NADD_LE_ANTISYM"
+ "NADD_LE_ADD" > "HOLLight.hollight.NADD_LE_ADD"
+ "NADD_LE_0" > "HOLLight.hollight.NADD_LE_0"
+ "NADD_LDISTRIB" > "HOLLight.hollight.NADD_LDISTRIB"
+ "NADD_LBOUND" > "HOLLight.hollight.NADD_LBOUND"
+ "NADD_INV_WELLDEF" > "HOLLight.hollight.NADD_INV_WELLDEF"
+ "NADD_INV_0" > "HOLLight.hollight.NADD_INV_0"
+ "NADD_INV" > "HOLLight.hollight.NADD_INV"
+ "NADD_EQ_TRANS" > "HOLLight.hollight.NADD_EQ_TRANS"
+ "NADD_EQ_SYM" > "HOLLight.hollight.NADD_EQ_SYM"
+ "NADD_EQ_REFL" > "HOLLight.hollight.NADD_EQ_REFL"
+ "NADD_EQ_IMP_LE" > "HOLLight.hollight.NADD_EQ_IMP_LE"
+ "NADD_DIST_LEMMA" > "HOLLight.hollight.NADD_DIST_LEMMA"
+ "NADD_DIST" > "HOLLight.hollight.NADD_DIST"
+ "NADD_COMPLETE" > "HOLLight.hollight.NADD_COMPLETE"
+ "NADD_CAUCHY" > "HOLLight.hollight.NADD_CAUCHY"
+ "NADD_BOUND" > "HOLLight.hollight.NADD_BOUND"
+ "NADD_ARCH_ZERO" > "HOLLight.hollight.NADD_ARCH_ZERO"
+ "NADD_ARCH_MULT" > "HOLLight.hollight.NADD_ARCH_MULT"
+ "NADD_ARCH_LEMMA" > "HOLLight.hollight.NADD_ARCH_LEMMA"
+ "NADD_ARCH" > "HOLLight.hollight.NADD_ARCH"
+ "NADD_ALTMUL" > "HOLLight.hollight.NADD_ALTMUL"
+ "NADD_ADD_WELLDEF" > "HOLLight.hollight.NADD_ADD_WELLDEF"
+ "NADD_ADD_SYM" > "HOLLight.hollight.NADD_ADD_SYM"
+ "NADD_ADD_LID" > "HOLLight.hollight.NADD_ADD_LID"
+ "NADD_ADD_LCANCEL" > "HOLLight.hollight.NADD_ADD_LCANCEL"
+ "NADD_ADD_ASSOC" > "HOLLight.hollight.NADD_ADD_ASSOC"
+ "NADD_ADDITIVE" > "HOLLight.hollight.NADD_ADDITIVE"
+ "NADD_ADD" > "HOLLight.hollight.NADD_ADD"
+ "MVT_LEMMA" > "HOLLight.hollight.MVT_LEMMA"
+ "MVT_ALT" > "HOLLight.hollight.MVT_ALT"
+ "MVT" > "HOLLight.hollight.MVT"
+ "MULT_SYM" > "IntDef.zmult_ac_2"
+ "MULT_SUC" > "Nat.mult_Suc_right"
+ "MULT_EXP" > "HOLLight.hollight.MULT_EXP"
+ "MULT_EQ_1" > "HOLLight.hollight.MULT_EQ_1"
+ "MULT_EQ_0" > "Nat.mult_is_0"
+ "MULT_DIV_2" > "HOLLight.hollight.MULT_DIV_2"
+ "MULT_CLAUSES" > "HOLLight.hollight.MULT_CLAUSES"
+ "MULT_ASSOC" > "IntDef.zmult_ac_1"
+ "MULT_AC" > "HOLLight.hollight.MULT_AC"
+ "MULT_2" > "HOLLight.hollight.MULT_2"
+ "MULT_0" > "Nat.mult_0_right"
+ "MTOP_TENDS_UNIQ" > "HOLLight.hollight.MTOP_TENDS_UNIQ"
+ "MTOP_TENDS" > "HOLLight.hollight.MTOP_TENDS"
+ "MTOP_OPEN" > "HOLLight.hollight.MTOP_OPEN"
+ "MTOP_LIMPT" > "HOLLight.hollight.MTOP_LIMPT"
+ "MR1_SUB_LT" > "HOLLight.hollight.MR1_SUB_LT"
+ "MR1_SUB_LE" > "HOLLight.hollight.MR1_SUB_LE"
+ "MR1_SUB" > "HOLLight.hollight.MR1_SUB"
+ "MR1_LIMPT" > "HOLLight.hollight.MR1_LIMPT"
+ "MR1_DEF" > "HOLLight.hollight.MR1_DEF"
+ "MR1_BOUNDED" > "HOLLight.hollight.MR1_BOUNDED"
+ "MR1_BETWEEN1" > "HOLLight.hollight.MR1_BETWEEN1"
+ "MR1_ADD_LT" > "HOLLight.hollight.MR1_ADD_LT"
+ "MR1_ADD_LE" > "HOLLight.hollight.MR1_ADD_LE"
+ "MR1_ADD" > "HOLLight.hollight.MR1_ADD"
+ "MONO_SUC" > "HOLLight.hollight.MONO_SUC"
+ "MONO_FORALL" > "Inductive.basic_monos_6"
+ "MONO_EXISTS" > "Inductive.basic_monos_5"
+ "MONO_COND" > "HOLLight.hollight.MONO_COND"
+ "MONO_ALL2" > "HOLLight.hollight.MONO_ALL2"
+ "MONO_ALL" > "HOLLight.hollight.MONO_ALL"
+ "MONOIDAL_REAL_MUL" > "HOLLight.hollight.MONOIDAL_REAL_MUL"
+ "MONOIDAL_REAL_ADD" > "HOLLight.hollight.MONOIDAL_REAL_ADD"
+ "MONOIDAL_MUL" > "HOLLight.hollight.MONOIDAL_MUL"
+ "MONOIDAL_ADD" > "HOLLight.hollight.MONOIDAL_ADD"
+ "MOD_def" > "HOLLight.hollight.MOD_def"
+ "MOD_UNIQ" > "HOLLight.hollight.MOD_UNIQ"
+ "MOD_MULT_RMOD" > "HOLLight.hollight.MOD_MULT_RMOD"
+ "MOD_MULT_MOD2" > "HOLLight.hollight.MOD_MULT_MOD2"
+ "MOD_MULT_LMOD" > "HOLLight.hollight.MOD_MULT_LMOD"
+ "MOD_MULT_ADD" > "HOLLight.hollight.MOD_MULT_ADD"
+ "MOD_MULT2" > "HOLLight.hollight.MOD_MULT2"
+ "MOD_MULT" > "HOLLight.hollight.MOD_MULT"
+ "MOD_MOD_REFL" > "HOLLight.hollight.MOD_MOD_REFL"
+ "MOD_MOD" > "HOLLight.hollight.MOD_MOD"
+ "MOD_LT" > "HOLLight.hollight.MOD_LT"
+ "MOD_LE" > "HOLLight.hollight.MOD_LE"
+ "MOD_EXP_MOD" > "HOLLight.hollight.MOD_EXP_MOD"
+ "MOD_EXISTS" > "HOLLight.hollight.MOD_EXISTS"
+ "MOD_EQ_0" > "HOLLight.hollight.MOD_EQ_0"
+ "MOD_EQ" > "HOLLight.hollight.MOD_EQ"
+ "MOD_ADD_MOD" > "HOLLight.hollight.MOD_ADD_MOD"
+ "MOD_1" > "HOLLight.hollight.MOD_1"
+ "MOD_0" > "HOLLight.hollight.MOD_0"
+ "MK_REC_INJ" > "HOLLight.hollight.MK_REC_INJ"
+ "MINIMAL" > "HOLLight.hollight.MINIMAL"
+ "METRIC_ZERO" > "HOLLight.hollight.METRIC_ZERO"
+ "METRIC_TRIANGLE" > "HOLLight.hollight.METRIC_TRIANGLE"
+ "METRIC_SYM" > "HOLLight.hollight.METRIC_SYM"
+ "METRIC_SAME" > "HOLLight.hollight.METRIC_SAME"
+ "METRIC_POS" > "HOLLight.hollight.METRIC_POS"
+ "METRIC_NZ" > "HOLLight.hollight.METRIC_NZ"
+ "METRIC_ISMET" > "HOLLight.hollight.METRIC_ISMET"
+ "MEM_def" > "HOLLight.hollight.MEM_def"
+ "MEM_MAP" > "HOLLight.hollight.MEM_MAP"
+ "MEM_LIST_OF_SET" > "HOLLight.hollight.MEM_LIST_OF_SET"
+ "MEM_FILTER" > "HOLLight.hollight.MEM_FILTER"
+ "MEM_EL" > "HOLLight.hollight.MEM_EL"
+ "MEM_ASSOC" > "HOLLight.hollight.MEM_ASSOC"
+ "MEM_APPEND" > "HOLLight.hollight.MEM_APPEND"
+ "MEMBER_NOT_EMPTY" > "HOLLight.hollight.MEMBER_NOT_EMPTY"
+ "MEASURE_LE" > "HOLLight.hollight.MEASURE_LE"
+ "MCLAURIN_ZERO" > "HOLLight.hollight.MCLAURIN_ZERO"
+ "MCLAURIN_SIN" > "HOLLight.hollight.MCLAURIN_SIN"
+ "MCLAURIN_NEG" > "HOLLight.hollight.MCLAURIN_NEG"
+ "MCLAURIN_LN_POS" > "HOLLight.hollight.MCLAURIN_LN_POS"
+ "MCLAURIN_LN_NEG" > "HOLLight.hollight.MCLAURIN_LN_NEG"
+ "MCLAURIN_EXP_LT" > "HOLLight.hollight.MCLAURIN_EXP_LT"
+ "MCLAURIN_EXP_LEMMA" > "HOLLight.hollight.MCLAURIN_EXP_LEMMA"
+ "MCLAURIN_EXP_LE" > "HOLLight.hollight.MCLAURIN_EXP_LE"
+ "MCLAURIN_COS" > "HOLLight.hollight.MCLAURIN_COS"
+ "MCLAURIN_BI_LE" > "HOLLight.hollight.MCLAURIN_BI_LE"
+ "MCLAURIN_ATN" > "HOLLight.hollight.MCLAURIN_ATN"
+ "MCLAURIN_ALL_LT" > "HOLLight.hollight.MCLAURIN_ALL_LT"
+ "MCLAURIN_ALL_LE" > "HOLLight.hollight.MCLAURIN_ALL_LE"
+ "MCLAURIN" > "HOLLight.hollight.MCLAURIN"
+ "MAX_LEMMA" > "HOLLight.hollight.MAX_LEMMA"
+ "MAP_o" > "HOLLight.hollight.MAP_o"
+ "MAP_def" > "HOLLight.hollight.MAP_def"
+ "MAP_SND_ZIP" > "HOLLight.hollight.MAP_SND_ZIP"
+ "MAP_FST_ZIP" > "HOLLight.hollight.MAP_FST_ZIP"
+ "MAP_EQ_DEGEN" > "HOLLight.hollight.MAP_EQ_DEGEN"
+ "MAP_EQ_ALL2" > "HOLLight.hollight.MAP_EQ_ALL2"
+ "MAP_EQ" > "HOLLight.hollight.MAP_EQ"
+ "MAP_APPEND" > "HOLLight.hollight.MAP_APPEND"
+ "MAP2_def" > "HOLLight.hollight.MAP2_def"
+ "MAP2" > "HOLLight.hollight.MAP2"
+ "LT_TRANS" > "HOLLight.hollight.LT_TRANS"
+ "LT_SUC_LE" > "HOLLight.hollight.LT_SUC_LE"
+ "LT_SUC" > "HOLLight.hollight.LT_SUC"
+ "LT_REFL" > "HOLLight.hollight.LT_REFL"
+ "LT_NZ" > "HOLLight.hollight.LT_NZ"
+ "LT_MULT_RCANCEL" > "HOLLight.hollight.LT_MULT_RCANCEL"
+ "LT_MULT_LCANCEL" > "HOLLight.hollight.LT_MULT_LCANCEL"
+ "LT_MULT2" > "HOLLight.hollight.LT_MULT2"
+ "LT_MULT" > "HOLLight.hollight.LT_MULT"
+ "LT_LMULT" > "HOLLight.hollight.LT_LMULT"
+ "LT_LE" > "HOLLight.hollight.LT_LE"
+ "LT_IMP_LE" > "HOLLight.hollight.LT_IMP_LE"
+ "LT_EXP" > "HOLLight.hollight.LT_EXP"
+ "LT_EXISTS" > "HOLLight.hollight.LT_EXISTS"
+ "LT_CASES" > "HOLLight.hollight.LT_CASES"
+ "LT_ANTISYM" > "HOLLight.hollight.LT_ANTISYM"
+ "LT_ADD_RCANCEL" > "HOLLight.hollight.LT_ADD_RCANCEL"
+ "LT_ADD_LCANCEL" > "HOLLight.hollight.LT_ADD_LCANCEL"
+ "LT_ADDR" > "HOLLight.hollight.LT_ADDR"
+ "LT_ADD2" > "HOLLight.hollight.LT_ADD2"
+ "LT_ADD" > "HOLLight.hollight.LT_ADD"
+ "LT_0" > "HOLLight.hollight.LT_0"
+ "LTE_TRANS" > "HOLLight.hollight.LTE_TRANS"
+ "LTE_CASES" > "HOLLight.hollight.LTE_CASES"
+ "LTE_ANTISYM" > "HOLLight.hollight.LTE_ANTISYM"
+ "LTE_ADD2" > "HOLLight.hollight.LTE_ADD2"
+ "LN_POW" > "HOLLight.hollight.LN_POW"
+ "LN_POS_LT" > "HOLLight.hollight.LN_POS_LT"
+ "LN_POS" > "HOLLight.hollight.LN_POS"
+ "LN_MUL" > "HOLLight.hollight.LN_MUL"
+ "LN_MONO_LT" > "HOLLight.hollight.LN_MONO_LT"
+ "LN_MONO_LE" > "HOLLight.hollight.LN_MONO_LE"
+ "LN_LT_X" > "HOLLight.hollight.LN_LT_X"
+ "LN_LE" > "HOLLight.hollight.LN_LE"
+ "LN_INV" > "HOLLight.hollight.LN_INV"
+ "LN_INJ" > "HOLLight.hollight.LN_INJ"
+ "LN_EXP" > "HOLLight.hollight.LN_EXP"
+ "LN_DIV" > "HOLLight.hollight.LN_DIV"
+ "LN_1" > "HOLLight.hollight.LN_1"
+ "LIST_OF_SET_PROPERTIES" > "HOLLight.hollight.LIST_OF_SET_PROPERTIES"
+ "LIM_X" > "HOLLight.hollight.LIM_X"
+ "LIM_UNIQ" > "HOLLight.hollight.LIM_UNIQ"
+ "LIM_TRANSFORM" > "HOLLight.hollight.LIM_TRANSFORM"
+ "LIM_TENDS2" > "HOLLight.hollight.LIM_TENDS2"
+ "LIM_TENDS" > "HOLLight.hollight.LIM_TENDS"
+ "LIM_SUM" > "HOLLight.hollight.LIM_SUM"
+ "LIM_SUB" > "HOLLight.hollight.LIM_SUB"
+ "LIM_NULL" > "HOLLight.hollight.LIM_NULL"
+ "LIM_NEG" > "HOLLight.hollight.LIM_NEG"
+ "LIM_MUL" > "HOLLight.hollight.LIM_MUL"
+ "LIM_INV" > "HOLLight.hollight.LIM_INV"
+ "LIM_EQUAL" > "HOLLight.hollight.LIM_EQUAL"
+ "LIM_DIV" > "HOLLight.hollight.LIM_DIV"
+ "LIM_CONST" > "HOLLight.hollight.LIM_CONST"
+ "LIM_ADD" > "HOLLight.hollight.LIM_ADD"
+ "LIM" > "HOLLight.hollight.LIM"
+ "LE_TRANS" > "HOLLight.hollight.LE_TRANS"
+ "LE_SUC_LT" > "HOLLight.hollight.LE_SUC_LT"
+ "LE_SUC" > "HOLLight.hollight.LE_SUC"
+ "LE_SQUARE_REFL" > "HOLLight.hollight.LE_SQUARE_REFL"
+ "LE_REFL" > "HOLLight.hollight.LE_REFL"
+ "LE_RDIV_EQ" > "HOLLight.hollight.LE_RDIV_EQ"
+ "LE_MULT_RCANCEL" > "HOLLight.hollight.LE_MULT_RCANCEL"
+ "LE_MULT_LCANCEL" > "HOLLight.hollight.LE_MULT_LCANCEL"
+ "LE_MULT2" > "HOLLight.hollight.LE_MULT2"
+ "LE_LT" > "HOLLight.hollight.LE_LT"
+ "LE_LDIV_EQ" > "HOLLight.hollight.LE_LDIV_EQ"
+ "LE_LDIV" > "HOLLight.hollight.LE_LDIV"
+ "LE_EXP" > "HOLLight.hollight.LE_EXP"
+ "LE_EXISTS" > "HOLLight.hollight.LE_EXISTS"
+ "LE_CASES" > "HOLLight.hollight.LE_CASES"
+ "LE_ANTISYM" > "HOLLight.hollight.LE_ANTISYM"
+ "LE_ADD_RCANCEL" > "HOLLight.hollight.LE_ADD_RCANCEL"
+ "LE_ADD_LCANCEL" > "HOLLight.hollight.LE_ADD_LCANCEL"
+ "LE_ADDR" > "HOLLight.hollight.LE_ADDR"
+ "LE_ADD2" > "HOLLight.hollight.LE_ADD2"
+ "LE_ADD" > "HOLLight.hollight.LE_ADD"
+ "LE_0" > "HOLLight.hollight.LE_0"
+ "LET_TRANS" > "HOLLight.hollight.LET_TRANS"
+ "LET_END_def" > "HOLLight.hollight.LET_END_def"
+ "LET_CASES" > "HOLLight.hollight.LET_CASES"
+ "LET_ANTISYM" > "HOLLight.hollight.LET_ANTISYM"
+ "LET_ADD2" > "HOLLight.hollight.LET_ADD2"
+ "LESS_SUC_EQ" > "HOLLight.hollight.LESS_SUC_EQ"
+ "LESS_1" > "HOLLight.hollight.LESS_1"
+ "LENGTH_def" > "HOLLight.hollight.LENGTH_def"
+ "LENGTH_REPLICATE" > "HOLLight.hollight.LENGTH_REPLICATE"
+ "LENGTH_MAP2" > "HOLLight.hollight.LENGTH_MAP2"
+ "LENGTH_MAP" > "HOLLight.hollight.LENGTH_MAP"
+ "LENGTH_LIST_OF_SET" > "HOLLight.hollight.LENGTH_LIST_OF_SET"
+ "LENGTH_EQ_NIL" > "HOLLight.hollight.LENGTH_EQ_NIL"
+ "LENGTH_EQ_CONS" > "HOLLight.hollight.LENGTH_EQ_CONS"
+ "LENGTH_APPEND" > "HOLLight.hollight.LENGTH_APPEND"
+ "LEFT_SUB_DISTRIB" > "Nat.nat_distrib_4"
+ "LEFT_OR_FORALL_THM" > "HOL.all_simps_3"
+ "LEFT_OR_EXISTS_THM" > "HOL.ex_simps_3"
+ "LEFT_OR_DISTRIB" > "HOL.conj_disj_distribL"
+ "LEFT_IMP_FORALL_THM" > "HOL.imp_all"
+ "LEFT_IMP_EXISTS_THM" > "HOL.imp_ex"
+ "LEFT_FORALL_OR_THM" > "HOL.all_simps_3"
+ "LEFT_FORALL_IMP_THM" > "HOL.imp_ex"
+ "LEFT_EXISTS_IMP_THM" > "HOL.imp_all"
+ "LEFT_EXISTS_AND_THM" > "HOL.ex_simps_1"
+ "LEFT_AND_FORALL_THM" > "HOL.all_simps_1"
+ "LEFT_AND_EXISTS_THM" > "HOL.ex_simps_1"
+ "LEFT_ADD_DISTRIB" > "Nat.nat_distrib_2"
+ "LAST_def" > "HOLLight.hollight.LAST_def"
+ "LAST_CLAUSES" > "HOLLight.hollight.LAST_CLAUSES"
+ "LAMBDA_UNIQUE" > "HOLLight.hollight.LAMBDA_UNIQUE"
+ "LAMBDA_ETA" > "HOLLight.hollight.LAMBDA_ETA"
+ "LAMBDA_BETA" > "HOLLight.hollight.LAMBDA_BETA"
+ "I_THM" > "Fun.id_apply"
+ "I_O_ID" > "HOLLight.hollight.I_O_ID"
+ "IVT_DERIVATIVE_POS" > "HOLLight.hollight.IVT_DERIVATIVE_POS"
+ "IVT_DERIVATIVE_NEG" > "HOLLight.hollight.IVT_DERIVATIVE_NEG"
+ "IVT_DERIVATIVE_0" > "HOLLight.hollight.IVT_DERIVATIVE_0"
+ "IVT2" > "HOLLight.hollight.IVT2"
+ "IVT" > "HOLLight.hollight.IVT"
+ "ITSET_def" > "HOLLight.hollight.ITSET_def"
+ "ITSET_EQ" > "HOLLight.hollight.ITSET_EQ"
+ "ITLIST_def" > "HOLLight.hollight.ITLIST_def"
+ "ITLIST_EXTRA" > "HOLLight.hollight.ITLIST_EXTRA"
+ "ITLIST2_def" > "HOLLight.hollight.ITLIST2_def"
+ "ITLIST2" > "HOLLight.hollight.ITLIST2"
+ "ITERATE_UNION_GEN" > "HOLLight.hollight.ITERATE_UNION_GEN"
+ "ITERATE_UNION" > "HOLLight.hollight.ITERATE_UNION"
+ "ITERATE_SUPPORT" > "HOLLight.hollight.ITERATE_SUPPORT"
+ "ITERATE_SING" > "HOLLight.hollight.ITERATE_SING"
+ "ITERATE_RELATED" > "HOLLight.hollight.ITERATE_RELATED"
+ "ITERATE_IMAGE" > "HOLLight.hollight.ITERATE_IMAGE"
+ "ITERATE_EQ_NEUTRAL" > "HOLLight.hollight.ITERATE_EQ_NEUTRAL"
+ "ITERATE_DIFF_GEN" > "HOLLight.hollight.ITERATE_DIFF_GEN"
+ "ITERATE_DIFF" > "HOLLight.hollight.ITERATE_DIFF"
+ "ITERATE_DELTA" > "HOLLight.hollight.ITERATE_DELTA"
+ "ITERATE_CLOSED_GEN" > "HOLLight.hollight.ITERATE_CLOSED_GEN"
+ "ITERATE_CLOSED" > "HOLLight.hollight.ITERATE_CLOSED"
+ "ITERATE_CLAUSES_GEN" > "HOLLight.hollight.ITERATE_CLAUSES_GEN"
+ "ITERATE_CLAUSES" > "HOLLight.hollight.ITERATE_CLAUSES"
+ "ISO_def" > "HOLLight.hollight.ISO_def"
+ "ISO_USAGE" > "HOLLight.hollight.ISO_USAGE"
+ "ISO_REFL" > "HOLLight.hollight.ISO_REFL"
+ "ISO_FUN" > "HOLLight.hollight.ISO_FUN"
+ "ISMET_R1" > "HOLLight.hollight.ISMET_R1"
+ "IN_def" > "HOLLight.hollight.IN_def"
+ "IN_UNIV" > "HOLLight.hollight.IN_UNIV"
+ "IN_UNIONS" > "HOLLight.hollight.IN_UNIONS"
+ "IN_UNION" > "HOLLight.hollight.IN_UNION"
+ "IN_SUPPORT" > "HOLLight.hollight.IN_SUPPORT"
+ "IN_SING" > "HOLLight.hollight.IN_SING"
+ "IN_SET_OF_LIST" > "HOLLight.hollight.IN_SET_OF_LIST"
+ "IN_REST" > "HOLLight.hollight.IN_REST"
+ "IN_NUMSEG" > "HOLLight.hollight.IN_NUMSEG"
+ "IN_INTERS" > "HOLLight.hollight.IN_INTERS"
+ "IN_INTER" > "HOLLight.hollight.IN_INTER"
+ "IN_INSERT" > "HOLLight.hollight.IN_INSERT"
+ "IN_IMAGE" > "HOLLight.hollight.IN_IMAGE"
+ "IN_ELIM_THM" > "HOLLight.hollight.IN_ELIM_THM"
+ "IN_DISJOINT" > "HOLLight.hollight.IN_DISJOINT"
+ "IN_DIFF" > "HOLLight.hollight.IN_DIFF"
+ "IN_DELETE_EQ" > "HOLLight.hollight.IN_DELETE_EQ"
+ "IN_DELETE" > "HOLLight.hollight.IN_DELETE"
+ "INT_POW" > "HOLLight.hollight.INT_POW"
+ "INT_LT_DISCRETE" > "HOLLight.hollight.INT_LT_DISCRETE"
+ "INT_LT" > "HOLLight.hollight.INT_LT"
+ "INT_IMAGE" > "HOLLight.hollight.INT_IMAGE"
+ "INT_GT_DISCRETE" > "HOLLight.hollight.INT_GT_DISCRETE"
+ "INT_GT" > "HOLLight.hollight.INT_GT"
+ "INT_GE" > "HOLLight.hollight.INT_GE"
+ "INT_FORALL_POS" > "HOLLight.hollight.INT_FORALL_POS"
+ "INT_ARCH" > "HOLLight.hollight.INT_ARCH"
+ "INT_ABS_MUL_1" > "HOLLight.hollight.INT_ABS_MUL_1"
+ "INT_ABS" > "HOLLight.hollight.INT_ABS"
+ "INTER_def" > "HOLLight.hollight.INTER_def"
+ "INTER_UNIV" > "HOLLight.hollight.INTER_UNIV"
+ "INTER_SUBSET" > "HOLLight.hollight.INTER_SUBSET"
+ "INTER_OVER_UNION" > "HOLLight.hollight.INTER_OVER_UNION"
+ "INTER_IDEMPOT" > "HOLLight.hollight.INTER_IDEMPOT"
+ "INTER_EMPTY" > "HOLLight.hollight.INTER_EMPTY"
+ "INTER_COMM" > "HOLLight.hollight.INTER_COMM"
+ "INTER_ASSOC" > "HOLLight.hollight.INTER_ASSOC"
+ "INTER_ACI" > "HOLLight.hollight.INTER_ACI"
+ "INTERVAL_LEMMA_LT" > "HOLLight.hollight.INTERVAL_LEMMA_LT"
+ "INTERVAL_LEMMA" > "HOLLight.hollight.INTERVAL_LEMMA"
+ "INTERVAL_ABS" > "HOLLight.hollight.INTERVAL_ABS"
+ "INTERS_def" > "HOLLight.hollight.INTERS_def"
+ "INTEGRAL_NULL" > "HOLLight.hollight.INTEGRAL_NULL"
+ "INSERT_def" > "HOLLight.hollight.INSERT_def"
+ "INSERT_UNIV" > "HOLLight.hollight.INSERT_UNIV"
+ "INSERT_UNION_EQ" > "HOLLight.hollight.INSERT_UNION_EQ"
+ "INSERT_UNION" > "HOLLight.hollight.INSERT_UNION"
+ "INSERT_SUBSET" > "HOLLight.hollight.INSERT_SUBSET"
+ "INSERT_INTER" > "HOLLight.hollight.INSERT_INTER"
+ "INSERT_INSERT" > "HOLLight.hollight.INSERT_INSERT"
+ "INSERT_DIFF" > "HOLLight.hollight.INSERT_DIFF"
+ "INSERT_DELETE" > "HOLLight.hollight.INSERT_DELETE"
+ "INSERT_COMM" > "HOLLight.hollight.INSERT_COMM"
+ "INSERT_AC" > "HOLLight.hollight.INSERT_AC"
+ "INSERT" > "HOLLight.hollight.INSERT"
+ "INR_def" > "HOLLight.hollight.INR_def"
+ "INL_def" > "HOLLight.hollight.INL_def"
+ "INJ_def" > "HOLLight.hollight.INJ_def"
+ "INJ_INVERSE2" > "HOLLight.hollight.INJ_INVERSE2"
+ "INJP_def" > "HOLLight.hollight.INJP_def"
+ "INJP_INJ" > "HOLLight.hollight.INJP_INJ"
+ "INJN_def" > "HOLLight.hollight.INJN_def"
+ "INJN_INJ" > "HOLLight.hollight.INJN_INJ"
+ "INJF_def" > "HOLLight.hollight.INJF_def"
+ "INJF_INJ" > "HOLLight.hollight.INJF_INJ"
+ "INJECTIVE_ON_LEFT_INVERSE" > "HOLLight.hollight.INJECTIVE_ON_LEFT_INVERSE"
+ "INJECTIVE_LEFT_INVERSE" > "HOLLight.hollight.INJECTIVE_LEFT_INVERSE"
+ "INJA_def" > "HOLLight.hollight.INJA_def"
+ "INJA_INJ" > "HOLLight.hollight.INJA_INJ"
+ "INFINITE_def" > "HOLLight.hollight.INFINITE_def"
+ "INFINITE_NONEMPTY" > "HOLLight.hollight.INFINITE_NONEMPTY"
+ "INFINITE_IMAGE_INJ" > "HOLLight.hollight.INFINITE_IMAGE_INJ"
+ "INFINITE_DIFF_FINITE" > "HOLLight.hollight.INFINITE_DIFF_FINITE"
+ "IMP_EQ_CLAUSE" > "HOLLight.hollight.IMP_EQ_CLAUSE"
+ "IMP_CONJ" > "HOL.imp_conjL"
+ "IMP_CLAUSES" > "HOLLight.hollight.IMP_CLAUSES"
+ "IMAGE_o" > "HOLLight.hollight.IMAGE_o"
+ "IMAGE_def" > "HOLLight.hollight.IMAGE_def"
+ "IMAGE_UNION" > "HOLLight.hollight.IMAGE_UNION"
+ "IMAGE_SUBSET" > "HOLLight.hollight.IMAGE_SUBSET"
+ "IMAGE_IMP_INJECTIVE_GEN" > "HOLLight.hollight.IMAGE_IMP_INJECTIVE_GEN"
+ "IMAGE_IMP_INJECTIVE" > "HOLLight.hollight.IMAGE_IMP_INJECTIVE"
+ "IMAGE_EQ_EMPTY" > "HOLLight.hollight.IMAGE_EQ_EMPTY"
+ "IMAGE_DIFF_INJ" > "HOLLight.hollight.IMAGE_DIFF_INJ"
+ "IMAGE_DELETE_INJ" > "HOLLight.hollight.IMAGE_DELETE_INJ"
+ "IMAGE_CONST" > "HOLLight.hollight.IMAGE_CONST"
+ "IMAGE_CLAUSES" > "HOLLight.hollight.IMAGE_CLAUSES"
+ "HREAL_MUL_RZERO" > "HOLLight.hollight.HREAL_MUL_RZERO"
+ "HREAL_MUL_LZERO" > "HOLLight.hollight.HREAL_MUL_LZERO"
+ "HREAL_LE_MUL_RCANCEL_IMP" > "HOLLight.hollight.HREAL_LE_MUL_RCANCEL_IMP"
+ "HREAL_LE_EXISTS_DEF" > "HOLLight.hollight.HREAL_LE_EXISTS_DEF"
+ "HREAL_LE_ADD_RCANCEL" > "HOLLight.hollight.HREAL_LE_ADD_RCANCEL"
+ "HREAL_LE_ADD_LCANCEL" > "HOLLight.hollight.HREAL_LE_ADD_LCANCEL"
+ "HREAL_LE_ADD2" > "HOLLight.hollight.HREAL_LE_ADD2"
+ "HREAL_EQ_ADD_RCANCEL" > "HOLLight.hollight.HREAL_EQ_ADD_RCANCEL"
+ "HREAL_EQ_ADD_LCANCEL" > "HOLLight.hollight.HREAL_EQ_ADD_LCANCEL"
+ "HREAL_ADD_RID" > "HOLLight.hollight.HREAL_ADD_RID"
+ "HREAL_ADD_RDISTRIB" > "HOLLight.hollight.HREAL_ADD_RDISTRIB"
+ "HREAL_ADD_AC" > "HOLLight.hollight.HREAL_ADD_AC"
+ "HD_def" > "HOLLight.hollight.HD_def"
+ "HAS_SIZE_def" > "HOLLight.hollight.HAS_SIZE_def"
+ "HAS_SIZE_UNIONS" > "HOLLight.hollight.HAS_SIZE_UNIONS"
+ "HAS_SIZE_UNION" > "HOLLight.hollight.HAS_SIZE_UNION"
+ "HAS_SIZE_SUC" > "HOLLight.hollight.HAS_SIZE_SUC"
+ "HAS_SIZE_PRODUCT_DEPENDENT" > "HOLLight.hollight.HAS_SIZE_PRODUCT_DEPENDENT"
+ "HAS_SIZE_PRODUCT" > "HOLLight.hollight.HAS_SIZE_PRODUCT"
+ "HAS_SIZE_POWERSET" > "HOLLight.hollight.HAS_SIZE_POWERSET"
+ "HAS_SIZE_NUMSEG_LT" > "HOLLight.hollight.HAS_SIZE_NUMSEG_LT"
+ "HAS_SIZE_NUMSEG_LE" > "HOLLight.hollight.HAS_SIZE_NUMSEG_LE"
+ "HAS_SIZE_NUMSEG_1" > "HOLLight.hollight.HAS_SIZE_NUMSEG_1"
+ "HAS_SIZE_NUMSEG" > "HOLLight.hollight.HAS_SIZE_NUMSEG"
+ "HAS_SIZE_INDEX" > "HOLLight.hollight.HAS_SIZE_INDEX"
+ "HAS_SIZE_IMAGE_INJ" > "HOLLight.hollight.HAS_SIZE_IMAGE_INJ"
+ "HAS_SIZE_FUNSPACE" > "HOLLight.hollight.HAS_SIZE_FUNSPACE"
+ "HAS_SIZE_FINITE_IMAGE" > "HOLLight.hollight.HAS_SIZE_FINITE_IMAGE"
+ "HAS_SIZE_CLAUSES" > "HOLLight.hollight.HAS_SIZE_CLAUSES"
+ "HAS_SIZE_CARD" > "HOLLight.hollight.HAS_SIZE_CARD"
+ "HAS_SIZE_0" > "HOLLight.hollight.HAS_SIZE_0"
+ "GSPEC_def" > "HOLLight.hollight.GSPEC_def"
+ "GP_FINITE" > "HOLLight.hollight.GP_FINITE"
+ "GP" > "HOLLight.hollight.GP"
+ "GEQ_def" > "HOLLight.hollight.GEQ_def"
+ "GAUGE_MIN" > "HOLLight.hollight.GAUGE_MIN"
+ "GABS_def" > "HOLLight.hollight.GABS_def"
+ "FUN_EQ_THM" > "Fun.expand_fun_eq"
+ "FUNCTION_FACTORS_RIGHT" > "HOLLight.hollight.FUNCTION_FACTORS_RIGHT"
+ "FUNCTION_FACTORS_LEFT" > "HOLLight.hollight.FUNCTION_FACTORS_LEFT"
+ "FTC1" > "HOLLight.hollight.FTC1"
+ "FSTCART_PASTECART" > "HOLLight.hollight.FSTCART_PASTECART"
+ "FST" > "Product_Type.fst_conv"
+ "FORALL_SIMP" > "HOL.simp_thms_35"
+ "FORALL_PASTECART" > "HOLLight.hollight.FORALL_PASTECART"
+ "FORALL_PAIR_THM" > "Product_Type.split_paired_All"
+ "FORALL_NOT_THM" > "Inductive.basic_monos_16"
+ "FORALL_IN_UNIONS" > "HOLLight.hollight.FORALL_IN_UNIONS"
+ "FORALL_IN_IMAGE" > "HOLLight.hollight.FORALL_IN_IMAGE"
+ "FORALL_IN_CLAUSES" > "HOLLight.hollight.FORALL_IN_CLAUSES"
+ "FORALL_FINITE_INDEX" > "HOLLight.hollight.FORALL_FINITE_INDEX"
+ "FORALL_BOOL_THM" > "Set.all_bool_eq"
+ "FORALL_AND_THM" > "HOL.all_conj_distrib"
+ "FORALL_ALL" > "HOLLight.hollight.FORALL_ALL"
+ "FNIL_def" > "HOLLight.hollight.FNIL_def"
+ "FINREC_def" > "HOLLight.hollight.FINREC_def"
+ "FINREC_UNIQUE_LEMMA" > "HOLLight.hollight.FINREC_UNIQUE_LEMMA"
+ "FINREC_SUC_LEMMA" > "HOLLight.hollight.FINREC_SUC_LEMMA"
+ "FINREC_FUN_LEMMA" > "HOLLight.hollight.FINREC_FUN_LEMMA"
+ "FINREC_FUN" > "HOLLight.hollight.FINREC_FUN"
+ "FINREC_EXISTS_LEMMA" > "HOLLight.hollight.FINREC_EXISTS_LEMMA"
+ "FINREC_1_LEMMA" > "HOLLight.hollight.FINREC_1_LEMMA"
+ "FINITE_def" > "HOLLight.hollight.FINITE_def"
+ "FINITE_UNION_IMP" > "HOLLight.hollight.FINITE_UNION_IMP"
+ "FINITE_UNIONS" > "HOLLight.hollight.FINITE_UNIONS"
+ "FINITE_UNION" > "HOLLight.hollight.FINITE_UNION"
+ "FINITE_SUPPORT_DELTA" > "HOLLight.hollight.FINITE_SUPPORT_DELTA"
+ "FINITE_SUPPORT" > "HOLLight.hollight.FINITE_SUPPORT"
+ "FINITE_SUBSET_IMAGE_IMP" > "HOLLight.hollight.FINITE_SUBSET_IMAGE_IMP"
+ "FINITE_SUBSET_IMAGE" > "HOLLight.hollight.FINITE_SUBSET_IMAGE"
+ "FINITE_SUBSETS" > "HOLLight.hollight.FINITE_SUBSETS"
+ "FINITE_SUBSET" > "HOLLight.hollight.FINITE_SUBSET"
+ "FINITE_SET_OF_LIST" > "HOLLight.hollight.FINITE_SET_OF_LIST"
+ "FINITE_RESTRICT" > "HOLLight.hollight.FINITE_RESTRICT"
+ "FINITE_RECURSION_DELETE" > "HOLLight.hollight.FINITE_RECURSION_DELETE"
+ "FINITE_RECURSION" > "HOLLight.hollight.FINITE_RECURSION"
+ "FINITE_PRODUCT_DEPENDENT" > "HOLLight.hollight.FINITE_PRODUCT_DEPENDENT"
+ "FINITE_PRODUCT" > "HOLLight.hollight.FINITE_PRODUCT"
+ "FINITE_POWERSET" > "HOLLight.hollight.FINITE_POWERSET"
+ "FINITE_NUMSEG_LT" > "HOLLight.hollight.FINITE_NUMSEG_LT"
+ "FINITE_NUMSEG_LE" > "HOLLight.hollight.FINITE_NUMSEG_LE"
+ "FINITE_NUMSEG" > "HOLLight.hollight.FINITE_NUMSEG"
+ "FINITE_INTER" > "HOLLight.hollight.FINITE_INTER"
+ "FINITE_INSERT" > "HOLLight.hollight.FINITE_INSERT"
+ "FINITE_INDUCT_STRONG" > "HOLLight.hollight.FINITE_INDUCT_STRONG"
+ "FINITE_INDEX_WORKS_FINITE" > "HOLLight.hollight.FINITE_INDEX_WORKS_FINITE"
+ "FINITE_INDEX_WORKS" > "HOLLight.hollight.FINITE_INDEX_WORKS"
+ "FINITE_INDEX_NUMSEG" > "HOLLight.hollight.FINITE_INDEX_NUMSEG"
+ "FINITE_INDEX_NUMBERS" > "HOLLight.hollight.FINITE_INDEX_NUMBERS"
+ "FINITE_INDEX_INJ" > "HOLLight.hollight.FINITE_INDEX_INJ"
+ "FINITE_IMAGE_INJ_GENERAL" > "HOLLight.hollight.FINITE_IMAGE_INJ_GENERAL"
+ "FINITE_IMAGE_INJ" > "HOLLight.hollight.FINITE_IMAGE_INJ"
+ "FINITE_IMAGE_IMAGE" > "HOLLight.hollight.FINITE_IMAGE_IMAGE"
+ "FINITE_IMAGE_EXPAND" > "HOLLight.hollight.FINITE_IMAGE_EXPAND"
+ "FINITE_IMAGE" > "HOLLight.hollight.FINITE_IMAGE"
+ "FINITE_HAS_SIZE_LEMMA" > "HOLLight.hollight.FINITE_HAS_SIZE_LEMMA"
+ "FINITE_FUNSPACE" > "HOLLight.hollight.FINITE_FUNSPACE"
+ "FINITE_FINITE_IMAGE" > "HOLLight.hollight.FINITE_FINITE_IMAGE"
+ "FINITE_DIFF" > "HOLLight.hollight.FINITE_DIFF"
+ "FINITE_DELETE_IMP" > "HOLLight.hollight.FINITE_DELETE_IMP"
+ "FINITE_DELETE" > "HOLLight.hollight.FINITE_DELETE"
+ "FINE_MIN" > "HOLLight.hollight.FINE_MIN"
+ "FILTER_def" > "HOLLight.hollight.FILTER_def"
+ "FILTER_MAP" > "HOLLight.hollight.FILTER_MAP"
+ "FILTER_APPEND" > "HOLLight.hollight.FILTER_APPEND"
+ "FCONS_def" > "HOLLight.hollight.FCONS_def"
+ "FCONS_UNDO" > "HOLLight.hollight.FCONS_UNDO"
+ "FACT_def" > "HOLLight.hollight.FACT_def"
+ "FACT_MONO" > "HOLLight.hollight.FACT_MONO"
+ "FACT_LT" > "HOLLight.hollight.FACT_LT"
+ "FACT_LE" > "HOLLight.hollight.FACT_LE"
+ "EX_def" > "HOLLight.hollight.EX_def"
+ "EX_MEM" > "HOLLight.hollight.EX_MEM"
+ "EX_MAP" > "HOLLight.hollight.EX_MAP"
+ "EX_IMP" > "HOLLight.hollight.EX_IMP"
+ "EXTENSION" > "HOLLight.hollight.EXTENSION"
+ "EXP_def" > "HOLLight.hollight.EXP_def"
+ "EXP_ONE" > "HOLLight.hollight.EXP_ONE"
+ "EXP_MULT" > "HOLLight.hollight.EXP_MULT"
+ "EXP_LT_0" > "HOLLight.hollight.EXP_LT_0"
+ "EXP_EQ_0" > "HOLLight.hollight.EXP_EQ_0"
+ "EXP_ADD" > "HOLLight.hollight.EXP_ADD"
+ "EXP_2" > "HOLLight.hollight.EXP_2"
+ "EXP_1" > "HOLLight.hollight.EXP_1"
+ "EXISTS_UNIQUE_THM" > "HOL4Compat.EXISTS_UNIQUE_DEF"
+ "EXISTS_UNIQUE_REFL" > "HOL.ex1_eq_1"
+ "EXISTS_UNIQUE_ALT" > "HOLLight.hollight.EXISTS_UNIQUE_ALT"
+ "EXISTS_UNIQUE" > "HOL.Ex1_def"
+ "EXISTS_THM" > "HOL4Setup.EXISTS_DEF"
+ "EXISTS_SIMP" > "HOL.simp_thms_36"
+ "EXISTS_REFL" > "HOL.simp_thms_37"
+ "EXISTS_PASTECART" > "HOLLight.hollight.EXISTS_PASTECART"
+ "EXISTS_PAIR_THM" > "Product_Type.split_paired_Ex"
+ "EXISTS_OR_THM" > "HOL.ex_disj_distrib"
+ "EXISTS_ONE_REP" > "HOLLight.hollight.EXISTS_ONE_REP"
+ "EXISTS_NOT_THM" > "Inductive.basic_monos_15"
+ "EXISTS_IN_IMAGE" > "HOLLight.hollight.EXISTS_IN_IMAGE"
+ "EXISTS_IN_CLAUSES" > "HOLLight.hollight.EXISTS_IN_CLAUSES"
+ "EXISTS_EX" > "HOLLight.hollight.EXISTS_EX"
+ "EXISTS_BOOL_THM" > "Set.ex_bool_eq"
+ "EXCLUDED_MIDDLE" > "HOLLight.hollight.EXCLUDED_MIDDLE"
+ "EVEN_def" > "HOLLight.hollight.EVEN_def"
+ "EVEN_OR_ODD" > "HOLLight.hollight.EVEN_OR_ODD"
+ "EVEN_ODD_DECOMPOSITION" > "HOLLight.hollight.EVEN_ODD_DECOMPOSITION"
+ "EVEN_MULT" > "HOLLight.hollight.EVEN_MULT"
+ "EVEN_MOD" > "HOLLight.hollight.EVEN_MOD"
+ "EVEN_EXP" > "HOLLight.hollight.EVEN_EXP"
+ "EVEN_EXISTS_LEMMA" > "HOLLight.hollight.EVEN_EXISTS_LEMMA"
+ "EVEN_EXISTS" > "HOLLight.hollight.EVEN_EXISTS"
+ "EVEN_DOUBLE" > "HOLLight.hollight.EVEN_DOUBLE"
+ "EVEN_DIV2" > "HOLLight.hollight.EVEN_DIV2"
+ "EVEN_AND_ODD" > "HOLLight.hollight.EVEN_AND_ODD"
+ "EVEN_ADD" > "HOLLight.hollight.EVEN_ADD"
+ "EQ_UNIV" > "HOLLight.hollight.EQ_UNIV"
+ "EQ_TRANS" > "Set.basic_trans_rules_31"
+ "EQ_SYM_EQ" > "HOL.eq_sym_conv"
+ "EQ_SYM" > "HOL.meta_eq_to_obj_eq"
+ "EQ_SUC" > "Nat.nat.simps_3"
+ "EQ_REFL_T" > "HOL.simp_thms_6"
+ "EQ_REFL" > "Presburger.fm_modd_pinf"
+ "EQ_MULT_RCANCEL" > "Nat.mult_cancel2"
+ "EQ_MULT_LCANCEL" > "NatBin.nat_mult_eq_cancel_disj"
+ "EQ_IMP_LE" > "HOLLight.hollight.EQ_IMP_LE"
+ "EQ_EXT" > "HOL.meta_eq_to_obj_eq"
+ "EQ_CLAUSES" > "HOLLight.hollight.EQ_CLAUSES"
+ "EQ_ADD_RCANCEL_0" > "HOLLight.hollight.EQ_ADD_RCANCEL_0"
+ "EQ_ADD_RCANCEL" > "Nat.nat_add_right_cancel"
+ "EQ_ADD_LCANCEL_0" > "HOLLight.hollight.EQ_ADD_LCANCEL_0"
+ "EQ_ADD_LCANCEL" > "Nat.nat_add_left_cancel"
+ "EMPTY_def" > "HOLLight.hollight.EMPTY_def"
+ "EMPTY_UNIONS" > "HOLLight.hollight.EMPTY_UNIONS"
+ "EMPTY_UNION" > "HOLLight.hollight.EMPTY_UNION"
+ "EMPTY_SUBSET" > "HOLLight.hollight.EMPTY_SUBSET"
+ "EMPTY_NOT_UNIV" > "HOLLight.hollight.EMPTY_NOT_UNIV"
+ "EMPTY_GSPEC" > "HOLLight.hollight.EMPTY_GSPEC"
+ "EMPTY_DIFF" > "HOLLight.hollight.EMPTY_DIFF"
+ "EMPTY_DELETE" > "HOLLight.hollight.EMPTY_DELETE"
+ "EL_def" > "HOLLight.hollight.EL_def"
+ "DORDER_TENDSTO" > "HOLLight.hollight.DORDER_TENDSTO"
+ "DORDER_NGE" > "HOLLight.hollight.DORDER_NGE"
+ "DORDER_LEMMA" > "HOLLight.hollight.DORDER_LEMMA"
+ "DIV_def" > "HOLLight.hollight.DIV_def"
+ "DIV_UNIQ" > "HOLLight.hollight.DIV_UNIQ"
+ "DIV_REFL" > "HOLLight.hollight.DIV_REFL"
+ "DIV_MUL_LE" > "HOLLight.hollight.DIV_MUL_LE"
+ "DIV_MULT2" > "HOLLight.hollight.DIV_MULT2"
+ "DIV_MULT" > "HOLLight.hollight.DIV_MULT"
+ "DIV_MONO_LT" > "HOLLight.hollight.DIV_MONO_LT"
+ "DIV_MONO2" > "HOLLight.hollight.DIV_MONO2"
+ "DIV_MONO" > "HOLLight.hollight.DIV_MONO"
+ "DIV_MOD" > "HOLLight.hollight.DIV_MOD"
+ "DIV_LT" > "HOLLight.hollight.DIV_LT"
+ "DIV_LE_EXCLUSION" > "HOLLight.hollight.DIV_LE_EXCLUSION"
+ "DIV_LE" > "HOLLight.hollight.DIV_LE"
+ "DIV_EQ_EXCLUSION" > "HOLLight.hollight.DIV_EQ_EXCLUSION"
+ "DIV_EQ_0" > "HOLLight.hollight.DIV_EQ_0"
+ "DIV_DIV" > "HOLLight.hollight.DIV_DIV"
+ "DIV_ADD_MOD" > "HOLLight.hollight.DIV_ADD_MOD"
+ "DIV_1" > "HOLLight.hollight.DIV_1"
+ "DIV_0" > "HOLLight.hollight.DIV_0"
+ "DIVMOD_UNIQ_LEMMA" > "HOLLight.hollight.DIVMOD_UNIQ_LEMMA"
+ "DIVMOD_UNIQ" > "HOLLight.hollight.DIVMOD_UNIQ"
+ "DIVMOD_EXIST_0" > "HOLLight.hollight.DIVMOD_EXIST_0"
+ "DIVMOD_EXIST" > "HOLLight.hollight.DIVMOD_EXIST"
+ "DIVMOD_ELIM_THM" > "HOLLight.hollight.DIVMOD_ELIM_THM"
+ "DIVISION_UBOUND_LT" > "HOLLight.hollight.DIVISION_UBOUND_LT"
+ "DIVISION_UBOUND" > "HOLLight.hollight.DIVISION_UBOUND"
+ "DIVISION_THM" > "HOLLight.hollight.DIVISION_THM"
+ "DIVISION_SINGLE" > "HOLLight.hollight.DIVISION_SINGLE"
+ "DIVISION_RHS" > "HOLLight.hollight.DIVISION_RHS"
+ "DIVISION_LT_GEN" > "HOLLight.hollight.DIVISION_LT_GEN"
+ "DIVISION_LT" > "HOLLight.hollight.DIVISION_LT"
+ "DIVISION_LHS" > "HOLLight.hollight.DIVISION_LHS"
+ "DIVISION_LE" > "HOLLight.hollight.DIVISION_LE"
+ "DIVISION_LBOUND_LT" > "HOLLight.hollight.DIVISION_LBOUND_LT"
+ "DIVISION_LBOUND" > "HOLLight.hollight.DIVISION_LBOUND"
+ "DIVISION_GT" > "HOLLight.hollight.DIVISION_GT"
+ "DIVISION_EXISTS" > "HOLLight.hollight.DIVISION_EXISTS"
+ "DIVISION_EQ" > "HOLLight.hollight.DIVISION_EQ"
+ "DIVISION_APPEND_LEMMA2" > "HOLLight.hollight.DIVISION_APPEND_LEMMA2"
+ "DIVISION_APPEND_LEMMA1" > "HOLLight.hollight.DIVISION_APPEND_LEMMA1"
+ "DIVISION_APPEND" > "HOLLight.hollight.DIVISION_APPEND"
+ "DIVISION_1" > "HOLLight.hollight.DIVISION_1"
+ "DIVISION_0" > "HOLLight.hollight.DIVISION_0"
+ "DIVISION" > "HOLLight.hollight.DIVISION"
+ "DIST_TRIANGLE_LE" > "HOLLight.hollight.DIST_TRIANGLE_LE"
+ "DIST_TRIANGLES_LE" > "HOLLight.hollight.DIST_TRIANGLES_LE"
+ "DIST_TRIANGLE" > "HOLLight.hollight.DIST_TRIANGLE"
+ "DIST_SYM" > "HOLLight.hollight.DIST_SYM"
+ "DIST_RZERO" > "HOLLight.hollight.DIST_RZERO"
+ "DIST_RMUL" > "HOLLight.hollight.DIST_RMUL"
+ "DIST_REFL" > "HOLLight.hollight.DIST_REFL"
+ "DIST_RADD_0" > "HOLLight.hollight.DIST_RADD_0"
+ "DIST_RADD" > "HOLLight.hollight.DIST_RADD"
+ "DIST_LZERO" > "HOLLight.hollight.DIST_LZERO"
+ "DIST_LMUL" > "HOLLight.hollight.DIST_LMUL"
+ "DIST_LE_CASES" > "HOLLight.hollight.DIST_LE_CASES"
+ "DIST_LADD_0" > "HOLLight.hollight.DIST_LADD_0"
+ "DIST_LADD" > "HOLLight.hollight.DIST_LADD"
+ "DIST_EQ_0" > "HOLLight.hollight.DIST_EQ_0"
+ "DIST_ELIM_THM" > "HOLLight.hollight.DIST_ELIM_THM"
+ "DIST_ADDBOUND" > "HOLLight.hollight.DIST_ADDBOUND"
+ "DIST_ADD2_REV" > "HOLLight.hollight.DIST_ADD2_REV"
+ "DIST_ADD2" > "HOLLight.hollight.DIST_ADD2"
+ "DISJ_SYM" > "HOL.disj_comms_1"
+ "DISJ_ASSOC" > "Recdef.tfl_disj_assoc"
+ "DISJ_ACI" > "HOLLight.hollight.DISJ_ACI"
+ "DISJOINT_def" > "HOLLight.hollight.DISJOINT_def"
+ "DISJOINT_UNION" > "HOLLight.hollight.DISJOINT_UNION"
+ "DISJOINT_SYM" > "HOLLight.hollight.DISJOINT_SYM"
+ "DISJOINT_NUMSEG" > "HOLLight.hollight.DISJOINT_NUMSEG"
+ "DISJOINT_INSERT" > "HOLLight.hollight.DISJOINT_INSERT"
+ "DISJOINT_EMPTY_REFL" > "HOLLight.hollight.DISJOINT_EMPTY_REFL"
+ "DISJOINT_EMPTY" > "HOLLight.hollight.DISJOINT_EMPTY"
+ "DISJOINT_DELETE_SYM" > "HOLLight.hollight.DISJOINT_DELETE_SYM"
+ "DINT_UNIQ" > "HOLLight.hollight.DINT_UNIQ"
+ "DIMINDEX_NONZERO" > "HOLLight.hollight.DIMINDEX_NONZERO"
+ "DIMINDEX_HAS_SIZE_FINITE_SUM" > "HOLLight.hollight.DIMINDEX_HAS_SIZE_FINITE_SUM"
+ "DIMINDEX_GE_1" > "HOLLight.hollight.DIMINDEX_GE_1"
+ "DIMINDEX_FINITE_SUM" > "HOLLight.hollight.DIMINDEX_FINITE_SUM"
+ "DIMINDEX_FINITE_IMAGE" > "HOLLight.hollight.DIMINDEX_FINITE_IMAGE"
+ "DIFF_def" > "HOLLight.hollight.DIFF_def"
+ "DIFF_XM1" > "HOLLight.hollight.DIFF_XM1"
+ "DIFF_X" > "HOLLight.hollight.DIFF_X"
+ "DIFF_UNIV" > "HOLLight.hollight.DIFF_UNIV"
+ "DIFF_UNIQ" > "HOLLight.hollight.DIFF_UNIQ"
+ "DIFF_TAN_COMPOSITE" > "HOLLight.hollight.DIFF_TAN_COMPOSITE"
+ "DIFF_TAN" > "HOLLight.hollight.DIFF_TAN"
+ "DIFF_SUM" > "HOLLight.hollight.DIFF_SUM"
+ "DIFF_SUB" > "HOLLight.hollight.DIFF_SUB"
+ "DIFF_SIN" > "HOLLight.hollight.DIFF_SIN"
+ "DIFF_POW" > "HOLLight.hollight.DIFF_POW"
+ "DIFF_NEG" > "HOLLight.hollight.DIFF_NEG"
+ "DIFF_MUL" > "HOLLight.hollight.DIFF_MUL"
+ "DIFF_LN_COMPOSITE" > "HOLLight.hollight.DIFF_LN_COMPOSITE"
+ "DIFF_LN" > "HOLLight.hollight.DIFF_LN"
+ "DIFF_LMIN" > "HOLLight.hollight.DIFF_LMIN"
+ "DIFF_LMAX" > "HOLLight.hollight.DIFF_LMAX"
+ "DIFF_LINC" > "HOLLight.hollight.DIFF_LINC"
+ "DIFF_LDEC" > "HOLLight.hollight.DIFF_LDEC"
+ "DIFF_LCONST" > "HOLLight.hollight.DIFF_LCONST"
+ "DIFF_ISCONST_END_SIMPLE" > "HOLLight.hollight.DIFF_ISCONST_END_SIMPLE"
+ "DIFF_ISCONST_END" > "HOLLight.hollight.DIFF_ISCONST_END"
+ "DIFF_ISCONST_ALL" > "HOLLight.hollight.DIFF_ISCONST_ALL"
+ "DIFF_ISCONST" > "HOLLight.hollight.DIFF_ISCONST"
+ "DIFF_INVERSE_LT" > "HOLLight.hollight.DIFF_INVERSE_LT"
+ "DIFF_INVERSE" > "HOLLight.hollight.DIFF_INVERSE"
+ "DIFF_INV" > "HOLLight.hollight.DIFF_INV"
+ "DIFF_INSERT" > "HOLLight.hollight.DIFF_INSERT"
+ "DIFF_EXP" > "HOLLight.hollight.DIFF_EXP"
+ "DIFF_EQ_EMPTY" > "HOLLight.hollight.DIFF_EQ_EMPTY"
+ "DIFF_EMPTY" > "HOLLight.hollight.DIFF_EMPTY"
+ "DIFF_DIV" > "HOLLight.hollight.DIFF_DIV"
+ "DIFF_DIFF" > "HOLLight.hollight.DIFF_DIFF"
+ "DIFF_COS" > "HOLLight.hollight.DIFF_COS"
+ "DIFF_CONT" > "HOLLight.hollight.DIFF_CONT"
+ "DIFF_CONST" > "HOLLight.hollight.DIFF_CONST"
+ "DIFF_COMPOSITE" > "HOLLight.hollight.DIFF_COMPOSITE"
+ "DIFF_CMUL" > "HOLLight.hollight.DIFF_CMUL"
+ "DIFF_CHAIN" > "HOLLight.hollight.DIFF_CHAIN"
+ "DIFF_CARAT" > "HOLLight.hollight.DIFF_CARAT"
+ "DIFF_ATN_COMPOSITE" > "HOLLight.hollight.DIFF_ATN_COMPOSITE"
+ "DIFF_ATN" > "HOLLight.hollight.DIFF_ATN"
+ "DIFF_ASN_COS" > "HOLLight.hollight.DIFF_ASN_COS"
+ "DIFF_ASN" > "HOLLight.hollight.DIFF_ASN"
+ "DIFF_ADD" > "HOLLight.hollight.DIFF_ADD"
+ "DIFF_ACS_SIN" > "HOLLight.hollight.DIFF_ACS_SIN"
+ "DIFF_ACS" > "HOLLight.hollight.DIFF_ACS"
+ "DIFFS_NEG" > "HOLLight.hollight.DIFFS_NEG"
+ "DIFFS_LEMMA2" > "HOLLight.hollight.DIFFS_LEMMA2"
+ "DIFFS_LEMMA" > "HOLLight.hollight.DIFFS_LEMMA"
+ "DIFFS_EQUIV" > "HOLLight.hollight.DIFFS_EQUIV"
+ "DEST_REC_INJ" > "HOLLight.hollight.recspace._dest_rec_inject"
+ "DELETE_def" > "HOLLight.hollight.DELETE_def"
+ "DELETE_SUBSET" > "HOLLight.hollight.DELETE_SUBSET"
+ "DELETE_NON_ELEMENT" > "HOLLight.hollight.DELETE_NON_ELEMENT"
+ "DELETE_INTER" > "HOLLight.hollight.DELETE_INTER"
+ "DELETE_INSERT" > "HOLLight.hollight.DELETE_INSERT"
+ "DELETE_DELETE" > "HOLLight.hollight.DELETE_DELETE"
+ "DELETE_COMM" > "HOLLight.hollight.DELETE_COMM"
+ "DEF_~" > "HOL.simp_thms_19"
+ "DEF_two_2" > "HOLLight.hollight.DEF_two_2"
+ "DEF_two_1" > "HOLLight.hollight.DEF_two_1"
+ "DEF_treal_of_num" > "HOLLight.hollight.DEF_treal_of_num"
+ "DEF_treal_neg" > "HOLLight.hollight.DEF_treal_neg"
+ "DEF_treal_mul" > "HOLLight.hollight.DEF_treal_mul"
+ "DEF_treal_le" > "HOLLight.hollight.DEF_treal_le"
+ "DEF_treal_inv" > "HOLLight.hollight.DEF_treal_inv"
+ "DEF_treal_eq" > "HOLLight.hollight.DEF_treal_eq"
+ "DEF_treal_add" > "HOLLight.hollight.DEF_treal_add"
+ "DEF_three_3" > "HOLLight.hollight.DEF_three_3"
+ "DEF_three_2" > "HOLLight.hollight.DEF_three_2"
+ "DEF_three_1" > "HOLLight.hollight.DEF_three_1"
+ "DEF_tendsto" > "HOLLight.hollight.DEF_tendsto"
+ "DEF_tends_real_real" > "HOLLight.hollight.DEF_tends_real_real"
+ "DEF_tends_num_real" > "HOLLight.hollight.DEF_tends_num_real"
+ "DEF_tends" > "HOLLight.hollight.DEF_tends"
+ "DEF_tdiv" > "HOLLight.hollight.DEF_tdiv"
+ "DEF_tan" > "HOLLight.hollight.DEF_tan"
+ "DEF_tailadmissible" > "HOLLight.hollight.DEF_tailadmissible"
+ "DEF_support" > "HOLLight.hollight.DEF_support"
+ "DEF_superadmissible" > "HOLLight.hollight.DEF_superadmissible"
+ "DEF_sup" > "HOLLight.hollight.DEF_sup"
+ "DEF_sums" > "HOLLight.hollight.DEF_sums"
+ "DEF_summable" > "HOLLight.hollight.DEF_summable"
+ "DEF_suminf" > "HOLLight.hollight.DEF_suminf"
+ "DEF_sum" > "HOLLight.hollight.DEF_sum"
+ "DEF_subseq" > "HOLLight.hollight.DEF_subseq"
+ "DEF_sqrt" > "HOLLight.hollight.DEF_sqrt"
+ "DEF_sndcart" > "HOLLight.hollight.DEF_sndcart"
+ "DEF_sin" > "HOLLight.hollight.DEF_sin"
+ "DEF_set_of_list" > "HOLLight.hollight.DEF_set_of_list"
+ "DEF_rsum" > "HOLLight.hollight.DEF_rsum"
+ "DEF_root" > "HOLLight.hollight.DEF_root"
+ "DEF_real_sub" > "HOLLight.hollight.DEF_real_sub"
+ "DEF_real_pow" > "HOLLight.hollight.DEF_real_pow"
+ "DEF_real_of_num" > "HOLLight.hollight.DEF_real_of_num"
+ "DEF_real_neg" > "HOLLight.hollight.DEF_real_neg"
+ "DEF_real_mul" > "HOLLight.hollight.DEF_real_mul"
+ "DEF_real_min" > "HOLLight.hollight.DEF_real_min"
+ "DEF_real_max" > "HOLLight.hollight.DEF_real_max"
+ "DEF_real_lt" > "HOLLight.hollight.DEF_real_lt"
+ "DEF_real_le" > "HOLLight.hollight.DEF_real_le"
+ "DEF_real_inv" > "HOLLight.hollight.DEF_real_inv"
+ "DEF_real_gt" > "HOLLight.hollight.DEF_real_gt"
+ "DEF_real_ge" > "HOLLight.hollight.DEF_real_ge"
+ "DEF_real_div" > "HOLLight.hollight.DEF_real_div"
+ "DEF_real_add" > "HOLLight.hollight.DEF_real_add"
+ "DEF_real_abs" > "HOLLight.hollight.DEF_real_abs"
+ "DEF_re_universe" > "HOLLight.hollight.DEF_re_universe"
+ "DEF_re_union" > "HOLLight.hollight.DEF_re_union"
+ "DEF_re_subset" > "HOLLight.hollight.DEF_re_subset"
+ "DEF_re_null" > "HOLLight.hollight.DEF_re_null"
+ "DEF_re_intersect" > "HOLLight.hollight.DEF_re_intersect"
+ "DEF_re_compl" > "HOLLight.hollight.DEF_re_compl"
+ "DEF_re_Union" > "HOLLight.hollight.DEF_re_Union"
+ "DEF_psum" > "HOLLight.hollight.DEF_psum"
+ "DEF_pi" > "HOLLight.hollight.DEF_pi"
+ "DEF_pastecart" > "HOLLight.hollight.DEF_pastecart"
+ "DEF_pairwise" > "HOLLight.hollight.DEF_pairwise"
+ "DEF_o" > "Fun.o_apply"
+ "DEF_nsum" > "HOLLight.hollight.DEF_nsum"
+ "DEF_neutral" > "HOLLight.hollight.DEF_neutral"
+ "DEF_neigh" > "HOLLight.hollight.DEF_neigh"
+ "DEF_nadd_rinv" > "HOLLight.hollight.DEF_nadd_rinv"
+ "DEF_nadd_of_num" > "HOLLight.hollight.DEF_nadd_of_num"
+ "DEF_nadd_mul" > "HOLLight.hollight.DEF_nadd_mul"
+ "DEF_nadd_le" > "HOLLight.hollight.DEF_nadd_le"
+ "DEF_nadd_inv" > "HOLLight.hollight.DEF_nadd_inv"
+ "DEF_nadd_eq" > "HOLLight.hollight.DEF_nadd_eq"
+ "DEF_nadd_add" > "HOLLight.hollight.DEF_nadd_add"
+ "DEF_mtop" > "HOLLight.hollight.DEF_mtop"
+ "DEF_mr1" > "HOLLight.hollight.DEF_mr1"
+ "DEF_monoidal" > "HOLLight.hollight.DEF_monoidal"
+ "DEF_mono" > "HOLLight.hollight.DEF_mono"
+ "DEF_mod_real" > "HOLLight.hollight.DEF_mod_real"
+ "DEF_mod_nat" > "HOLLight.hollight.DEF_mod_nat"
+ "DEF_mod_int" > "HOLLight.hollight.DEF_mod_int"
+ "DEF_mk_pair" > "Product_Type.Pair_Rep_def"
+ "DEF_minimal" > "HOLLight.hollight.DEF_minimal"
+ "DEF_measure" > "HOLLight.hollight.DEF_measure"
+ "DEF_ln" > "HOLLight.hollight.DEF_ln"
+ "DEF_list_of_set" > "HOLLight.hollight.DEF_list_of_set"
+ "DEF_limpt" > "HOLLight.hollight.DEF_limpt"
+ "DEF_lim" > "HOLLight.hollight.DEF_lim"
+ "DEF_lambda" > "HOLLight.hollight.DEF_lambda"
+ "DEF_iterate" > "HOLLight.hollight.DEF_iterate"
+ "DEF_istopology" > "HOLLight.hollight.DEF_istopology"
+ "DEF_ismet" > "HOLLight.hollight.DEF_ismet"
+ "DEF_is_nadd" > "HOLLight.hollight.DEF_is_nadd"
+ "DEF_is_int" > "HOLLight.hollight.DEF_is_int"
+ "DEF_int_sub" > "HOLLight.hollight.DEF_int_sub"
+ "DEF_int_pow" > "HOLLight.hollight.DEF_int_pow"
+ "DEF_int_of_num" > "HOLLight.hollight.DEF_int_of_num"
+ "DEF_int_neg" > "HOLLight.hollight.DEF_int_neg"
+ "DEF_int_mul" > "HOLLight.hollight.DEF_int_mul"
+ "DEF_int_min" > "HOLLight.hollight.DEF_int_min"
+ "DEF_int_max" > "HOLLight.hollight.DEF_int_max"
+ "DEF_int_lt" > "HOLLight.hollight.DEF_int_lt"
+ "DEF_int_le" > "HOLLight.hollight.DEF_int_le"
+ "DEF_int_gt" > "HOLLight.hollight.DEF_int_gt"
+ "DEF_int_ge" > "HOLLight.hollight.DEF_int_ge"
+ "DEF_int_add" > "HOLLight.hollight.DEF_int_add"
+ "DEF_int_abs" > "HOLLight.hollight.DEF_int_abs"
+ "DEF_hreal_of_num" > "HOLLight.hollight.DEF_hreal_of_num"
+ "DEF_hreal_mul" > "HOLLight.hollight.DEF_hreal_mul"
+ "DEF_hreal_le" > "HOLLight.hollight.DEF_hreal_le"
+ "DEF_hreal_inv" > "HOLLight.hollight.DEF_hreal_inv"
+ "DEF_hreal_add" > "HOLLight.hollight.DEF_hreal_add"
+ "DEF_gauge" > "HOLLight.hollight.DEF_gauge"
+ "DEF_fstcart" > "HOLLight.hollight.DEF_fstcart"
+ "DEF_finite_index" > "HOLLight.hollight.DEF_finite_index"
+ "DEF_fine" > "HOLLight.hollight.DEF_fine"
+ "DEF_exp" > "HOLLight.hollight.DEF_exp"
+ "DEF_dsize" > "HOLLight.hollight.DEF_dsize"
+ "DEF_dorder" > "HOLLight.hollight.DEF_dorder"
+ "DEF_division" > "HOLLight.hollight.DEF_division"
+ "DEF_dist" > "HOLLight.hollight.DEF_dist"
+ "DEF_dimindex" > "HOLLight.hollight.DEF_dimindex"
+ "DEF_diffs" > "HOLLight.hollight.DEF_diffs"
+ "DEF_diffl" > "HOLLight.hollight.DEF_diffl"
+ "DEF_differentiable" > "HOLLight.hollight.DEF_differentiable"
+ "DEF_defint" > "HOLLight.hollight.DEF_defint"
+ "DEF_cos" > "HOLLight.hollight.DEF_cos"
+ "DEF_convergent" > "HOLLight.hollight.DEF_convergent"
+ "DEF_contl" > "HOLLight.hollight.DEF_contl"
+ "DEF_closed" > "HOLLight.hollight.DEF_closed"
+ "DEF_cauchy" > "HOLLight.hollight.DEF_cauchy"
+ "DEF_bounded" > "HOLLight.hollight.DEF_bounded"
+ "DEF_ball" > "HOLLight.hollight.DEF_ball"
+ "DEF_atn" > "HOLLight.hollight.DEF_atn"
+ "DEF_asn" > "HOLLight.hollight.DEF_asn"
+ "DEF_admissible" > "HOLLight.hollight.DEF_admissible"
+ "DEF_acs" > "HOLLight.hollight.DEF_acs"
+ "DEF__star_" > "HOLLightCompat.mult_altdef"
+ "DEF__slash__backslash_" > "HOLLightCompat.light_and_def"
+ "DEF__questionmark__exclamationmark_" > "HOL4Compat.EXISTS_UNIQUE_DEF"
+ "DEF__questionmark_" > "HOL.Ex_def"
+ "DEF__lessthan__equal_" > "HOLLight.hollight.DEF__lessthan__equal_"
+ "DEF__lessthan_" > "HOLLight.hollight.DEF__lessthan_"
+ "DEF__greaterthan__equal_" > "HOLLight.hollight.DEF__greaterthan__equal_"
+ "DEF__greaterthan_" > "HOLLight.hollight.DEF__greaterthan_"
+ "DEF__exclamationmark_" > "HOL.All_def"
+ "DEF__equal__equal__greaterthan_" > "HOLLightCompat.light_imp_def"
+ "DEF__equal__equal_" > "HOLLight.hollight.DEF__equal__equal_"
+ "DEF__dot__dot_" > "HOLLight.hollight.DEF__dot__dot_"
+ "DEF__backslash__slash_" > "HOL.or_def"
+ "DEF__FALSITY_" > "HOLLight.hollight.DEF__FALSITY_"
+ "DEF__10314" > "HOLLight.hollight.DEF__10314"
+ "DEF__10313" > "HOLLight.hollight.DEF__10313"
+ "DEF__10312" > "HOLLight.hollight.DEF__10312"
+ "DEF__10289" > "HOLLight.hollight.DEF__10289"
+ "DEF__10288" > "HOLLight.hollight.DEF__10288"
+ "DEF_ZRECSPACE" > "HOLLight.hollight.DEF_ZRECSPACE"
+ "DEF_ZIP" > "HOLLight.hollight.DEF_ZIP"
+ "DEF_ZCONSTR" > "HOLLight.hollight.DEF_ZCONSTR"
+ "DEF_ZBOT" > "HOLLight.hollight.DEF_ZBOT"
+ "DEF_WF" > "HOLLight.hollight.DEF_WF"
+ "DEF_UNIV" > "HOLLight.hollight.DEF_UNIV"
+ "DEF_UNIONS" > "HOLLight.hollight.DEF_UNIONS"
+ "DEF_UNION" > "HOLLight.hollight.DEF_UNION"
+ "DEF_UNCURRY" > "HOLLight.hollight.DEF_UNCURRY"
+ "DEF_TL" > "HOLLight.hollight.DEF_TL"
+ "DEF_T" > "HOL.True_def"
+ "DEF_SURJ" > "HOLLight.hollight.DEF_SURJ"
+ "DEF_SUBSET" > "HOLLight.hollight.DEF_SUBSET"
+ "DEF_SOME" > "HOLLight.hollight.DEF_SOME"
+ "DEF_SND" > "HOLLightCompat.snd_altdef"
+ "DEF_SING" > "HOLLight.hollight.DEF_SING"
+ "DEF_SETSPEC" > "HOLLight.hollight.DEF_SETSPEC"
+ "DEF_REVERSE" > "HOLLight.hollight.DEF_REVERSE"
+ "DEF_REST" > "HOLLight.hollight.DEF_REST"
+ "DEF_REPLICATE" > "HOLLight.hollight.DEF_REPLICATE"
+ "DEF_PSUBSET" > "HOLLight.hollight.DEF_PSUBSET"
+ "DEF_PRE" > "HOLLightCompat.Pred_altdef"
+ "DEF_PASSOC" > "HOLLight.hollight.DEF_PASSOC"
+ "DEF_PAIRWISE" > "HOLLight.hollight.DEF_PAIRWISE"
+ "DEF_OUTR" > "HOLLight.hollight.DEF_OUTR"
+ "DEF_OUTL" > "HOLLight.hollight.DEF_OUTL"
+ "DEF_ONTO" > "Fun.surj_def"
+ "DEF_ONE_ONE" > "HOL4Setup.ONE_ONE_DEF"
+ "DEF_ODD" > "HOLLight.hollight.DEF_ODD"
+ "DEF_NUMSUM" > "HOLLight.hollight.DEF_NUMSUM"
+ "DEF_NUMSND" > "HOLLight.hollight.DEF_NUMSND"
+ "DEF_NUMRIGHT" > "HOLLight.hollight.DEF_NUMRIGHT"
+ "DEF_NUMPAIR" > "HOLLight.hollight.DEF_NUMPAIR"
+ "DEF_NUMLEFT" > "HOLLight.hollight.DEF_NUMLEFT"
+ "DEF_NUMFST" > "HOLLight.hollight.DEF_NUMFST"
+ "DEF_NUMERAL" > "HOLLightCompat.NUMERAL_rew"
+ "DEF_NULL" > "HOLLight.hollight.DEF_NULL"
+ "DEF_NONE" > "HOLLight.hollight.DEF_NONE"
+ "DEF_NIL" > "HOLLight.hollight.DEF_NIL"
+ "DEF_MOD" > "HOLLight.hollight.DEF_MOD"
+ "DEF_MEM" > "HOLLight.hollight.DEF_MEM"
+ "DEF_MAP2" > "HOLLight.hollight.DEF_MAP2"
+ "DEF_MAP" > "HOLLight.hollight.DEF_MAP"
+ "DEF_LET_END" > "HOLLight.hollight.DEF_LET_END"
+ "DEF_LET" > "HOL4Compat.LET_def"
+ "DEF_LENGTH" > "HOLLight.hollight.DEF_LENGTH"
+ "DEF_LAST" > "HOLLight.hollight.DEF_LAST"
+ "DEF_ITSET" > "HOLLight.hollight.DEF_ITSET"
+ "DEF_ITLIST2" > "HOLLight.hollight.DEF_ITLIST2"
+ "DEF_ITLIST" > "HOLLight.hollight.DEF_ITLIST"
+ "DEF_ISO" > "HOLLight.hollight.DEF_ISO"
+ "DEF_INTERS" > "HOLLight.hollight.DEF_INTERS"
+ "DEF_INTER" > "HOLLight.hollight.DEF_INTER"
+ "DEF_INSERT" > "HOLLight.hollight.DEF_INSERT"
+ "DEF_INR" > "HOLLight.hollight.DEF_INR"
+ "DEF_INL" > "HOLLight.hollight.DEF_INL"
+ "DEF_INJP" > "HOLLight.hollight.DEF_INJP"
+ "DEF_INJN" > "HOLLight.hollight.DEF_INJN"
+ "DEF_INJF" > "HOLLight.hollight.DEF_INJF"
+ "DEF_INJA" > "HOLLight.hollight.DEF_INJA"
+ "DEF_INJ" > "HOLLight.hollight.DEF_INJ"
+ "DEF_INFINITE" > "HOLLight.hollight.DEF_INFINITE"
+ "DEF_IN" > "HOLLight.hollight.DEF_IN"
+ "DEF_IMAGE" > "HOLLight.hollight.DEF_IMAGE"
+ "DEF_I" > "Fun.id_apply"
+ "DEF_HD" > "HOLLight.hollight.DEF_HD"
+ "DEF_HAS_SIZE" > "HOLLight.hollight.DEF_HAS_SIZE"
+ "DEF_GSPEC" > "HOLLight.hollight.DEF_GSPEC"
+ "DEF_GEQ" > "HOLLight.hollight.DEF_GEQ"
+ "DEF_GABS" > "HOLLight.hollight.DEF_GABS"
+ "DEF_FST" > "HOLLightCompat.fst_altdef"
+ "DEF_FNIL" > "HOLLight.hollight.DEF_FNIL"
+ "DEF_FINREC" > "HOLLight.hollight.DEF_FINREC"
+ "DEF_FINITE" > "HOLLight.hollight.DEF_FINITE"
+ "DEF_FILTER" > "HOLLight.hollight.DEF_FILTER"
+ "DEF_FCONS" > "HOLLight.hollight.DEF_FCONS"
+ "DEF_FACT" > "HOLLight.hollight.DEF_FACT"
+ "DEF_F" > "HOL.False_def"
+ "DEF_EXP" > "HOLLight.hollight.DEF_EXP"
+ "DEF_EX" > "HOLLight.hollight.DEF_EX"
+ "DEF_EVEN" > "HOLLight.hollight.DEF_EVEN"
+ "DEF_EMPTY" > "HOLLight.hollight.DEF_EMPTY"
+ "DEF_EL" > "HOLLight.hollight.DEF_EL"
+ "DEF_DIV" > "HOLLight.hollight.DEF_DIV"
+ "DEF_DISJOINT" > "HOLLight.hollight.DEF_DISJOINT"
+ "DEF_DIFF" > "HOLLight.hollight.DEF_DIFF"
+ "DEF_DELETE" > "HOLLight.hollight.DEF_DELETE"
+ "DEF_DECIMAL" > "HOLLight.hollight.DEF_DECIMAL"
+ "DEF_CURRY" > "HOLLight.hollight.DEF_CURRY"
+ "DEF_COUNTABLE" > "HOLLight.hollight.DEF_COUNTABLE"
+ "DEF_CONSTR" > "HOLLight.hollight.DEF_CONSTR"
+ "DEF_CONS" > "HOLLight.hollight.DEF_CONS"
+ "DEF_COND" > "HOLLight.hollight.DEF_COND"
+ "DEF_CHOICE" > "HOLLight.hollight.DEF_CHOICE"
+ "DEF_CASEWISE" > "HOLLight.hollight.DEF_CASEWISE"
+ "DEF_CARD_LT" > "HOLLight.hollight.DEF_CARD_LT"
+ "DEF_CARD_LE" > "HOLLight.hollight.DEF_CARD_LE"
+ "DEF_CARD_GT" > "HOLLight.hollight.DEF_CARD_GT"
+ "DEF_CARD_GE" > "HOLLight.hollight.DEF_CARD_GE"
+ "DEF_CARD_EQ" > "HOLLight.hollight.DEF_CARD_EQ"
+ "DEF_CARD" > "HOLLight.hollight.DEF_CARD"
+ "DEF_BOTTOM" > "HOLLight.hollight.DEF_BOTTOM"
+ "DEF_BIT1" > "HOLLightCompat.NUMERAL_BIT1_altdef"
+ "DEF_BIT0" > "HOLLightCompat.NUMERAL_BIT0_def"
+ "DEF_BIJ" > "HOLLight.hollight.DEF_BIJ"
+ "DEF_ASSOC" > "HOLLight.hollight.DEF_ASSOC"
+ "DEF_APPEND" > "HOLLight.hollight.DEF_APPEND"
+ "DEF_ALL2" > "HOLLight.hollight.DEF_ALL2"
+ "DEF_ALL" > "HOLLight.hollight.DEF_ALL"
+ "DEF_-" > "HOLLightCompat.sub_altdef"
+ "DEF_," > "Product_Type.Pair_def"
+ "DEF_+" > "HOLLightCompat.add_altdef"
+ "DEF_$" > "HOLLight.hollight.DEF_$"
+ "DECOMPOSITION" > "HOLLight.hollight.DECOMPOSITION"
+ "DECIMAL_def" > "HOLLight.hollight.DECIMAL_def"
+ "CURRY_def" > "HOLLight.hollight.CURRY_def"
+ "COUNTABLE_def" > "HOLLight.hollight.COUNTABLE_def"
+ "COS_ZERO_LEMMA" > "HOLLight.hollight.COS_ZERO_LEMMA"
+ "COS_ZERO" > "HOLLight.hollight.COS_ZERO"
+ "COS_TOTAL" > "HOLLight.hollight.COS_TOTAL"
+ "COS_SIN_SQRT" > "HOLLight.hollight.COS_SIN_SQRT"
+ "COS_SIN" > "HOLLight.hollight.COS_SIN"
+ "COS_POS_PI2" > "HOLLight.hollight.COS_POS_PI2"
+ "COS_POS_PI" > "HOLLight.hollight.COS_POS_PI"
+ "COS_PI2" > "HOLLight.hollight.COS_PI2"
+ "COS_PI" > "HOLLight.hollight.COS_PI"
+ "COS_PERIODIC_PI" > "HOLLight.hollight.COS_PERIODIC_PI"
+ "COS_PERIODIC" > "HOLLight.hollight.COS_PERIODIC"
+ "COS_PAIRED" > "HOLLight.hollight.COS_PAIRED"
+ "COS_ONE_2PI" > "HOLLight.hollight.COS_ONE_2PI"
+ "COS_NPI" > "HOLLight.hollight.COS_NPI"
+ "COS_NEG" > "HOLLight.hollight.COS_NEG"
+ "COS_ISZERO" > "HOLLight.hollight.COS_ISZERO"
+ "COS_FDIFF" > "HOLLight.hollight.COS_FDIFF"
+ "COS_DOUBLE" > "HOLLight.hollight.COS_DOUBLE"
+ "COS_CONVERGES" > "HOLLight.hollight.COS_CONVERGES"
+ "COS_BOUNDS" > "HOLLight.hollight.COS_BOUNDS"
+ "COS_BOUND" > "HOLLight.hollight.COS_BOUND"
+ "COS_ATN_NZ" > "HOLLight.hollight.COS_ATN_NZ"
+ "COS_ASN_NZ" > "HOLLight.hollight.COS_ASN_NZ"
+ "COS_ADD" > "HOLLight.hollight.COS_ADD"
+ "COS_ACS" > "HOLLight.hollight.COS_ACS"
+ "COS_ABS" > "HOLLight.hollight.COS_ABS"
+ "COS_2" > "HOLLight.hollight.COS_2"
+ "COS_0" > "HOLLight.hollight.COS_0"
+ "CONT_X" > "HOLLight.hollight.CONT_X"
+ "CONT_SUB" > "HOLLight.hollight.CONT_SUB"
+ "CONT_NEG" > "HOLLight.hollight.CONT_NEG"
+ "CONT_MUL" > "HOLLight.hollight.CONT_MUL"
+ "CONT_INVERSE" > "HOLLight.hollight.CONT_INVERSE"
+ "CONT_INV" > "HOLLight.hollight.CONT_INV"
+ "CONT_INJ_RANGE" > "HOLLight.hollight.CONT_INJ_RANGE"
+ "CONT_INJ_LEMMA2" > "HOLLight.hollight.CONT_INJ_LEMMA2"
+ "CONT_INJ_LEMMA" > "HOLLight.hollight.CONT_INJ_LEMMA"
+ "CONT_HASSUP" > "HOLLight.hollight.CONT_HASSUP"
+ "CONT_DIV" > "HOLLight.hollight.CONT_DIV"
+ "CONT_CONST" > "HOLLight.hollight.CONT_CONST"
+ "CONT_COMPOSE" > "HOLLight.hollight.CONT_COMPOSE"
+ "CONT_BOUNDED_ABS" > "HOLLight.hollight.CONT_BOUNDED_ABS"
+ "CONT_BOUNDED" > "HOLLight.hollight.CONT_BOUNDED"
+ "CONT_ATTAINS_ALL" > "HOLLight.hollight.CONT_ATTAINS_ALL"
+ "CONT_ATTAINS2" > "HOLLight.hollight.CONT_ATTAINS2"
+ "CONT_ATTAINS" > "HOLLight.hollight.CONT_ATTAINS"
+ "CONT_ADD" > "HOLLight.hollight.CONT_ADD"
+ "CONTL_LIM" > "HOLLight.hollight.CONTL_LIM"
+ "CONS_def" > "HOLLight.hollight.CONS_def"
+ "CONS_11" > "HOLLight.hollight.CONS_11"
+ "CONSTR_def" > "HOLLight.hollight.CONSTR_def"
+ "CONSTR_REC" > "HOLLight.hollight.CONSTR_REC"
+ "CONSTR_INJ" > "HOLLight.hollight.CONSTR_INJ"
+ "CONSTR_IND" > "HOLLight.hollight.CONSTR_IND"
+ "CONSTR_BOT" > "HOLLight.hollight.CONSTR_BOT"
+ "CONJ_SYM" > "HOL.conj_comms_1"
+ "CONJ_ASSOC" > "HOL.conj_assoc"
+ "CONJ_ACI" > "HOLLight.hollight.CONJ_ACI"
+ "COND_def" > "HOLLight.hollight.COND_def"
+ "COND_RATOR" > "HOLLight.hollight.COND_RATOR"
+ "COND_RAND" > "HOLLight.hollight.COND_RAND"
+ "COND_ID" > "HOLLight.hollight.COND_ID"
+ "COND_EXPAND" > "HOLLight.hollight.COND_EXPAND"
+ "COND_EQ_CLAUSE" > "HOLLight.hollight.COND_EQ_CLAUSE"
+ "COND_ELIM_THM" > "HOLLight.hollight.COND_ELIM_THM"
+ "COND_CLAUSES" > "HOLLight.hollight.COND_CLAUSES"
+ "COND_ABS" > "HOLLight.hollight.COND_ABS"
+ "COMPONENT" > "HOLLight.hollight.COMPONENT"
+ "COMPL_MEM" > "HOLLight.hollight.COMPL_MEM"
+ "CLOSED_LIMPT" > "HOLLight.hollight.CLOSED_LIMPT"
+ "CIRCLE_SINCOS" > "HOLLight.hollight.CIRCLE_SINCOS"
+ "CHOOSE_SUBSET" > "HOLLight.hollight.CHOOSE_SUBSET"
+ "CHOICE_def" > "HOLLight.hollight.CHOICE_def"
+ "CHOICE_DEF" > "HOLLight.hollight.CHOICE_DEF"
+ "CASEWISE_def" > "HOLLight.hollight.CASEWISE_def"
+ "CASEWISE_WORKS" > "HOLLight.hollight.CASEWISE_WORKS"
+ "CASEWISE_CASES" > "HOLLight.hollight.CASEWISE_CASES"
+ "CASEWISE" > "HOLLight.hollight.CASEWISE"
+ "CART_EQ" > "HOLLight.hollight.CART_EQ"
+ "CARD_def" > "HOLLight.hollight.CARD_def"
+ "CARD_UNION_LE" > "HOLLight.hollight.CARD_UNION_LE"
+ "CARD_UNION_EQ" > "HOLLight.hollight.CARD_UNION_EQ"
+ "CARD_UNIONS_LE" > "HOLLight.hollight.CARD_UNIONS_LE"
+ "CARD_UNION" > "HOLLight.hollight.CARD_UNION"
+ "CARD_SUBSET_LE" > "HOLLight.hollight.CARD_SUBSET_LE"
+ "CARD_SUBSET_EQ" > "HOLLight.hollight.CARD_SUBSET_EQ"
+ "CARD_SUBSET" > "HOLLight.hollight.CARD_SUBSET"
+ "CARD_PSUBSET" > "HOLLight.hollight.CARD_PSUBSET"
+ "CARD_PRODUCT" > "HOLLight.hollight.CARD_PRODUCT"
+ "CARD_POWERSET" > "HOLLight.hollight.CARD_POWERSET"
+ "CARD_NUMSEG_LT" > "HOLLight.hollight.CARD_NUMSEG_LT"
+ "CARD_NUMSEG_LEMMA" > "HOLLight.hollight.CARD_NUMSEG_LEMMA"
+ "CARD_NUMSEG_LE" > "HOLLight.hollight.CARD_NUMSEG_LE"
+ "CARD_NUMSEG_1" > "HOLLight.hollight.CARD_NUMSEG_1"
+ "CARD_NUMSEG" > "HOLLight.hollight.CARD_NUMSEG"
+ "CARD_LT_def" > "HOLLight.hollight.CARD_LT_def"
+ "CARD_LE_def" > "HOLLight.hollight.CARD_LE_def"
+ "CARD_LE_INJ" > "HOLLight.hollight.CARD_LE_INJ"
+ "CARD_IMAGE_LE" > "HOLLight.hollight.CARD_IMAGE_LE"
+ "CARD_IMAGE_INJ" > "HOLLight.hollight.CARD_IMAGE_INJ"
+ "CARD_GT_def" > "HOLLight.hollight.CARD_GT_def"
+ "CARD_GE_def" > "HOLLight.hollight.CARD_GE_def"
+ "CARD_GE_TRANS" > "HOLLight.hollight.CARD_GE_TRANS"
+ "CARD_GE_REFL" > "HOLLight.hollight.CARD_GE_REFL"
+ "CARD_FUNSPACE" > "HOLLight.hollight.CARD_FUNSPACE"
+ "CARD_FINITE_IMAGE" > "HOLLight.hollight.CARD_FINITE_IMAGE"
+ "CARD_EQ_def" > "HOLLight.hollight.CARD_EQ_def"
+ "CARD_EQ_SUM" > "HOLLight.hollight.CARD_EQ_SUM"
+ "CARD_EQ_NSUM" > "HOLLight.hollight.CARD_EQ_NSUM"
+ "CARD_EQ_0" > "HOLLight.hollight.CARD_EQ_0"
+ "CARD_DELETE" > "HOLLight.hollight.CARD_DELETE"
+ "CARD_CLAUSES" > "HOLLight.hollight.CARD_CLAUSES"
+ "BOUNDS_NOTZERO" > "HOLLight.hollight.BOUNDS_NOTZERO"
+ "BOUNDS_LINEAR_0" > "HOLLight.hollight.BOUNDS_LINEAR_0"
+ "BOUNDS_LINEAR" > "HOLLight.hollight.BOUNDS_LINEAR"
+ "BOUNDS_IGNORE" > "HOLLight.hollight.BOUNDS_IGNORE"
+ "BOUNDS_DIVIDED" > "HOLLight.hollight.BOUNDS_DIVIDED"
+ "BOTTOM_def" > "HOLLight.hollight.BOTTOM_def"
+ "BOOL_CASES_AX" > "Datatype.bool.nchotomy"
+ "BOLZANO_LEMMA" > "HOLLight.hollight.BOLZANO_LEMMA"
+ "BIT1_THM" > "HOLLightCompat.NUMERAL_BIT1_altdef"
+ "BIT0_THM" > "HOLLightCompat.NUMERAL_BIT0_def"
+ "BIJ_def" > "HOLLight.hollight.BIJ_def"
+ "BETA_THM" > "Presburger.fm_modd_pinf"
+ "BALL_OPEN" > "HOLLight.hollight.BALL_OPEN"
+ "BALL_NEIGH" > "HOLLight.hollight.BALL_NEIGH"
+ "ATN_TAN" > "HOLLight.hollight.ATN_TAN"
+ "ATN_POS_LT" > "HOLLight.hollight.ATN_POS_LT"
+ "ATN_POS_LE" > "HOLLight.hollight.ATN_POS_LE"
+ "ATN_NEG" > "HOLLight.hollight.ATN_NEG"
+ "ATN_MONO_LT_EQ" > "HOLLight.hollight.ATN_MONO_LT_EQ"
+ "ATN_MONO_LT" > "HOLLight.hollight.ATN_MONO_LT"
+ "ATN_MONO_LE_EQ" > "HOLLight.hollight.ATN_MONO_LE_EQ"
+ "ATN_LT_PI4_POS" > "HOLLight.hollight.ATN_LT_PI4_POS"
+ "ATN_LT_PI4_NEG" > "HOLLight.hollight.ATN_LT_PI4_NEG"
+ "ATN_LT_PI4" > "HOLLight.hollight.ATN_LT_PI4"
+ "ATN_LE_PI4" > "HOLLight.hollight.ATN_LE_PI4"
+ "ATN_INJ" > "HOLLight.hollight.ATN_INJ"
+ "ATN_BOUNDS" > "HOLLight.hollight.ATN_BOUNDS"
+ "ATN_1" > "HOLLight.hollight.ATN_1"
+ "ATN_0" > "HOLLight.hollight.ATN_0"
+ "ATN" > "HOLLight.hollight.ATN"
+ "ASSOC_def" > "HOLLight.hollight.ASSOC_def"
+ "ASN_SIN" > "HOLLight.hollight.ASN_SIN"
+ "ASN_BOUNDS_LT" > "HOLLight.hollight.ASN_BOUNDS_LT"
+ "ASN_BOUNDS" > "HOLLight.hollight.ASN_BOUNDS"
+ "ASN" > "HOLLight.hollight.ASN"
+ "ARITH_ZERO" > "HOLLight.hollight.ARITH_ZERO"
+ "ARITH_SUC" > "HOLLight.hollight.ARITH_SUC"
+ "ARITH_SUB" > "HOLLight.hollight.ARITH_SUB"
+ "ARITH_PRE" > "HOLLight.hollight.ARITH_PRE"
+ "ARITH_ODD" > "HOLLight.hollight.ARITH_ODD"
+ "ARITH_MULT" > "HOLLight.hollight.ARITH_MULT"
+ "ARITH_LT" > "HOLLight.hollight.ARITH_LT"
+ "ARITH_LE" > "HOLLight.hollight.ARITH_LE"
+ "ARITH_EXP" > "HOLLight.hollight.ARITH_EXP"
+ "ARITH_EVEN" > "HOLLight.hollight.ARITH_EVEN"
+ "ARITH_EQ" > "HOLLight.hollight.ARITH_EQ"
+ "ARITH_ADD" > "HOLLight.hollight.ARITH_ADD"
+ "APPEND_def" > "HOLLight.hollight.APPEND_def"
+ "APPEND_NIL" > "HOLLight.hollight.APPEND_NIL"
+ "APPEND_EQ_NIL" > "HOLLight.hollight.APPEND_EQ_NIL"
+ "APPEND_ASSOC" > "HOLLight.hollight.APPEND_ASSOC"
+ "AND_FORALL_THM" > "HOL.all_conj_distrib"
+ "AND_CLAUSES" > "HOLLight.hollight.AND_CLAUSES"
+ "AND_ALL2" > "HOLLight.hollight.AND_ALL2"
+ "AND_ALL" > "HOLLight.hollight.AND_ALL"
+ "ALL_list_def" > "HOLLight.hollight.ALL_list_def"
+ "ALL_T" > "HOLLight.hollight.ALL_T"
+ "ALL_MP" > "HOLLight.hollight.ALL_MP"
+ "ALL_MEM" > "HOLLight.hollight.ALL_MEM"
+ "ALL_MAP" > "HOLLight.hollight.ALL_MAP"
+ "ALL_IMP" > "HOLLight.hollight.ALL_IMP"
+ "ALL_APPEND" > "HOLLight.hollight.ALL_APPEND"
+ "ALL2_def" > "HOLLight.hollight.ALL2_def"
+ "ALL2_MAP2" > "HOLLight.hollight.ALL2_MAP2"
+ "ALL2_MAP" > "HOLLight.hollight.ALL2_MAP"
+ "ALL2_AND_RIGHT" > "HOLLight.hollight.ALL2_AND_RIGHT"
+ "ALL2_ALL" > "HOLLight.hollight.ALL2_ALL"
+ "ALL2" > "HOLLight.hollight.ALL2"
+ "ADMISSIBLE_NEST" > "HOLLight.hollight.ADMISSIBLE_NEST"
+ "ADMISSIBLE_LAMBDA" > "HOLLight.hollight.ADMISSIBLE_LAMBDA"
+ "ADMISSIBLE_IMP_SUPERADMISSIBLE" > "HOLLight.hollight.ADMISSIBLE_IMP_SUPERADMISSIBLE"
+ "ADMISSIBLE_CONST" > "HOLLight.hollight.ADMISSIBLE_CONST"
+ "ADMISSIBLE_COND" > "HOLLight.hollight.ADMISSIBLE_COND"
+ "ADMISSIBLE_COMB" > "HOLLight.hollight.ADMISSIBLE_COMB"
+ "ADMISSIBLE_BASE" > "HOLLight.hollight.ADMISSIBLE_BASE"
+ "ADD_SYM" > "Finite_Set.AC_add.f.AC_2"
+ "ADD_SUC" > "Nat.add_Suc_right"
+ "ADD_SUBR2" > "Nat.diff_add_0"
+ "ADD_SUBR" > "HOLLight.hollight.ADD_SUBR"
+ "ADD_SUB2" > "Nat.diff_add_inverse"
+ "ADD_SUB" > "Nat.diff_add_inverse2"
+ "ADD_EQ_0" > "Nat.add_is_0"
+ "ADD_CLAUSES" > "HOLLight.hollight.ADD_CLAUSES"
+ "ADD_ASSOC" > "Finite_Set.AC_add.f.AC_1"
+ "ADD_AC" > "HOLLight.hollight.ADD_AC"
+ "ADD_0" > "Finite_Set.AC_add.f_e.ident"
+ "ADD1" > "HOLLight.hollight.ADD1"
+ "ACS_MONO_LT" > "HOLLight.hollight.ACS_MONO_LT"
+ "ACS_COS" > "HOLLight.hollight.ACS_COS"
+ "ACS_BOUNDS_LT" > "HOLLight.hollight.ACS_BOUNDS_LT"
+ "ACS_BOUNDS" > "HOLLight.hollight.ACS_BOUNDS"
+ "ACS" > "HOLLight.hollight.ACS"
+ "ABS_ZERO" > "HOLLight.hollight.ABS_ZERO"
+ "ABS_TRIANGLE" > "HOLLight.hollight.ABS_TRIANGLE"
+ "ABS_SUM" > "HOLLight.hollight.ABS_SUM"
+ "ABS_SUB_ABS" > "HOLLight.hollight.ABS_SUB_ABS"
+ "ABS_SUB" > "HOLLight.hollight.ABS_SUB"
+ "ABS_STILLNZ" > "HOLLight.hollight.ABS_STILLNZ"
+ "ABS_SIMP" > "Presburger.fm_modd_pinf"
+ "ABS_SIGN2" > "HOLLight.hollight.ABS_SIGN2"
+ "ABS_SIGN" > "HOLLight.hollight.ABS_SIGN"
+ "ABS_REFL" > "HOLLight.hollight.ABS_REFL"
+ "ABS_POW2" > "HOLLight.hollight.ABS_POW2"
+ "ABS_POS" > "HOLLight.hollight.ABS_POS"
+ "ABS_NZ" > "HOLLight.hollight.ABS_NZ"
+ "ABS_NEG_LEMMA" > "HOLLight.hollight.ABS_NEG_LEMMA"
+ "ABS_NEG" > "HOLLight.hollight.ABS_NEG"
+ "ABS_N" > "HOLLight.hollight.ABS_N"
+ "ABS_MUL" > "HOLLight.hollight.ABS_MUL"
+ "ABS_LT_MUL2" > "HOLLight.hollight.ABS_LT_MUL2"
+ "ABS_LE" > "HOLLight.hollight.ABS_LE"
+ "ABS_INV" > "HOLLight.hollight.ABS_INV"
+ "ABS_DIV" > "HOLLight.hollight.ABS_DIV"
+ "ABS_CIRCLE" > "HOLLight.hollight.ABS_CIRCLE"
+ "ABS_CASES" > "HOLLight.hollight.ABS_CASES"
+ "ABS_BOUNDS" > "HOLLight.hollight.ABS_BOUNDS"
+ "ABS_BOUND" > "HOLLight.hollight.ABS_BOUND"
+ "ABS_BETWEEN2" > "HOLLight.hollight.ABS_BETWEEN2"
+ "ABS_BETWEEN1" > "HOLLight.hollight.ABS_BETWEEN1"
+ "ABS_BETWEEN" > "HOLLight.hollight.ABS_BETWEEN"
+ "ABS_ABS" > "HOLLight.hollight.ABS_ABS"
+ "ABS_1" > "HOLLight.hollight.ABS_1"
+ "ABS_0" > "HOLLight.hollight.ABS_0"
+ "ABSORPTION" > "HOLLight.hollight.ABSORPTION"
+ ">_def" > "HOLLight.hollight.>_def"
+ ">=_def" > "HOLLight.hollight.>=_def"
+ "<_def" > "HOLLight.hollight.<_def"
+ "<=_def" > "HOLLight.hollight.<=_def"
+ "$_def" > "HOLLight.hollight.$_def"
+
+ignore_thms
+ "TYDEF_prod"
+ "TYDEF_num"
+ "TYDEF_1"
+ "IND_SUC_0_EXISTS"
+ "DEF_one"
+ "DEF__0"
+ "DEF_SUC"
+ "DEF_NUM_REP"
+ "DEF_IND_SUC"
+ "DEF_IND_0"
+
+end
--- a/src/HOL/Import/hol4rews.ML Mon Sep 26 02:06:44 2005 +0200
+++ b/src/HOL/Import/hol4rews.ML Mon Sep 26 02:27:14 2005 +0200
@@ -333,9 +333,10 @@
end
fun add_hol4_mapping bthy bthm isathm thy =
- let
- val isathm = follow_name isathm thy
- val _ = message ("Adding theorem map: " ^ bthy ^ "." ^ bthm ^ " --> " ^ isathm)
+ let
+ (* val _ = writeln ("Before follow_name: "^isathm) *)
+ val isathm = follow_name isathm thy
+ (* val _ = writeln ("Adding theorem map: " ^ bthy ^ "." ^ bthm ^ " --> " ^ isathm)*)
val curmaps = HOL4Maps.get thy
val newmaps = StringPair.update_new ((bthy,bthm),SOME isathm) curmaps
val upd_thy = HOL4Maps.put newmaps thy
--- a/src/HOL/Import/import_package.ML Mon Sep 26 02:06:44 2005 +0200
+++ b/src/HOL/Import/import_package.ML Mon Sep 26 02:27:14 2005 +0200
@@ -41,6 +41,7 @@
let
val sg = sign_of_thm th
val prem = hd (prems_of th)
+ val _ = message ("Import_tac: thyname="^thyname^", thmname="^thmname)
val _ = message ("Import trying to prove " ^ (string_of_cterm (cterm_of sg prem)))
val int_thms = case ImportData.get thy of
NONE => fst (Replay.setup_int_thms thyname thy)
@@ -52,6 +53,7 @@
val thm = equal_elim rew thm
val prew = ProofKernel.rewrite_hol4_term prem thy
val prem' = #2 (Logic.dest_equals (prop_of prew))
+ val thm = Drule.disambiguate_frees thm
val _ = message ("Import proved " ^ (string_of_thm thm))
in
case Shuffler.set_prop thy prem' [("",thm)] of
--- a/src/HOL/Import/import_syntax.ML Mon Sep 26 02:06:44 2005 +0200
+++ b/src/HOL/Import/import_syntax.ML Mon Sep 26 02:27:14 2005 +0200
@@ -50,6 +50,8 @@
val segname = get_import_segment thy
val (int_thms,facts) = Replay.setup_int_thms thyname thy
val thmnames = List.filter (not o should_ignore thyname thy) facts
+ (* val _ = set show_types
+ val _ = set show_sorts*)
in
thy |> clear_import_thy
|> set_segment thyname segname
--- a/src/HOL/Import/proof_kernel.ML Mon Sep 26 02:06:44 2005 +0200
+++ b/src/HOL/Import/proof_kernel.ML Mon Sep 26 02:27:14 2005 +0200
@@ -1290,13 +1290,14 @@
let
val sg = sign_of thy
val (hth' as HOLThm (args as (_,th))) = norm_hthm sg hth
- val _ = if has_ren hth' then warning ("Theorem " ^ thmname ^ " needs variable-disambiguating")
- else ()
val rew = rewrite_hol4_term (concl_of th) thy
val th = equal_elim rew th
val thy' = add_hol4_pending thyname thmname args thy
+ val th = Drule.disambiguate_frees th
val thy2 = if gen_output
- then add_dump ("lemma " ^ (quotename thmname) ^ ": " ^ (smart_string_of_thm th) ^ "\n by (import " ^ thyname ^ " " ^ (quotename thmname) ^ ")") thy'
+ then add_dump ("lemma " ^ (quotename thmname) ^ ": " ^
+ (smart_string_of_thm th) ^ "\n by (import " ^
+ thyname ^ " " ^ (quotename thmname) ^ ")") thy'
else thy'
in
(thy2,hth')