removed old HOL4 import -- corresponding exporter is lost, code is broken, no users known, maintenance nightmare
--- a/etc/settings Sun Apr 01 14:50:47 2012 +0200
+++ b/etc/settings Sun Apr 01 22:03:45 2012 +0200
@@ -190,9 +190,6 @@
## Set HOME only for tools you have installed!
-# HOL4 proof objects (cf. src/HOL/Import)
-#HOL4_PROOFS="$ISABELLE_HOME_USER/proofs:$ISABELLE_HOME/proofs"
-
# SVC (Stanford Validity Checker)
#SVC_HOME=
#SVC_MACHINE=i386-redhat-linux
--- a/src/HOL/Import/HOL4/Compatibility.thy Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,504 +0,0 @@
-(* Title: HOL/Import/HOL4/Compatibility.thy
- Author: Sebastian Skalberg (TU Muenchen)
-*)
-
-theory Compatibility
-imports
- Complex_Main
- "~~/src/HOL/Old_Number_Theory/Primes"
- "~~/src/HOL/Library/ContNotDenum"
- "~~/src/HOL/Import/Importer"
-begin
-
-abbreviation (input) mem (infixl "mem" 55) where "x mem xs \<equiv> List.member xs x"
-no_notation differentiable (infixl "differentiable" 60)
-no_notation sums (infixr "sums" 80)
-
-lemma EXISTS_UNIQUE_DEF: "(Ex1 P) = (Ex P & (ALL x y. P x & P y --> (x = y)))"
- by auto
-
-lemma COND_DEF:"(If b t f) = (@x. ((b = True) --> (x = t)) & ((b = False) --> (x = f)))"
- by auto
-
-definition LET :: "['a \<Rightarrow> 'b,'a] \<Rightarrow> 'b" where
- "LET f s == f s"
-
-lemma [import_rew]: "LET f s = Let s f"
- by (simp add: LET_def Let_def)
-
-lemmas [import_rew] = ONE_ONE_rew
-
-lemma bool_case_DEF: "(bool_case x y b) = (if b then x else y)"
- by simp
-
-lemma INR_INL_11: "(ALL y x. (Inl x = Inl y) = (x = y)) & (ALL y x. (Inr x = Inr y) = (x = y))"
- by safe
-
-(*lemma INL_neq_INR: "ALL v1 v2. Sum_Type.Inr v2 ~= Sum_Type.Inl v1"
- by simp*)
-
-primrec ISL :: "'a + 'b => bool" where
- "ISL (Inl x) = True"
-| "ISL (Inr x) = False"
-
-primrec ISR :: "'a + 'b => bool" where
- "ISR (Inl x) = False"
-| "ISR (Inr x) = True"
-
-lemma ISL: "(ALL x. ISL (Inl x)) & (ALL y. ~ISL (Inr y))"
- by simp
-
-lemma ISR: "(ALL x. ISR (Inr x)) & (ALL y. ~ISR (Inl y))"
- by simp
-
-primrec OUTL :: "'a + 'b => 'a" where
- "OUTL (Inl x) = x"
-
-primrec OUTR :: "'a + 'b => 'b" where
- "OUTR (Inr x) = x"
-
-lemma OUTL: "OUTL (Inl x) = x"
- by simp
-
-lemma OUTR: "OUTR (Inr x) = x"
- by simp
-
-lemma sum_axiom: "EX! h. h o Inl = f & h o Inr = g"
- apply (intro allI ex1I[of _ "sum_case f g"] conjI)
- apply (simp_all add: o_def fun_eq_iff)
- apply (rule)
- apply (induct_tac x)
- apply simp_all
- done
-
-lemma sum_case_def: "(ALL f g x. sum_case f g (Inl x) = f x) & (ALL f g y. sum_case f g (Inr y) = g y)"
- by simp
-
-lemma one: "ALL v. v = ()"
- by simp
-
-lemma option_case_def: "(!u f. option_case u f None = u) & (!u f x. option_case u f (Some x) = f x)"
- by simp
-
-lemma OPTION_MAP_DEF: "(!f x. Option.map f (Some x) = Some (f x)) & (!f. Option.map f None = None)"
- by simp
-
-primrec IS_SOME :: "'a option => bool" where
- "IS_SOME (Some x) = True"
-| "IS_SOME None = False"
-
-primrec IS_NONE :: "'a option => bool" where
- "IS_NONE (Some x) = False"
-| "IS_NONE None = True"
-
-lemma IS_NONE_DEF: "(!x. IS_NONE (Some x) = False) & (IS_NONE None = True)"
- by simp
-
-lemma IS_SOME_DEF: "(!x. IS_SOME (Some x) = True) & (IS_SOME None = False)"
- by simp
-
-primrec OPTION_JOIN :: "'a option option => 'a option" where
- "OPTION_JOIN None = None"
-| "OPTION_JOIN (Some x) = x"
-
-lemma OPTION_JOIN_DEF: "(OPTION_JOIN None = None) & (ALL x. OPTION_JOIN (Some x) = x)"
- by simp
-
-lemma PAIR: "(fst x,snd x) = x"
- by simp
-
-lemma PAIR_MAP: "map_pair f g p = (f (fst p),g (snd p))"
- by (simp add: map_pair_def split_def)
-
-lemma pair_case_def: "split = split"
- ..
-
-lemma LESS_OR_EQ: "m <= (n::nat) = (m < n | m = n)"
- by auto
-
-definition nat_gt :: "nat => nat => bool" where
- "nat_gt == %m n. n < m"
-
-definition nat_ge :: "nat => nat => bool" where
- "nat_ge == %m n. nat_gt m n | m = n"
-
-lemma [import_rew]: "nat_gt m n = (n < m)"
- by (simp add: nat_gt_def)
-
-lemma [import_rew]: "nat_ge m n = (n <= m)"
- by (auto simp add: nat_ge_def nat_gt_def)
-
-lemma GREATER_DEF: "ALL m n. (n < m) = (n < m)"
- by simp
-
-lemma GREATER_OR_EQ: "ALL m n. n <= (m::nat) = (n < m | m = n)"
- by auto
-
-lemma LESS_DEF: "m < n = (? P. (!n. P (Suc n) --> P n) & P m & ~P n)"
-proof safe
- assume 1: "m < n"
- def P == "%n. n <= m"
- have "(!n. P (Suc n) \<longrightarrow> P n) & P m & ~P n"
- proof (auto simp add: P_def)
- assume "n <= m"
- with 1
- show False
- by auto
- qed
- thus "? P. (!n. P (Suc n) \<longrightarrow> P n) & P m & ~P n"
- by auto
-next
- fix P
- assume alln: "!n. P (Suc n) \<longrightarrow> P n"
- assume pm: "P m"
- assume npn: "~P n"
- have "!k q. q + k = m \<longrightarrow> P q"
- proof
- fix k
- show "!q. q + k = m \<longrightarrow> P q"
- proof (induct k,simp_all)
- show "P m" by fact
- next
- fix k
- assume ind: "!q. q + k = m \<longrightarrow> P q"
- show "!q. Suc (q + k) = m \<longrightarrow> P q"
- proof (rule+)
- fix q
- assume "Suc (q + k) = m"
- hence "(Suc q) + k = m"
- by simp
- with ind
- have psq: "P (Suc q)"
- by simp
- from alln
- have "P (Suc q) --> P q"
- ..
- with psq
- show "P q"
- by simp
- qed
- qed
- qed
- hence "!q. q + (m - n) = m \<longrightarrow> P q"
- ..
- hence hehe: "n + (m - n) = m \<longrightarrow> P n"
- ..
- show "m < n"
- proof (rule classical)
- assume "~(m<n)"
- hence "n <= m"
- by simp
- with hehe
- have "P n"
- by simp
- with npn
- show "m < n"
- ..
- qed
-qed
-
-definition FUNPOW :: "('a => 'a) => nat => 'a => 'a" where
- "FUNPOW f n == f ^^ n"
-
-lemma FUNPOW: "(ALL f x. (f ^^ 0) x = x) &
- (ALL f n x. (f ^^ Suc n) x = (f ^^ n) (f x))"
- by (simp add: funpow_swap1)
-
-lemma [import_rew]: "FUNPOW f n = f ^^ n"
- by (simp add: FUNPOW_def)
-
-lemma ADD: "(!n. (0::nat) + n = n) & (!m n. Suc m + n = Suc (m + n))"
- by simp
-
-lemma MULT: "(!n. (0::nat) * n = 0) & (!m n. Suc m * n = m * n + n)"
- by simp
-
-lemma SUB: "(!m. (0::nat) - m = 0) & (!m n. (Suc m) - n = (if m < n then 0 else Suc (m - n)))"
- by (simp) arith
-
-lemma MAX_DEF: "max (m::nat) n = (if m < n then n else m)"
- by (simp add: max_def)
-
-lemma MIN_DEF: "min (m::nat) n = (if m < n then m else n)"
- by (simp add: min_def)
-
-lemma DIVISION: "(0::nat) < n --> (!k. (k = k div n * n + k mod n) & k mod n < n)"
- by simp
-
-definition ALT_ZERO :: nat where
- "ALT_ZERO == 0"
-
-definition NUMERAL_BIT1 :: "nat \<Rightarrow> nat" where
- "NUMERAL_BIT1 n == n + (n + Suc 0)"
-
-definition NUMERAL_BIT2 :: "nat \<Rightarrow> nat" where
- "NUMERAL_BIT2 n == n + (n + Suc (Suc 0))"
-
-definition NUMERAL :: "nat \<Rightarrow> nat" where
- "NUMERAL x == x"
-
-lemma [import_rew]: "NUMERAL ALT_ZERO = 0"
- by (simp add: ALT_ZERO_def NUMERAL_def)
-
-lemma [import_rew]: "NUMERAL (NUMERAL_BIT1 ALT_ZERO) = 1"
- by (simp add: ALT_ZERO_def NUMERAL_BIT1_def NUMERAL_def)
-
-lemma [import_rew]: "NUMERAL (NUMERAL_BIT2 ALT_ZERO) = 2"
- by (simp add: ALT_ZERO_def NUMERAL_BIT2_def NUMERAL_def)
-
-lemma EXP: "(!m. m ^ 0 = (1::nat)) & (!m n. m ^ Suc n = m * (m::nat) ^ n)"
- by auto
-
-lemma num_case_def: "(!b f. nat_case b f 0 = b) & (!b f n. nat_case b f (Suc n) = f n)"
- by simp
-
-lemma divides_def: "(a::nat) dvd b = (? q. b = q * a)"
- by (auto simp add: dvd_def)
-
-lemma list_case_def: "(!v f. list_case v f [] = v) & (!v f a0 a1. list_case v f (a0#a1) = f a0 a1)"
- by simp
-
-primrec list_size :: "('a \<Rightarrow> nat) \<Rightarrow> 'a list \<Rightarrow> nat" where
- "list_size f [] = 0"
-| "list_size f (a0#a1) = 1 + (f a0 + list_size f a1)"
-
-lemma list_size_def': "(!f. list_size f [] = 0) &
- (!f a0 a1. list_size f (a0#a1) = 1 + (f a0 + list_size f a1))"
- by simp
-
-lemma list_case_cong: "! M M' v f. M = M' & (M' = [] \<longrightarrow> v = v') &
- (!a0 a1. (M' = a0#a1) \<longrightarrow> (f a0 a1 = f' a0 a1)) -->
- (list_case v f M = list_case v' f' M')"
-proof clarify
- fix M M' v f
- assume 1: "M' = [] \<longrightarrow> v = v'"
- and 2: "!a0 a1. M' = a0 # a1 \<longrightarrow> f a0 a1 = f' a0 a1"
- show "list_case v f M' = list_case v' f' M'"
- proof (rule List.list.case_cong)
- show "M' = M'"
- ..
- next
- assume "M' = []"
- with 1 2
- show "v = v'"
- by auto
- next
- fix a0 a1
- assume "M' = a0 # a1"
- with 1 2
- show "f a0 a1 = f' a0 a1"
- by auto
- qed
-qed
-
-lemma list_Axiom: "ALL f0 f1. EX fn. (fn [] = f0) & (ALL a0 a1. fn (a0#a1) = f1 a0 a1 (fn a1))"
-proof safe
- fix f0 f1
- def fn == "list_rec f0 f1"
- have "fn [] = f0 & (ALL a0 a1. fn (a0 # a1) = f1 a0 a1 (fn a1))"
- by (simp add: fn_def)
- thus "EX fn. fn [] = f0 & (ALL a0 a1. fn (a0 # a1) = f1 a0 a1 (fn a1))"
- by auto
-qed
-
-lemma list_Axiom_old: "EX! fn. (fn [] = x) & (ALL h t. fn (h#t) = f (fn t) h t)"
-proof safe
- def fn == "list_rec x (%h t r. f r h t)"
- have "fn [] = x & (ALL h t. fn (h # t) = f (fn t) h t)"
- by (simp add: fn_def)
- thus "EX fn. fn [] = x & (ALL h t. fn (h # t) = f (fn t) h t)"
- by auto
-next
- fix fn1 fn2
- assume 1: "ALL h t. fn1 (h # t) = f (fn1 t) h t"
- assume 2: "ALL h t. fn2 (h # t) = f (fn2 t) h t"
- assume 3: "fn2 [] = fn1 []"
- show "fn1 = fn2"
- proof
- fix xs
- show "fn1 xs = fn2 xs"
- by (induct xs) (simp_all add: 1 2 3)
- qed
-qed
-
-lemma NULL_DEF: "(List.null [] = True) & (!h t. List.null (h # t) = False)"
- by (simp add: null_def)
-
-definition sum :: "nat list \<Rightarrow> nat" where
- "sum l == foldr (op +) l 0"
-
-lemma SUM: "(sum [] = 0) & (!h t. sum (h#t) = h + sum t)"
- by (simp add: sum_def)
-
-lemma APPEND: "(!l. [] @ l = l) & (!l1 l2 h. (h#l1) @ l2 = h# l1 @ l2)"
- by simp
-
-lemma FLAT: "(concat [] = []) & (!h t. concat (h#t) = h @ (concat t))"
- by simp
-
-lemma LENGTH: "(length [] = 0) & (!h t. length (h#t) = Suc (length t))"
- by simp
-
-lemma MAP: "(!f. map f [] = []) & (!f h t. map f (h#t) = f h#map f t)"
- by simp
-
-lemma MEM: "(!x. List.member [] x = False) & (!x h t. List.member (h#t) x = ((x = h) | List.member t x))"
- by (simp add: member_def)
-
-lemma FILTER: "(!P. filter P [] = []) & (!P h t.
- filter P (h#t) = (if P h then h#filter P t else filter P t))"
- by simp
-
-lemma REPLICATE: "(ALL x. replicate 0 x = []) &
- (ALL n x. replicate (Suc n) x = x # replicate n x)"
- by simp
-
-definition FOLDR :: "[['a,'b]\<Rightarrow>'b,'b,'a list] \<Rightarrow> 'b" where
- "FOLDR f e l == foldr f l e"
-
-lemma [import_rew]: "FOLDR f e l = foldr f l e"
- by (simp add: FOLDR_def)
-
-lemma FOLDR: "(!f e. foldr f [] e = e) & (!f e x l. foldr f (x#l) e = f x (foldr f l e))"
- by simp
-
-lemma FOLDL: "(!f e. foldl f e [] = e) & (!f e x l. foldl f e (x#l) = foldl f (f e x) l)"
- by simp
-
-lemma EVERY_DEF: "(!P. list_all P [] = True) & (!P h t. list_all P (h#t) = (P h & list_all P t))"
- by simp
-
-lemma list_exists_DEF: "(!P. list_ex P [] = False) & (!P h t. list_ex P (h#t) = (P h | list_ex P t))"
- by simp
-
-primrec map2 :: "[['a,'b]\<Rightarrow>'c,'a list,'b list] \<Rightarrow> 'c list" where
- map2_Nil: "map2 f [] l2 = []"
-| map2_Cons: "map2 f (x#xs) l2 = f x (hd l2) # map2 f xs (tl l2)"
-
-lemma MAP2: "(!f. map2 f [] [] = []) & (!f h1 t1 h2 t2. map2 f (h1#t1) (h2#t2) = f h1 h2#map2 f t1 t2)"
- by simp
-
-lemma list_INDUCT: "\<lbrakk> P [] ; !t. P t \<longrightarrow> (!h. P (h#t)) \<rbrakk> \<Longrightarrow> !l. P l"
-proof
- fix l
- assume "P []"
- assume allt: "!t. P t \<longrightarrow> (!h. P (h # t))"
- show "P l"
- proof (induct l)
- show "P []" by fact
- next
- fix h t
- assume "P t"
- with allt
- have "!h. P (h # t)"
- by auto
- thus "P (h # t)"
- ..
- qed
-qed
-
-lemma list_CASES: "(l = []) | (? t h. l = h#t)"
- by (induct l,auto)
-
-definition ZIP :: "'a list * 'b list \<Rightarrow> ('a * 'b) list" where
- "ZIP == %(a,b). zip a b"
-
-lemma ZIP: "(zip [] [] = []) &
- (!x1 l1 x2 l2. zip (x1#l1) (x2#l2) = (x1,x2)#zip l1 l2)"
- by simp
-
-lemma [import_rew]: "ZIP (a,b) = zip a b"
- by (simp add: ZIP_def)
-
-primrec unzip :: "('a * 'b) list \<Rightarrow> 'a list * 'b list" where
- unzip_Nil: "unzip [] = ([],[])"
-| unzip_Cons: "unzip (xy#xys) = (let zs = unzip xys in (fst xy # fst zs,snd xy # snd zs))"
-
-lemma UNZIP: "(unzip [] = ([],[])) &
- (!x l. unzip (x#l) = (fst x#fst (unzip l),snd x#snd (unzip l)))"
- by (simp add: Let_def)
-
-lemma REVERSE: "(rev [] = []) & (!h t. rev (h#t) = (rev t) @ [h])"
- by simp
-
-lemma REAL_SUP_ALLPOS: "\<lbrakk> ALL x. P (x::real) \<longrightarrow> 0 < x ; EX x. P x; EX z. ALL x. P x \<longrightarrow> x < z \<rbrakk> \<Longrightarrow> EX s. ALL y. (EX x. P x & y < x) = (y < s)"
-proof safe
- fix x z
- assume allx: "ALL x. P x \<longrightarrow> 0 < x"
- assume px: "P x"
- assume allx': "ALL x. P x \<longrightarrow> x < z"
- have "EX s. ALL y. (EX x : Collect P. y < x) = (y < s)"
- proof (rule posreal_complete)
- from px
- show "EX x. x : Collect P"
- by auto
- next
- from allx'
- show "EX y. ALL x : Collect P. x < y"
- apply simp
- ..
- qed
- thus "EX s. ALL y. (EX x. P x & y < x) = (y < s)"
- by simp
-qed
-
-lemma REAL_10: "~((1::real) = 0)"
- by simp
-
-lemma REAL_ADD_ASSOC: "(x::real) + (y + z) = x + y + z"
- by simp
-
-lemma REAL_MUL_ASSOC: "(x::real) * (y * z) = x * y * z"
- by simp
-
-lemma REAL_ADD_LINV: "-x + x = (0::real)"
- by simp
-
-lemma REAL_MUL_LINV: "x ~= (0::real) ==> inverse x * x = 1"
- by simp
-
-lemma REAL_LT_TOTAL: "((x::real) = y) | x < y | y < x"
- by auto
-
-lemma [import_rew]: "real (0::nat) = 0"
- by simp
-
-lemma [import_rew]: "real (1::nat) = 1"
- by simp
-
-lemma [import_rew]: "real (2::nat) = 2"
- by simp
-
-lemma real_lte: "((x::real) <= y) = (~(y < x))"
- by auto
-
-lemma real_of_num: "((0::real) = 0) & (!n. real (Suc n) = real n + 1)"
- by (simp add: real_of_nat_Suc)
-
-lemma abs: "abs (x::real) = (if 0 <= x then x else -x)"
- by (simp add: abs_if)
-
-lemma pow: "(!x::real. x ^ 0 = 1) & (!x::real. ALL n. x ^ (Suc n) = x * x ^ n)"
- by simp
-
-definition real_gt :: "real => real => bool" where
- "real_gt == %x y. y < x"
-
-lemma [import_rew]: "real_gt x y = (y < x)"
- by (simp add: real_gt_def)
-
-lemma real_gt: "ALL x (y::real). (y < x) = (y < x)"
- by simp
-
-definition real_ge :: "real => real => bool" where
- "real_ge x y == y <= x"
-
-lemma [import_rew]: "real_ge x y = (y <= x)"
- by (simp add: real_ge_def)
-
-lemma real_ge: "ALL x y. (y <= x) = (y <= x)"
- by simp
-
-definition [import_rew]: "list_mem x xs = List.member xs x"
-
-end
--- a/src/HOL/Import/HOL4/Generate.thy Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,5 +0,0 @@
-theory Generate
-imports "Template/GenHOL4Prob" "Template/GenHOL4Vec" "Template/GenHOL4Word32"
-begin
-
-end
--- a/src/HOL/Import/HOL4/Generated/HOL4Base.thy Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,4501 +0,0 @@
-(* AUTOMATICALLY GENERATED, DO NOT EDIT! *)
-
-theory HOL4Base
-imports "../../Importer" "../Compatibility"
-begin
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" bool
-
-definition
- ARB :: "'a" where
- "ARB == SOME x. True"
-
-lemma ARB_DEF: "ARB = (SOME x. True)"
- sorry
-
-definition
- IN :: "'a => ('a => bool) => bool" where
- "IN == %x f. f x"
-
-lemma IN_DEF: "IN = (%x f. f x)"
- sorry
-
-definition
- RES_FORALL :: "('a => bool) => ('a => bool) => bool" where
- "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)"
- sorry
-
-definition
- RES_EXISTS :: "('a => bool) => ('a => bool) => bool" where
- "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)"
- sorry
-
-definition
- RES_EXISTS_UNIQUE :: "('a => bool) => ('a => bool) => bool" where
- "RES_EXISTS_UNIQUE ==
-%p m. RES_EXISTS p m &
- RES_FORALL p (%x. RES_FORALL p (%y. 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)))"
- sorry
-
-definition
- RES_SELECT :: "('a => bool) => ('a => bool) => 'a" where
- "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)"
- sorry
-
-lemma EXCLUDED_MIDDLE: "t | ~ t"
- sorry
-
-lemma FORALL_THM: "All f = All f"
- sorry
-
-lemma EXISTS_THM: "Ex f = Ex f"
- sorry
-
-lemma F_IMP: "[| ~ t; t |] ==> False"
- sorry
-
-lemma NOT_AND: "~ (t & ~ t)"
- sorry
-
-lemma AND_CLAUSES: "(True & t) = t &
-(t & True) = t & (False & t) = False & (t & False) = False & (t & t) = t"
- sorry
-
-lemma OR_CLAUSES: "(True | t) = True &
-(t | True) = True & (False | t) = t & (t | False) = t & (t | t) = t"
- sorry
-
-lemma IMP_CLAUSES: "(True --> t) = t &
-(t --> True) = True &
-(False --> t) = True & (t --> t) = True & (t --> False) = (~ t)"
- sorry
-
-lemma NOT_CLAUSES: "(ALL t. (~ ~ t) = t) & (~ True) = False & (~ False) = True"
- sorry
-
-lemma BOOL_EQ_DISTINCT: "True ~= False & False ~= True"
- sorry
-
-lemma EQ_CLAUSES: "(True = t) = t & (t = True) = t & (False = t) = (~ t) & (t = False) = (~ t)"
- sorry
-
-lemma COND_CLAUSES: "(if True then t1 else t2) = t1 & (if False then t1 else t2) = t2"
- sorry
-
-lemma SELECT_UNIQUE: "(!!y. P y = (y = x)) ==> Eps P = x"
- sorry
-
-lemma BOTH_EXISTS_AND_THM: "(EX x::'a. (P::bool) & (Q::bool)) = ((EX x::'a. P) & (EX x::'a. Q))"
- sorry
-
-lemma BOTH_FORALL_OR_THM: "(ALL x::'a. (P::bool) | (Q::bool)) = ((ALL x::'a. P) | (ALL x::'a. Q))"
- sorry
-
-lemma BOTH_FORALL_IMP_THM: "(ALL x::'a. (P::bool) --> (Q::bool)) = ((EX x::'a. P) --> (ALL x::'a. Q))"
- sorry
-
-lemma BOTH_EXISTS_IMP_THM: "(EX x::'a. (P::bool) --> (Q::bool)) = ((ALL x::'a. P) --> (EX x::'a. Q))"
- sorry
-
-lemma OR_IMP_THM: "(A = (B | A)) = (B --> A)"
- sorry
-
-lemma DE_MORGAN_THM: "(~ (A & B)) = (~ A | ~ B) & (~ (A | B)) = (~ A & ~ B)"
- sorry
-
-lemma IMP_F_EQ_F: "(t --> False) = (t = False)"
- sorry
-
-lemma COND_RATOR: "(if b::bool then f::'a => 'b else (g::'a => 'b)) (x::'a) =
-(if b then f x else g x)"
- sorry
-
-lemma COND_ABS: "(%x. if b then f x else g x) = (if b then f else g)"
- sorry
-
-lemma COND_EXPAND: "(if b then t1 else t2) = ((~ b | t1) & (b | t2))"
- sorry
-
-lemma ONE_ONE_THM: "inj f = (ALL x1 x2. f x1 = f x2 --> x1 = x2)"
- sorry
-
-lemma ABS_REP_THM: "(op ==>::prop => prop => prop)
- ((Trueprop::bool => prop)
- ((Ex::(('b::type => 'a::type) => bool) => bool)
- ((TYPE_DEFINITION::('a::type => bool)
- => ('b::type => 'a::type) => bool)
- (P::'a::type => bool))))
- ((Trueprop::bool => prop)
- ((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::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::type => 'a::type => bool) (x (abs r))
- r)))))))"
- sorry
-
-lemma LET_RAND: "(P::'b => bool) (Let (M::'a) (N::'a => 'b)) = (let x::'a = M in P (N x))"
- sorry
-
-lemma LET_RATOR: "Let (M::'a) (N::'a => 'b => 'c) (b::'b) = (let x::'a = M in N x b)"
- sorry
-
-lemma AND_CONG: "(Q --> P = P') & (P' --> Q = Q') ==> (P & Q) = (P' & Q')"
- sorry
-
-lemma OR_CONG: "(~ Q --> P = P') & (~ P' --> Q = Q') ==> (P | Q) = (P' | Q')"
- sorry
-
-lemma COND_CONG: "P = Q & (Q --> x = x') & (~ Q --> y = y')
-==> (if P then x else y) = (if Q then x' else y')"
- sorry
-
-lemma MONO_COND: "[| x ==> y; z ==> w; if b then x else z |] ==> if b then y else w"
- sorry
-
-lemma SKOLEM_THM: "(ALL x. Ex (P x)) = (EX f. ALL x. P x (f x))"
- sorry
-
-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)"
- sorry
-
-lemma bool_case_ID: "(case b of True => x | _ => x) = x"
- sorry
-
-lemma boolAxiom: "EX x. x True = e0 & x False = e1"
- sorry
-
-lemma UEXISTS_OR_THM: "EX! x. P x | Q x ==> Ex1 P | Ex1 Q"
- sorry
-
-lemma UEXISTS_SIMP: "(EX! x::'a. (t::bool)) = (t & (ALL x::'a. All (op = x)))"
- sorry
-
-consts
- RES_ABSTRACT :: "('a => bool) => ('a => 'b) => 'a => 'b"
-
-specification (RES_ABSTRACT) RES_ABSTRACT_DEF: "(ALL (p::'a => bool) (m::'a => 'b) x::'a.
- 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) -->
- RES_ABSTRACT p m1 = RES_ABSTRACT p m2)"
- sorry
-
-lemma BOOL_FUN_CASES_THM: "f = (%b. True) | f = (%b. False) | f = (%b. b) | f = Not"
- sorry
-
-lemma BOOL_FUN_INDUCT: "P (%b. True) & P (%b. False) & P (%b. b) & P Not ==> P x"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" combin
-
-definition
- K :: "'a => 'b => 'a" where
- "K == %x y. x"
-
-lemma K_DEF: "K = (%x y. x)"
- sorry
-
-definition
- S :: "('a => 'b => 'c) => ('a => 'b) => 'a => 'c" where
- "S == %f g x. f x (g x)"
-
-lemma S_DEF: "S = (%f g x. f x (g x))"
- sorry
-
-definition
- I :: "'a => 'a" where
- "(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))"
- sorry
-
-definition
- C :: "('a => 'b => 'c) => 'b => 'a => 'c" where
- "C == %f x y. f y x"
-
-lemma C_DEF: "C = (%f x y. f y x)"
- sorry
-
-definition
- W :: "('a => 'a => 'b) => 'a => 'b" where
- "W == %f x. f x x"
-
-lemma W_DEF: "W = (%f x. f x x)"
- sorry
-
-lemma I_THM: "I x = x"
- sorry
-
-lemma I_o_ID: "I o f = f & f o I = f"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" sum
-
-lemma ISL_OR_ISR: "ISL x | ISR x"
- sorry
-
-lemma INL: "ISL x ==> Inl (OUTL x) = x"
- sorry
-
-lemma INR: "ISR x ==> Inr (OUTR x) = x"
- sorry
-
-lemma sum_case_cong: "(M::'b + 'c) = (M'::'b + 'c) &
-(ALL x::'b. M' = Inl x --> (f::'b => 'a) x = (f'::'b => 'a) x) &
-(ALL y::'c. M' = Inr y --> (g::'c => 'a) y = (g'::'c => 'a) y)
-==> sum_case f g M = sum_case f' g' M'"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" one
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" option
-
-lemma option_CLAUSES: "(op &::bool => bool => bool)
- ((All::('a::type => bool) => bool)
- (%x::'a::type.
- (All::('a::type => bool) => bool)
- (%y::'a::type.
- (op =::bool => bool => bool)
- ((op =::'a::type option => 'a::type option => bool)
- ((Some::'a::type => 'a::type option) x)
- ((Some::'a::type => 'a::type option) y))
- ((op =::'a::type => 'a::type => bool) x y))))
- ((op &::bool => bool => bool)
- ((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 option) x))
- x))
- ((op &::bool => bool => bool)
- ((All::('a::type => bool) => bool)
- (%x::'a::type.
- (op ~=::'a::type option => 'a::type option => bool)
- (None::'a::type option)
- ((Some::'a::type => 'a::type option) x)))
- ((op &::bool => bool => bool)
- ((All::('a::type => bool) => bool)
- (%x::'a::type.
- (op ~=::'a::type option => 'a::type option => bool)
- ((Some::'a::type => 'a::type option) x)
- (None::'a::type option)))
- ((op &::bool => bool => bool)
- ((All::('a::type => bool) => bool)
- (%x::'a::type.
- (op =::bool => bool => bool)
- ((IS_SOME::'a::type option => bool)
- ((Some::'a::type => 'a::type option) x))
- (True::bool)))
- ((op &::bool => bool => bool)
- ((op =::bool => bool => bool)
- ((IS_SOME::'a::type option => bool) (None::'a::type option))
- (False::bool))
- ((op &::bool => bool => bool)
- ((All::('a::type option => bool) => bool)
- (%x::'a::type option.
- (op =::bool => bool => bool)
- ((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::type option => bool) => bool)
- (%x::'a::type option.
- (op =::bool => bool => bool)
- ((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::type option => bool) => bool)
- (%x::'a::type option.
- (op -->::bool => bool => bool)
- ((IS_SOME::'a::type option => bool) x)
- ((op =::'a::type option => 'a::type option => bool)
- ((Some::'a::type => 'a::type option)
- ((the::'a::type option => 'a::type) x))
- x)))
- ((op &::bool => bool => bool)
- ((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 option) => 'a::type option => 'a::type option)
- (None::'a::type option)
- (Some::'a::type => 'a::type option) x)
- x))
- ((op &::bool => bool => bool)
- ((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 option) => 'a::type option => 'a::type option)
- x (Some::'a::type => 'a::type option) x)
- x))
- ((op &::bool => bool => bool)
- ((All::('a::type option => bool) => bool)
- (%x::'a::type option.
- (op -->::bool => bool => bool)
- ((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::type option => bool) => bool)
- (%x::'a::type option.
- (op -->::bool => bool => bool)
- ((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::type option => 'a::type)
- x)))))
- ((op &::bool => bool => bool)
- ((All::('a::type option => bool) => bool)
- (%x::'a::type option.
- (op -->::bool => bool => bool)
- ((IS_SOME::'a::type option => bool) x)
- ((op =::'a::type option
- => 'a::type option => bool)
- ((option_case::'a::type option
- => ('a::type => 'a::type option)
- => 'a::type option => 'a::type option)
-(ea::'a::type option) (Some::'a::type => 'a::type option) x)
- x)))
- ((op &::bool => bool => bool)
- ((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::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 option) x))
- (f x)))))
- ((op &::bool => bool => bool)
- ((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 option)
- f ((Some::'a::type => 'a::type option) x))
- ((Some::'b::type => 'b::type option) (f x)))))
- ((op &::bool => bool => bool)
- ((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 option)
- f (None::'a::type option))
- (None::'b::type option)))
- ((op &::bool => bool => bool)
- ((op =::'a::type option
- => 'a::type option => bool)
- ((OPTION_JOIN::'a::type option option => 'a::type option)
- (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 option)
- ((Some::'a::type option => 'a::type option option) x))
- x))))))))))))))))))))"
- sorry
-
-lemma option_case_compute: "option_case (e::'b) (f::'a => 'b) (x::'a option) =
-(if IS_SOME x then f (the x) else e)"
- sorry
-
-lemma OPTION_MAP_EQ_SOME: "(Option.map (f::'a => 'b) (x::'a option) = Some (y::'b)) =
-(EX z::'a. x = Some z & y = f z)"
- sorry
-
-lemma OPTION_JOIN_EQ_SOME: "(OPTION_JOIN x = Some xa) = (x = Some (Some xa))"
- sorry
-
-lemma option_case_cong: "M = M' & (M' = None --> u = u') & (ALL x. M' = Some x --> f x = f' x)
-==> option_case u f M = option_case u' f' M'"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" marker
-
-consts
- stmarker :: "'a => 'a"
-
-defs
- stmarker_primdef: "stmarker == %x. x"
-
-lemma stmarker_def: "stmarker x = x"
- sorry
-
-lemma move_left_conj: "(x & stmarker xb) = (stmarker xb & x) &
-((stmarker xb & x) & xa) = (stmarker xb & x & xa) &
-(x & stmarker xb & xa) = (stmarker xb & x & xa)"
- sorry
-
-lemma move_right_conj: "(stmarker xb & x) = (x & stmarker xb) &
-(x & xa & stmarker xb) = ((x & xa) & stmarker xb) &
-((x & stmarker xb) & xa) = ((x & xa) & stmarker xb)"
- sorry
-
-lemma move_left_disj: "(x | stmarker xb) = (stmarker xb | x) &
-((stmarker xb | x) | xa) = (stmarker xb | x | xa) &
-(x | stmarker xb | xa) = (stmarker xb | x | xa)"
- sorry
-
-lemma move_right_disj: "(stmarker xb | x) = (x | stmarker xb) &
-(x | xa | stmarker xb) = ((x | xa) | stmarker xb) &
-((x | stmarker xb) | xa) = ((x | xa) | stmarker xb)"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" relation
-
-definition
- TC :: "('a => 'a => bool) => 'a => 'a => bool" where
- "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) -->
- P a b"
-
-lemma TC_DEF: "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) -->
- P a b)"
- sorry
-
-definition
- RTC :: "('a => 'a => bool) => 'a => 'a => bool" where
- "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: "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)"
- sorry
-
-consts
- RC :: "('a => 'a => bool) => 'a => 'a => bool"
-
-defs
- RC_primdef: "RC == %R x y. x = y | R x y"
-
-lemma RC_def: "RC R x y = (x = y | R x y)"
- sorry
-
-consts
- transitive :: "('a => 'a => bool) => bool"
-
-defs
- transitive_primdef: "transitive == %R. ALL x y z. R x y & R y z --> R x z"
-
-lemma transitive_def: "transitive R = (ALL x y z. R x y & R y z --> R x z)"
- sorry
-
-definition
- pred_reflexive :: "('a => 'a => bool) => bool" where
- "pred_reflexive == %R. ALL x. R x x"
-
-lemma reflexive_def: "pred_reflexive R = (ALL x. R x x)"
- sorry
-
-lemma TC_TRANSITIVE: "transitive (TC x)"
- sorry
-
-lemma RTC_INDUCT: "[| (ALL x. xa x x) & (ALL xb y z. x xb y & xa y z --> xa xb z);
- RTC x xb xc |]
-==> xa xb xc"
- sorry
-
-lemma TC_RULES: "(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)"
- sorry
-
-lemma RTC_RULES: "(ALL xa. RTC x xa xa) &
-(ALL xa xb xc. x xa xb & RTC x xb xc --> RTC x xa xc)"
- sorry
-
-lemma RTC_STRONG_INDUCT: "[| (ALL x. P x x) & (ALL x y z. R x y & RTC R y z & P y z --> P x z);
- RTC R x y |]
-==> P x y"
- sorry
-
-lemma RTC_RTC: "[| RTC R x y; RTC R y z |] ==> RTC R x z"
- sorry
-
-lemma RTC_TRANSITIVE: "transitive (RTC x)"
- sorry
-
-lemma RTC_REFLEXIVE: "pred_reflexive (RTC R)"
- sorry
-
-lemma RC_REFLEXIVE: "pred_reflexive (RC R)"
- sorry
-
-lemma TC_SUBSET: "x xa xb ==> TC x xa xb"
- sorry
-
-lemma RTC_SUBSET: "R x y ==> RTC R x y"
- sorry
-
-lemma RC_SUBSET: "R x y ==> RC R x y"
- sorry
-
-lemma RC_RTC: "RC R x y ==> RTC R x y"
- sorry
-
-lemma TC_INDUCT: "[| (ALL xb y. x xb y --> xa xb y) & (ALL x y z. xa x y & xa y z --> xa x z);
- TC x xb xc |]
-==> xa xb xc"
- sorry
-
-lemma TC_INDUCT_LEFT1: "[| (ALL xb y. x xb y --> xa xb y) &
- (ALL xb y z. x xb y & xa y z --> xa xb z);
- TC x xb xc |]
-==> xa xb xc"
- sorry
-
-lemma TC_STRONG_INDUCT: "[| (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);
- TC R u v |]
-==> P u v"
- sorry
-
-lemma TC_STRONG_INDUCT_LEFT1: "[| (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);
- TC R u v |]
-==> P u v"
- sorry
-
-lemma TC_RTC: "TC R x y ==> RTC R x y"
- sorry
-
-lemma RTC_TC_RC: "RTC R x y ==> RC R x y | TC R x y"
- sorry
-
-lemma TC_RC_EQNS: "RC (TC R) = RTC R & TC (RC R) = RTC R"
- sorry
-
-lemma RC_IDEM: "RC (RC R) = RC R"
- sorry
-
-lemma TC_IDEM: "TC (TC R) = TC R"
- sorry
-
-lemma RTC_IDEM: "RTC (RTC R) = RTC R"
- sorry
-
-lemma RTC_CASES1: "RTC x xa xb = (xa = xb | (EX u. x xa u & RTC x u xb))"
- sorry
-
-lemma RTC_CASES2: "RTC x xa xb = (xa = xb | (EX u. RTC x xa u & x u xb))"
- sorry
-
-lemma RTC_CASES_RTC_TWICE: "RTC x xa xb = (EX u. RTC x xa u & RTC x u xb)"
- sorry
-
-lemma TC_CASES1: "TC R x z ==> R x z | (EX y. R x y & TC R y z)"
- sorry
-
-lemma TC_CASES2: "TC R x z ==> R x z | (EX y. TC R x y & R y z)"
- sorry
-
-lemma TC_MONOTONE: "[| !!x y. R x y ==> Q x y; TC R x y |] ==> TC Q x y"
- sorry
-
-lemma RTC_MONOTONE: "[| !!x y. R x y ==> Q x y; RTC R x y |] ==> RTC Q x y"
- sorry
-
-definition
- WF :: "('a => 'a => bool) => bool" where
- "WF == %R. ALL B. Ex B --> (EX min. B min & (ALL b. R b min --> ~ B b))"
-
-lemma WF_DEF: "WF R = (ALL B. Ex B --> (EX min. B min & (ALL b. R b min --> ~ B b)))"
- sorry
-
-lemma WF_INDUCTION_THM: "[| WF R; !!x. (!!y. R y x ==> P y) ==> P x |] ==> P x"
- sorry
-
-lemma WF_NOT_REFL: "[| WF x; x xa xb |] ==> xa ~= xb"
- sorry
-
-definition
- EMPTY_REL :: "'a => 'a => bool" where
- "EMPTY_REL == %x y. False"
-
-lemma EMPTY_REL_DEF: "EMPTY_REL x y = False"
- sorry
-
-lemma WF_EMPTY_REL: "WF EMPTY_REL"
- sorry
-
-lemma WF_SUBSET: "WF x & (ALL xb y. xa xb y --> x xb y) ==> WF xa"
- sorry
-
-lemma WF_TC: "WF R ==> WF (TC R)"
- sorry
-
-consts
- inv_image :: "('b => 'b => bool) => ('a => 'b) => 'a => 'a => 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: "relation.inv_image R f = (%x y. R (f x) (f y))"
- sorry
-
-lemma WF_inv_image: "WF (R::'b => 'b => bool) ==> WF (relation.inv_image R (f::'a => 'b))"
- sorry
-
-definition
- RESTRICT :: "('a => 'b) => ('a => 'a => bool) => 'a => 'a => 'b" where
- "RESTRICT == %f R x y. if R y x then f y else ARB"
-
-lemma RESTRICT_DEF: "RESTRICT f R x = (%y. if R y x then f y else ARB)"
- sorry
-
-lemma RESTRICT_LEMMA: "xa xb xc ==> RESTRICT x xa xc xb = x xb"
- sorry
-
-consts
- approx :: "('a => 'a => bool) => (('a => 'b) => 'a => 'b) => 'a => ('a => 'b) => bool"
-
-defs
- approx_primdef: "approx == %R M x f. f = RESTRICT (%y. M (RESTRICT f R y) y) R x"
-
-lemma approx_def: "approx R M x f = (f = RESTRICT (%y. M (RESTRICT f R y) y) R x)"
- sorry
-
-consts
- the_fun :: "('a => 'a => bool) => (('a => 'b) => 'a => 'b) => 'a => 'a => 'b"
-
-defs
- the_fun_primdef: "the_fun == %R M x. Eps (approx R M x)"
-
-lemma the_fun_def: "the_fun R M x = Eps (approx R M x)"
- sorry
-
-definition
- WFREC :: "('a => 'a => bool) => (('a => 'b) => 'a => 'b) => 'a => 'b" where
- "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: "WFREC R M =
-(%x. M (RESTRICT (the_fun (TC R) (%f v. M (RESTRICT f R v) v) x) R x) x)"
- sorry
-
-lemma WFREC_THM: "WF R ==> WFREC R M x = M (RESTRICT (WFREC R M) R x) x"
- sorry
-
-lemma WFREC_COROLLARY: "[| f = WFREC R M; WF R |] ==> f x = M (RESTRICT f R x) x"
- sorry
-
-lemma WF_RECURSION_THM: "WF R ==> EX! f. ALL x. f x = M (RESTRICT f R x) x"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" pair
-
-lemma CURRY_ONE_ONE_THM: "(curry f = curry g) = (f = g)"
- sorry
-
-lemma UNCURRY_ONE_ONE_THM: "((%(x, y). f x y) = (%(x, y). g x y)) = (f = g)"
- sorry
-
-lemma pair_Axiom: "EX x. ALL xa y. x (xa, y) = f xa y"
- sorry
-
-lemma UNCURRY_CONG: "M = M' & (ALL x y. M' = (x, y) --> f x y = f' x y)
-==> prod_case f M = prod_case f' M'"
- sorry
-
-lemma ELIM_PEXISTS: "(EX p. P (fst p) (snd p)) = (EX p1. Ex (P p1))"
- sorry
-
-lemma ELIM_PFORALL: "(ALL p. P (fst p) (snd p)) = (ALL p1. All (P p1))"
- sorry
-
-lemma PFORALL_THM: "(ALL xa. All (x xa)) = All (%(xa, y). x xa y)"
- sorry
-
-lemma PEXISTS_THM: "(EX xa. Ex (x xa)) = Ex (%(xa, y). x xa y)"
- sorry
-
-lemma LET2_RAND: "(x::'c => 'd)
- (let (x::'a, y::'b) = xa::'a * 'b in (xb::'a => 'b => 'c) x y) =
-(let (xa::'a, y::'b) = xa in x (xb xa y))"
- sorry
-
-lemma LET2_RATOR: "(let (x::'a1, y::'a2) = x::'a1 * 'a2 in (xa::'a1 => 'a2 => 'b => 'c) x y)
- (xb::'b) =
-(let (x::'a1, y::'a2) = x in xa x y xb)"
- sorry
-
-lemma pair_case_cong: "x = xa & (ALL x y. xa = (x, y) --> xb x y = f' x y)
-==> prod_case xb x = prod_case f' xa"
- sorry
-
-definition
- LEX :: "('a => 'a => bool) => ('b => 'b => bool) => 'a * 'b => 'a * 'b => bool" where
- "LEX == %R1 R2 (s, t) (u, v). R1 s u | s = u & R2 t v"
-
-lemma LEX_DEF: "LEX R1 R2 = (%(s, t) (u, v). R1 s u | s = u & R2 t v)"
- sorry
-
-lemma WF_LEX: "WF x & WF xa ==> WF (LEX x xa)"
- sorry
-
-definition
- RPROD :: "('a => 'a => bool) => ('b => 'b => bool) => 'a * 'b => 'a * 'b => bool" where
- "RPROD == %R1 R2 (s, t) (u, v). R1 s u & R2 t v"
-
-lemma RPROD_DEF: "RPROD R1 R2 = (%(s, t) (u, v). R1 s u & R2 t v)"
- sorry
-
-lemma WF_RPROD: "WF R & WF Q ==> WF (RPROD R Q)"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" num
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" prim_rec
-
-lemma LESS_0_0: "0 < Suc 0"
- sorry
-
-lemma LESS_LEMMA1: "x < Suc xa ==> x = xa | x < xa"
- sorry
-
-lemma LESS_LEMMA2: "m = n | m < n ==> m < Suc n"
- sorry
-
-lemma LESS_THM: "(m < Suc n) = (m = n | m < n)"
- sorry
-
-lemma LESS_SUC_IMP: "[| x < Suc xa; x ~= xa |] ==> x < xa"
- sorry
-
-lemma EQ_LESS: "Suc m = n ==> m < n"
- sorry
-
-lemma NOT_LESS_EQ: "(m::nat) = (n::nat) ==> ~ m < n"
- sorry
-
-definition
- SIMP_REC_REL :: "(nat => 'a) => 'a => ('a => 'a) => nat => bool" where
- "SIMP_REC_REL == %fun x f n. fun 0 = x & (ALL m<n. fun (Suc m) = f (fun m))"
-
-lemma SIMP_REC_REL: "SIMP_REC_REL fun x f n = (fun 0 = x & (ALL m<n. fun (Suc m) = f (fun m)))"
- sorry
-
-lemma SIMP_REC_EXISTS: "EX fun. SIMP_REC_REL fun x f n"
- sorry
-
-lemma SIMP_REC_REL_UNIQUE: "[| SIMP_REC_REL xb x xa xd & SIMP_REC_REL xc x xa xe; n < xd & n < xe |]
-==> xb n = xc n"
- sorry
-
-lemma SIMP_REC_REL_UNIQUE_RESULT: "EX! y. EX g. SIMP_REC_REL g x f (Suc n) & y = g n"
- sorry
-
-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"
- sorry
-
-lemma LESS_SUC_SUC: "m < Suc m & m < Suc (Suc m)"
- sorry
-
-lemma SIMP_REC_THM: "SIMP_REC x f 0 = x & (ALL m. SIMP_REC x f (Suc m) = f (SIMP_REC x f m))"
- sorry
-
-definition
- PRE :: "nat => nat" where
- "PRE == %m. if m = 0 then 0 else SOME n. m = Suc n"
-
-lemma PRE_DEF: "PRE m = (if m = 0 then 0 else SOME n. m = Suc n)"
- sorry
-
-lemma PRE: "PRE 0 = 0 & (ALL m. PRE (Suc m) = m)"
- sorry
-
-definition
- PRIM_REC_FUN :: "'a => ('a => nat => 'a) => nat => nat => 'a" where
- "PRIM_REC_FUN == %x f. SIMP_REC (%n. x) (%fun n. f (fun (PRE n)) n)"
-
-lemma PRIM_REC_FUN: "PRIM_REC_FUN x f = SIMP_REC (%n. x) (%fun n. f (fun (PRE n)) n)"
- sorry
-
-lemma PRIM_REC_EQN: "(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)"
- sorry
-
-definition
- PRIM_REC :: "'a => ('a => nat => 'a) => nat => 'a" where
- "PRIM_REC == %x f m. PRIM_REC_FUN x f m (PRE m)"
-
-lemma PRIM_REC: "PRIM_REC x f m = PRIM_REC_FUN x f m (PRE m)"
- sorry
-
-lemma PRIM_REC_THM: "PRIM_REC x f 0 = x & (ALL m. PRIM_REC x f (Suc m) = f (PRIM_REC x f m) m)"
- sorry
-
-lemma DC: "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)))"
- sorry
-
-lemma num_Axiom_old: "EX! fn1. fn1 0 = e & (ALL n. fn1 (Suc n) = f (fn1 n) n)"
- sorry
-
-lemma num_Axiom: "EX x. x 0 = e & (ALL n. x (Suc n) = f n (x n))"
- sorry
-
-consts
- wellfounded :: "('a => 'a => bool) => bool"
-
-defs
- wellfounded_primdef: "wellfounded == %R. ~ (EX f. ALL n. R (f (Suc n)) (f n))"
-
-lemma wellfounded_def: "wellfounded R = (~ (EX f. ALL n. R (f (Suc n)) (f n)))"
- sorry
-
-lemma WF_IFF_WELLFOUNDED: "WF R = wellfounded R"
- sorry
-
-lemma WF_PRED: "WF (%x y. y = Suc x)"
- sorry
-
-lemma WF_LESS: "(WF::(nat => nat => bool) => bool) (op <::nat => nat => bool)"
- sorry
-
-consts
- measure :: "('a => nat) => 'a => 'a => bool"
-
-defs
- measure_primdef: "prim_rec.measure == relation.inv_image op <"
-
-lemma measure_def: "prim_rec.measure = relation.inv_image op <"
- sorry
-
-lemma WF_measure: "WF (prim_rec.measure x)"
- sorry
-
-lemma measure_thm: "prim_rec.measure x xa xb = (x xa < x xb)"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" arithmetic
-
-definition
- nat_elim__magic :: "nat => nat" where
- "nat_elim__magic == %n. n"
-
-lemma nat_elim__magic: "nat_elim__magic n = n"
- sorry
-
-consts
- EVEN :: "nat => bool"
-
-specification (EVEN) EVEN: "EVEN 0 = True & (ALL n. EVEN (Suc n) = (~ EVEN n))"
- sorry
-
-consts
- ODD :: "nat => bool"
-
-specification (ODD) ODD: "ODD 0 = False & (ALL n. ODD (Suc n) = (~ ODD n))"
- sorry
-
-lemma TWO: "2 = Suc 1"
- sorry
-
-lemma NORM_0: "(0::nat) = (0::nat)"
- sorry
-
-lemma num_case_compute: "nat_case f g n = (if n = 0 then f else g (PRE n))"
- sorry
-
-lemma ADD_CLAUSES: "0 + m = m & m + 0 = m & Suc m + n = Suc (m + n) & m + Suc n = Suc (m + n)"
- sorry
-
-lemma LESS_ADD: "(n::nat) < (m::nat) ==> EX p::nat. p + n = m"
- sorry
-
-lemma LESS_ANTISYM: "~ ((m::nat) < (n::nat) & n < m)"
- sorry
-
-lemma LESS_LESS_SUC: "~ (x < xa & xa < Suc x)"
- sorry
-
-lemma FUN_EQ_LEMMA: "f x1 & ~ f x2 ==> x1 ~= x2"
- sorry
-
-lemma LESS_NOT_SUC: "m < n & n ~= Suc m ==> Suc m < n"
- sorry
-
-lemma LESS_0_CASES: "(0::nat) = (m::nat) | (0::nat) < m"
- sorry
-
-lemma LESS_CASES_IMP: "~ (m::nat) < (n::nat) & m ~= n ==> n < m"
- sorry
-
-lemma LESS_CASES: "(m::nat) < (n::nat) | n <= m"
- sorry
-
-lemma LESS_EQ_SUC_REFL: "m <= Suc m"
- sorry
-
-lemma LESS_ADD_NONZERO: "(n::nat) ~= (0::nat) ==> (m::nat) < m + n"
- sorry
-
-lemma LESS_EQ_ANTISYM: "~ ((x::nat) < (xa::nat) & xa <= x)"
- sorry
-
-lemma SUB_0: "(0::nat) - (m::nat) = (0::nat) & m - (0::nat) = m"
- sorry
-
-lemma PRE_SUB1: "PRE m = m - 1"
- sorry
-
-lemma MULT_CLAUSES: "0 * x = 0 &
-x * 0 = 0 &
-1 * x = x & x * 1 = x & Suc x * xa = x * xa + xa & x * Suc xa = x + x * xa"
- sorry
-
-lemma PRE_SUB: "PRE (m - n) = PRE m - n"
- sorry
-
-lemma ADD_EQ_1: "((m::nat) + (n::nat) = (1::nat)) =
-(m = (1::nat) & n = (0::nat) | m = (0::nat) & n = (1::nat))"
- sorry
-
-lemma ADD_INV_0_EQ: "((m::nat) + (n::nat) = m) = (n = (0::nat))"
- sorry
-
-lemma PRE_SUC_EQ: "0 < n ==> (m = PRE n) = (Suc m = n)"
- sorry
-
-lemma INV_PRE_EQ: "0 < m & 0 < n ==> (PRE m = PRE n) = (m = n)"
- sorry
-
-lemma LESS_SUC_NOT: "m < n ==> ~ n < Suc m"
- sorry
-
-lemma ADD_EQ_SUB: "(n::nat) <= (p::nat) ==> ((m::nat) + n = p) = (m = p - n)"
- sorry
-
-lemma LESS_ADD_1: "(xa::nat) < (x::nat) ==> EX xb::nat. x = xa + (xb + (1::nat))"
- sorry
-
-lemma NOT_ODD_EQ_EVEN: "Suc (n + n) ~= m + m"
- sorry
-
-lemma MULT_SUC_EQ: "(n * Suc p = m * Suc p) = (n = m)"
- sorry
-
-lemma MULT_EXP_MONO: "(n * Suc q ^ p = m * Suc q ^ p) = (n = m)"
- sorry
-
-lemma LESS_ADD_SUC: "m < m + Suc n"
- sorry
-
-lemma LESS_OR_EQ_ADD: "(n::nat) < (m::nat) | (EX p::nat. n = p + m)"
- sorry
-
-lemma WOP: "Ex (P::nat => bool) ==> EX n::nat. P n & (ALL m<n. ~ P m)"
- sorry
-
-lemma INV_PRE_LESS: "0 < m ==> (PRE m < PRE n) = (m < n)"
- sorry
-
-lemma INV_PRE_LESS_EQ: "0 < n ==> (PRE m <= PRE n) = (m <= n)"
- sorry
-
-lemma SUB_EQ_EQ_0: "((m::nat) - (n::nat) = m) = (m = (0::nat) | n = (0::nat))"
- sorry
-
-lemma SUB_LESS_OR: "(n::nat) < (m::nat) ==> n <= m - (1::nat)"
- sorry
-
-lemma LESS_SUB_ADD_LESS: "(i::nat) < (n::nat) - (m::nat) ==> i + m < n"
- sorry
-
-lemma LESS_EQ_SUB_LESS: "(xa::nat) <= (x::nat) ==> (x - xa < (c::nat)) = (x < xa + c)"
- sorry
-
-lemma NOT_SUC_LESS_EQ: "(~ Suc x <= xa) = (xa <= x)"
- sorry
-
-lemma SUB_LESS_EQ_ADD: "(m::nat) <= (p::nat) ==> (p - m <= (n::nat)) = (p <= m + n)"
- sorry
-
-lemma SUB_CANCEL: "(xa::nat) <= (x::nat) & (xb::nat) <= x ==> (x - xa = x - xb) = (xa = xb)"
- sorry
-
-lemma NOT_EXP_0: "Suc n ^ m ~= 0"
- sorry
-
-lemma ZERO_LESS_EXP: "0 < Suc n ^ m"
- sorry
-
-lemma ODD_OR_EVEN: "EX xa. x = Suc (Suc 0) * xa | x = Suc (Suc 0) * xa + 1"
- sorry
-
-lemma LESS_EXP_SUC_MONO: "Suc (Suc m) ^ n < Suc (Suc m) ^ Suc n"
- sorry
-
-lemma LESS_LESS_CASES: "(m::nat) = (n::nat) | m < n | n < m"
- sorry
-
-consts
- FACT :: "nat => nat"
-
-specification (FACT) FACT: "FACT 0 = 1 & (ALL n. FACT (Suc n) = Suc n * FACT n)"
- sorry
-
-lemma FACT_LESS: "0 < FACT n"
- sorry
-
-lemma EVEN_ODD: "EVEN n = (~ ODD n)"
- sorry
-
-lemma ODD_EVEN: "ODD x = (~ EVEN x)"
- sorry
-
-lemma EVEN_OR_ODD: "EVEN x | ODD x"
- sorry
-
-lemma EVEN_AND_ODD: "~ (EVEN x & ODD x)"
- sorry
-
-lemma EVEN_ADD: "EVEN (m + n) = (EVEN m = EVEN n)"
- sorry
-
-lemma EVEN_MULT: "EVEN (m * n) = (EVEN m | EVEN n)"
- sorry
-
-lemma ODD_ADD: "ODD (m + n) = (ODD m ~= ODD n)"
- sorry
-
-lemma ODD_MULT: "ODD (m * n) = (ODD m & ODD n)"
- sorry
-
-lemma EVEN_DOUBLE: "EVEN (2 * n)"
- sorry
-
-lemma ODD_DOUBLE: "ODD (Suc (2 * x))"
- sorry
-
-lemma EVEN_ODD_EXISTS: "(EVEN x --> (EX m. x = 2 * m)) & (ODD x --> (EX m. x = Suc (2 * m)))"
- sorry
-
-lemma EVEN_EXISTS: "EVEN n = (EX m. n = 2 * m)"
- sorry
-
-lemma ODD_EXISTS: "ODD n = (EX m. n = Suc (2 * m))"
- sorry
-
-lemma NOT_SUC_LESS_EQ_0: "~ Suc x <= 0"
- sorry
-
-lemma NOT_NUM_EQ: "(x ~= xa) = (Suc x <= xa | Suc xa <= x)"
- sorry
-
-lemma SUC_ADD_SYM: "Suc (m + n) = Suc n + m"
- sorry
-
-lemma NOT_SUC_ADD_LESS_EQ: "~ Suc (m + n) <= m"
- sorry
-
-lemma SUB_LEFT_ADD: "(m::nat) + ((n::nat) - (p::nat)) = (if n <= p then m else m + n - p)"
- sorry
-
-lemma SUB_RIGHT_ADD: "(m::nat) - (n::nat) + (p::nat) = (if m <= n then p else m + p - n)"
- sorry
-
-lemma SUB_LEFT_SUB: "(m::nat) - ((n::nat) - (p::nat)) = (if n <= p then m else m + p - n)"
- sorry
-
-lemma SUB_LEFT_SUC: "Suc (m - n) = (if m <= n then Suc 0 else Suc m - n)"
- sorry
-
-lemma SUB_LEFT_LESS_EQ: "((m::nat) <= (n::nat) - (p::nat)) = (m + p <= n | m <= (0::nat))"
- sorry
-
-lemma SUB_RIGHT_LESS_EQ: "((m::nat) - (n::nat) <= (p::nat)) = (m <= n + p)"
- sorry
-
-lemma SUB_RIGHT_LESS: "((m::nat) - (n::nat) < (p::nat)) = (m < n + p & (0::nat) < p)"
- sorry
-
-lemma SUB_RIGHT_GREATER_EQ: "((p::nat) <= (m::nat) - (n::nat)) = (n + p <= m | p <= (0::nat))"
- sorry
-
-lemma SUB_LEFT_GREATER: "((n::nat) - (p::nat) < (m::nat)) = (n < m + p & (0::nat) < m)"
- sorry
-
-lemma SUB_RIGHT_GREATER: "((p::nat) < (m::nat) - (n::nat)) = (n + p < m)"
- sorry
-
-lemma SUB_LEFT_EQ: "((m::nat) = (n::nat) - (p::nat)) = (m + p = n | m <= (0::nat) & n <= p)"
- sorry
-
-lemma SUB_RIGHT_EQ: "((m::nat) - (n::nat) = (p::nat)) = (m = n + p | m <= n & p <= (0::nat))"
- sorry
-
-lemma LE: "(ALL n::nat. (n <= (0::nat)) = (n = (0::nat))) &
-(ALL (m::nat) n::nat. (m <= Suc n) = (m = Suc n | m <= n))"
- sorry
-
-lemma DA: "(0::nat) < (n::nat) ==> EX (x::nat) q::nat. (k::nat) = q * n + x & x < n"
- sorry
-
-lemma DIV_LESS_EQ: "(0::nat) < (n::nat) ==> (k::nat) div n <= k"
- sorry
-
-lemma DIV_UNIQUE: "EX r::nat. (k::nat) = (q::nat) * (n::nat) + r & r < n ==> k div n = q"
- sorry
-
-lemma MOD_UNIQUE: "EX q::nat. (k::nat) = q * (n::nat) + (r::nat) & r < n ==> k mod n = r"
- sorry
-
-lemma DIV_MULT: "(r::nat) < (n::nat) ==> ((q::nat) * n + r) div n = q"
- sorry
-
-lemma MOD_EQ_0: "(0::nat) < (n::nat) ==> (k::nat) * n mod n = (0::nat)"
- sorry
-
-lemma ZERO_MOD: "(0::nat) < (n::nat) ==> (0::nat) mod n = (0::nat)"
- sorry
-
-lemma ZERO_DIV: "(0::nat) < (n::nat) ==> (0::nat) div n = (0::nat)"
- sorry
-
-lemma MOD_MULT: "(r::nat) < (n::nat) ==> ((q::nat) * n + r) mod n = r"
- sorry
-
-lemma MOD_TIMES: "(0::nat) < (n::nat) ==> ((q::nat) * n + (r::nat)) mod n = r mod n"
- sorry
-
-lemma MOD_PLUS: "(0::nat) < (n::nat)
-==> ((j::nat) mod n + (k::nat) mod n) mod n = (j + k) mod n"
- sorry
-
-lemma MOD_MOD: "(0::nat) < (n::nat) ==> (k::nat) mod n mod n = k mod n"
- sorry
-
-lemma ADD_DIV_ADD_DIV: "(0::nat) < (x::nat) ==> ((xa::nat) * x + (r::nat)) div x = xa + r div x"
- sorry
-
-lemma MOD_MULT_MOD: "(0::nat) < (n::nat) & (0::nat) < (m::nat)
-==> (x::nat) mod (n * m) mod n = x mod n"
- sorry
-
-lemma DIVMOD_ID: "(0::nat) < (n::nat) ==> n div n = (1::nat) & n mod n = (0::nat)"
- sorry
-
-lemma DIV_DIV_DIV_MULT: "(0::nat) < (x::nat) & (0::nat) < (xa::nat)
-==> (xb::nat) div x div xa = xb div (x * xa)"
- sorry
-
-lemma DIV_P: "(0::nat) < (q::nat)
-==> (P::nat => bool) ((p::nat) div q) =
- (EX (k::nat) r::nat. p = k * q + r & r < q & P k)"
- sorry
-
-lemma MOD_P: "(0::nat) < (q::nat)
-==> (P::nat => bool) ((p::nat) mod q) =
- (EX (k::nat) r::nat. p = k * q + r & r < q & P r)"
- sorry
-
-lemma MOD_TIMES2: "(0::nat) < (n::nat)
-==> (j::nat) mod n * ((k::nat) mod n) mod n = j * k mod n"
- sorry
-
-lemma MOD_COMMON_FACTOR: "(0::nat) < (n::nat) & (0::nat) < (q::nat)
-==> n * ((p::nat) mod q) = n * p mod (n * q)"
- sorry
-
-lemma num_case_cong: "M = M' & (M' = 0 --> b = b') & (ALL n. M' = Suc n --> f n = f' n)
-==> nat_case b f M = nat_case b' f' M'"
- sorry
-
-lemma SUC_ELIM_THM: "(ALL n. P (Suc n) n) = (ALL n>0. P n (n - 1))"
- sorry
-
-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))"
- sorry
-
-lemma PRE_ELIM_THM: "P (PRE n) = (ALL m. (n = 0 --> P 0) & (n = Suc m --> P m))"
- sorry
-
-lemma MULT_INCREASES: "1 < m & 0 < n ==> Suc n <= m * n"
- sorry
-
-lemma EXP_ALWAYS_BIG_ENOUGH: "(1::nat) < (b::nat) ==> EX m::nat. (n::nat) <= b ^ m"
- sorry
-
-lemma EXP_EQ_0: "((n::nat) ^ (m::nat) = (0::nat)) = (n = (0::nat) & (0::nat) < m)"
- sorry
-
-lemma EXP_1: "(1::nat) ^ (x::nat) = (1::nat) & x ^ (1::nat) = x"
- sorry
-
-lemma MIN_MAX_EQ: "(min (x::nat) (xa::nat) = max x xa) = (x = xa)"
- sorry
-
-lemma MIN_MAX_LT: "(min (x::nat) (xa::nat) < max x xa) = (x ~= xa)"
- sorry
-
-lemma MIN_MAX_PRED: "(P::nat => bool) (m::nat) & P (n::nat) ==> P (min m n) & P (max m n)"
- sorry
-
-lemma MIN_LT: "(min (xa::nat) (x::nat) < xa) = (xa ~= x & min xa x = x) &
-(min xa x < x) = (xa ~= x & min xa x = xa) &
-(xa < min xa x) = False & (x < min xa x) = False"
- sorry
-
-lemma MAX_LT: "((xa::nat) < max xa (x::nat)) = (xa ~= x & max xa x = x) &
-(x < max xa x) = (xa ~= x & max xa x = xa) &
-(max xa x < xa) = False & (max xa x < x) = False"
- sorry
-
-lemma MIN_LE: "min (xa::nat) (x::nat) <= xa & min xa x <= x"
- sorry
-
-lemma MAX_LE: "(xa::nat) <= max xa (x::nat) & x <= max xa x"
- sorry
-
-lemma MIN_0: "min (x::nat) (0::nat) = (0::nat) & min (0::nat) x = (0::nat)"
- sorry
-
-lemma MAX_0: "max (x::nat) (0::nat) = x & max (0::nat) x = x"
- sorry
-
-lemma EXISTS_GREATEST: "(Ex (P::nat => bool) & (EX x::nat. ALL y>x. ~ P y)) =
-(EX x::nat. P x & (ALL y>x. ~ P y))"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" hrat
-
-definition
- trat_1 :: "nat * nat" where
- "trat_1 == (0, 0)"
-
-lemma trat_1: "trat_1 = (0, 0)"
- sorry
-
-definition
- trat_inv :: "nat * nat => nat * nat" where
- "trat_inv == %(x, y). (y, x)"
-
-lemma trat_inv: "trat_inv (x, y) = (y, x)"
- sorry
-
-definition
- trat_add :: "nat * nat => nat * nat => nat * nat" where
- "trat_add ==
-%(x, y) (x', y').
- (PRE (Suc x * Suc y' + Suc x' * Suc y), PRE (Suc y * Suc y'))"
-
-lemma trat_add: "trat_add (x, y) (x', y') =
-(PRE (Suc x * Suc y' + Suc x' * Suc y), PRE (Suc y * Suc y'))"
- sorry
-
-definition
- trat_mul :: "nat * nat => nat * nat => nat * nat" where
- "trat_mul == %(x, y) (x', y'). (PRE (Suc x * Suc x'), PRE (Suc y * Suc y'))"
-
-lemma trat_mul: "trat_mul (x, y) (x', y') = (PRE (Suc x * Suc x'), PRE (Suc y * Suc y'))"
- sorry
-
-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)"
- sorry
-
-definition
- trat_eq :: "nat * nat => nat * nat => bool" where
- "trat_eq == %(x, y) (x', y'). Suc x * Suc y' = Suc x' * Suc y"
-
-lemma trat_eq: "trat_eq (x, y) (x', y') = (Suc x * Suc y' = Suc x' * Suc y)"
- sorry
-
-lemma TRAT_EQ_REFL: "trat_eq p p"
- sorry
-
-lemma TRAT_EQ_SYM: "trat_eq p q = trat_eq q p"
- sorry
-
-lemma TRAT_EQ_TRANS: "trat_eq p q & trat_eq q r ==> trat_eq p r"
- sorry
-
-lemma TRAT_EQ_AP: "p = q ==> trat_eq p q"
- sorry
-
-lemma TRAT_ADD_SYM_EQ: "trat_add h i = trat_add i h"
- sorry
-
-lemma TRAT_MUL_SYM_EQ: "trat_mul h i = trat_mul i h"
- sorry
-
-lemma TRAT_INV_WELLDEFINED: "trat_eq p q ==> trat_eq (trat_inv p) (trat_inv q)"
- sorry
-
-lemma TRAT_ADD_WELLDEFINED: "trat_eq p q ==> trat_eq (trat_add p r) (trat_add q r)"
- sorry
-
-lemma TRAT_ADD_WELLDEFINED2: "trat_eq p1 p2 & trat_eq q1 q2 ==> trat_eq (trat_add p1 q1) (trat_add p2 q2)"
- sorry
-
-lemma TRAT_MUL_WELLDEFINED: "trat_eq p q ==> trat_eq (trat_mul p r) (trat_mul q r)"
- sorry
-
-lemma TRAT_MUL_WELLDEFINED2: "trat_eq p1 p2 & trat_eq q1 q2 ==> trat_eq (trat_mul p1 q1) (trat_mul p2 q2)"
- sorry
-
-lemma TRAT_ADD_SYM: "trat_eq (trat_add h i) (trat_add i h)"
- sorry
-
-lemma TRAT_ADD_ASSOC: "trat_eq (trat_add h (trat_add i j)) (trat_add (trat_add h i) j)"
- sorry
-
-lemma TRAT_MUL_SYM: "trat_eq (trat_mul h i) (trat_mul i h)"
- sorry
-
-lemma TRAT_MUL_ASSOC: "trat_eq (trat_mul h (trat_mul i j)) (trat_mul (trat_mul h i) j)"
- sorry
-
-lemma TRAT_LDISTRIB: "trat_eq (trat_mul h (trat_add i j)) (trat_add (trat_mul h i) (trat_mul h j))"
- sorry
-
-lemma TRAT_MUL_LID: "trat_eq (trat_mul trat_1 h) h"
- sorry
-
-lemma TRAT_MUL_LINV: "trat_eq (trat_mul (trat_inv h) h) trat_1"
- sorry
-
-lemma TRAT_NOZERO: "~ trat_eq (trat_add h i) h"
- sorry
-
-lemma TRAT_ADD_TOTAL: "trat_eq h i |
-(EX d. trat_eq h (trat_add i d)) | (EX d. trat_eq i (trat_add h d))"
- sorry
-
-lemma TRAT_SUCINT_0: "trat_eq (trat_sucint n) (n, 0)"
- sorry
-
-lemma TRAT_ARCH: "EX n d. trat_eq (trat_sucint n) (trat_add h d)"
- sorry
-
-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))"
- sorry
-
-lemma TRAT_EQ_EQUIV: "trat_eq p q = (trat_eq p = trat_eq q)"
- sorry
-
-typedef (open) hrat = "{x. EX xa. x = trat_eq xa}"
- sorry
-
-lemmas hrat_TY_DEF = typedef_hol2hol4 [OF type_definition_hrat]
-
-consts
- 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))"
- sorry
-
-definition
- hrat_1 :: "hrat" where
- "hrat_1 == mk_hrat (trat_eq trat_1)"
-
-lemma hrat_1: "hrat_1 = mk_hrat (trat_eq trat_1)"
- sorry
-
-definition
- hrat_inv :: "hrat => hrat" where
- "hrat_inv == %T1. mk_hrat (trat_eq (trat_inv (Eps (dest_hrat T1))))"
-
-lemma hrat_inv: "hrat_inv T1 = mk_hrat (trat_eq (trat_inv (Eps (dest_hrat T1))))"
- sorry
-
-definition
- hrat_add :: "hrat => hrat => hrat" where
- "hrat_add ==
-%T1 T2.
- mk_hrat (trat_eq (trat_add (Eps (dest_hrat T1)) (Eps (dest_hrat T2))))"
-
-lemma hrat_add: "hrat_add T1 T2 =
-mk_hrat (trat_eq (trat_add (Eps (dest_hrat T1)) (Eps (dest_hrat T2))))"
- sorry
-
-definition
- hrat_mul :: "hrat => hrat => hrat" where
- "hrat_mul ==
-%T1 T2.
- mk_hrat (trat_eq (trat_mul (Eps (dest_hrat T1)) (Eps (dest_hrat T2))))"
-
-lemma hrat_mul: "hrat_mul T1 T2 =
-mk_hrat (trat_eq (trat_mul (Eps (dest_hrat T1)) (Eps (dest_hrat T2))))"
- sorry
-
-definition
- hrat_sucint :: "nat => hrat" where
- "hrat_sucint == %T1. mk_hrat (trat_eq (trat_sucint T1))"
-
-lemma hrat_sucint: "hrat_sucint T1 = mk_hrat (trat_eq (trat_sucint T1))"
- sorry
-
-lemma HRAT_ADD_SYM: "hrat_add h i = hrat_add i h"
- sorry
-
-lemma HRAT_ADD_ASSOC: "hrat_add h (hrat_add i j) = hrat_add (hrat_add h i) j"
- sorry
-
-lemma HRAT_MUL_SYM: "hrat_mul h i = hrat_mul i h"
- sorry
-
-lemma HRAT_MUL_ASSOC: "hrat_mul h (hrat_mul i j) = hrat_mul (hrat_mul h i) j"
- sorry
-
-lemma HRAT_LDISTRIB: "hrat_mul h (hrat_add i j) = hrat_add (hrat_mul h i) (hrat_mul h j)"
- sorry
-
-lemma HRAT_MUL_LID: "hrat_mul hrat_1 h = h"
- sorry
-
-lemma HRAT_MUL_LINV: "hrat_mul (hrat_inv h) h = hrat_1"
- sorry
-
-lemma HRAT_NOZERO: "hrat_add h i ~= h"
- sorry
-
-lemma HRAT_ADD_TOTAL: "h = i | (EX x. h = hrat_add i x) | (EX x. i = hrat_add h x)"
- sorry
-
-lemma HRAT_ARCH: "EX x xa. hrat_sucint x = hrat_add h xa"
- sorry
-
-lemma HRAT_SUCINT: "hrat_sucint 0 = hrat_1 &
-(ALL x. hrat_sucint (Suc x) = hrat_add (hrat_sucint x) hrat_1)"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" hreal
-
-definition
- hrat_lt :: "hrat => hrat => bool" where
- "hrat_lt == %x y. EX d. y = hrat_add x d"
-
-lemma hrat_lt: "hrat_lt x y = (EX d. y = hrat_add x d)"
- sorry
-
-lemma HRAT_LT_REFL: "~ hrat_lt x x"
- sorry
-
-lemma HRAT_LT_TRANS: "hrat_lt x y & hrat_lt y z ==> hrat_lt x z"
- sorry
-
-lemma HRAT_LT_ANTISYM: "~ (hrat_lt x y & hrat_lt y x)"
- sorry
-
-lemma HRAT_LT_TOTAL: "x = y | hrat_lt x y | hrat_lt y x"
- sorry
-
-lemma HRAT_MUL_RID: "hrat_mul x hrat_1 = x"
- sorry
-
-lemma HRAT_MUL_RINV: "hrat_mul x (hrat_inv x) = hrat_1"
- sorry
-
-lemma HRAT_RDISTRIB: "hrat_mul (hrat_add x y) z = hrat_add (hrat_mul x z) (hrat_mul y z)"
- sorry
-
-lemma HRAT_LT_ADDL: "hrat_lt x (hrat_add x y)"
- sorry
-
-lemma HRAT_LT_ADDR: "hrat_lt xa (hrat_add x xa)"
- sorry
-
-lemma HRAT_LT_GT: "hrat_lt x y ==> ~ hrat_lt y x"
- sorry
-
-lemma HRAT_LT_NE: "hrat_lt x y ==> x ~= y"
- sorry
-
-lemma HRAT_EQ_LADD: "(hrat_add x y = hrat_add x z) = (y = z)"
- sorry
-
-lemma HRAT_EQ_LMUL: "(hrat_mul x y = hrat_mul x z) = (y = z)"
- sorry
-
-lemma HRAT_LT_ADD2: "hrat_lt u x & hrat_lt v y ==> hrat_lt (hrat_add u v) (hrat_add x y)"
- sorry
-
-lemma HRAT_LT_LADD: "hrat_lt (hrat_add z x) (hrat_add z y) = hrat_lt x y"
- sorry
-
-lemma HRAT_LT_RADD: "hrat_lt (hrat_add x z) (hrat_add y z) = hrat_lt x y"
- sorry
-
-lemma HRAT_LT_MUL2: "hrat_lt u x & hrat_lt v y ==> hrat_lt (hrat_mul u v) (hrat_mul x y)"
- sorry
-
-lemma HRAT_LT_LMUL: "hrat_lt (hrat_mul z x) (hrat_mul z y) = hrat_lt x y"
- sorry
-
-lemma HRAT_LT_RMUL: "hrat_lt (hrat_mul x z) (hrat_mul y z) = hrat_lt x y"
- sorry
-
-lemma HRAT_LT_LMUL1: "hrat_lt (hrat_mul x y) y = hrat_lt x hrat_1"
- sorry
-
-lemma HRAT_LT_RMUL1: "hrat_lt (hrat_mul x y) x = hrat_lt y hrat_1"
- sorry
-
-lemma HRAT_GT_LMUL1: "hrat_lt y (hrat_mul x y) = hrat_lt hrat_1 x"
- sorry
-
-lemma HRAT_LT_L1: "hrat_lt (hrat_mul (hrat_inv x) y) hrat_1 = hrat_lt y x"
- sorry
-
-lemma HRAT_LT_R1: "hrat_lt (hrat_mul x (hrat_inv y)) hrat_1 = hrat_lt x y"
- sorry
-
-lemma HRAT_GT_L1: "hrat_lt hrat_1 (hrat_mul (hrat_inv x) y) = hrat_lt x y"
- sorry
-
-lemma HRAT_INV_MUL: "hrat_inv (hrat_mul x y) = hrat_mul (hrat_inv x) (hrat_inv y)"
- sorry
-
-lemma HRAT_UP: "Ex (hrat_lt x)"
- sorry
-
-lemma HRAT_DOWN: "EX xa. hrat_lt xa x"
- sorry
-
-lemma HRAT_DOWN2: "EX xa. hrat_lt xa x & hrat_lt xa y"
- sorry
-
-lemma HRAT_MEAN: "hrat_lt x y ==> EX xa. hrat_lt x xa & hrat_lt xa y"
- sorry
-
-definition
- isacut :: "(hrat => bool) => bool" where
- "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: "isacut (CC::hrat => bool) =
-(Ex CC &
- (EX x::hrat. ~ CC x) &
- (ALL (x::hrat) y::hrat. CC x & hrat_lt y x --> CC y) &
- (ALL x::hrat. CC x --> (EX y::hrat. CC y & hrat_lt x y)))"
- sorry
-
-definition
- cut_of_hrat :: "hrat => hrat => bool" where
- "cut_of_hrat == %x y. hrat_lt y x"
-
-lemma cut_of_hrat: "cut_of_hrat x = (%y. hrat_lt y x)"
- sorry
-
-lemma ISACUT_HRAT: "isacut (cut_of_hrat h)"
- sorry
-
-typedef (open) hreal = "Collect isacut"
- sorry
-
-lemmas hreal_TY_DEF = typedef_hol2hol4 [OF type_definition_hreal]
-
-consts
- hreal :: "(hrat => bool) => hreal"
- cut :: "hreal => hrat => bool"
-
-specification (cut hreal) hreal_tybij: "(ALL a. hreal (cut a) = a) & (ALL r. isacut r = (cut (hreal r) = r))"
- sorry
-
-lemma EQUAL_CUTS: "cut X = cut Y ==> X = Y"
- sorry
-
-lemma CUT_ISACUT: "isacut (cut x)"
- sorry
-
-lemma CUT_NONEMPTY: "Ex (cut x)"
- sorry
-
-lemma CUT_BOUNDED: "EX xa. ~ cut x xa"
- sorry
-
-lemma CUT_DOWN: "cut x xa & hrat_lt xb xa ==> cut x xb"
- sorry
-
-lemma CUT_UP: "cut x xa ==> EX y. cut x y & hrat_lt xa y"
- sorry
-
-lemma CUT_UBOUND: "~ cut x xa & hrat_lt xa xb ==> ~ cut x xb"
- sorry
-
-lemma CUT_STRADDLE: "cut X x & ~ cut X y ==> hrat_lt x y"
- sorry
-
-lemma CUT_NEARTOP_ADD: "EX x. cut X x & ~ cut X (hrat_add x e)"
- sorry
-
-lemma CUT_NEARTOP_MUL: "hrat_lt hrat_1 u ==> EX x. cut X x & ~ cut X (hrat_mul u x)"
- sorry
-
-definition
- hreal_1 :: "hreal" where
- "hreal_1 == hreal (cut_of_hrat hrat_1)"
-
-lemma hreal_1: "hreal_1 = hreal (cut_of_hrat hrat_1)"
- sorry
-
-definition
- hreal_add :: "hreal => hreal => hreal" where
- "hreal_add == %X Y. hreal (%w. EX x y. w = hrat_add x y & cut X x & cut Y y)"
-
-lemma hreal_add: "hreal_add X Y = hreal (%w. EX x y. w = hrat_add x y & cut X x & cut Y y)"
- sorry
-
-definition
- hreal_mul :: "hreal => hreal => hreal" where
- "hreal_mul == %X Y. hreal (%w. EX x y. w = hrat_mul x y & cut X x & cut Y y)"
-
-lemma hreal_mul: "hreal_mul X Y = hreal (%w. EX x y. w = hrat_mul x y & cut X x & cut Y y)"
- sorry
-
-definition
- hreal_inv :: "hreal => hreal" where
- "hreal_inv ==
-%X. hreal
- (%w. EX d. hrat_lt d hrat_1 &
- (ALL x. cut X x --> hrat_lt (hrat_mul w x) d))"
-
-lemma hreal_inv: "hreal_inv X =
-hreal
- (%w. EX d. hrat_lt d hrat_1 &
- (ALL x. cut X x --> hrat_lt (hrat_mul w x) d))"
- sorry
-
-definition
- hreal_sup :: "(hreal => bool) => hreal" where
- "hreal_sup == %P. hreal (%w. EX X. P X & cut X w)"
-
-lemma hreal_sup: "hreal_sup P = hreal (%w. EX X. P X & cut X w)"
- sorry
-
-definition
- hreal_lt :: "hreal => hreal => bool" where
- "hreal_lt == %X Y. X ~= Y & (ALL x. cut X x --> cut Y x)"
-
-lemma hreal_lt: "hreal_lt X Y = (X ~= Y & (ALL x. cut X x --> cut Y x))"
- sorry
-
-lemma HREAL_INV_ISACUT: "isacut
- (%w. EX d. hrat_lt d hrat_1 &
- (ALL x. cut X x --> hrat_lt (hrat_mul w x) d))"
- sorry
-
-lemma HREAL_ADD_ISACUT: "isacut (%w. EX x y. w = hrat_add x y & cut X x & cut Y y)"
- sorry
-
-lemma HREAL_MUL_ISACUT: "isacut (%w. EX x y. w = hrat_mul x y & cut X x & cut Y y)"
- sorry
-
-lemma HREAL_ADD_SYM: "hreal_add X Y = hreal_add Y X"
- sorry
-
-lemma HREAL_MUL_SYM: "hreal_mul X Y = hreal_mul Y X"
- sorry
-
-lemma HREAL_ADD_ASSOC: "hreal_add X (hreal_add Y Z) = hreal_add (hreal_add X Y) Z"
- sorry
-
-lemma HREAL_MUL_ASSOC: "hreal_mul X (hreal_mul Y Z) = hreal_mul (hreal_mul X Y) Z"
- sorry
-
-lemma HREAL_LDISTRIB: "hreal_mul X (hreal_add Y Z) = hreal_add (hreal_mul X Y) (hreal_mul X Z)"
- sorry
-
-lemma HREAL_MUL_LID: "hreal_mul hreal_1 X = X"
- sorry
-
-lemma HREAL_MUL_LINV: "hreal_mul (hreal_inv X) X = hreal_1"
- sorry
-
-lemma HREAL_NOZERO: "hreal_add X Y ~= X"
- sorry
-
-definition
- hreal_sub :: "hreal => hreal => hreal" where
- "hreal_sub == %Y X. hreal (%w. EX x. ~ cut X x & cut Y (hrat_add x w))"
-
-lemma hreal_sub: "hreal_sub Y X = hreal (%w. EX x. ~ cut X x & cut Y (hrat_add x w))"
- sorry
-
-lemma HREAL_LT_LEMMA: "hreal_lt X Y ==> EX x. ~ cut X x & cut Y x"
- sorry
-
-lemma HREAL_SUB_ISACUT: "hreal_lt X Y ==> isacut (%w. EX x. ~ cut X x & cut Y (hrat_add x w))"
- sorry
-
-lemma HREAL_SUB_ADD: "hreal_lt X Y ==> hreal_add (hreal_sub Y X) X = Y"
- sorry
-
-lemma HREAL_LT_TOTAL: "X = Y | hreal_lt X Y | hreal_lt Y X"
- sorry
-
-lemma HREAL_LT: "hreal_lt X Y = (EX D. Y = hreal_add X D)"
- sorry
-
-lemma HREAL_ADD_TOTAL: "X = Y | (EX D. Y = hreal_add X D) | (EX D. X = hreal_add Y D)"
- sorry
-
-lemma HREAL_SUP_ISACUT: "Ex P & (EX Y. ALL X. P X --> hreal_lt X Y)
-==> isacut (%w. EX X. P X & cut X w)"
- sorry
-
-lemma HREAL_SUP: "Ex P & (EX Y. ALL X. P X --> hreal_lt X Y)
-==> (EX X. P X & hreal_lt Y X) = hreal_lt Y (hreal_sup P)"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" 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))"
- sorry
-
-definition
- iZ :: "nat => nat" where
- "iZ == %x. x"
-
-lemma iZ: "iZ x = x"
- sorry
-
-definition
- iiSUC :: "nat => nat" where
- "iiSUC == %n. Suc (Suc n)"
-
-lemma iiSUC: "iiSUC n = Suc (Suc n)"
- sorry
-
-lemma numeral_distrib: "(ALL x::nat. (0::nat) + x = x) &
-(ALL x::nat. x + (0::nat) = x) &
-(ALL (x::nat) xa::nat. NUMERAL x + NUMERAL xa = NUMERAL (iZ (x + xa))) &
-(ALL x::nat. (0::nat) * x = (0::nat)) &
-(ALL x::nat. x * (0::nat) = (0::nat)) &
-(ALL (x::nat) xa::nat. NUMERAL x * NUMERAL xa = NUMERAL (x * xa)) &
-(ALL x::nat. (0::nat) - x = (0::nat)) &
-(ALL x::nat. x - (0::nat) = x) &
-(ALL (x::nat) xa::nat. NUMERAL x - NUMERAL xa = NUMERAL (x - xa)) &
-(ALL x::nat. (0::nat) ^ NUMERAL (NUMERAL_BIT1 x) = (0::nat)) &
-(ALL x::nat. (0::nat) ^ NUMERAL (NUMERAL_BIT2 x) = (0::nat)) &
-(ALL x::nat. x ^ (0::nat) = (1::nat)) &
-(ALL (x::nat) xa::nat. NUMERAL x ^ NUMERAL xa = NUMERAL (x ^ xa)) &
-Suc (0::nat) = (1::nat) &
-(ALL x::nat. Suc (NUMERAL x) = NUMERAL (Suc x)) &
-PRE (0::nat) = (0::nat) &
-(ALL x::nat. PRE (NUMERAL x) = NUMERAL (PRE x)) &
-(ALL x::nat. (NUMERAL x = (0::nat)) = (x = ALT_ZERO)) &
-(ALL x::nat. ((0::nat) = NUMERAL x) = (x = ALT_ZERO)) &
-(ALL (x::nat) xa::nat. (NUMERAL x = NUMERAL xa) = (x = xa)) &
-(ALL x::nat. (x < (0::nat)) = False) &
-(ALL x::nat. ((0::nat) < NUMERAL x) = (ALT_ZERO < x)) &
-(ALL (x::nat) xa::nat. (NUMERAL x < NUMERAL xa) = (x < xa)) &
-(ALL x::nat. (x < (0::nat)) = False) &
-(ALL x::nat. ((0::nat) < NUMERAL x) = (ALT_ZERO < x)) &
-(ALL (x::nat) xa::nat. (NUMERAL xa < NUMERAL x) = (xa < x)) &
-(ALL x::nat. ((0::nat) <= x) = True) &
-(ALL x::nat. (NUMERAL x <= (0::nat)) = (x <= ALT_ZERO)) &
-(ALL (x::nat) xa::nat. (NUMERAL x <= NUMERAL xa) = (x <= xa)) &
-(ALL x::nat. ((0::nat) <= x) = True) &
-(ALL x::nat. (x <= (0::nat)) = (x = (0::nat))) &
-(ALL (x::nat) xa::nat. (NUMERAL xa <= NUMERAL x) = (xa <= x)) &
-(ALL x::nat. ODD (NUMERAL x) = ODD x) &
-(ALL x::nat. EVEN (NUMERAL x) = EVEN x) & ~ ODD (0::nat) & EVEN (0::nat)"
- sorry
-
-lemma numeral_iisuc: "iiSUC ALT_ZERO = NUMERAL_BIT2 ALT_ZERO &
-iiSUC (NUMERAL_BIT1 n) = NUMERAL_BIT1 (Suc n) &
-iiSUC (NUMERAL_BIT2 n) = NUMERAL_BIT2 (Suc n)"
- sorry
-
-lemma numeral_add: "iZ (ALT_ZERO + x) = x &
-iZ (x + ALT_ZERO) = x &
-iZ (NUMERAL_BIT1 x + NUMERAL_BIT1 xa) = NUMERAL_BIT2 (iZ (x + xa)) &
-iZ (NUMERAL_BIT1 x + NUMERAL_BIT2 xa) = NUMERAL_BIT1 (Suc (x + xa)) &
-iZ (NUMERAL_BIT2 x + NUMERAL_BIT1 xa) = NUMERAL_BIT1 (Suc (x + xa)) &
-iZ (NUMERAL_BIT2 x + NUMERAL_BIT2 xa) = NUMERAL_BIT2 (Suc (x + xa)) &
-Suc (ALT_ZERO + x) = Suc x &
-Suc (x + ALT_ZERO) = Suc x &
-Suc (NUMERAL_BIT1 x + NUMERAL_BIT1 xa) = NUMERAL_BIT1 (Suc (x + xa)) &
-Suc (NUMERAL_BIT1 x + NUMERAL_BIT2 xa) = NUMERAL_BIT2 (Suc (x + xa)) &
-Suc (NUMERAL_BIT2 x + NUMERAL_BIT1 xa) = NUMERAL_BIT2 (Suc (x + xa)) &
-Suc (NUMERAL_BIT2 x + NUMERAL_BIT2 xa) = NUMERAL_BIT1 (iiSUC (x + xa)) &
-iiSUC (ALT_ZERO + x) = iiSUC x &
-iiSUC (x + ALT_ZERO) = iiSUC x &
-iiSUC (NUMERAL_BIT1 x + NUMERAL_BIT1 xa) = NUMERAL_BIT2 (Suc (x + xa)) &
-iiSUC (NUMERAL_BIT1 x + NUMERAL_BIT2 xa) = NUMERAL_BIT1 (iiSUC (x + xa)) &
-iiSUC (NUMERAL_BIT2 x + NUMERAL_BIT1 xa) = NUMERAL_BIT1 (iiSUC (x + xa)) &
-iiSUC (NUMERAL_BIT2 x + NUMERAL_BIT2 xa) = NUMERAL_BIT2 (iiSUC (x + xa))"
- sorry
-
-lemma numeral_eq: "(ALT_ZERO = NUMERAL_BIT1 x) = False &
-(NUMERAL_BIT1 x = ALT_ZERO) = False &
-(ALT_ZERO = NUMERAL_BIT2 x) = False &
-(NUMERAL_BIT2 x = ALT_ZERO) = False &
-(NUMERAL_BIT1 x = NUMERAL_BIT2 xa) = False &
-(NUMERAL_BIT2 x = NUMERAL_BIT1 xa) = False &
-(NUMERAL_BIT1 x = NUMERAL_BIT1 xa) = (x = xa) &
-(NUMERAL_BIT2 x = NUMERAL_BIT2 xa) = (x = xa)"
- sorry
-
-lemma numeral_lt: "(ALT_ZERO < NUMERAL_BIT1 x) = True &
-(ALT_ZERO < NUMERAL_BIT2 x) = True &
-(x < ALT_ZERO) = False &
-(NUMERAL_BIT1 x < NUMERAL_BIT1 xa) = (x < xa) &
-(NUMERAL_BIT2 x < NUMERAL_BIT2 xa) = (x < xa) &
-(NUMERAL_BIT1 x < NUMERAL_BIT2 xa) = (~ xa < x) &
-(NUMERAL_BIT2 x < NUMERAL_BIT1 xa) = (x < xa)"
- sorry
-
-lemma numeral_lte: "(ALT_ZERO <= x) = True &
-(NUMERAL_BIT1 x <= ALT_ZERO) = False &
-(NUMERAL_BIT2 x <= ALT_ZERO) = False &
-(NUMERAL_BIT1 x <= NUMERAL_BIT1 xa) = (x <= xa) &
-(NUMERAL_BIT1 x <= NUMERAL_BIT2 xa) = (x <= xa) &
-(NUMERAL_BIT2 x <= NUMERAL_BIT1 xa) = (~ xa <= x) &
-(NUMERAL_BIT2 x <= NUMERAL_BIT2 xa) = (x <= xa)"
- sorry
-
-lemma numeral_pre: "PRE ALT_ZERO = ALT_ZERO &
-PRE (NUMERAL_BIT1 ALT_ZERO) = ALT_ZERO &
-(ALL x.
- PRE (NUMERAL_BIT1 (NUMERAL_BIT1 x)) =
- NUMERAL_BIT2 (PRE (NUMERAL_BIT1 x))) &
-(ALL x.
- PRE (NUMERAL_BIT1 (NUMERAL_BIT2 x)) = NUMERAL_BIT2 (NUMERAL_BIT1 x)) &
-(ALL x. PRE (NUMERAL_BIT2 x) = NUMERAL_BIT1 x)"
- sorry
-
-lemma bit_initiality: "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))"
- sorry
-
-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 ALT_ZERO zf bf1 bf2 = zf) &
-(ALL (n::nat) (zf::'a) (bf1::nat => 'a) bf2::nat => 'a.
- iBIT_cases (NUMERAL_BIT1 n) zf bf1 bf2 = bf1 n) &
-(ALL (n::nat) (zf::'a) (bf1::nat => 'a) bf2::nat => 'a.
- iBIT_cases (NUMERAL_BIT2 n) zf bf1 bf2 = bf2 n)"
- sorry
-
-definition
- iDUB :: "nat => nat" where
- "iDUB == %x. x + x"
-
-lemma iDUB: "iDUB x = x + x"
- sorry
-
-consts
- iSUB :: "bool => nat => nat => nat"
-
-specification (iSUB) iSUB_DEF: "(ALL b x. iSUB b ALT_ZERO x = ALT_ZERO) &
-(ALL b n x.
- 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.
- 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))))"
- sorry
-
-lemma bit_induction: "P ALT_ZERO &
-(ALL n. P n --> P (NUMERAL_BIT1 n)) & (ALL n. P n --> P (NUMERAL_BIT2 n))
-==> P x"
- sorry
-
-lemma iSUB_THM: "iSUB (x::bool) ALT_ZERO (xn::nat) = ALT_ZERO &
-iSUB True (xa::nat) ALT_ZERO = xa &
-iSUB False (NUMERAL_BIT1 xa) ALT_ZERO = iDUB xa &
-iSUB True (NUMERAL_BIT1 xa) (NUMERAL_BIT1 (xb::nat)) =
-iDUB (iSUB True xa xb) &
-iSUB False (NUMERAL_BIT1 xa) (NUMERAL_BIT1 xb) =
-NUMERAL_BIT1 (iSUB False xa xb) &
-iSUB True (NUMERAL_BIT1 xa) (NUMERAL_BIT2 xb) =
-NUMERAL_BIT1 (iSUB False xa xb) &
-iSUB False (NUMERAL_BIT1 xa) (NUMERAL_BIT2 xb) = iDUB (iSUB False xa xb) &
-iSUB False (NUMERAL_BIT2 xa) ALT_ZERO = NUMERAL_BIT1 xa &
-iSUB True (NUMERAL_BIT2 xa) (NUMERAL_BIT1 xb) =
-NUMERAL_BIT1 (iSUB True xa xb) &
-iSUB False (NUMERAL_BIT2 xa) (NUMERAL_BIT1 xb) = iDUB (iSUB True xa xb) &
-iSUB True (NUMERAL_BIT2 xa) (NUMERAL_BIT2 xb) = iDUB (iSUB True xa xb) &
-iSUB False (NUMERAL_BIT2 xa) (NUMERAL_BIT2 xb) =
-NUMERAL_BIT1 (iSUB False xa xb)"
- sorry
-
-lemma numeral_sub: "NUMERAL (x - xa) = (if xa < x then NUMERAL (iSUB True x xa) else 0)"
- sorry
-
-lemma iDUB_removal: "iDUB (NUMERAL_BIT1 x) = NUMERAL_BIT2 (iDUB x) &
-iDUB (NUMERAL_BIT2 x) = NUMERAL_BIT2 (NUMERAL_BIT1 x) &
-iDUB ALT_ZERO = ALT_ZERO"
- sorry
-
-lemma numeral_mult: "ALT_ZERO * x = ALT_ZERO &
-x * ALT_ZERO = ALT_ZERO &
-NUMERAL_BIT1 x * xa = iZ (iDUB (x * xa) + xa) &
-NUMERAL_BIT2 x * xa = iDUB (iZ (x * xa + xa))"
- sorry
-
-definition
- iSQR :: "nat => nat" where
- "iSQR == %x. x * x"
-
-lemma iSQR: "iSQR x = x * x"
- sorry
-
-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))"
- sorry
-
-lemma numeral_evenodd: "EVEN ALT_ZERO &
-EVEN (NUMERAL_BIT2 x) &
-~ EVEN (NUMERAL_BIT1 x) &
-~ ODD ALT_ZERO & ~ ODD (NUMERAL_BIT2 x) & ODD (NUMERAL_BIT1 x)"
- sorry
-
-lemma numeral_fact: "FACT n = (if n = 0 then 1 else n * FACT (PRE n))"
- sorry
-
-lemma numeral_funpow: "(f ^^ n) x = (if n = 0 then x else (f ^^ (n - 1)) (f x))"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" ind_type
-
-lemma INJ_INVERSE2: "(!!(x1::'A) (y1::'B) (x2::'A) y2::'B.
- ((P::'A => 'B => 'C) 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"
- sorry
-
-definition
- NUMPAIR :: "nat => nat => nat" where
- "NUMPAIR == %x y. 2 ^ x * (2 * y + 1)"
-
-lemma NUMPAIR: "NUMPAIR x y = 2 ^ x * (2 * y + 1)"
- sorry
-
-lemma NUMPAIR_INJ_LEMMA: "NUMPAIR x xa = NUMPAIR xb xc ==> x = xb"
- sorry
-
-lemma NUMPAIR_INJ: "(NUMPAIR x1 y1 = NUMPAIR x2 y2) = (x1 = x2 & y1 = y2)"
- sorry
-
-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"
- sorry
-
-definition
- NUMSUM :: "bool => nat => nat" where
- "NUMSUM == %b x. if b then Suc (2 * x) else 2 * x"
-
-lemma NUMSUM: "NUMSUM b x = (if b then Suc (2 * x) else 2 * x)"
- sorry
-
-lemma NUMSUM_INJ: "(NUMSUM b1 x1 = NUMSUM b2 x2) = (b1 = b2 & x1 = x2)"
- sorry
-
-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"
- sorry
-
-definition
- INJN :: "nat => nat => 'a => bool" where
- "INJN == %m n a. n = m"
-
-lemma INJN: "INJN m = (%n a. n = m)"
- sorry
-
-lemma INJN_INJ: "(INJN n1 = INJN n2) = (n1 = n2)"
- sorry
-
-definition
- INJA :: "'a => nat => 'a => bool" where
- "INJA == %a n b. b = a"
-
-lemma INJA: "INJA a = (%n b. b = a)"
- sorry
-
-lemma INJA_INJ: "(INJA a1 = INJA a2) = (a1 = a2)"
- sorry
-
-definition
- INJF :: "(nat => nat => 'a => bool) => nat => 'a => bool" where
- "INJF == %f n. f (NUMFST n) (NUMSND n)"
-
-lemma INJF: "INJF f = (%n. f (NUMFST n) (NUMSND n))"
- sorry
-
-lemma INJF_INJ: "(INJF f1 = INJF f2) = (f1 = f2)"
- sorry
-
-definition
- INJP :: "(nat => 'a => bool) => (nat => 'a => bool) => nat => 'a => bool" where
- "INJP ==
-%f1 f2 n a. if NUMLEFT n then f1 (NUMRIGHT n) a else f2 (NUMRIGHT n) a"
-
-lemma INJP: "INJP f1 f2 =
-(%n a. if NUMLEFT n then f1 (NUMRIGHT n) a else f2 (NUMRIGHT n) a)"
- sorry
-
-lemma INJP_INJ: "(INJP f1 f2 = INJP f1' f2') = (f1 = f1' & f2 = f2')"
- sorry
-
-definition
- ZCONSTR :: "nat => 'a => (nat => nat => 'a => bool) => nat => 'a => bool" where
- "ZCONSTR == %c i r. INJP (INJN (Suc c)) (INJP (INJA i) (INJF r))"
-
-lemma ZCONSTR: "ZCONSTR c i r = INJP (INJN (Suc c)) (INJP (INJA i) (INJF r))"
- sorry
-
-definition
- ZBOT :: "nat => 'a => bool" where
- "ZBOT == INJP (INJN 0) (SOME z. True)"
-
-lemma ZBOT: "ZBOT = INJP (INJN 0) (SOME z. True)"
- sorry
-
-lemma ZCONSTR_ZBOT: "ZCONSTR x xa xb ~= ZBOT"
- sorry
-
-definition
- ZRECSPACE :: "(nat => 'a => bool) => bool" where
- "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"
-
-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)"
- sorry
-
-lemma ZRECSPACE_rules: "(op &::bool => bool => bool)
- ((ZRECSPACE::(nat => 'a::type => bool) => bool)
- (ZBOT::nat => 'a::type => bool))
- ((All::(nat => bool) => bool)
- (%c::nat.
- (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::type => bool) => bool)
- (r n)))
- ((ZRECSPACE::(nat => 'a::type => bool) => bool)
- ((ZCONSTR::nat
- => 'a::type
- => (nat => nat => 'a::type => bool)
- => nat => 'a::type => bool)
- c i r))))))"
- sorry
-
-lemma ZRECSPACE_ind: "[| x ZBOT & (ALL c i r. (ALL n. x (r n)) --> x (ZCONSTR c i r));
- ZRECSPACE a0 |]
-==> x a0"
- sorry
-
-lemma ZRECSPACE_cases: "ZRECSPACE a0 =
-(a0 = ZBOT | (EX c i r. a0 = ZCONSTR c i r & (ALL n. ZRECSPACE (r n))))"
- sorry
-
-typedef (open) ('a) recspace = "Collect ZRECSPACE :: (nat \<Rightarrow> 'a\<Colon>type \<Rightarrow> bool) set"
- sorry
-
-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))"
- sorry
-
-definition
- BOTTOM :: "'a recspace" where
- "BOTTOM == mk_rec ZBOT"
-
-lemma BOTTOM: "BOTTOM = mk_rec ZBOT"
- sorry
-
-definition
- CONSTR :: "nat => 'a => (nat => 'a recspace) => 'a recspace" where
- "CONSTR == %c i r. mk_rec (ZCONSTR c i (%n. dest_rec (r n)))"
-
-lemma CONSTR: "CONSTR c i r = mk_rec (ZCONSTR c i (%n. dest_rec (r n)))"
- sorry
-
-lemma MK_REC_INJ: "[| mk_rec x = mk_rec y; ZRECSPACE x & ZRECSPACE y |] ==> x = y"
- sorry
-
-lemma DEST_REC_INJ: "(dest_rec x = dest_rec y) = (x = y)"
- sorry
-
-lemma CONSTR_BOT: "CONSTR c i r ~= BOTTOM"
- sorry
-
-lemma CONSTR_INJ: "(CONSTR c1 i1 r1 = CONSTR c2 i2 r2) = (c1 = c2 & i1 = i2 & r1 = r2)"
- sorry
-
-lemma CONSTR_IND: "P BOTTOM & (ALL c i r. (ALL n. P (r n)) --> P (CONSTR c i r)) ==> P x"
- sorry
-
-lemma CONSTR_REC: "EX f. ALL c i r. f (CONSTR c i r) = Fn c i r (%n. f (r n))"
- sorry
-
-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)"
- sorry
-
-definition
- FNIL :: "nat => 'a" where
- "FNIL == %n. SOME x. True"
-
-lemma FNIL: "FNIL n = (SOME x. True)"
- sorry
-
-definition
- ISO :: "('a => 'b) => ('b => 'a) => bool" where
- "ISO == %f g. (ALL x. f (g x) = x) & (ALL y. g (f y) = y)"
-
-lemma ISO: "ISO f g = ((ALL x. f (g x) = x) & (ALL y. g (f y) = y))"
- sorry
-
-lemma ISO_REFL: "ISO (%x. x) (%x. x)"
- sorry
-
-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)))"
- sorry
-
-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))"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" divides
-
-lemma DIVIDES_FACT: "0 < b ==> b dvd FACT b"
- sorry
-
-lemma DIVIDES_MULT_LEFT: "((x::nat) * (xa::nat) dvd xa) = (xa = (0::nat) | x = (1::nat))"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" prime
-
-consts
- prime :: "nat => bool"
-
-defs
- prime_primdef: "prime.prime == %a. a ~= 1 & (ALL b. b dvd a --> b = a | b = 1)"
-
-lemma prime_def: "prime.prime a = (a ~= 1 & (ALL b. b dvd a --> b = a | b = 1))"
- sorry
-
-lemma NOT_PRIME_0: "~ prime.prime 0"
- sorry
-
-lemma NOT_PRIME_1: "~ prime.prime 1"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" 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))"
- sorry
-
-lemma NULL: "(op &::bool => bool => bool)
- ((List.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)
- ((List.null::'a::type list => bool)
- ((op #::'a::type => 'a::type list => 'a::type list) x xa)))))"
- sorry
-
-lemma list_case_compute: "list_case (b::'b) (f::'a => 'a list => 'b) (l::'a list) =
-(if List.null l then b else f (hd l) (tl l))"
- sorry
-
-lemma LIST_NOT_EQ: "l1 ~= l2 ==> x # l1 ~= xa # l2"
- sorry
-
-lemma NOT_EQ_LIST: "h1 ~= h2 ==> h1 # x ~= h2 # xa"
- sorry
-
-lemma EQ_LIST: "[| h1 = h2; l1 = l2 |] ==> h1 # l1 = h2 # l2"
- sorry
-
-lemma CONS: "~ List.null l ==> hd l # tl l = l"
- sorry
-
-lemma MAP_EQ_NIL: "(map (f::'a => 'b) (l::'a list) = []) = (l = []) & ([] = map f l) = (l = [])"
- sorry
-
-lemma EVERY_EL: "list_all P l = (ALL n<length l. P (EL n l))"
- sorry
-
-lemma EVERY_CONJ: "list_all (%x. P x & Q x) l = (list_all P l & list_all Q l)"
- sorry
-
-lemma EVERY_MEM: "list_all P l = (ALL e. List.member l e --> P e)"
- sorry
-
-lemma EXISTS_MEM: "list_ex P l = (EX e. List.member l e & P e)"
- sorry
-
-lemma MEM_APPEND: "List.member (l1 @ l2) e = (List.member l1 e | List.member l2 e)"
- sorry
-
-lemma NOT_EVERY: "(~ list_all P l) = list_ex (Not o P) l"
- sorry
-
-lemma NOT_EXISTS: "(~ list_ex P l) = list_all (Not o P) l"
- sorry
-
-lemma MEM_MAP: "List.member (map (f::'a => 'b) (l::'a list)) (x::'b) =
-(EX y::'a. x = f y & List.member l y)"
- sorry
-
-lemma LENGTH_CONS: "(length l = Suc n) = (EX h l'. length l' = n & l = h # l')"
- sorry
-
-lemma LENGTH_EQ_CONS: "(ALL l. length l = Suc n --> P l) =
-(ALL l. length l = n --> (ALL x. P (x # l)))"
- sorry
-
-lemma LENGTH_EQ_NIL: "(ALL l. length l = 0 --> P l) = P []"
- sorry
-
-lemma CONS_ACYCLIC: "l ~= x # l & x # l ~= l"
- sorry
-
-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 = []))"
- sorry
-
-lemma APPEND_11: "(ALL (l1::'a list) (l2::'a list) l3::'a list.
- (l1 @ l2 = l1 @ l3) = (l2 = l3)) &
-(ALL (l1::'a list) (l2::'a list) l3::'a list.
- (l2 @ l1 = l3 @ l1) = (l2 = l3))"
- sorry
-
-lemma EL_compute: "EL n l = (if n = 0 then hd l else EL (PRE n) (tl l))"
- sorry
-
-lemma WF_LIST_PRED: "WF (%L1 L2. EX h. L2 = h # L1)"
- sorry
-
-lemma list_size_cong: "M = N & (ALL x. List.member N x --> f x = f' x)
-==> Compatibility.list_size f M = Compatibility.list_size f' N"
- sorry
-
-lemma FOLDR_CONG: "l = l' & b = b' & (ALL x a. List.member l' x --> f x a = f' x a)
-==> foldr f l b = foldr f' l' b'"
- sorry
-
-lemma FOLDL_CONG: "l = l' & b = b' & (ALL x a. List.member l' x --> f a x = f' a x)
-==> foldl f b l = foldl f' b' l'"
- sorry
-
-lemma MAP_CONG: "l1 = l2 & (ALL x. List.member l2 x --> f x = f' x) ==> map f l1 = map f' l2"
- sorry
-
-lemma EXISTS_CONG: "l1 = l2 & (ALL x. List.member l2 x --> P x = P' x)
-==> list_ex P l1 = list_ex P' l2"
- sorry
-
-lemma EVERY_CONG: "l1 = l2 & (ALL x. List.member l2 x --> P x = P' x)
-==> list_all P l1 = list_all P' l2"
- sorry
-
-lemma EVERY_MONOTONIC: "[| !!x. P x ==> Q x; list_all P l |] ==> list_all Q l"
- sorry
-
-lemma LENGTH_ZIP: "length l1 = length l2
-==> length (zip l1 l2) = length l1 & length (zip l1 l2) = length l2"
- sorry
-
-lemma LENGTH_UNZIP: "length (fst (unzip pl)) = length pl & length (snd (unzip pl)) = length pl"
- sorry
-
-lemma ZIP_UNZIP: "ZIP (unzip l) = l"
- sorry
-
-lemma UNZIP_ZIP: "length l1 = length l2 ==> unzip (zip l1 l2) = (l1, l2)"
- sorry
-
-lemma ZIP_MAP: "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)"
- sorry
-
-lemma MEM_ZIP: "length l1 = length l2
-==> List.member (zip l1 l2) p = (EX n<length l1. p = (EL n l1, EL n l2))"
- sorry
-
-lemma EL_ZIP: "length l1 = length l2 & n < length l1
-==> EL n (zip l1 l2) = (EL n l1, EL n l2)"
- sorry
-
-lemma MAP2_ZIP: "length l1 = length l2 ==> map2 f l1 l2 = map (%(x, y). f x y) (zip l1 l2)"
- sorry
-
-lemma MEM_EL: "List.member l x = (EX n<length l. x = EL n l)"
- sorry
-
-lemma LAST_CONS: "(ALL x::'a. last [x] = x) &
-(ALL (x::'a) (xa::'a) xb::'a list. last (x # xa # xb) = last (xa # xb))"
- sorry
-
-lemma FRONT_CONS: "(ALL x::'a. butlast [x] = []) &
-(ALL (x::'a) (xa::'a) xb::'a list.
- butlast (x # xa # xb) = x # butlast (xa # xb))"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" pred_set
-
-lemma EXTENSION: "(s = t) = (ALL x. IN x s = IN x t)"
- sorry
-
-lemma NOT_EQUAL_SETS: "(x ~= xa) = (EX xb. IN xb xa = (~ IN xb x))"
- sorry
-
-lemma NUM_SET_WOP: "(EX n::nat. IN n (s::nat => bool)) =
-(EX n::nat. IN n s & (ALL m::nat. IN m s --> n <= m))"
- sorry
-
-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)"
- sorry
-
-lemma SET_MINIMUM: "(EX x::'a. IN x (s::'a => bool)) =
-(EX x::'a. IN x s & (ALL y::'a. IN y s --> (M::'a => nat) x <= M y))"
- sorry
-
-definition
- EMPTY :: "'a => bool" where
- "EMPTY == %x. False"
-
-lemma EMPTY_DEF: "EMPTY = (%x. False)"
- sorry
-
-lemma NOT_IN_EMPTY: "~ IN x EMPTY"
- sorry
-
-lemma MEMBER_NOT_EMPTY: "(EX xa. IN xa x) = (x ~= EMPTY)"
- sorry
-
-definition
- UNIV :: "'a => bool" where
- "UNIV == %x. True"
-
-lemma UNIV_DEF: "pred_set.UNIV = (%x. True)"
- sorry
-
-lemma IN_UNIV: "IN x pred_set.UNIV"
- sorry
-
-lemma UNIV_NOT_EMPTY: "pred_set.UNIV ~= EMPTY"
- sorry
-
-lemma EMPTY_NOT_UNIV: "EMPTY ~= pred_set.UNIV"
- sorry
-
-lemma EQ_UNIV: "(ALL x. IN x s) = (s = pred_set.UNIV)"
- sorry
-
-definition
- SUBSET :: "('a => bool) => ('a => bool) => bool" where
- "SUBSET == %s t. ALL x. IN x s --> IN x t"
-
-lemma SUBSET_DEF: "SUBSET s t = (ALL x. IN x s --> IN x t)"
- sorry
-
-lemma SUBSET_TRANS: "SUBSET x xa & SUBSET xa xb ==> SUBSET x xb"
- sorry
-
-lemma SUBSET_REFL: "SUBSET x x"
- sorry
-
-lemma SUBSET_ANTISYM: "SUBSET x xa & SUBSET xa x ==> x = xa"
- sorry
-
-lemma EMPTY_SUBSET: "SUBSET EMPTY x"
- sorry
-
-lemma SUBSET_EMPTY: "SUBSET x EMPTY = (x = EMPTY)"
- sorry
-
-lemma SUBSET_UNIV: "SUBSET x pred_set.UNIV"
- sorry
-
-lemma UNIV_SUBSET: "SUBSET pred_set.UNIV x = (x = pred_set.UNIV)"
- sorry
-
-definition
- PSUBSET :: "('a => bool) => ('a => bool) => bool" where
- "PSUBSET == %s t. SUBSET s t & s ~= t"
-
-lemma PSUBSET_DEF: "PSUBSET s t = (SUBSET s t & s ~= t)"
- sorry
-
-lemma PSUBSET_TRANS: "PSUBSET x xa & PSUBSET xa xb ==> PSUBSET x xb"
- sorry
-
-lemma PSUBSET_IRREFL: "~ PSUBSET x x"
- sorry
-
-lemma NOT_PSUBSET_EMPTY: "~ PSUBSET x EMPTY"
- sorry
-
-lemma NOT_UNIV_PSUBSET: "~ PSUBSET pred_set.UNIV x"
- sorry
-
-lemma PSUBSET_UNIV: "PSUBSET x pred_set.UNIV = (EX xa. ~ IN xa x)"
- sorry
-
-definition
- UNION :: "('a => bool) => ('a => bool) => 'a => bool" where
- "UNION == %s t. GSPEC (%x. (x, IN x s | IN x t))"
-
-lemma UNION_DEF: "pred_set.UNION s t = GSPEC (%x. (x, IN x s | IN x t))"
- sorry
-
-lemma IN_UNION: "IN xb (pred_set.UNION x xa) = (IN xb x | IN xb xa)"
- sorry
-
-lemma UNION_ASSOC: "pred_set.UNION x (pred_set.UNION xa xb) =
-pred_set.UNION (pred_set.UNION x xa) xb"
- sorry
-
-lemma UNION_IDEMPOT: "pred_set.UNION x x = x"
- sorry
-
-lemma UNION_COMM: "pred_set.UNION x xa = pred_set.UNION xa x"
- sorry
-
-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))"
- sorry
-
-lemma UNION_SUBSET: "SUBSET (pred_set.UNION s t) u = (SUBSET s u & SUBSET t u)"
- sorry
-
-lemma SUBSET_UNION_ABSORPTION: "SUBSET x xa = (pred_set.UNION x xa = xa)"
- sorry
-
-lemma UNION_EMPTY: "(ALL x::'a => bool. pred_set.UNION EMPTY x = x) &
-(ALL x::'a => bool. pred_set.UNION x EMPTY = x)"
- sorry
-
-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)"
- sorry
-
-lemma EMPTY_UNION: "(pred_set.UNION x xa = EMPTY) = (x = EMPTY & xa = EMPTY)"
- sorry
-
-definition
- INTER :: "('a => bool) => ('a => bool) => 'a => bool" where
- "INTER == %s t. GSPEC (%x. (x, IN x s & IN x t))"
-
-lemma INTER_DEF: "pred_set.INTER s t = GSPEC (%x. (x, IN x s & IN x t))"
- sorry
-
-lemma IN_INTER: "IN xb (pred_set.INTER x xa) = (IN xb x & IN xb xa)"
- sorry
-
-lemma INTER_ASSOC: "pred_set.INTER x (pred_set.INTER xa xb) =
-pred_set.INTER (pred_set.INTER x xa) xb"
- sorry
-
-lemma INTER_IDEMPOT: "pred_set.INTER x x = x"
- sorry
-
-lemma INTER_COMM: "pred_set.INTER x xa = pred_set.INTER xa x"
- sorry
-
-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)"
- sorry
-
-lemma SUBSET_INTER: "SUBSET s (pred_set.INTER t u) = (SUBSET s t & SUBSET s u)"
- sorry
-
-lemma SUBSET_INTER_ABSORPTION: "SUBSET x xa = (pred_set.INTER x xa = x)"
- sorry
-
-lemma INTER_EMPTY: "(ALL x::'a => bool. pred_set.INTER EMPTY x = EMPTY) &
-(ALL x::'a => bool. pred_set.INTER x EMPTY = EMPTY)"
- sorry
-
-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)"
- sorry
-
-lemma UNION_OVER_INTER: "pred_set.INTER x (pred_set.UNION xa xb) =
-pred_set.UNION (pred_set.INTER x xa) (pred_set.INTER x xb)"
- sorry
-
-lemma INTER_OVER_UNION: "pred_set.UNION x (pred_set.INTER xa xb) =
-pred_set.INTER (pred_set.UNION x xa) (pred_set.UNION x xb)"
- sorry
-
-definition
- DISJOINT :: "('a => bool) => ('a => bool) => bool" where
- "DISJOINT == %s t. pred_set.INTER s t = EMPTY"
-
-lemma DISJOINT_DEF: "DISJOINT s t = (pred_set.INTER s t = EMPTY)"
- sorry
-
-lemma IN_DISJOINT: "DISJOINT x xa = (~ (EX xb. IN xb x & IN xb xa))"
- sorry
-
-lemma DISJOINT_SYM: "DISJOINT x xa = DISJOINT xa x"
- sorry
-
-lemma DISJOINT_EMPTY: "DISJOINT EMPTY x & DISJOINT x EMPTY"
- sorry
-
-lemma DISJOINT_EMPTY_REFL: "(x = EMPTY) = DISJOINT x x"
- sorry
-
-lemma DISJOINT_UNION: "DISJOINT (pred_set.UNION x xa) xb = (DISJOINT x xb & DISJOINT xa xb)"
- sorry
-
-lemma DISJOINT_UNION_BOTH: "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)"
- sorry
-
-definition
- DIFF :: "('a => bool) => ('a => bool) => 'a => bool" where
- "DIFF == %s t. GSPEC (%x. (x, IN x s & ~ IN x t))"
-
-lemma DIFF_DEF: "DIFF s t = GSPEC (%x. (x, IN x s & ~ IN x t))"
- sorry
-
-lemma IN_DIFF: "IN x (DIFF s t) = (IN x s & ~ IN x t)"
- sorry
-
-lemma DIFF_EMPTY: "DIFF s EMPTY = s"
- sorry
-
-lemma EMPTY_DIFF: "DIFF EMPTY s = EMPTY"
- sorry
-
-lemma DIFF_UNIV: "DIFF s pred_set.UNIV = EMPTY"
- sorry
-
-lemma DIFF_DIFF: "DIFF (DIFF x xa) xa = DIFF x xa"
- sorry
-
-lemma DIFF_EQ_EMPTY: "DIFF x x = EMPTY"
- sorry
-
-definition
- INSERT :: "'a => ('a => bool) => 'a => bool" where
- "INSERT == %x s. GSPEC (%y. (y, y = x | IN y s))"
-
-lemma INSERT_DEF: "INSERT x s = GSPEC (%y. (y, y = x | IN y s))"
- sorry
-
-lemma IN_INSERT: "IN x (INSERT xa xb) = (x = xa | IN x xb)"
- sorry
-
-lemma COMPONENT: "IN x (INSERT x xa)"
- sorry
-
-lemma SET_CASES: "x = EMPTY | (EX xa xb. x = INSERT xa xb & ~ IN xa xb)"
- sorry
-
-lemma DECOMPOSITION: "IN x s = (EX t. s = INSERT x t & ~ IN x t)"
- sorry
-
-lemma ABSORPTION: "IN x xa = (INSERT x xa = xa)"
- sorry
-
-lemma INSERT_INSERT: "INSERT x (INSERT x xa) = INSERT x xa"
- sorry
-
-lemma INSERT_COMM: "INSERT x (INSERT xa xb) = INSERT xa (INSERT x xb)"
- sorry
-
-lemma INSERT_UNIV: "INSERT x pred_set.UNIV = pred_set.UNIV"
- sorry
-
-lemma NOT_INSERT_EMPTY: "INSERT x xa ~= EMPTY"
- sorry
-
-lemma NOT_EMPTY_INSERT: "EMPTY ~= INSERT x xa"
- sorry
-
-lemma INSERT_UNION: "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))"
- sorry
-
-lemma INSERT_UNION_EQ: "pred_set.UNION (INSERT x s) t = INSERT x (pred_set.UNION s t)"
- sorry
-
-lemma INSERT_INTER: "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)"
- sorry
-
-lemma DISJOINT_INSERT: "DISJOINT (INSERT x xa) xb = (DISJOINT xa xb & ~ IN x xb)"
- sorry
-
-lemma INSERT_SUBSET: "SUBSET (INSERT x xa) xb = (IN x xb & SUBSET xa xb)"
- sorry
-
-lemma SUBSET_INSERT: "~ IN x xa ==> SUBSET xa (INSERT x xb) = SUBSET xa xb"
- sorry
-
-lemma INSERT_DIFF: "DIFF (INSERT x s) t = (if IN x t then DIFF s t else INSERT x (DIFF s t))"
- sorry
-
-definition
- DELETE :: "('a => bool) => 'a => 'a => bool" where
- "DELETE == %s x. DIFF s (INSERT x EMPTY)"
-
-lemma DELETE_DEF: "DELETE s x = DIFF s (INSERT x EMPTY)"
- sorry
-
-lemma IN_DELETE: "IN xa (DELETE x xb) = (IN xa x & xa ~= xb)"
- sorry
-
-lemma DELETE_NON_ELEMENT: "(~ IN x xa) = (DELETE xa x = xa)"
- sorry
-
-lemma IN_DELETE_EQ: "(IN x s = IN x' s) = (IN x (DELETE s x') = IN x' (DELETE s x))"
- sorry
-
-lemma EMPTY_DELETE: "DELETE EMPTY x = EMPTY"
- sorry
-
-lemma DELETE_DELETE: "DELETE (DELETE xa x) x = DELETE xa x"
- sorry
-
-lemma DELETE_COMM: "DELETE (DELETE xb x) xa = DELETE (DELETE xb xa) x"
- sorry
-
-lemma DELETE_SUBSET: "SUBSET (DELETE xa x) xa"
- sorry
-
-lemma SUBSET_DELETE: "SUBSET xa (DELETE xb x) = (~ IN x xa & SUBSET xa xb)"
- sorry
-
-lemma SUBSET_INSERT_DELETE: "SUBSET s (INSERT x t) = SUBSET (DELETE s x) t"
- sorry
-
-lemma DIFF_INSERT: "DIFF x (INSERT xb xa) = DIFF (DELETE x xb) xa"
- sorry
-
-lemma PSUBSET_INSERT_SUBSET: "PSUBSET x xa = (EX xb. ~ IN xb x & SUBSET (INSERT xb x) xa)"
- sorry
-
-lemma PSUBSET_MEMBER: "PSUBSET s t = (SUBSET s t & (EX y. IN y t & ~ IN y s))"
- sorry
-
-lemma DELETE_INSERT: "DELETE (INSERT x xb) xa =
-(if x = xa then DELETE xb xa else INSERT x (DELETE xb xa))"
- sorry
-
-lemma INSERT_DELETE: "IN x xa ==> INSERT x (DELETE xa x) = xa"
- sorry
-
-lemma DELETE_INTER: "pred_set.INTER (DELETE x xb) xa = DELETE (pred_set.INTER x xa) xb"
- sorry
-
-lemma DISJOINT_DELETE_SYM: "DISJOINT (DELETE x xb) xa = DISJOINT (DELETE xa xb) x"
- sorry
-
-consts
- CHOICE :: "('a => bool) => 'a"
-
-specification (CHOICE) CHOICE_DEF: "ALL x. x ~= EMPTY --> IN (CHOICE x) x"
- sorry
-
-definition
- REST :: "('a => bool) => 'a => bool" where
- "REST == %s. DELETE s (CHOICE s)"
-
-lemma REST_DEF: "REST s = DELETE s (CHOICE s)"
- sorry
-
-lemma CHOICE_NOT_IN_REST: "~ IN (CHOICE x) (REST x)"
- sorry
-
-lemma CHOICE_INSERT_REST: "s ~= EMPTY ==> INSERT (CHOICE s) (REST s) = s"
- sorry
-
-lemma REST_SUBSET: "SUBSET (REST x) x"
- sorry
-
-lemma REST_PSUBSET: "x ~= EMPTY ==> PSUBSET (REST x) x"
- sorry
-
-definition
- SING :: "('a => bool) => bool" where
- "SING == %s. EX x. s = INSERT x EMPTY"
-
-lemma SING_DEF: "SING s = (EX x. s = INSERT x EMPTY)"
- sorry
-
-lemma SING: "SING (INSERT x EMPTY)"
- sorry
-
-lemma IN_SING: "IN x (INSERT xa EMPTY) = (x = xa)"
- sorry
-
-lemma NOT_SING_EMPTY: "INSERT x EMPTY ~= EMPTY"
- sorry
-
-lemma NOT_EMPTY_SING: "EMPTY ~= INSERT x EMPTY"
- sorry
-
-lemma EQUAL_SING: "(INSERT x EMPTY = INSERT xa EMPTY) = (x = xa)"
- sorry
-
-lemma DISJOINT_SING_EMPTY: "DISJOINT (INSERT x EMPTY) EMPTY"
- sorry
-
-lemma INSERT_SING_UNION: "INSERT xa x = pred_set.UNION (INSERT xa EMPTY) x"
- sorry
-
-lemma SING_DELETE: "DELETE (INSERT x EMPTY) x = EMPTY"
- sorry
-
-lemma DELETE_EQ_SING: "IN xa x ==> (DELETE x xa = EMPTY) = (x = INSERT xa EMPTY)"
- sorry
-
-lemma CHOICE_SING: "CHOICE (INSERT x EMPTY) = x"
- sorry
-
-lemma REST_SING: "REST (INSERT x EMPTY) = EMPTY"
- sorry
-
-lemma SING_IFF_EMPTY_REST: "SING x = (x ~= EMPTY & REST x = EMPTY)"
- sorry
-
-definition
- IMAGE :: "('a => 'b) => ('a => bool) => 'b => bool" where
- "IMAGE == %f s. GSPEC (%x. (f x, IN x s))"
-
-lemma IMAGE_DEF: "IMAGE (f::'a => 'b) (s::'a => bool) = GSPEC (%x::'a. (f x, IN x s))"
- sorry
-
-lemma IN_IMAGE: "IN (x::'b) (IMAGE (xb::'a => 'b) (xa::'a => bool)) =
-(EX xc::'a. x = xb xc & IN xc xa)"
- sorry
-
-lemma IMAGE_IN: "IN x xa ==> IN (xb x) (IMAGE xb xa)"
- sorry
-
-lemma IMAGE_EMPTY: "IMAGE (x::'a => 'b) EMPTY = EMPTY"
- sorry
-
-lemma IMAGE_ID: "IMAGE (%x. x) x = x"
- sorry
-
-lemma IMAGE_COMPOSE: "IMAGE ((x::'b => 'c) o (xa::'a => 'b)) (xb::'a => bool) =
-IMAGE x (IMAGE xa xb)"
- sorry
-
-lemma IMAGE_INSERT: "IMAGE (x::'a => 'b) (INSERT (xa::'a) (xb::'a => bool)) =
-INSERT (x xa) (IMAGE x xb)"
- sorry
-
-lemma IMAGE_EQ_EMPTY: "(IMAGE (x::'a => 'b) (s::'a => bool) = EMPTY) = (s = EMPTY)"
- sorry
-
-lemma IMAGE_DELETE: "~ IN x s ==> IMAGE f (DELETE s x) = IMAGE f s"
- sorry
-
-lemma IMAGE_UNION: "IMAGE (x::'a => 'b) (pred_set.UNION (xa::'a => bool) (xb::'a => bool)) =
-pred_set.UNION (IMAGE x xa) (IMAGE x xb)"
- sorry
-
-lemma IMAGE_SUBSET: "SUBSET x xa ==> SUBSET (IMAGE xb x) (IMAGE xb xa)"
- sorry
-
-lemma IMAGE_INTER: "SUBSET
- (IMAGE (f::'a => 'b) (pred_set.INTER (s::'a => bool) (t::'a => bool)))
- (pred_set.INTER (IMAGE f s) (IMAGE f t))"
- sorry
-
-definition
- INJ :: "('a => 'b) => ('a => bool) => ('b => bool) => bool" where
- "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: "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))"
- sorry
-
-lemma INJ_ID: "INJ (%x. x) x x"
- sorry
-
-lemma INJ_COMPOSE: "INJ x xb xc & INJ xa xc xd ==> INJ (xa o x) xb xd"
- sorry
-
-lemma INJ_EMPTY: "All (INJ (x::'a => 'b) EMPTY) &
-(ALL xa::'a => bool. INJ x xa EMPTY = (xa = EMPTY))"
- sorry
-
-definition
- SURJ :: "('a => 'b) => ('a => bool) => ('b => bool) => bool" where
- "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: "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)))"
- sorry
-
-lemma SURJ_ID: "SURJ (%x. x) x x"
- sorry
-
-lemma SURJ_COMPOSE: "SURJ x xb xc & SURJ xa xc xd ==> SURJ (xa o x) xb xd"
- sorry
-
-lemma SURJ_EMPTY: "(ALL xa::'b => bool. SURJ (x::'a => 'b) EMPTY xa = (xa = EMPTY)) &
-(ALL xa::'a => bool. SURJ x xa EMPTY = (xa = EMPTY))"
- sorry
-
-lemma IMAGE_SURJ: "SURJ x xa xb = (IMAGE x xa = xb)"
- sorry
-
-definition
- BIJ :: "('a => 'b) => ('a => bool) => ('b => bool) => bool" where
- "BIJ == %f s t. INJ f s t & SURJ f s t"
-
-lemma BIJ_DEF: "BIJ f s t = (INJ f s t & SURJ f s t)"
- sorry
-
-lemma BIJ_ID: "BIJ (%x. x) x x"
- sorry
-
-lemma BIJ_EMPTY: "(ALL xa::'b => bool. BIJ (x::'a => 'b) EMPTY xa = (xa = EMPTY)) &
-(ALL xa::'a => bool. BIJ x xa EMPTY = (xa = EMPTY))"
- sorry
-
-lemma BIJ_COMPOSE: "BIJ x xb xc & BIJ xa xc xd ==> BIJ (xa o x) xb xd"
- sorry
-
-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)"
- sorry
-
-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)"
- sorry
-
-definition
- FINITE :: "('a => bool) => bool" where
- "FINITE ==
-%s. ALL P. P EMPTY & (ALL s. P s --> (ALL e. P (INSERT e s))) --> P s"
-
-lemma FINITE_DEF: "FINITE s =
-(ALL P. P EMPTY & (ALL s. P s --> (ALL e. P (INSERT e s))) --> P s)"
- sorry
-
-lemma FINITE_EMPTY: "FINITE EMPTY"
- sorry
-
-lemma FINITE_INDUCT: "[| P EMPTY &
- (ALL s. FINITE s & P s --> (ALL e. ~ IN e s --> P (INSERT e s)));
- FINITE s |]
-==> P s"
- sorry
-
-lemma FINITE_INSERT: "FINITE (INSERT x s) = FINITE s"
- sorry
-
-lemma FINITE_DELETE: "FINITE (DELETE s x) = FINITE s"
- sorry
-
-lemma FINITE_UNION: "FINITE (pred_set.UNION s t) = (FINITE s & FINITE t)"
- sorry
-
-lemma INTER_FINITE: "FINITE s ==> FINITE (pred_set.INTER s t)"
- sorry
-
-lemma SUBSET_FINITE: "[| FINITE s; SUBSET t s |] ==> FINITE t"
- sorry
-
-lemma PSUBSET_FINITE: "[| FINITE x; PSUBSET xa x |] ==> FINITE xa"
- sorry
-
-lemma FINITE_DIFF: "FINITE s ==> FINITE (DIFF s t)"
- sorry
-
-lemma FINITE_SING: "FINITE (INSERT x EMPTY)"
- sorry
-
-lemma SING_FINITE: "SING x ==> FINITE x"
- sorry
-
-lemma IMAGE_FINITE: "FINITE s ==> FINITE (IMAGE f s)"
- sorry
-
-consts
- CARD :: "('a => bool) => nat"
-
-specification (CARD) CARD_DEF: "(op &::bool => bool => bool)
- ((op =::nat => nat => bool)
- ((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::type => bool) => nat)
- ((INSERT::'a::type
- => ('a::type => bool) => 'a::type => bool)
- x s))
- ((If::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)))))))"
- sorry
-
-lemma CARD_EMPTY: "CARD EMPTY = 0"
- sorry
-
-lemma CARD_INSERT: "FINITE s ==> CARD (INSERT x s) = (if IN x s then CARD s else Suc (CARD s))"
- sorry
-
-lemma CARD_EQ_0: "FINITE s ==> (CARD s = 0) = (s = EMPTY)"
- sorry
-
-lemma CARD_DELETE: "FINITE s ==> CARD (DELETE s x) = (if IN x s then CARD s - 1 else CARD s)"
- sorry
-
-lemma CARD_INTER_LESS_EQ: "FINITE s ==> CARD (pred_set.INTER s t) <= CARD s"
- sorry
-
-lemma CARD_UNION: "[| FINITE s; FINITE t |]
-==> CARD (pred_set.UNION s t) + CARD (pred_set.INTER s t) = CARD s + CARD t"
- sorry
-
-lemma CARD_SUBSET: "[| FINITE s; SUBSET t s |] ==> CARD t <= CARD s"
- sorry
-
-lemma CARD_PSUBSET: "[| FINITE s; PSUBSET t s |] ==> CARD t < CARD s"
- sorry
-
-lemma CARD_SING: "CARD (INSERT x EMPTY) = 1"
- sorry
-
-lemma SING_IFF_CARD1: "SING x = (CARD x = 1 & FINITE x)"
- sorry
-
-lemma CARD_DIFF: "[| FINITE t; FINITE s |]
-==> CARD (DIFF s t) = CARD s - CARD (pred_set.INTER s t)"
- sorry
-
-lemma LESS_CARD_DIFF: "[| FINITE t; FINITE s; CARD t < CARD s |] ==> 0 < CARD (DIFF s t)"
- sorry
-
-lemma FINITE_COMPLETE_INDUCTION: "[| !!x. [| !!y. PSUBSET y x ==> P y; FINITE x |] ==> P x; FINITE x |]
-==> P x"
- sorry
-
-definition
- INFINITE :: "('a => bool) => bool" where
- "INFINITE == %s. ~ FINITE s"
-
-lemma INFINITE_DEF: "INFINITE s = (~ FINITE s)"
- sorry
-
-lemma NOT_IN_FINITE: "(op =::bool => bool => 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)
- ((Ex::('a::type => bool) => bool)
- (%x::'a::type.
- (Not::bool => bool)
- ((IN::'a::type => ('a::type => bool) => bool) x s)))))"
- sorry
-
-lemma INFINITE_INHAB: "INFINITE x ==> EX xa. IN xa x"
- sorry
-
-lemma IMAGE_11_INFINITE: "[| !!x y. f x = f y ==> x = y; INFINITE s |] ==> INFINITE (IMAGE f s)"
- sorry
-
-lemma INFINITE_SUBSET: "[| INFINITE x; SUBSET x xa |] ==> INFINITE xa"
- sorry
-
-lemma IN_INFINITE_NOT_FINITE: "INFINITE x & FINITE xa ==> EX xb. IN xb x & ~ IN xb xa"
- sorry
-
-lemma INFINITE_UNIV: "(op =::bool => bool => bool)
- ((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::type => bool) => bool)
- (%x::'a::type.
- (All::('a::type => bool) => bool)
- (%y::'a::type.
- (op -->::bool => bool => bool)
- ((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.
- (op ~=::'a::type => 'a::type => bool) (f x) y)))))"
- sorry
-
-lemma FINITE_PSUBSET_INFINITE: "INFINITE x = (ALL xa. FINITE xa --> SUBSET xa x --> PSUBSET xa x)"
- sorry
-
-lemma FINITE_PSUBSET_UNIV: "(op =::bool => bool => 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))))"
- sorry
-
-lemma INFINITE_DIFF_FINITE: "INFINITE s & FINITE t ==> DIFF s t ~= EMPTY"
- sorry
-
-lemma FINITE_ISO_NUM: "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))"
- sorry
-
-lemma FINITE_WEAK_ENUMERATE: "FINITE (x::'a => bool) =
-(EX (f::nat => 'a) b::nat. ALL e::'a. IN e x = (EX n<b. e = f n))"
- sorry
-
-definition
- BIGUNION :: "(('a => bool) => bool) => 'a => bool" where
- "BIGUNION == %P. GSPEC (%x. (x, EX p. IN p P & IN x p))"
-
-lemma BIGUNION: "BIGUNION P = GSPEC (%x. (x, EX p. IN p P & IN x p))"
- sorry
-
-lemma IN_BIGUNION: "IN x (BIGUNION xa) = (EX s. IN x s & IN s xa)"
- sorry
-
-lemma BIGUNION_EMPTY: "BIGUNION EMPTY = EMPTY"
- sorry
-
-lemma BIGUNION_SING: "BIGUNION (INSERT x EMPTY) = x"
- sorry
-
-lemma BIGUNION_UNION: "BIGUNION (pred_set.UNION x xa) = pred_set.UNION (BIGUNION x) (BIGUNION xa)"
- sorry
-
-lemma DISJOINT_BIGUNION: "(ALL (s::('a => bool) => bool) t::'a => bool.
- DISJOINT (BIGUNION s) t =
- (ALL s'::'a => bool. IN s' s --> DISJOINT s' t)) &
-(ALL (x::('a => bool) => bool) xa::'a => bool.
- DISJOINT xa (BIGUNION x) =
- (ALL xb::'a => bool. IN xb x --> DISJOINT xa xb))"
- sorry
-
-lemma BIGUNION_INSERT: "BIGUNION (INSERT x xa) = pred_set.UNION x (BIGUNION xa)"
- sorry
-
-lemma BIGUNION_SUBSET: "SUBSET (BIGUNION P) X = (ALL Y. IN Y P --> SUBSET Y X)"
- sorry
-
-lemma FINITE_BIGUNION: "FINITE x & (ALL s. IN s x --> FINITE s) ==> FINITE (BIGUNION x)"
- sorry
-
-definition
- BIGINTER :: "(('a => bool) => bool) => 'a => bool" where
- "BIGINTER == %B. GSPEC (%x. (x, ALL P. IN P B --> IN x P))"
-
-lemma BIGINTER: "BIGINTER B = GSPEC (%x. (x, ALL P. IN P B --> IN x P))"
- sorry
-
-lemma IN_BIGINTER: "IN x (BIGINTER B) = (ALL P. IN P B --> IN x P)"
- sorry
-
-lemma BIGINTER_INSERT: "BIGINTER (INSERT P B) = pred_set.INTER P (BIGINTER B)"
- sorry
-
-lemma BIGINTER_EMPTY: "BIGINTER EMPTY = pred_set.UNIV"
- sorry
-
-lemma BIGINTER_INTER: "BIGINTER (INSERT x (INSERT xa EMPTY)) = pred_set.INTER x xa"
- sorry
-
-lemma BIGINTER_SING: "BIGINTER (INSERT x EMPTY) = x"
- sorry
-
-lemma SUBSET_BIGINTER: "SUBSET X (BIGINTER P) = (ALL x. IN x P --> SUBSET X x)"
- sorry
-
-lemma DISJOINT_BIGINTER: "IN xa xb & DISJOINT xa x
-==> DISJOINT x (BIGINTER xb) & DISJOINT (BIGINTER xb) x"
- sorry
-
-definition
- CROSS :: "('a => bool) => ('b => bool) => 'a * 'b => bool" where
- "CROSS == %P Q. GSPEC (%p. (p, IN (fst p) P & IN (snd p) Q))"
-
-lemma CROSS_DEF: "CROSS P Q = GSPEC (%p. (p, IN (fst p) P & IN (snd p) Q))"
- sorry
-
-lemma IN_CROSS: "IN xb (CROSS x xa) = (IN (fst xb) x & IN (snd xb) xa)"
- sorry
-
-lemma CROSS_EMPTY: "CROSS x EMPTY = EMPTY & CROSS EMPTY x = EMPTY"
- sorry
-
-lemma CROSS_INSERT_LEFT: "CROSS (INSERT xb x) xa =
-pred_set.UNION (CROSS (INSERT xb EMPTY) xa) (CROSS x xa)"
- sorry
-
-lemma CROSS_INSERT_RIGHT: "CROSS x (INSERT xb xa) =
-pred_set.UNION (CROSS x (INSERT xb EMPTY)) (CROSS x xa)"
- sorry
-
-lemma FINITE_CROSS: "FINITE x & FINITE xa ==> FINITE (CROSS x xa)"
- sorry
-
-lemma CROSS_SINGS: "CROSS (INSERT x EMPTY) (INSERT xa EMPTY) = INSERT (x, xa) EMPTY"
- sorry
-
-lemma CARD_SING_CROSS: "FINITE (s::'b => bool) ==> CARD (CROSS (INSERT (x::'a) EMPTY) s) = CARD s"
- sorry
-
-lemma CARD_CROSS: "FINITE x & FINITE xa ==> CARD (CROSS x xa) = CARD x * CARD xa"
- sorry
-
-lemma CROSS_SUBSET: "SUBSET (CROSS xb xc) (CROSS x xa) =
-(xb = EMPTY | xc = EMPTY | SUBSET xb x & SUBSET xc xa)"
- sorry
-
-lemma FINITE_CROSS_EQ: "FINITE (CROSS P Q) = (P = EMPTY | Q = EMPTY | FINITE P & FINITE Q)"
- sorry
-
-definition
- COMPL :: "('a => bool) => 'a => bool" where
- "COMPL == DIFF pred_set.UNIV"
-
-lemma COMPL_DEF: "COMPL P = DIFF pred_set.UNIV P"
- sorry
-
-lemma IN_COMPL: "IN x (COMPL xa) = (~ IN x xa)"
- sorry
-
-lemma COMPL_COMPL: "COMPL (COMPL x) = x"
- sorry
-
-lemma COMPL_CLAUSES: "pred_set.INTER (COMPL x) x = EMPTY &
-pred_set.UNION (COMPL x) x = pred_set.UNIV"
- sorry
-
-lemma COMPL_SPLITS: "pred_set.UNION (pred_set.INTER x xa) (pred_set.INTER (COMPL x) xa) = xa"
- sorry
-
-lemma INTER_UNION_COMPL: "pred_set.INTER x xa = COMPL (pred_set.UNION (COMPL x) (COMPL xa))"
- sorry
-
-lemma COMPL_EMPTY: "COMPL EMPTY = pred_set.UNIV"
- sorry
-
-consts
- count :: "nat => nat => bool"
-
-defs
- count_primdef: "count == %n. GSPEC (%m. (m, m < n))"
-
-lemma count_def: "count n = GSPEC (%m. (m, m < n))"
- sorry
-
-lemma IN_COUNT: "IN m (count n) = (m < n)"
- sorry
-
-lemma COUNT_ZERO: "count 0 = EMPTY"
- sorry
-
-lemma COUNT_SUC: "count (Suc n) = INSERT n (count n)"
- sorry
-
-lemma FINITE_COUNT: "FINITE (count n)"
- sorry
-
-lemma CARD_COUNT: "CARD (count n) = n"
- sorry
-
-definition
- ITSET_tupled :: "('a => 'b => 'b) => ('a => bool) * 'b => 'b" where
- "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: "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)"
- sorry
-
-definition
- ITSET :: "('a => 'b => 'b) => ('a => bool) => 'b => 'b" where
- "ITSET == %f x x1. ITSET_tupled f (x, x1)"
-
-lemma ITSET_curried_def: "ITSET (f::'a => 'b => 'b) (x::'a => bool) (x1::'b) = ITSET_tupled f (x, x1)"
- sorry
-
-lemma ITSET_IND: "(!!(s::'a => bool) b::'b.
- (FINITE s & s ~= EMPTY
- ==> (P::('a => bool) => 'b => bool) (REST s)
- ((f::'a => 'b => 'b) (CHOICE s) b))
- ==> P s b)
-==> P (v::'a => bool) (x::'b)"
- sorry
-
-lemma ITSET_THM: "FINITE s
-==> ITSET f s b =
- (if s = EMPTY then b else ITSET f (REST s) (f (CHOICE s) b))"
- sorry
-
-lemma ITSET_EMPTY: "ITSET (x::'a => 'b => 'b) EMPTY (xa::'b) = xa"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" operator
-
-definition
- ASSOC :: "('a => 'a => 'a) => bool" where
- "ASSOC == %f. ALL x y z. f x (f y z) = f (f x y) z"
-
-lemma ASSOC_DEF: "ASSOC f = (ALL x y z. f x (f y z) = f (f x y) z)"
- sorry
-
-definition
- COMM :: "('a => 'a => 'b) => bool" where
- "COMM == %f. ALL x y. f x y = f y x"
-
-lemma COMM_DEF: "COMM f = (ALL x y. f x y = f y x)"
- sorry
-
-definition
- FCOMM :: "('a => 'b => 'a) => ('c => 'a => 'a) => bool" where
- "FCOMM == %f g. ALL x y z. g x (f y z) = f (g x y) z"
-
-lemma FCOMM_DEF: "FCOMM f g = (ALL x y z. g x (f y z) = f (g x y) z)"
- sorry
-
-definition
- RIGHT_ID :: "('a => 'b => 'a) => 'b => bool" where
- "RIGHT_ID == %f e. ALL x. f x e = x"
-
-lemma RIGHT_ID_DEF: "RIGHT_ID f e = (ALL x. f x e = x)"
- sorry
-
-definition
- LEFT_ID :: "('a => 'b => 'b) => 'a => bool" where
- "LEFT_ID == %f e. ALL x. f e x = x"
-
-lemma LEFT_ID_DEF: "LEFT_ID f e = (ALL x. f e x = x)"
- sorry
-
-definition
- MONOID :: "('a => 'a => 'a) => 'a => bool" where
- "MONOID == %f e. ASSOC f & RIGHT_ID f e & LEFT_ID f e"
-
-lemma MONOID_DEF: "MONOID f e = (ASSOC f & RIGHT_ID f e & LEFT_ID f e)"
- sorry
-
-lemma ASSOC_CONJ: "ASSOC op &"
- sorry
-
-lemma ASSOC_DISJ: "ASSOC op |"
- sorry
-
-lemma FCOMM_ASSOC: "FCOMM x x = ASSOC x"
- sorry
-
-lemma MONOID_CONJ_T: "MONOID op & True"
- sorry
-
-lemma MONOID_DISJ_F: "MONOID op | False"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" 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)"
- sorry
-
-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)"
- sorry
-
-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 f e (x # l) = f x (hd (SCANR f e l)) # SCANR f e l)"
- sorry
-
-lemma IS_EL_DEF: "List.member l x = list_ex (op = x) l"
- sorry
-
-definition
- AND_EL :: "bool list => bool" where
- "AND_EL == list_all I"
-
-lemma AND_EL_DEF: "AND_EL = list_all I"
- sorry
-
-definition
- OR_EL :: "bool list => bool" where
- "OR_EL == list_ex I"
-
-lemma OR_EL_DEF: "OR_EL = list_ex I"
- sorry
-
-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)"
- sorry
-
-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)"
- sorry
-
-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 (Suc m) (0::nat) (x # l) = x # SEG m (0::nat) l) &
-(ALL (m::nat) (k::nat) (x::'a) l::'a list.
- SEG (Suc m) (Suc k) (x # l) = SEG (Suc m) k l)"
- sorry
-
-lemma LAST: "last (SNOC x l) = x"
- sorry
-
-lemma BUTLAST: "butlast (SNOC x l) = l"
- sorry
-
-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 (Suc n) (SNOC x l) = SNOC x (LASTN n l))"
- sorry
-
-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 (Suc n) (SNOC x l) = BUTLASTN n l)"
- sorry
-
-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))"
- sorry
-
-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))"
- sorry
-
-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 (x1 # l1) (x2 # l2) = (x1 = x2 & IS_PREFIX l1 l2))"
- sorry
-
-lemma SNOC_APPEND: "SNOC x l = l @ [x]"
- sorry
-
-lemma REVERSE: "rev [] = [] & (ALL (x::'a) xa::'a list. rev (x # xa) = SNOC x (rev xa))"
- sorry
-
-lemma REVERSE_SNOC: "rev (SNOC x l) = x # rev l"
- sorry
-
-lemma SNOC_Axiom: "EX x. x [] = e & (ALL xa l. x (SNOC xa l) = f xa l (x l))"
- sorry
-
-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 (SNOC x1 l1) (SNOC x2 l2) = (x1 = x2 & IS_SUFFIX l1 l2))"
- sorry
-
-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 (x1 # l1) (x2 # l2) =
- (x1 = x2 & IS_PREFIX l1 l2 | IS_SUBLIST l1 (x2 # l2)))"
- sorry
-
-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 P (x # l) =
- (if P x then ([], x # l) else (x # fst (SPLITP P l), snd (SPLITP P l))))"
- sorry
-
-definition
- PREFIX :: "('a => bool) => 'a list => 'a list" where
- "PREFIX == %P l. fst (SPLITP (Not o P) l)"
-
-lemma PREFIX_DEF: "PREFIX P l = fst (SPLITP (Not o P) l)"
- sorry
-
-definition
- SUFFIX :: "('a => bool) => 'a list => 'a list" where
- "SUFFIX == %P. foldl (%l' x. if P x then SNOC x l' else []) []"
-
-lemma SUFFIX_DEF: "SUFFIX P l = foldl (%l' x. if P x then SNOC x l' else []) [] l"
- sorry
-
-definition
- UNZIP_FST :: "('a * 'b) list => 'a list" where
- "UNZIP_FST == %l. fst (unzip l)"
-
-lemma UNZIP_FST_DEF: "UNZIP_FST l = fst (unzip l)"
- sorry
-
-definition
- UNZIP_SND :: "('a * 'b) list => 'b list" where
- "UNZIP_SND == %l. snd (unzip l)"
-
-lemma UNZIP_SND_DEF: "UNZIP_SND (l::('a * 'b) list) = snd (unzip l)"
- sorry
-
-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))"
- sorry
-
-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)"
- sorry
-
-lemma LENGTH_MAP2: "length l1 = length l2
-==> length (map2 f l1 l2) = length l1 & length (map2 f l1 l2) = length l2"
- sorry
-
-lemma LENGTH_EQ: "x = y ==> length x = length y"
- sorry
-
-lemma LENGTH_NOT_NULL: "(0 < length l) = (~ List.null l)"
- sorry
-
-lemma SNOC_INDUCT: "P [] & (ALL l. P l --> (ALL x. P (SNOC x l))) ==> P x"
- sorry
-
-lemma SNOC_CASES: "x' = [] | (EX x l. x' = SNOC x l)"
- sorry
-
-lemma LENGTH_SNOC: "length (SNOC x l) = Suc (length l)"
- sorry
-
-lemma NOT_NIL_SNOC: "[] ~= SNOC x xa"
- sorry
-
-lemma NOT_SNOC_NIL: "SNOC x xa ~= []"
- sorry
-
-lemma SNOC_11: "(SNOC x l = SNOC x' l') = (x = x' & l = l')"
- sorry
-
-lemma SNOC_EQ_LENGTH_EQ: "SNOC x1 l1 = SNOC x2 l2 ==> length l1 = length l2"
- sorry
-
-lemma SNOC_REVERSE_CONS: "SNOC x xa = rev (x # rev xa)"
- sorry
-
-lemma MAP_SNOC: "map (x::'a => 'b) (SNOC (xa::'a) (xb::'a list)) = SNOC (x xa) (map x xb)"
- sorry
-
-lemma FOLDR_SNOC: "foldr (f::'a => 'b => 'b) (SNOC (x::'a) (l::'a list)) (e::'b) =
-foldr f l (f x e)"
- sorry
-
-lemma FOLDL_SNOC: "foldl (f::'b => 'a => 'b) (e::'b) (SNOC (x::'a) (l::'a list)) =
-f (foldl f e l) x"
- sorry
-
-lemma FOLDR_FOLDL: "MONOID f e ==> foldr f l e = foldl f e l"
- sorry
-
-lemma LENGTH_FOLDR: "length l = foldr (%x. Suc) l 0"
- sorry
-
-lemma LENGTH_FOLDL: "length l = foldl (%l' x. Suc l') 0 l"
- sorry
-
-lemma MAP_FOLDR: "map (f::'a => 'b) (l::'a list) = foldr (%x::'a. op # (f x)) l []"
- sorry
-
-lemma MAP_FOLDL: "map (f::'a => 'b) (l::'a list) =
-foldl (%(l'::'b list) x::'a. SNOC (f x) l') [] l"
- sorry
-
-lemma FILTER_FOLDR: "filter P l = foldr (%x l'. if P x then x # l' else l') l []"
- sorry
-
-lemma FILTER_SNOC: "filter P (SNOC x l) = (if P x then SNOC x (filter P l) else filter P l)"
- sorry
-
-lemma FILTER_FOLDL: "filter P l = foldl (%l' x. if P x then SNOC x l' else l') [] l"
- sorry
-
-lemma FILTER_COMM: "filter f1 (filter f2 l) = filter f2 (filter f1 l)"
- sorry
-
-lemma FILTER_IDEM: "filter f (filter f l) = filter f l"
- sorry
-
-lemma LENGTH_SEG: "n + k <= length l ==> length (SEG n k l) = n"
- sorry
-
-lemma APPEND_NIL: "(ALL l::'a list. l @ [] = l) & (ALL x::'a list. [] @ x = x)"
- sorry
-
-lemma APPEND_SNOC: "l1 @ SNOC x l2 = SNOC x (l1 @ l2)"
- sorry
-
-lemma APPEND_FOLDR: "l1 @ l2 = foldr op # l1 l2"
- sorry
-
-lemma APPEND_FOLDL: "l1 @ l2 = foldl (%l' x. SNOC x l') l1 l2"
- sorry
-
-lemma CONS_APPEND: "x # l = [x] @ l"
- sorry
-
-lemma ASSOC_APPEND: "ASSOC op @"
- sorry
-
-lemma MONOID_APPEND_NIL: "MONOID op @ []"
- sorry
-
-lemma APPEND_LENGTH_EQ: "[| length l1 = length l1'; length l2 = length l2' |]
-==> (l1 @ l2 = l1' @ l2') = (l1 = l1' & l2 = l2')"
- sorry
-
-lemma FLAT_SNOC: "concat (SNOC x l) = concat l @ x"
- sorry
-
-lemma FLAT_FOLDR: "concat l = foldr op @ l []"
- sorry
-
-lemma LENGTH_FLAT: "length (concat l) = Compatibility.sum (map length l)"
- sorry
-
-lemma REVERSE_FOLDR: "rev l = foldr SNOC l []"
- sorry
-
-lemma ALL_EL_SNOC: "list_all P (SNOC x l) = (list_all P l & P x)"
- sorry
-
-lemma ALL_EL_MAP: "list_all (P::'b => bool) (map (f::'a => 'b) (l::'a list)) =
-list_all (P o f) l"
- sorry
-
-lemma SOME_EL_SNOC: "list_ex P (SNOC x l) = (P x | list_ex P l)"
- sorry
-
-lemma IS_EL_SNOC: "List.member (SNOC x l) y = (y = x | List.member l y)"
- sorry
-
-lemma SUM_SNOC: "Compatibility.sum (SNOC x l) = Compatibility.sum l + x"
- sorry
-
-lemma SUM_FOLDL: "Compatibility.sum l = foldl op + 0 l"
- sorry
-
-lemma IS_PREFIX_APPEND: "IS_PREFIX l1 l2 = (EX l. l1 = l2 @ l)"
- sorry
-
-lemma IS_SUFFIX_APPEND: "IS_SUFFIX l1 l2 = (EX l. l1 = l @ l2)"
- sorry
-
-lemma IS_SUBLIST_APPEND: "IS_SUBLIST l1 l2 = (EX l l'. l1 = l @ l2 @ l')"
- sorry
-
-lemma IS_PREFIX_IS_SUBLIST: "IS_PREFIX l1 l2 ==> IS_SUBLIST l1 l2"
- sorry
-
-lemma IS_SUFFIX_IS_SUBLIST: "IS_SUFFIX l1 l2 ==> IS_SUBLIST l1 l2"
- sorry
-
-lemma IS_PREFIX_REVERSE: "IS_PREFIX (rev l1) (rev l2) = IS_SUFFIX l1 l2"
- sorry
-
-lemma IS_SUFFIX_REVERSE: "IS_SUFFIX (rev l1) (rev l2) = IS_PREFIX l1 l2"
- sorry
-
-lemma IS_SUBLIST_REVERSE: "IS_SUBLIST (rev l1) (rev l2) = IS_SUBLIST l1 l2"
- sorry
-
-lemma PREFIX_FOLDR: "PREFIX P x = foldr (%x l'. if P x then x # l' else []) x []"
- sorry
-
-lemma PREFIX: "(ALL x::'a => bool. PREFIX x [] = []) &
-(ALL (x::'a => bool) (xa::'a) xb::'a list.
- PREFIX x (xa # xb) = (if x xa then xa # PREFIX x xb else []))"
- sorry
-
-lemma IS_PREFIX_PREFIX: "IS_PREFIX l (PREFIX P l)"
- sorry
-
-lemma LENGTH_SCANL: "length (SCANL (f::'b => 'a => 'b) (e::'b) (l::'a list)) = Suc (length l)"
- sorry
-
-lemma LENGTH_SCANR: "length (SCANR (f::'a => 'b => 'b) (e::'b) (l::'a list)) = Suc (length l)"
- sorry
-
-lemma COMM_MONOID_FOLDL: "[| COMM x; MONOID x xa |] ==> foldl x e l = x e (foldl x xa l)"
- sorry
-
-lemma COMM_MONOID_FOLDR: "[| COMM x; MONOID x xa |] ==> foldr x l e = x e (foldr x l xa)"
- sorry
-
-lemma FCOMM_FOLDR_APPEND: "[| FCOMM x xa; LEFT_ID x xb |]
-==> foldr xa (l1 @ l2) xb = x (foldr xa l1 xb) (foldr xa l2 xb)"
- sorry
-
-lemma FCOMM_FOLDL_APPEND: "[| FCOMM x xa; RIGHT_ID xa xb |]
-==> foldl x xb (l1 @ l2) = xa (foldl x xb l1) (foldl x xb l2)"
- sorry
-
-lemma FOLDL_SINGLE: "foldl x xa [xb] = x xa xb"
- sorry
-
-lemma FOLDR_SINGLE: "foldr (x::'a => 'b => 'b) [xb::'a] (xa::'b) = x xb xa"
- sorry
-
-lemma FOLDR_CONS_NIL: "foldr op # l [] = l"
- sorry
-
-lemma FOLDL_SNOC_NIL: "foldl (%xs x. SNOC x xs) [] l = l"
- sorry
-
-lemma FOLDR_REVERSE: "foldr (x::'a => 'b => 'b) (rev (xb::'a list)) (xa::'b) =
-foldl (%(xa::'b) y::'a. x y xa) xa xb"
- sorry
-
-lemma FOLDL_REVERSE: "foldl x xa (rev xb) = foldr (%xa y. x y xa) xb xa"
- sorry
-
-lemma FOLDR_MAP: "foldr (f::'a => 'a => 'a) (map (g::'b => 'a) (l::'b list)) (e::'a) =
-foldr (%x::'b. f (g x)) l e"
- sorry
-
-lemma ALL_EL_FOLDR: "list_all P l = foldr (%x. op & (P x)) l True"
- sorry
-
-lemma ALL_EL_FOLDL: "list_all P l = foldl (%l' x. l' & P x) True l"
- sorry
-
-lemma SOME_EL_FOLDR: "list_ex P l = foldr (%x. op | (P x)) l False"
- sorry
-
-lemma SOME_EL_FOLDL: "list_ex P l = foldl (%l' x. l' | P x) False l"
- sorry
-
-lemma ALL_EL_FOLDR_MAP: "list_all x xa = foldr op & (map x xa) True"
- sorry
-
-lemma ALL_EL_FOLDL_MAP: "list_all x xa = foldl op & True (map x xa)"
- sorry
-
-lemma SOME_EL_FOLDR_MAP: "list_ex x xa = foldr op | (map x xa) False"
- sorry
-
-lemma SOME_EL_FOLDL_MAP: "list_ex x xa = foldl op | False (map x xa)"
- sorry
-
-lemma FOLDR_FILTER: "foldr (f::'a => 'a => 'a) (filter (P::'a => bool) (l::'a list)) (e::'a) =
-foldr (%(x::'a) y::'a. if P x then f x y else y) l e"
- sorry
-
-lemma FOLDL_FILTER: "foldl (f::'a => 'a => 'a) (e::'a) (filter (P::'a => bool) (l::'a list)) =
-foldl (%(x::'a) y::'a. if P y then f x y else x) e l"
- sorry
-
-lemma ASSOC_FOLDR_FLAT: "[| ASSOC f; LEFT_ID f e |]
-==> foldr f (concat l) e = foldr f (map (FOLDR f e) l) e"
- sorry
-
-lemma ASSOC_FOLDL_FLAT: "[| ASSOC f; RIGHT_ID f e |]
-==> foldl f e (concat l) = foldl f e (map (foldl f e) l)"
- sorry
-
-lemma SOME_EL_MAP: "list_ex (P::'b => bool) (map (f::'a => 'b) (l::'a list)) = list_ex (P o f) l"
- sorry
-
-lemma SOME_EL_DISJ: "list_ex (%x. P x | Q x) l = (list_ex P l | list_ex Q l)"
- sorry
-
-lemma IS_EL_FOLDR: "List.member xa x = foldr (%xa. op | (x = xa)) xa False"
- sorry
-
-lemma IS_EL_FOLDL: "List.member xa x = foldl (%l' xa. l' | x = xa) False xa"
- sorry
-
-lemma NULL_FOLDR: "List.null l = foldr (%x l'. False) l True"
- sorry
-
-lemma NULL_FOLDL: "List.null l = foldl (%x l'. False) True l"
- sorry
-
-lemma SEG_LENGTH_ID: "SEG (length l) 0 l = l"
- sorry
-
-lemma SEG_SUC_CONS: "SEG m (Suc n) (x # l) = SEG m n l"
- sorry
-
-lemma SEG_0_SNOC: "m <= length l ==> SEG m 0 (SNOC x l) = SEG m 0 l"
- sorry
-
-lemma BUTLASTN_SEG: "n <= length l ==> BUTLASTN n l = SEG (length l - n) 0 l"
- sorry
-
-lemma LASTN_CONS: "n <= length l ==> LASTN n (x # l) = LASTN n l"
- sorry
-
-lemma LENGTH_LASTN: "n <= length l ==> length (LASTN n l) = n"
- sorry
-
-lemma LASTN_LENGTH_ID: "LASTN (length l) l = l"
- sorry
-
-lemma LASTN_LASTN: "[| m <= length l; n <= m |] ==> LASTN n (LASTN m l) = LASTN n l"
- sorry
-
-lemma FIRSTN_LENGTH_ID: "FIRSTN (length l) l = l"
- sorry
-
-lemma FIRSTN_SNOC: "n <= length l ==> FIRSTN n (SNOC x l) = FIRSTN n l"
- sorry
-
-lemma BUTLASTN_LENGTH_NIL: "BUTLASTN (length l) l = []"
- sorry
-
-lemma BUTLASTN_SUC_BUTLAST: "n < length l ==> BUTLASTN (Suc n) l = BUTLASTN n (butlast l)"
- sorry
-
-lemma BUTLASTN_BUTLAST: "n < length l ==> BUTLASTN n (butlast l) = butlast (BUTLASTN n l)"
- sorry
-
-lemma LENGTH_BUTLASTN: "n <= length l ==> length (BUTLASTN n l) = length l - n"
- sorry
-
-lemma BUTLASTN_BUTLASTN: "n + m <= length l ==> BUTLASTN n (BUTLASTN m l) = BUTLASTN (n + m) l"
- sorry
-
-lemma APPEND_BUTLASTN_LASTN: "n <= length l ==> BUTLASTN n l @ LASTN n l = l"
- sorry
-
-lemma APPEND_FIRSTN_LASTN: "m + n = length l ==> FIRSTN n l @ LASTN m l = l"
- sorry
-
-lemma BUTLASTN_APPEND2: "n <= length l2 ==> BUTLASTN n (l1 @ l2) = l1 @ BUTLASTN n l2"
- sorry
-
-lemma BUTLASTN_LENGTH_APPEND: "BUTLASTN (length l2) (l1 @ l2) = l1"
- sorry
-
-lemma LASTN_LENGTH_APPEND: "LASTN (length l2) (l1 @ l2) = l2"
- sorry
-
-lemma BUTLASTN_CONS: "n <= length l ==> BUTLASTN n (x # l) = x # BUTLASTN n l"
- sorry
-
-lemma BUTLASTN_LENGTH_CONS: "BUTLASTN (length l) (x # l) = [x]"
- sorry
-
-lemma LAST_LASTN_LAST: "[| n <= length l; 0 < n |] ==> last (LASTN n l) = last l"
- sorry
-
-lemma BUTLASTN_LASTN_NIL: "n <= length l ==> BUTLASTN n (LASTN n l) = []"
- sorry
-
-lemma LASTN_BUTLASTN: "n + m <= length l ==> LASTN n (BUTLASTN m l) = BUTLASTN m (LASTN (n + m) l)"
- sorry
-
-lemma BUTLASTN_LASTN: "m <= n & n <= length l
-==> BUTLASTN m (LASTN n l) = LASTN (n - m) (BUTLASTN m l)"
- sorry
-
-lemma LASTN_1: "l ~= [] ==> LASTN 1 l = [last l]"
- sorry
-
-lemma BUTLASTN_1: "l ~= [] ==> BUTLASTN 1 l = butlast l"
- sorry
-
-lemma BUTLASTN_APPEND1: "length l2 <= n ==> BUTLASTN n (l1 @ l2) = BUTLASTN (n - length l2) l1"
- sorry
-
-lemma LASTN_APPEND2: "n <= length l2 ==> LASTN n (l1 @ l2) = LASTN n l2"
- sorry
-
-lemma LASTN_APPEND1: "length l2 <= n ==> LASTN n (l1 @ l2) = LASTN (n - length l2) l1 @ l2"
- sorry
-
-lemma LASTN_MAP: "n <= length l ==> LASTN n (map f l) = map f (LASTN n l)"
- sorry
-
-lemma BUTLASTN_MAP: "n <= length l ==> BUTLASTN n (map f l) = map f (BUTLASTN n l)"
- sorry
-
-lemma ALL_EL_LASTN: "[| list_all P l; m <= length l |] ==> list_all P (LASTN m l)"
- sorry
-
-lemma ALL_EL_BUTLASTN: "[| list_all P l; m <= length l |] ==> list_all P (BUTLASTN m l)"
- sorry
-
-lemma LENGTH_FIRSTN: "n <= length l ==> length (FIRSTN n l) = n"
- sorry
-
-lemma FIRSTN_FIRSTN: "[| m <= length l; n <= m |] ==> FIRSTN n (FIRSTN m l) = FIRSTN n l"
- sorry
-
-lemma LENGTH_BUTFIRSTN: "n <= length l ==> length (BUTFIRSTN n l) = length l - n"
- sorry
-
-lemma BUTFIRSTN_LENGTH_NIL: "BUTFIRSTN (length l) l = []"
- sorry
-
-lemma BUTFIRSTN_APPEND1: "n <= length l1 ==> BUTFIRSTN n (l1 @ l2) = BUTFIRSTN n l1 @ l2"
- sorry
-
-lemma BUTFIRSTN_APPEND2: "length l1 <= n ==> BUTFIRSTN n (l1 @ l2) = BUTFIRSTN (n - length l1) l2"
- sorry
-
-lemma BUTFIRSTN_BUTFIRSTN: "n + m <= length l ==> BUTFIRSTN n (BUTFIRSTN m l) = BUTFIRSTN (n + m) l"
- sorry
-
-lemma APPEND_FIRSTN_BUTFIRSTN: "n <= length l ==> FIRSTN n l @ BUTFIRSTN n l = l"
- sorry
-
-lemma LASTN_SEG: "n <= length l ==> LASTN n l = SEG n (length l - n) l"
- sorry
-
-lemma FIRSTN_SEG: "n <= length l ==> FIRSTN n l = SEG n 0 l"
- sorry
-
-lemma BUTFIRSTN_SEG: "n <= length l ==> BUTFIRSTN n l = SEG (length l - n) n l"
- sorry
-
-lemma BUTFIRSTN_SNOC: "n <= length l ==> BUTFIRSTN n (SNOC x l) = SNOC x (BUTFIRSTN n l)"
- sorry
-
-lemma APPEND_BUTLASTN_BUTFIRSTN: "m + n = length l ==> BUTLASTN m l @ BUTFIRSTN n l = l"
- sorry
-
-lemma SEG_SEG: "n1 + m1 <= length l & n2 + m2 <= n1
-==> SEG n2 m2 (SEG n1 m1 l) = SEG n2 (m1 + m2) l"
- sorry
-
-lemma SEG_APPEND1: "n + m <= length l1 ==> SEG n m (l1 @ l2) = SEG n m l1"
- sorry
-
-lemma SEG_APPEND2: "length l1 <= m & n <= length l2
-==> SEG n m (l1 @ l2) = SEG n (m - length l1) l2"
- sorry
-
-lemma SEG_FIRSTN_BUTFISTN: "n + m <= length l ==> SEG n m l = FIRSTN n (BUTFIRSTN m l)"
- sorry
-
-lemma SEG_APPEND: "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"
- sorry
-
-lemma SEG_LENGTH_SNOC: "SEG 1 (length x) (SNOC xa x) = [xa]"
- sorry
-
-lemma SEG_SNOC: "n + m <= length l ==> SEG n m (SNOC x l) = SEG n m l"
- sorry
-
-lemma ELL_SEG: "n < length l ==> ELL n l = hd (SEG 1 (PRE (length l - n)) l)"
- sorry
-
-lemma SNOC_FOLDR: "SNOC x l = foldr op # l [x]"
- sorry
-
-lemma IS_EL_FOLDR_MAP: "List.member xa x = foldr op | (map (op = x) xa) False"
- sorry
-
-lemma IS_EL_FOLDL_MAP: "List.member xa x = foldl op | False (map (op = x) xa)"
- sorry
-
-lemma FILTER_FILTER: "filter P (filter Q l) = [x<-l. P x & Q x]"
- sorry
-
-lemma FCOMM_FOLDR_FLAT: "[| FCOMM g f; LEFT_ID g e |]
-==> foldr f (concat l) e = foldr g (map (FOLDR f e) l) e"
- sorry
-
-lemma FCOMM_FOLDL_FLAT: "[| FCOMM f g; RIGHT_ID g e |]
-==> foldl f e (concat l) = foldl g e (map (foldl f e) l)"
- sorry
-
-lemma FOLDR_MAP_REVERSE: "(!!(a::'a) (b::'a) c::'a. (f::'a => 'a => 'a) a (f b c) = f b (f a c))
-==> foldr f (map (g::'b => 'a) (rev (l::'b list))) (e::'a) =
- foldr f (map g l) e"
- sorry
-
-lemma FOLDR_FILTER_REVERSE: "(!!(a::'a) (b::'a) c::'a. (f::'a => 'a => 'a) a (f b c) = f b (f a c))
-==> foldr f (filter (P::'a => bool) (rev (l::'a list))) (e::'a) =
- foldr f (filter P l) e"
- sorry
-
-lemma COMM_ASSOC_FOLDR_REVERSE: "[| COMM f; ASSOC f |] ==> foldr f (rev l) e = foldr f l e"
- sorry
-
-lemma COMM_ASSOC_FOLDL_REVERSE: "[| COMM f; ASSOC f |] ==> foldl f e (rev l) = foldl f e l"
- sorry
-
-lemma ELL_LAST: "~ List.null l ==> ELL 0 l = last l"
- sorry
-
-lemma ELL_0_SNOC: "ELL 0 (SNOC x l) = x"
- sorry
-
-lemma ELL_SNOC: "0 < n ==> ELL n (SNOC x l) = ELL (PRE n) l"
- sorry
-
-lemma ELL_SUC_SNOC: "ELL (Suc n) (SNOC x xa) = ELL n xa"
- sorry
-
-lemma ELL_CONS: "n < length l ==> ELL n (x # l) = ELL n l"
- sorry
-
-lemma ELL_LENGTH_CONS: "ELL (length l) (x # l) = x"
- sorry
-
-lemma ELL_LENGTH_SNOC: "ELL (length l) (SNOC x l) = (if List.null l then x else hd l)"
- sorry
-
-lemma ELL_APPEND2: "n < length l2 ==> ELL n (l1 @ l2) = ELL n l2"
- sorry
-
-lemma ELL_APPEND1: "length l2 <= n ==> ELL n (l1 @ l2) = ELL (n - length l2) l1"
- sorry
-
-lemma ELL_PRE_LENGTH: "l ~= [] ==> ELL (PRE (length l)) l = hd l"
- sorry
-
-lemma EL_LENGTH_SNOC: "EL (length l) (SNOC x l) = x"
- sorry
-
-lemma EL_PRE_LENGTH: "l ~= [] ==> EL (PRE (length l)) l = last l"
- sorry
-
-lemma EL_SNOC: "n < length l ==> EL n (SNOC x l) = EL n l"
- sorry
-
-lemma EL_ELL: "n < length l ==> EL n l = ELL (PRE (length l - n)) l"
- sorry
-
-lemma EL_LENGTH_APPEND: "~ List.null l2 ==> EL (length l1) (l1 @ l2) = hd l2"
- sorry
-
-lemma ELL_EL: "n < length l ==> ELL n l = EL (PRE (length l - n)) l"
- sorry
-
-lemma ELL_MAP: "n < length l ==> ELL n (map f l) = f (ELL n l)"
- sorry
-
-lemma LENGTH_BUTLAST: "l ~= [] ==> length (butlast l) = PRE (length l)"
- sorry
-
-lemma BUTFIRSTN_LENGTH_APPEND: "BUTFIRSTN (length l1) (l1 @ l2) = l2"
- sorry
-
-lemma FIRSTN_APPEND1: "n <= length l1 ==> FIRSTN n (l1 @ l2) = FIRSTN n l1"
- sorry
-
-lemma FIRSTN_APPEND2: "length l1 <= n ==> FIRSTN n (l1 @ l2) = l1 @ FIRSTN (n - length l1) l2"
- sorry
-
-lemma FIRSTN_LENGTH_APPEND: "FIRSTN (length l1) (l1 @ l2) = l1"
- sorry
-
-lemma REVERSE_FLAT: "rev (concat l) = concat (rev (map rev l))"
- sorry
-
-lemma MAP_FILTER: "(!!x. P (f x) = P x) ==> map f (filter P l) = filter P (map f l)"
- sorry
-
-lemma FLAT_REVERSE: "concat (rev l) = rev (concat (map rev l))"
- sorry
-
-lemma FLAT_FLAT: "concat (concat l) = concat (map concat l)"
- sorry
-
-lemma ALL_EL_SEG: "[| list_all P l; m + k <= length l |] ==> list_all P (SEG m k l)"
- sorry
-
-lemma ALL_EL_FIRSTN: "[| list_all P l; m <= length l |] ==> list_all P (FIRSTN m l)"
- sorry
-
-lemma ALL_EL_BUTFIRSTN: "[| list_all P l; m <= length l |] ==> list_all P (BUTFIRSTN m l)"
- sorry
-
-lemma SOME_EL_SEG: "[| m + k <= length l; list_ex P (SEG m k l) |] ==> list_ex P l"
- sorry
-
-lemma SOME_EL_FIRSTN: "[| m <= length l; list_ex P (FIRSTN m l) |] ==> list_ex P l"
- sorry
-
-lemma SOME_EL_BUTFIRSTN: "[| m <= length l; list_ex P (BUTFIRSTN m l) |] ==> list_ex P l"
- sorry
-
-lemma SOME_EL_LASTN: "[| m <= length l; list_ex P (LASTN m l) |] ==> list_ex P l"
- sorry
-
-lemma SOME_EL_BUTLASTN: "[| m <= length l; list_ex P (BUTLASTN m l) |] ==> list_ex P l"
- sorry
-
-lemma IS_EL_REVERSE: "List.member (rev l) x = List.member l x"
- sorry
-
-lemma IS_EL_FILTER: "P x ==> List.member (filter P l) x = List.member l x"
- sorry
-
-lemma IS_EL_SEG: "[| n + m <= length l; List.member (SEG n m l) x |] ==> List.member l x"
- sorry
-
-lemma IS_EL_SOME_EL: "List.member l x = list_ex (op = x) l"
- sorry
-
-lemma IS_EL_FIRSTN: "[| x <= length xa; List.member (FIRSTN x xa) xb |] ==> List.member xa xb"
- sorry
-
-lemma IS_EL_BUTFIRSTN: "[| x <= length xa; List.member (BUTFIRSTN x xa) xb |] ==> List.member xa xb"
- sorry
-
-lemma IS_EL_BUTLASTN: "[| x <= length xa; List.member (BUTLASTN x xa) xb |] ==> List.member xa xb"
- sorry
-
-lemma IS_EL_LASTN: "[| x <= length xa; List.member (LASTN x xa) xb |] ==> List.member xa xb"
- sorry
-
-lemma ZIP_SNOC: "length l1 = length l2
-==> zip (SNOC x1 l1) (SNOC x2 l2) = SNOC (x1, x2) (zip l1 l2)"
- sorry
-
-lemma UNZIP_SNOC: "unzip (SNOC x l) =
-(SNOC (fst x) (fst (unzip l)), SNOC (snd x) (snd (unzip l)))"
- sorry
-
-lemma LENGTH_UNZIP_FST: "length (UNZIP_FST x) = length x"
- sorry
-
-lemma LENGTH_UNZIP_SND: "length (UNZIP_SND (x::('a * 'b) list)) = length x"
- sorry
-
-lemma SUM_APPEND: "Compatibility.sum (l1 @ l2) = Compatibility.sum l1 + Compatibility.sum l2"
- sorry
-
-lemma SUM_REVERSE: "Compatibility.sum (rev l) = Compatibility.sum l"
- sorry
-
-lemma SUM_FLAT: "Compatibility.sum (concat l) = Compatibility.sum (map Compatibility.sum l)"
- sorry
-
-lemma EL_APPEND1: "n < length l1 ==> EL n (l1 @ l2) = EL n l1"
- sorry
-
-lemma EL_APPEND2: "length l1 <= n ==> EL n (l1 @ l2) = EL (n - length l1) l2"
- sorry
-
-lemma EL_MAP: "n < length l ==> EL n (map f l) = f (EL n l)"
- sorry
-
-lemma EL_CONS: "0 < n ==> EL n (x # l) = EL (PRE n) l"
- sorry
-
-lemma EL_SEG: "n < length l ==> EL n l = hd (SEG 1 n l)"
- sorry
-
-lemma EL_IS_EL: "n < length l ==> List.member l (EL n l)"
- sorry
-
-lemma TL_SNOC: "tl (SNOC x l) = (if List.null l then [] else SNOC x (tl l))"
- sorry
-
-lemma EL_REVERSE: "n < length l ==> EL n (rev l) = EL (PRE (length l - n)) l"
- sorry
-
-lemma EL_REVERSE_ELL: "n < length l ==> EL n (rev l) = ELL n l"
- sorry
-
-lemma ELL_LENGTH_APPEND: "~ List.null l1 ==> ELL (length l2) (l1 @ l2) = last l1"
- sorry
-
-lemma ELL_IS_EL: "n < length l ==> List.member l (ELL n l)"
- sorry
-
-lemma ELL_REVERSE: "n < length l ==> ELL n (rev l) = ELL (PRE (length l - n)) l"
- sorry
-
-lemma ELL_REVERSE_EL: "n < length l ==> ELL n (rev l) = EL n l"
- sorry
-
-lemma FIRSTN_BUTLASTN: "n <= length l ==> FIRSTN n l = BUTLASTN (length l - n) l"
- sorry
-
-lemma BUTLASTN_FIRSTN: "n <= length l ==> BUTLASTN n l = FIRSTN (length l - n) l"
- sorry
-
-lemma LASTN_BUTFIRSTN: "n <= length l ==> LASTN n l = BUTFIRSTN (length l - n) l"
- sorry
-
-lemma BUTFIRSTN_LASTN: "n <= length l ==> BUTFIRSTN n l = LASTN (length l - n) l"
- sorry
-
-lemma SEG_LASTN_BUTLASTN: "n + m <= length l ==> SEG n m l = LASTN n (BUTLASTN (length l - (n + m)) l)"
- sorry
-
-lemma BUTFIRSTN_REVERSE: "n <= length l ==> BUTFIRSTN n (rev l) = rev (BUTLASTN n l)"
- sorry
-
-lemma BUTLASTN_REVERSE: "n <= length l ==> BUTLASTN n (rev l) = rev (BUTFIRSTN n l)"
- sorry
-
-lemma LASTN_REVERSE: "n <= length l ==> LASTN n (rev l) = rev (FIRSTN n l)"
- sorry
-
-lemma FIRSTN_REVERSE: "n <= length l ==> FIRSTN n (rev l) = rev (LASTN n l)"
- sorry
-
-lemma SEG_REVERSE: "n + m <= length l ==> SEG n m (rev l) = rev (SEG n (length l - (n + m)) l)"
- sorry
-
-lemma LENGTH_GENLIST: "length (GENLIST f n) = n"
- sorry
-
-lemma LENGTH_REPLICATE: "length (REPLICATE n x) = n"
- sorry
-
-lemma IS_EL_REPLICATE: "0 < n ==> List.member (REPLICATE n x) x"
- sorry
-
-lemma ALL_EL_REPLICATE: "list_all (op = x) (REPLICATE n x)"
- sorry
-
-lemma AND_EL_FOLDL: "AND_EL l = foldl op & True l"
- sorry
-
-lemma AND_EL_FOLDR: "AND_EL l = foldr op & l True"
- sorry
-
-lemma OR_EL_FOLDL: "OR_EL l = foldl op | False l"
- sorry
-
-lemma OR_EL_FOLDR: "OR_EL l = foldr op | l False"
- sorry
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" state_transformer
-
-definition
- UNIT :: "'b => 'a => 'b * 'a" where
- "(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: "UNIT x = Pair x"
- sorry
-
-definition
- BIND :: "('a => 'b * 'a) => ('b => 'a => 'c * 'a) => 'a => 'c * 'a" where
- "BIND == %g f. (%(x, y). f x y) o g"
-
-lemma BIND_DEF: "BIND (g::'a => 'b * 'a) (f::'b => 'a => 'c * 'a) =
-(%(x::'b, y::'a). f x y) o g"
- sorry
-
-definition
- MMAP :: "('c => 'b) => ('a => 'c * 'a) => 'a => 'b * 'a" where
- "MMAP == %(f::'c => 'b) m::'a => 'c * 'a. BIND m (UNIT o f)"
-
-lemma MMAP_DEF: "MMAP f m = BIND m (UNIT o f)"
- sorry
-
-definition
- JOIN :: "('a => ('a => 'b * 'a) * 'a) => 'a => 'b * 'a" where
- "JOIN == %z. BIND z I"
-
-lemma JOIN_DEF: "JOIN z = BIND z I"
- sorry
-
-lemma BIND_LEFT_UNIT: "BIND (UNIT (x::'a)) (k::'a => 'b => 'c * 'b) = k x"
- sorry
-
-lemma UNIT_UNCURRY: "prod_case UNIT x = x"
- sorry
-
-lemma BIND_RIGHT_UNIT: "BIND k UNIT = k"
- sorry
-
-lemma BIND_ASSOC: "BIND (x::'a => 'b * 'a)
- (%a::'b. BIND ((xa::'b => 'a => 'c * 'a) a) (xb::'c => 'a => 'd * 'a)) =
-BIND (BIND x xa) xb"
- sorry
-
-lemma MMAP_ID: "MMAP I = I"
- sorry
-
-lemma MMAP_COMP: "MMAP ((f::'c => 'd) o (g::'b => 'c)) = MMAP f o MMAP g"
- sorry
-
-lemma MMAP_UNIT: "MMAP (f::'b => 'c) o UNIT = UNIT o f"
- sorry
-
-lemma MMAP_JOIN: "MMAP f o JOIN = JOIN o MMAP (MMAP f)"
- sorry
-
-lemma JOIN_UNIT: "JOIN o UNIT = I"
- sorry
-
-lemma JOIN_MMAP_UNIT: "JOIN o MMAP UNIT = I"
- sorry
-
-lemma JOIN_MAP_JOIN: "JOIN o MMAP JOIN = JOIN o JOIN"
- sorry
-
-lemma JOIN_MAP: "BIND (x::'a => 'b * 'a) (xa::'b => 'a => 'c * 'a) = JOIN (MMAP xa x)"
- sorry
-
-lemma FST_o_UNIT: "fst o UNIT (x::'a) = K x"
- sorry
-
-lemma SND_o_UNIT: "snd o UNIT (x::'a) = I"
- sorry
-
-lemma FST_o_MMAP: "fst o MMAP (x::'a => 'b) (xa::'c => 'a * 'c) = x o (fst o xa)"
- sorry
-
-;end_setup
-
-end
-
--- a/src/HOL/Import/HOL4/Generated/HOL4Prob.thy Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1594 +0,0 @@
-(* AUTOMATICALLY GENERATED, DO NOT EDIT! *)
-
-theory HOL4Prob imports HOL4Real begin
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" prob_extra
-
-lemma BOOL_BOOL_CASES_THM: "f = (%b. False) | f = (%b. True) | f = (%b. 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"
- by (import prob_extra EVEN_ODD_BASIC)
-
-lemma EVEN_ODD_EXISTS_EQ: "EVEN n = (EX m. n = 2 * m) & ODD n = (EX m. n = Suc (2 * m))"
- by (import prob_extra EVEN_ODD_EXISTS_EQ)
-
-lemma DIV_THEN_MULT: "Suc q * (p div Suc q) <= p"
- by (import prob_extra DIV_THEN_MULT)
-
-lemma DIV_TWO_UNIQUE: "(n::nat) = (2::nat) * (q::nat) + (r::nat) & (r = (0::nat) | r = (1::nat))
-==> q = n div (2::nat) & r = n mod (2::nat)"
- by (import prob_extra DIV_TWO_UNIQUE)
-
-lemma DIVISION_TWO: "(n::nat) = (2::nat) * (n div (2::nat)) + n mod (2::nat) &
-(n mod (2::nat) = (0::nat) | n mod (2::nat) = (1::nat))"
- by (import prob_extra DIVISION_TWO)
-
-lemma DIV_TWO: "(n::nat) = (2::nat) * (n div (2::nat)) + n mod (2::nat)"
- by (import prob_extra DIV_TWO)
-
-lemma MOD_TWO: "n mod 2 = (if EVEN n then 0 else 1)"
- by (import prob_extra MOD_TWO)
-
-lemma DIV_TWO_BASIC: "(0::nat) div (2::nat) = (0::nat) &
-(1::nat) div (2::nat) = (0::nat) & (2::nat) div (2::nat) = (1::nat)"
- by (import prob_extra DIV_TWO_BASIC)
-
-lemma DIV_TWO_MONO: "(m::nat) div (2::nat) < (n::nat) div (2::nat) ==> m < n"
- by (import prob_extra DIV_TWO_MONO)
-
-lemma DIV_TWO_MONO_EVEN: "EVEN n ==> (m div 2 < n div 2) = (m < n)"
- by (import prob_extra DIV_TWO_MONO_EVEN)
-
-lemma DIV_TWO_CANCEL: "2 * n div 2 = n & Suc (2 * n) div 2 = n"
- by (import prob_extra DIV_TWO_CANCEL)
-
-lemma EXP_DIV_TWO: "(2::nat) ^ Suc (n::nat) div (2::nat) = (2::nat) ^ n"
- by (import prob_extra EXP_DIV_TWO)
-
-lemma EVEN_EXP_TWO: "EVEN (2 ^ n) = (n ~= 0)"
- by (import prob_extra EVEN_EXP_TWO)
-
-lemma DIV_TWO_EXP: "((k::nat) div (2::nat) < (2::nat) ^ (n::nat)) = (k < (2::nat) ^ Suc n)"
- by (import prob_extra DIV_TWO_EXP)
-
-consts
- inf :: "(real => bool) => real"
-
-defs
- inf_primdef: "prob_extra.inf == %P. - real.sup (IMAGE uminus P)"
-
-lemma inf_def: "prob_extra.inf P = - real.sup (IMAGE uminus P)"
- by (import prob_extra inf_def)
-
-lemma INF_DEF_ALT: "prob_extra.inf P = - real.sup (%r. P (- r))"
- by (import prob_extra INF_DEF_ALT)
-
-lemma REAL_SUP_EXISTS_UNIQUE: "Ex (P::real => bool) & (EX z::real. ALL x::real. P x --> x <= z)
-==> EX! s::real. ALL y::real. (EX x::real. P x & y < x) = (y < s)"
- by (import prob_extra REAL_SUP_EXISTS_UNIQUE)
-
-lemma REAL_SUP_MAX: "P z & (ALL x. P x --> x <= z) ==> real.sup P = z"
- by (import prob_extra REAL_SUP_MAX)
-
-lemma REAL_INF_MIN: "P z & (ALL x. P x --> z <= x) ==> prob_extra.inf P = z"
- by (import prob_extra REAL_INF_MIN)
-
-lemma HALF_CANCEL: "(2::real) * ((1::real) / (2::real)) = (1::real)"
- by (import prob_extra HALF_CANCEL)
-
-lemma POW_HALF_POS: "(0::real) < ((1::real) / (2::real)) ^ (n::nat)"
- by (import prob_extra POW_HALF_POS)
-
-lemma POW_HALF_MONO: "(m::nat) <= (n::nat)
-==> ((1::real) / (2::real)) ^ n <= ((1::real) / (2::real)) ^ m"
- by (import prob_extra POW_HALF_MONO)
-
-lemma POW_HALF_TWICE: "((1::real) / (2::real)) ^ (n::nat) =
-(2::real) * ((1::real) / (2::real)) ^ Suc n"
- by (import prob_extra POW_HALF_TWICE)
-
-lemma X_HALF_HALF: "(1::real) / (2::real) * (x::real) + (1::real) / (2::real) * x = x"
- by (import prob_extra X_HALF_HALF)
-
-lemma REAL_SUP_LE_X: "Ex P & (ALL r. P r --> r <= x) ==> real.sup P <= x"
- by (import prob_extra REAL_SUP_LE_X)
-
-lemma REAL_X_LE_SUP: "Ex P & (EX z. ALL r. P r --> r <= z) & (EX r. P r & x <= r)
-==> x <= real.sup P"
- by (import prob_extra REAL_X_LE_SUP)
-
-lemma ABS_BETWEEN_LE: "((0::real) <= (d::real) & (x::real) - d <= (y::real) & y <= x + d) =
-(abs (y - x) <= d)"
- by (import prob_extra ABS_BETWEEN_LE)
-
-lemma ONE_MINUS_HALF: "(1::real) - (1::real) / (2::real) = (1::real) / (2::real)"
- by (import prob_extra ONE_MINUS_HALF)
-
-lemma HALF_LT_1: "(1::real) / (2::real) < (1::real)"
- by (import prob_extra HALF_LT_1)
-
-lemma POW_HALF_EXP: "((1::real) / (2::real)) ^ (n::nat) = inverse (real ((2::nat) ^ n))"
- by (import prob_extra POW_HALF_EXP)
-
-lemma INV_SUC_POS: "0 < 1 / real (Suc n)"
- by (import prob_extra INV_SUC_POS)
-
-lemma INV_SUC_MAX: "1 / real (Suc x) <= 1"
- by (import prob_extra INV_SUC_MAX)
-
-lemma INV_SUC: "0 < 1 / real (Suc n) & 1 / real (Suc n) <= 1"
- by (import prob_extra INV_SUC)
-
-lemma ABS_UNIT_INTERVAL: "(0::real) <= (x::real) &
-x <= (1::real) & (0::real) <= (y::real) & y <= (1::real)
-==> abs (x - y) <= (1::real)"
- by (import prob_extra ABS_UNIT_INTERVAL)
-
-lemma MEM_NIL: "(ALL x. ~ List.member l x) = (l = [])"
- by (import prob_extra MEM_NIL)
-
-lemma MAP_MEM: "List.member (map (f::'a => 'b) (l::'a list)) (x::'b) =
-(EX y::'a. List.member l y & x = f y)"
- by (import prob_extra MAP_MEM)
-
-lemma MEM_NIL_MAP_CONS: "~ List.member (map (op # x) l) []"
- by (import prob_extra MEM_NIL_MAP_CONS)
-
-lemma FILTER_TRUE: "[x<-l. True] = l"
- by (import prob_extra FILTER_TRUE)
-
-lemma FILTER_FALSE: "[x<-l. False] = []"
- by (import prob_extra FILTER_FALSE)
-
-lemma FILTER_MEM: "List.member (filter P l) x ==> P x"
- by (import prob_extra FILTER_MEM)
-
-lemma MEM_FILTER: "List.member (filter P l) x ==> List.member l x"
- by (import prob_extra MEM_FILTER)
-
-lemma FILTER_OUT_ELT: "List.member l x | [y<-l. y ~= x] = l"
- by (import prob_extra FILTER_OUT_ELT)
-
-lemma IS_PREFIX_NIL: "IS_PREFIX x [] & IS_PREFIX [] x = (x = [])"
- by (import prob_extra IS_PREFIX_NIL)
-
-lemma IS_PREFIX_REFL: "IS_PREFIX x x"
- by (import prob_extra IS_PREFIX_REFL)
-
-lemma IS_PREFIX_ANTISYM: "IS_PREFIX y x & IS_PREFIX x y ==> x = y"
- by (import prob_extra IS_PREFIX_ANTISYM)
-
-lemma IS_PREFIX_TRANS: "IS_PREFIX x y & IS_PREFIX y z ==> IS_PREFIX x z"
- by (import prob_extra IS_PREFIX_TRANS)
-
-lemma IS_PREFIX_BUTLAST: "IS_PREFIX (x # y) (butlast (x # y))"
- by (import prob_extra IS_PREFIX_BUTLAST)
-
-lemma IS_PREFIX_LENGTH: "IS_PREFIX y x ==> length x <= length y"
- by (import prob_extra IS_PREFIX_LENGTH)
-
-lemma IS_PREFIX_LENGTH_ANTI: "IS_PREFIX y x & length x = length y ==> x = y"
- by (import prob_extra IS_PREFIX_LENGTH_ANTI)
-
-lemma IS_PREFIX_SNOC: "IS_PREFIX (SNOC x y) z = (IS_PREFIX y z | z = SNOC x y)"
- by (import prob_extra IS_PREFIX_SNOC)
-
-lemma FOLDR_MAP: "foldr (f::'b => 'c => 'c) (map (g::'a => 'b) (l::'a list)) (e::'c) =
-foldr (%x::'a. f (g x)) l e"
- by (import prob_extra FOLDR_MAP)
-
-lemma LAST_MEM: "List.member (h # t) (last (h # t))"
- by (import prob_extra LAST_MEM)
-
-lemma LAST_MAP_CONS: "EX x::bool list.
- last (map (op # (b::bool)) ((h::bool list) # (t::bool list list))) =
- b # x"
- by (import prob_extra LAST_MAP_CONS)
-
-lemma EXISTS_LONGEST: "EX z. List.member (x # y) z &
- (ALL w. List.member (x # y) w --> length w <= length z)"
- by (import prob_extra EXISTS_LONGEST)
-
-lemma UNION_DEF_ALT: "pred_set.UNION s t = (%x. s x | t x)"
- by (import prob_extra UNION_DEF_ALT)
-
-lemma INTER_UNION_RDISTRIB: "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: "(x = xa) = (SUBSET x xa & SUBSET xa x)"
- by (import prob_extra SUBSET_EQ)
-
-lemma INTER_IS_EMPTY: "(pred_set.INTER s t = EMPTY) = (ALL x. ~ s x | ~ t x)"
- by (import prob_extra INTER_IS_EMPTY)
-
-lemma UNION_DISJOINT_SPLIT: "pred_set.UNION s t = pred_set.UNION s u &
-pred_set.INTER s t = EMPTY & pred_set.INTER s u = EMPTY
-==> t = u"
- by (import prob_extra UNION_DISJOINT_SPLIT)
-
-lemma GSPEC_DEF_ALT: "GSPEC (f::'a => 'b * bool) = (%v::'b. EX x::'a. (v, True) = f x)"
- by (import prob_extra GSPEC_DEF_ALT)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" prob_canon
-
-consts
- 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: "alg_twin x y = (EX l. x = SNOC True l & y = SNOC False l)"
- by (import prob_canon alg_twin_def)
-
-definition
- alg_order_tupled :: "bool list * bool list => bool" where
- "alg_order_tupled ==
-WFREC (SOME R. WF R & (ALL h' h t' t. R (t, t') (h # t, h' # t')))
- (%alg_order_tupled (v, v1).
- case v of [] => case v1 of [] => True | _ => True
- | v4 # v5 =>
- case v1 of [] => False
- | v10 # v11 =>
- v4 = True & v10 = False |
- v4 = v10 & alg_order_tupled (v5, v11))"
-
-lemma alg_order_tupled_primitive_def: "alg_order_tupled =
-WFREC (SOME R. WF R & (ALL h' h t' t. R (t, t') (h # t, h' # t')))
- (%alg_order_tupled (v, v1).
- case v of [] => case v1 of [] => True | _ => True
- | v4 # v5 =>
- case v1 of [] => False
- | v10 # v11 =>
- v4 = True & v10 = False |
- v4 = v10 & alg_order_tupled (v5, v11))"
- by (import prob_canon alg_order_tupled_primitive_def)
-
-consts
- 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: "alg_order x x1 = alg_order_tupled (x, x1)"
- by (import prob_canon alg_order_curried_def)
-
-lemma alg_order_ind: "(ALL (x::bool) xa::bool list.
- (P::bool list => bool list => bool) [] (x # xa)) &
-P [] [] &
-(ALL (x::bool) xa::bool list. P (x # xa) []) &
-(ALL (x::bool) (xa::bool list) (xb::bool) xc::bool list.
- P xa xc --> P (x # xa) (xb # xc))
-==> P (x::bool list) (xa::bool list)"
- by (import prob_canon alg_order_ind)
-
-lemma alg_order_def: "alg_order [] (v6 # v7) = True &
-alg_order [] [] = True &
-alg_order (v2 # v3) [] = False &
-alg_order (h # t) (h' # t') =
-(h = True & h' = False | h = h' & alg_order t t')"
- by (import prob_canon alg_order_def)
-
-consts
- alg_sorted :: "bool list list => bool"
-
-defs
- alg_sorted_primdef: "alg_sorted ==
-WFREC (SOME R. WF R & (ALL x z y. R (y # z) (x # y # z)))
- (%alg_sorted.
- list_case True
- (%v2. list_case True
- (%v6 v7. 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.
- list_case True
- (%v2. list_case True
- (%v6 v7. alg_order v2 v6 & alg_sorted (v6 # v7))))"
- by (import prob_canon alg_sorted_primitive_def)
-
-lemma alg_sorted_ind: "(ALL (x::bool list) (y::bool list) z::bool list list.
- (P::bool list list => bool) (y # z) --> P (x # y # z)) &
-(ALL v::bool list. P [v]) & P []
-==> P (x::bool list list)"
- 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"
- by (import prob_canon alg_sorted_def)
-
-consts
- alg_prefixfree :: "bool list list => bool"
-
-defs
- alg_prefixfree_primdef: "alg_prefixfree ==
-WFREC (SOME R. WF R & (ALL x z y. R (y # z) (x # y # z)))
- (%alg_prefixfree.
- list_case True
- (%v2. list_case True
- (%v6 v7. ~ 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.
- list_case True
- (%v2. list_case True
- (%v6 v7. ~ IS_PREFIX v6 v2 & alg_prefixfree (v6 # v7))))"
- by (import prob_canon alg_prefixfree_primitive_def)
-
-lemma alg_prefixfree_ind: "(ALL (x::bool list) (y::bool list) z::bool list list.
- (P::bool list list => bool) (y # z) --> P (x # y # z)) &
-(ALL v::bool list. P [v]) & P []
-==> P (x::bool list list)"
- 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"
- by (import prob_canon alg_prefixfree_def)
-
-consts
- alg_twinfree :: "bool list list => bool"
-
-defs
- alg_twinfree_primdef: "alg_twinfree ==
-WFREC (SOME R. WF R & (ALL x z y. R (y # z) (x # y # z)))
- (%alg_twinfree.
- list_case True
- (%v2. list_case True
- (%v6 v7. ~ 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.
- list_case True
- (%v2. list_case True
- (%v6 v7. ~ alg_twin v2 v6 & alg_twinfree (v6 # v7))))"
- by (import prob_canon alg_twinfree_primitive_def)
-
-lemma alg_twinfree_ind: "(ALL (x::bool list) (y::bool list) z::bool list list.
- (P::bool list list => bool) (y # z) --> P (x # y # z)) &
-(ALL v::bool list. P [v]) & P []
-==> P (x::bool list list)"
- 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"
- 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"
- 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.
- 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)
-
-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.
- 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
- else alg_canon_prefs l (h # t)))"
- by (import prob_canon alg_canon_find_def)
-
-consts
- alg_canon1 :: "bool list list => bool list list"
-
-defs
- alg_canon1_primdef: "alg_canon1 == FOLDR alg_canon_find []"
-
-lemma alg_canon1_def: "alg_canon1 = FOLDR alg_canon_find []"
- by (import prob_canon alg_canon1_def)
-
-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.
- 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)
-
-consts
- alg_canon2 :: "bool list list => bool list list"
-
-defs
- alg_canon2_primdef: "alg_canon2 == FOLDR alg_canon_merge []"
-
-lemma alg_canon2_def: "alg_canon2 = FOLDR alg_canon_merge []"
- by (import prob_canon alg_canon2_def)
-
-consts
- alg_canon :: "bool list list => bool list list"
-
-defs
- alg_canon_primdef: "alg_canon == %l. alg_canon2 (alg_canon1 l)"
-
-lemma alg_canon_def: "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: "algebra_canon l = (alg_canon l = l)"
- by (import prob_canon algebra_canon_def)
-
-lemma ALG_TWIN_NIL: "~ alg_twin l [] & ~ alg_twin [] l"
- by (import prob_canon ALG_TWIN_NIL)
-
-lemma ALG_TWIN_SING: "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: "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: "alg_twin (h # t) (h # t') = alg_twin t t'"
- by (import prob_canon ALG_TWIN_REDUCE)
-
-lemma ALG_TWINS_PREFIX: "IS_PREFIX x l
-==> x = l | IS_PREFIX x (SNOC True l) | IS_PREFIX x (SNOC False l)"
- by (import prob_canon ALG_TWINS_PREFIX)
-
-lemma ALG_ORDER_NIL: "alg_order [] x & alg_order x [] = (x = [])"
- by (import prob_canon ALG_ORDER_NIL)
-
-lemma ALG_ORDER_REFL: "alg_order x x"
- by (import prob_canon ALG_ORDER_REFL)
-
-lemma ALG_ORDER_ANTISYM: "alg_order x y & alg_order y x ==> x = y"
- by (import prob_canon ALG_ORDER_ANTISYM)
-
-lemma ALG_ORDER_TRANS: "alg_order x y & alg_order y z ==> alg_order x z"
- by (import prob_canon ALG_ORDER_TRANS)
-
-lemma ALG_ORDER_TOTAL: "alg_order x y | alg_order y x"
- by (import prob_canon ALG_ORDER_TOTAL)
-
-lemma ALG_ORDER_PREFIX: "IS_PREFIX y x ==> alg_order x y"
- by (import prob_canon ALG_ORDER_PREFIX)
-
-lemma ALG_ORDER_PREFIX_ANTI: "alg_order x y & IS_PREFIX x y ==> x = y"
- by (import prob_canon ALG_ORDER_PREFIX_ANTI)
-
-lemma ALG_ORDER_PREFIX_MONO: "alg_order x y & alg_order y z & IS_PREFIX z x ==> IS_PREFIX y x"
- by (import prob_canon ALG_ORDER_PREFIX_MONO)
-
-lemma ALG_ORDER_PREFIX_TRANS: "alg_order x y & IS_PREFIX y z ==> alg_order x z | IS_PREFIX x z"
- by (import prob_canon ALG_ORDER_PREFIX_TRANS)
-
-lemma ALG_ORDER_SNOC: "~ alg_order (SNOC x l) l"
- by (import prob_canon ALG_ORDER_SNOC)
-
-lemma ALG_SORTED_MIN: "[| alg_sorted (h # t); List.member t x |] ==> alg_order h x"
- by (import prob_canon ALG_SORTED_MIN)
-
-lemma ALG_SORTED_DEF_ALT: "alg_sorted (h # t) =
-((ALL x. List.member t x --> alg_order h x) & alg_sorted t)"
- by (import prob_canon ALG_SORTED_DEF_ALT)
-
-lemma ALG_SORTED_TL: "alg_sorted (h # t) ==> alg_sorted t"
- by (import prob_canon ALG_SORTED_TL)
-
-lemma ALG_SORTED_MONO: "alg_sorted (x # y # z) ==> alg_sorted (x # z)"
- by (import prob_canon ALG_SORTED_MONO)
-
-lemma ALG_SORTED_TLS: "alg_sorted (map (op # b) l) = alg_sorted l"
- by (import prob_canon ALG_SORTED_TLS)
-
-lemma ALG_SORTED_STEP: "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: "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)
-
-lemma ALG_SORTED_FILTER: "alg_sorted b ==> alg_sorted (filter P b)"
- by (import prob_canon ALG_SORTED_FILTER)
-
-lemma ALG_PREFIXFREE_TL: "alg_prefixfree (h # t) ==> alg_prefixfree t"
- by (import prob_canon ALG_PREFIXFREE_TL)
-
-lemma ALG_PREFIXFREE_MONO: "alg_sorted (x # y # z) & alg_prefixfree (x # y # z)
-==> alg_prefixfree (x # z)"
- by (import prob_canon ALG_PREFIXFREE_MONO)
-
-lemma ALG_PREFIXFREE_ELT: "[| alg_sorted (h # t) & alg_prefixfree (h # t); List.member t x |]
-==> ~ IS_PREFIX x h & ~ IS_PREFIX h x"
- by (import prob_canon ALG_PREFIXFREE_ELT)
-
-lemma ALG_PREFIXFREE_TLS: "alg_prefixfree (map (op # b) l) = alg_prefixfree l"
- by (import prob_canon ALG_PREFIXFREE_TLS)
-
-lemma ALG_PREFIXFREE_STEP: "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: "alg_prefixfree ((h # t) @ h' # t') =
-(alg_prefixfree (h # t) &
- alg_prefixfree (h' # t') & ~ IS_PREFIX h' (last (h # t)))"
- by (import prob_canon ALG_PREFIXFREE_APPEND)
-
-lemma ALG_PREFIXFREE_FILTER: "alg_sorted b & alg_prefixfree b ==> alg_prefixfree (filter P b)"
- by (import prob_canon ALG_PREFIXFREE_FILTER)
-
-lemma ALG_TWINFREE_TL: "alg_twinfree (h # t) ==> alg_twinfree t"
- by (import prob_canon ALG_TWINFREE_TL)
-
-lemma ALG_TWINFREE_TLS: "alg_twinfree (map (op # b) l) = alg_twinfree l"
- by (import prob_canon ALG_TWINFREE_TLS)
-
-lemma ALG_TWINFREE_STEP1: "alg_twinfree (map (op # True) l1 @ map (op # False) l2)
-==> alg_twinfree l1 & alg_twinfree l2"
- by (import prob_canon ALG_TWINFREE_STEP1)
-
-lemma ALG_TWINFREE_STEP2: "(~ List.member l1 [] | ~ List.member l2 []) &
-alg_twinfree l1 & alg_twinfree l2
-==> alg_twinfree (map (op # True) l1 @ map (op # False) l2)"
- by (import prob_canon ALG_TWINFREE_STEP2)
-
-lemma ALG_TWINFREE_STEP: "~ List.member l1 [] | ~ List.member l2 []
-==> alg_twinfree (map (op # True) l1 @ map (op # False) l2) =
- (alg_twinfree l1 & alg_twinfree l2)"
- by (import prob_canon ALG_TWINFREE_STEP)
-
-lemma ALG_LONGEST_HD: "length h <= alg_longest (h # t)"
- by (import prob_canon ALG_LONGEST_HD)
-
-lemma ALG_LONGEST_TL: "alg_longest t <= alg_longest (h # t)"
- by (import prob_canon ALG_LONGEST_TL)
-
-lemma ALG_LONGEST_TLS: "alg_longest (map (op # b) (h # t)) = Suc (alg_longest (h # t))"
- by (import prob_canon ALG_LONGEST_TLS)
-
-lemma ALG_LONGEST_APPEND: "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: "hd (alg_canon_prefs l b) = l"
- by (import prob_canon ALG_CANON_PREFS_HD)
-
-lemma ALG_CANON_PREFS_DELETES: "List.member (alg_canon_prefs l b) x ==> List.member (l # b) x"
- by (import prob_canon ALG_CANON_PREFS_DELETES)
-
-lemma ALG_CANON_PREFS_SORTED: "alg_sorted (l # b) ==> alg_sorted (alg_canon_prefs l b)"
- by (import prob_canon ALG_CANON_PREFS_SORTED)
-
-lemma ALG_CANON_PREFS_PREFIXFREE: "alg_sorted b & alg_prefixfree b ==> alg_prefixfree (alg_canon_prefs l b)"
- by (import prob_canon ALG_CANON_PREFS_PREFIXFREE)
-
-lemma ALG_CANON_PREFS_CONSTANT: "alg_prefixfree (l # b) ==> alg_canon_prefs l b = l # b"
- by (import prob_canon ALG_CANON_PREFS_CONSTANT)
-
-lemma ALG_CANON_FIND_HD: "hd (alg_canon_find l (h # t)) = l | hd (alg_canon_find l (h # t)) = h"
- by (import prob_canon ALG_CANON_FIND_HD)
-
-lemma ALG_CANON_FIND_DELETES: "List.member (alg_canon_find l b) x ==> List.member (l # b) x"
- by (import prob_canon ALG_CANON_FIND_DELETES)
-
-lemma ALG_CANON_FIND_SORTED: "alg_sorted b ==> alg_sorted (alg_canon_find l b)"
- by (import prob_canon ALG_CANON_FIND_SORTED)
-
-lemma ALG_CANON_FIND_PREFIXFREE: "alg_sorted b & alg_prefixfree b ==> alg_prefixfree (alg_canon_find l b)"
- by (import prob_canon ALG_CANON_FIND_PREFIXFREE)
-
-lemma ALG_CANON_FIND_CONSTANT: "alg_sorted (l # b) & alg_prefixfree (l # b) ==> alg_canon_find l b = l # b"
- by (import prob_canon ALG_CANON_FIND_CONSTANT)
-
-lemma ALG_CANON1_SORTED: "alg_sorted (alg_canon1 x)"
- by (import prob_canon ALG_CANON1_SORTED)
-
-lemma ALG_CANON1_PREFIXFREE: "alg_prefixfree (alg_canon1 l)"
- by (import prob_canon ALG_CANON1_PREFIXFREE)
-
-lemma ALG_CANON1_CONSTANT: "alg_sorted l & alg_prefixfree l ==> alg_canon1 l = l"
- by (import prob_canon ALG_CANON1_CONSTANT)
-
-lemma ALG_CANON_MERGE_SORTED_PREFIXFREE_TWINFREE: "alg_sorted (l # b) & alg_prefixfree (l # b) & alg_twinfree b
-==> alg_sorted (alg_canon_merge l b) &
- alg_prefixfree (alg_canon_merge l b) &
- alg_twinfree (alg_canon_merge l b)"
- by (import prob_canon ALG_CANON_MERGE_SORTED_PREFIXFREE_TWINFREE)
-
-lemma ALG_CANON_MERGE_PREFIXFREE_PRESERVE: "[| !!x. List.member (l # b) x ==> ~ IS_PREFIX h x & ~ IS_PREFIX x h;
- List.member (alg_canon_merge l b) x |]
-==> ~ IS_PREFIX h x & ~ IS_PREFIX x h"
- by (import prob_canon ALG_CANON_MERGE_PREFIXFREE_PRESERVE)
-
-lemma ALG_CANON_MERGE_SHORTENS: "List.member (alg_canon_merge l b) x
-==> EX y. List.member (l # b) y & IS_PREFIX y x"
- by (import prob_canon ALG_CANON_MERGE_SHORTENS)
-
-lemma ALG_CANON_MERGE_CONSTANT: "alg_twinfree (l # b) ==> alg_canon_merge l b = l # b"
- by (import prob_canon ALG_CANON_MERGE_CONSTANT)
-
-lemma ALG_CANON2_PREFIXFREE_PRESERVE: "[| !!xb. List.member x xb ==> ~ IS_PREFIX xa xb & ~ IS_PREFIX xb xa;
- List.member (alg_canon2 x) xb |]
-==> ~ IS_PREFIX xa xb & ~ IS_PREFIX xb xa"
- by (import prob_canon ALG_CANON2_PREFIXFREE_PRESERVE)
-
-lemma ALG_CANON2_SHORTENS: "List.member (alg_canon2 x) xa ==> EX y. List.member x y & IS_PREFIX y xa"
- by (import prob_canon ALG_CANON2_SHORTENS)
-
-lemma ALG_CANON2_SORTED_PREFIXFREE_TWINFREE: "alg_sorted x & alg_prefixfree x
-==> alg_sorted (alg_canon2 x) &
- alg_prefixfree (alg_canon2 x) & alg_twinfree (alg_canon2 x)"
- by (import prob_canon ALG_CANON2_SORTED_PREFIXFREE_TWINFREE)
-
-lemma ALG_CANON2_CONSTANT: "alg_twinfree l ==> alg_canon2 l = l"
- by (import prob_canon ALG_CANON2_CONSTANT)
-
-lemma ALG_CANON_SORTED_PREFIXFREE_TWINFREE: "alg_sorted (alg_canon l) &
-alg_prefixfree (alg_canon l) & alg_twinfree (alg_canon l)"
- by (import prob_canon ALG_CANON_SORTED_PREFIXFREE_TWINFREE)
-
-lemma ALG_CANON_CONSTANT: "alg_sorted l & alg_prefixfree l & alg_twinfree l ==> alg_canon l = l"
- by (import prob_canon ALG_CANON_CONSTANT)
-
-lemma ALG_CANON_IDEMPOT: "alg_canon (alg_canon l) = alg_canon l"
- by (import prob_canon ALG_CANON_IDEMPOT)
-
-lemma ALGEBRA_CANON_DEF_ALT: "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])"
- by (import prob_canon ALGEBRA_CANON_BASIC)
-
-lemma ALG_CANON_BASIC: "alg_canon [] = [] & alg_canon [[]] = [[]] & (ALL x. alg_canon [x] = [x])"
- by (import prob_canon ALG_CANON_BASIC)
-
-lemma ALGEBRA_CANON_TL: "algebra_canon (h # t) ==> algebra_canon t"
- by (import prob_canon ALGEBRA_CANON_TL)
-
-lemma ALGEBRA_CANON_NIL_MEM: "(algebra_canon l & List.member l []) = (l = [[]])"
- by (import prob_canon ALGEBRA_CANON_NIL_MEM)
-
-lemma ALGEBRA_CANON_TLS: "algebra_canon (map (op # b) l) = algebra_canon l"
- by (import prob_canon ALGEBRA_CANON_TLS)
-
-lemma ALGEBRA_CANON_STEP1: "algebra_canon (map (op # True) l1 @ map (op # False) l2)
-==> algebra_canon l1 & algebra_canon l2"
- by (import prob_canon ALGEBRA_CANON_STEP1)
-
-lemma ALGEBRA_CANON_STEP2: "(l1 ~= [[]] | l2 ~= [[]]) & algebra_canon l1 & algebra_canon l2
-==> algebra_canon (map (op # True) l1 @ map (op # False) l2)"
- by (import prob_canon ALGEBRA_CANON_STEP2)
-
-lemma ALGEBRA_CANON_STEP: "l1 ~= [[]] | l2 ~= [[]]
-==> algebra_canon (map (op # True) l1 @ map (op # False) l2) =
- (algebra_canon l1 & algebra_canon l2)"
- by (import prob_canon ALGEBRA_CANON_STEP)
-
-lemma ALGEBRA_CANON_CASES_THM: "algebra_canon l
-==> l = [] |
- l = [[]] |
- (EX l1 l2.
- algebra_canon l1 &
- algebra_canon l2 & l = map (op # True) l1 @ map (op # False) l2)"
- by (import prob_canon ALGEBRA_CANON_CASES_THM)
-
-lemma ALGEBRA_CANON_CASES: "[| P [] &
- P [[]] &
- (ALL l1 l2.
- algebra_canon l1 &
- algebra_canon l2 &
- algebra_canon (map (op # True) l1 @ map (op # False) l2) -->
- P (map (op # True) l1 @ map (op # False) l2));
- algebra_canon l |]
-==> P l"
- by (import prob_canon ALGEBRA_CANON_CASES)
-
-lemma ALGEBRA_CANON_INDUCTION: "[| P [] &
- P [[]] &
- (ALL l1 l2.
- algebra_canon l1 &
- algebra_canon l2 &
- P l1 &
- P l2 & algebra_canon (map (op # True) l1 @ map (op # False) l2) -->
- P (map (op # True) l1 @ map (op # False) l2));
- algebra_canon l |]
-==> P l"
- by (import prob_canon ALGEBRA_CANON_INDUCTION)
-
-lemma MEM_NIL_STEP: "~ List.member (map (op # True) l1 @ map (op # False) l2) []"
- by (import prob_canon MEM_NIL_STEP)
-
-lemma ALG_SORTED_PREFIXFREE_MEM_NIL: "(alg_sorted l & alg_prefixfree l & List.member l []) = (l = [[]])"
- by (import prob_canon ALG_SORTED_PREFIXFREE_MEM_NIL)
-
-lemma ALG_SORTED_PREFIXFREE_EQUALITY: "(ALL x. List.member l x = List.member l' x) &
-alg_sorted l & alg_sorted l' & alg_prefixfree l & alg_prefixfree l'
-==> l = l'"
- by (import prob_canon ALG_SORTED_PREFIXFREE_EQUALITY)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" boolean_sequence
-
-consts
- SHD :: "(nat => bool) => bool"
-
-defs
- SHD_primdef: "SHD == %f. f 0"
-
-lemma SHD_def: "SHD f = f 0"
- by (import boolean_sequence SHD_def)
-
-consts
- STL :: "(nat => bool) => nat => bool"
-
-defs
- STL_primdef: "STL == %f n. f (Suc n)"
-
-lemma STL_def: "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)"
- 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))"
- by (import boolean_sequence SDEST_def)
-
-consts
- SCONST :: "bool => nat => bool"
-
-defs
- SCONST_primdef: "SCONST == K"
-
-lemma SCONST_def: "SCONST = K"
- by (import boolean_sequence SCONST_def)
-
-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))"
- 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)"
- by (import boolean_sequence SDROP_def)
-
-lemma SCONS_SURJ: "EX xa t. x = SCONS xa t"
- by (import boolean_sequence SCONS_SURJ)
-
-lemma SHD_STL_ISO: "EX x. SHD x = h & STL x = t"
- by (import boolean_sequence SHD_STL_ISO)
-
-lemma SHD_SCONS: "SHD (SCONS h t) = h"
- by (import boolean_sequence SHD_SCONS)
-
-lemma STL_SCONS: "STL (SCONS h t) = t"
- by (import boolean_sequence STL_SCONS)
-
-lemma SHD_SCONST: "SHD (SCONST b) = b"
- by (import boolean_sequence SHD_SCONST)
-
-lemma STL_SCONST: "STL (SCONST b) = SCONST b"
- by (import boolean_sequence STL_SCONST)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" prob_algebra
-
-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)))"
- 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.
- algebra_embed (h # t) = pred_set.UNION (alg_embed h) (algebra_embed t))"
- by (import prob_algebra algebra_embed_def)
-
-consts
- measurable :: "((nat => bool) => bool) => bool"
-
-defs
- measurable_primdef: "measurable == %s. EX b. s = algebra_embed b"
-
-lemma measurable_def: "measurable s = (EX b. 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"
- by (import prob_algebra HALVES_INTER)
-
-lemma INTER_STL: "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: "COMPL (%x. SHD x = b) = (%x. 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))"
- by (import prob_algebra ALG_EMBED_BASIC)
-
-lemma ALG_EMBED_NIL: "All (alg_embed c) = (c = [])"
- by (import prob_algebra ALG_EMBED_NIL)
-
-lemma ALG_EMBED_POPULATED: "Ex (alg_embed b)"
- by (import prob_algebra ALG_EMBED_POPULATED)
-
-lemma ALG_EMBED_PREFIX: "alg_embed b s & alg_embed c s ==> IS_PREFIX b c | IS_PREFIX c b"
- by (import prob_algebra ALG_EMBED_PREFIX)
-
-lemma ALG_EMBED_PREFIX_SUBSET: "SUBSET (alg_embed b) (alg_embed c) = IS_PREFIX b c"
- by (import prob_algebra ALG_EMBED_PREFIX_SUBSET)
-
-lemma ALG_EMBED_TWINS: "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))"
- by (import prob_algebra ALGEBRA_EMBED_BASIC)
-
-lemma ALGEBRA_EMBED_MEM: "algebra_embed b x ==> EX l. List.member b l & alg_embed l x"
- by (import prob_algebra ALGEBRA_EMBED_MEM)
-
-lemma ALGEBRA_EMBED_APPEND: "algebra_embed (l1 @ l2) =
-pred_set.UNION (algebra_embed l1) (algebra_embed l2)"
- by (import prob_algebra ALGEBRA_EMBED_APPEND)
-
-lemma ALGEBRA_EMBED_TLS: "algebra_embed (map (op # b) l) (SCONS h t) = (h = b & algebra_embed l t)"
- by (import prob_algebra ALGEBRA_EMBED_TLS)
-
-lemma ALG_CANON_PREFS_EMBED: "algebra_embed (alg_canon_prefs l b) = algebra_embed (l # b)"
- by (import prob_algebra ALG_CANON_PREFS_EMBED)
-
-lemma ALG_CANON_FIND_EMBED: "algebra_embed (alg_canon_find l b) = algebra_embed (l # b)"
- by (import prob_algebra ALG_CANON_FIND_EMBED)
-
-lemma ALG_CANON1_EMBED: "algebra_embed (alg_canon1 x) = algebra_embed x"
- by (import prob_algebra ALG_CANON1_EMBED)
-
-lemma ALG_CANON_MERGE_EMBED: "algebra_embed (alg_canon_merge l b) = algebra_embed (l # b)"
- by (import prob_algebra ALG_CANON_MERGE_EMBED)
-
-lemma ALG_CANON2_EMBED: "algebra_embed (alg_canon2 x) = algebra_embed x"
- by (import prob_algebra ALG_CANON2_EMBED)
-
-lemma ALG_CANON_EMBED: "algebra_embed (alg_canon l) = algebra_embed l"
- by (import prob_algebra ALG_CANON_EMBED)
-
-lemma ALGEBRA_CANON_UNIV: "[| algebra_canon l; algebra_embed l = pred_set.UNIV |] ==> l = [[]]"
- by (import prob_algebra ALGEBRA_CANON_UNIV)
-
-lemma ALG_CANON_REP: "(alg_canon b = alg_canon c) = (algebra_embed b = algebra_embed c)"
- by (import prob_algebra ALG_CANON_REP)
-
-lemma ALGEBRA_CANON_EMBED_EMPTY: "algebra_canon l ==> (ALL v. ~ algebra_embed l v) = (l = [])"
- by (import prob_algebra ALGEBRA_CANON_EMBED_EMPTY)
-
-lemma ALGEBRA_CANON_EMBED_UNIV: "algebra_canon l ==> All (algebra_embed l) = (l = [[]])"
- by (import prob_algebra ALGEBRA_CANON_EMBED_UNIV)
-
-lemma MEASURABLE_ALGEBRA: "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))"
- by (import prob_algebra MEASURABLE_BASIC)
-
-lemma MEASURABLE_SHD: "measurable (%s. SHD s = b)"
- by (import prob_algebra MEASURABLE_SHD)
-
-lemma ALGEBRA_EMBED_COMPL: "EX l'. COMPL (algebra_embed l) = algebra_embed l'"
- by (import prob_algebra ALGEBRA_EMBED_COMPL)
-
-lemma MEASURABLE_COMPL: "measurable (COMPL s) = measurable s"
- by (import prob_algebra MEASURABLE_COMPL)
-
-lemma MEASURABLE_UNION: "measurable s & measurable t ==> measurable (pred_set.UNION s t)"
- by (import prob_algebra MEASURABLE_UNION)
-
-lemma MEASURABLE_INTER: "measurable s & measurable t ==> measurable (pred_set.INTER s t)"
- by (import prob_algebra MEASURABLE_INTER)
-
-lemma MEASURABLE_STL: "measurable (p o STL) = measurable p"
- by (import prob_algebra MEASURABLE_STL)
-
-lemma MEASURABLE_SDROP: "measurable (p o SDROP n) = measurable p"
- by (import prob_algebra MEASURABLE_SDROP)
-
-lemma MEASURABLE_INTER_HALVES: "(measurable (pred_set.INTER (%x. SHD x = True) p) &
- measurable (pred_set.INTER (%x. SHD x = False) p)) =
-measurable p"
- by (import prob_algebra MEASURABLE_INTER_HALVES)
-
-lemma MEASURABLE_HALVES: "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))"
- by (import prob_algebra MEASURABLE_HALVES)
-
-lemma MEASURABLE_INTER_SHD: "measurable (pred_set.INTER (%x. SHD x = b) (p o STL)) = measurable p"
- by (import prob_algebra MEASURABLE_INTER_SHD)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" prob
-
-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)"
- by (import prob alg_measure_def)
-
-consts
- algebra_measure :: "bool list list => real"
-
-defs
- algebra_measure_primdef: "algebra_measure ==
-%b. prob_extra.inf
- (%r. EX c. algebra_embed b = algebra_embed c & alg_measure c = r)"
-
-lemma algebra_measure_def: "algebra_measure b =
-prob_extra.inf
- (%r. EX c. algebra_embed b = algebra_embed c & alg_measure c = r)"
- by (import prob algebra_measure_def)
-
-consts
- prob :: "((nat => bool) => bool) => real"
-
-defs
- prob_primdef: "prob ==
-%s. real.sup (%r. EX b. algebra_measure b = r & SUBSET (algebra_embed b) s)"
-
-lemma prob_def: "prob s =
-real.sup (%r. EX b. algebra_measure b = r & SUBSET (algebra_embed b) s)"
- by (import prob prob_def)
-
-lemma ALG_TWINS_MEASURE: "((1::real) / (2::real)) ^ length (SNOC True (l::bool list)) +
-((1::real) / (2::real)) ^ length (SNOC False l) =
-((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)"
- by (import prob ALG_MEASURE_BASIC)
-
-lemma ALG_MEASURE_POS: "0 <= alg_measure l"
- by (import prob ALG_MEASURE_POS)
-
-lemma ALG_MEASURE_APPEND: "alg_measure (l1 @ l2) = alg_measure l1 + alg_measure l2"
- by (import prob ALG_MEASURE_APPEND)
-
-lemma ALG_MEASURE_TLS: "2 * alg_measure (map (op # b) l) = alg_measure l"
- by (import prob ALG_MEASURE_TLS)
-
-lemma ALG_CANON_PREFS_MONO: "alg_measure (alg_canon_prefs l b) <= alg_measure (l # b)"
- by (import prob ALG_CANON_PREFS_MONO)
-
-lemma ALG_CANON_FIND_MONO: "alg_measure (alg_canon_find l b) <= alg_measure (l # b)"
- by (import prob ALG_CANON_FIND_MONO)
-
-lemma ALG_CANON1_MONO: "alg_measure (alg_canon1 x) <= alg_measure x"
- by (import prob ALG_CANON1_MONO)
-
-lemma ALG_CANON_MERGE_MONO: "alg_measure (alg_canon_merge l b) <= alg_measure (l # b)"
- by (import prob ALG_CANON_MERGE_MONO)
-
-lemma ALG_CANON2_MONO: "alg_measure (alg_canon2 x) <= alg_measure x"
- by (import prob ALG_CANON2_MONO)
-
-lemma ALG_CANON_MONO: "alg_measure (alg_canon l) <= alg_measure l"
- by (import prob ALG_CANON_MONO)
-
-lemma ALGEBRA_MEASURE_DEF_ALT: "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)"
- by (import prob ALGEBRA_MEASURE_BASIC)
-
-lemma ALGEBRA_CANON_MEASURE_MAX: "algebra_canon l ==> alg_measure l <= 1"
- by (import prob ALGEBRA_CANON_MEASURE_MAX)
-
-lemma ALGEBRA_MEASURE_MAX: "algebra_measure l <= 1"
- by (import prob ALGEBRA_MEASURE_MAX)
-
-lemma ALGEBRA_MEASURE_MONO_EMBED: "SUBSET (algebra_embed x) (algebra_embed xa)
-==> algebra_measure x <= algebra_measure xa"
- by (import prob ALGEBRA_MEASURE_MONO_EMBED)
-
-lemma ALG_MEASURE_COMPL: "[| algebra_canon l; algebra_canon c;
- COMPL (algebra_embed l) = algebra_embed c |]
-==> alg_measure l + alg_measure c = 1"
- by (import prob ALG_MEASURE_COMPL)
-
-lemma ALG_MEASURE_ADDITIVE: "[| algebra_canon l; algebra_canon c; algebra_canon d;
- pred_set.INTER (algebra_embed c) (algebra_embed d) = EMPTY &
- algebra_embed l = pred_set.UNION (algebra_embed c) (algebra_embed d) |]
-==> alg_measure l = alg_measure c + alg_measure d"
- by (import prob ALG_MEASURE_ADDITIVE)
-
-lemma PROB_ALGEBRA: "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)"
- by (import prob PROB_BASIC)
-
-lemma PROB_ADDITIVE: "measurable s & measurable t & pred_set.INTER s t = EMPTY
-==> prob (pred_set.UNION s t) = prob s + prob t"
- by (import prob PROB_ADDITIVE)
-
-lemma PROB_COMPL: "measurable s ==> prob (COMPL s) = 1 - prob s"
- by (import prob PROB_COMPL)
-
-lemma PROB_SUP_EXISTS1: "EX x b. algebra_measure b = x & SUBSET (algebra_embed b) s"
- by (import prob PROB_SUP_EXISTS1)
-
-lemma PROB_SUP_EXISTS2: "EX x. ALL r.
- (EX b. algebra_measure b = r & SUBSET (algebra_embed b) s) -->
- r <= x"
- by (import prob PROB_SUP_EXISTS2)
-
-lemma PROB_LE_X: "(!!s'. measurable s' & SUBSET s' s ==> prob s' <= x) ==> prob s <= x"
- by (import prob PROB_LE_X)
-
-lemma X_LE_PROB: "EX s'. measurable s' & SUBSET s' s & x <= prob s' ==> x <= prob s"
- by (import prob X_LE_PROB)
-
-lemma PROB_SUBSET_MONO: "SUBSET s t ==> prob s <= prob t"
- by (import prob PROB_SUBSET_MONO)
-
-lemma PROB_ALG: "prob (alg_embed x) = (1 / 2) ^ length x"
- by (import prob PROB_ALG)
-
-lemma PROB_STL: "measurable p ==> prob (p o STL) = prob p"
- by (import prob PROB_STL)
-
-lemma PROB_SDROP: "measurable p ==> prob (p o SDROP n) = prob p"
- by (import prob PROB_SDROP)
-
-lemma PROB_INTER_HALVES: "measurable p
-==> prob (pred_set.INTER (%x. SHD x = True) p) +
- prob (pred_set.INTER (%x. SHD x = False) p) =
- prob p"
- by (import prob PROB_INTER_HALVES)
-
-lemma PROB_INTER_SHD: "measurable p
-==> prob (pred_set.INTER (%x. SHD x = b) (p o STL)) = 1 / 2 * prob p"
- by (import prob PROB_INTER_SHD)
-
-lemma ALGEBRA_MEASURE_POS: "0 <= algebra_measure l"
- by (import prob ALGEBRA_MEASURE_POS)
-
-lemma ALGEBRA_MEASURE_RANGE: "0 <= algebra_measure l & algebra_measure l <= 1"
- by (import prob ALGEBRA_MEASURE_RANGE)
-
-lemma PROB_POS: "0 <= prob p"
- by (import prob PROB_POS)
-
-lemma PROB_MAX: "prob p <= 1"
- by (import prob PROB_MAX)
-
-lemma PROB_RANGE: "0 <= prob p & prob p <= 1"
- by (import prob PROB_RANGE)
-
-lemma ABS_PROB: "abs (prob p) = prob p"
- by (import prob ABS_PROB)
-
-lemma PROB_SHD: "prob (%s. SHD s = b) = 1 / 2"
- by (import prob PROB_SHD)
-
-lemma PROB_COMPL_LE1: "measurable p ==> (prob (COMPL p) <= r) = (1 - r <= prob p)"
- by (import prob PROB_COMPL_LE1)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" prob_pseudo
-
-consts
- pseudo_linear_hd :: "nat => bool"
-
-defs
- pseudo_linear_hd_primdef: "pseudo_linear_hd == EVEN"
-
-lemma pseudo_linear_hd_def: "pseudo_linear_hd = EVEN"
- by (import prob_pseudo pseudo_linear_hd_def)
-
-consts
- 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: "pseudo_linear_tl a b n x = (a * x + b) mod (2 * n + 1)"
- 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))"
- 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.
- STL (pseudo_linear1 x) =
- pseudo_linear1
- (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)))))))
- x))"
- by (import prob_pseudo pseudo_linear1_def)
-
-consts
- pseudo :: "nat => nat => bool"
-
-defs
- pseudo_primdef: "pseudo == pseudo_linear1"
-
-lemma pseudo_def: "pseudo = pseudo_linear1"
- by (import prob_pseudo pseudo_def)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" prob_indep
-
-consts
- indep_set :: "((nat => bool) => bool) => ((nat => bool) => bool) => bool"
-
-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: "indep_set p q =
-(measurable p & measurable q & prob (pred_set.INTER p q) = prob p * prob q)"
- by (import prob_indep indep_set_def)
-
-consts
- alg_cover_set :: "bool list list => bool"
-
-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: "alg_cover_set l =
-(alg_sorted l & alg_prefixfree l & algebra_embed l = pred_set.UNIV)"
- by (import prob_indep alg_cover_set_def)
-
-consts
- alg_cover :: "bool list list => (nat => bool) => bool list"
-
-defs
- alg_cover_primdef: "alg_cover == %l x. SOME b. List.member l b & alg_embed b x"
-
-lemma alg_cover_def: "alg_cover l x = (SOME b. List.member l b & alg_embed b x)"
- by (import prob_indep alg_cover_def)
-
-consts
- indep :: "((nat => bool) => 'a * (nat => bool)) => bool"
-
-defs
- indep_primdef: "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)))"
-
-lemma indep_def: "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))))"
- by (import prob_indep indep_def)
-
-lemma INDEP_SET_BASIC: "measurable p ==> indep_set EMPTY p & indep_set pred_set.UNIV p"
- by (import prob_indep INDEP_SET_BASIC)
-
-lemma INDEP_SET_SYM: "indep_set p q = indep_set p q"
- by (import prob_indep INDEP_SET_SYM)
-
-lemma INDEP_SET_DISJOINT_DECOMP: "indep_set p r & indep_set q r & pred_set.INTER p q = EMPTY
-==> indep_set (pred_set.UNION p q) r"
- by (import prob_indep INDEP_SET_DISJOINT_DECOMP)
-
-lemma ALG_COVER_SET_BASIC: "~ alg_cover_set [] & alg_cover_set [[]] & alg_cover_set [[True], [False]]"
- by (import prob_indep ALG_COVER_SET_BASIC)
-
-lemma ALG_COVER_WELL_DEFINED: "alg_cover_set l
-==> List.member l (alg_cover l x) & alg_embed (alg_cover l x) x"
- by (import prob_indep ALG_COVER_WELL_DEFINED)
-
-lemma ALG_COVER_UNIV: "alg_cover [[]] = K []"
- by (import prob_indep ALG_COVER_UNIV)
-
-lemma MAP_CONS_TL_FILTER: "~ List.member (l::bool list list) []
-==> map (op # (b::bool)) (map tl [x::bool list<-l. hd x = b]) =
- [x::bool list<-l. hd x = b]"
- by (import prob_indep MAP_CONS_TL_FILTER)
-
-lemma ALG_COVER_SET_CASES_THM: "alg_cover_set l =
-(l = [[]] |
- (EX x xa.
- 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)
-
-lemma ALG_COVER_SET_CASES: "[| P [[]] &
- (ALL l1 l2.
- alg_cover_set l1 &
- alg_cover_set l2 &
- alg_cover_set (map (op # True) l1 @ map (op # False) l2) -->
- P (map (op # True) l1 @ map (op # False) l2));
- alg_cover_set l |]
-==> P l"
- by (import prob_indep ALG_COVER_SET_CASES)
-
-lemma ALG_COVER_SET_INDUCTION: "[| P [[]] &
- (ALL l1 l2.
- alg_cover_set l1 &
- alg_cover_set l2 &
- P l1 &
- P l2 & alg_cover_set (map (op # True) l1 @ map (op # False) l2) -->
- P (map (op # True) l1 @ map (op # False) l2));
- alg_cover_set l |]
-==> P l"
- by (import prob_indep ALG_COVER_SET_INDUCTION)
-
-lemma ALG_COVER_EXISTS_UNIQUE: "alg_cover_set l ==> EX! x. List.member l x & alg_embed x s"
- by (import prob_indep ALG_COVER_EXISTS_UNIQUE)
-
-lemma ALG_COVER_UNIQUE: "alg_cover_set l & List.member l x & alg_embed x s ==> alg_cover l s = x"
- by (import prob_indep ALG_COVER_UNIQUE)
-
-lemma ALG_COVER_STEP: "alg_cover_set l1 & alg_cover_set l2
-==> alg_cover (map (op # True) l1 @ map (op # False) l2) (SCONS h t) =
- (if h then True # alg_cover l1 t else False # alg_cover l2 t)"
- by (import prob_indep ALG_COVER_STEP)
-
-lemma ALG_COVER_HEAD: "alg_cover_set l ==> f o alg_cover l = algebra_embed (filter f l)"
- by (import prob_indep ALG_COVER_HEAD)
-
-lemma ALG_COVER_TAIL_STEP: "alg_cover_set l1 & alg_cover_set l2
-==> q o
- (%x. SDROP
- (length (alg_cover (map (op # True) l1 @ map (op # False) l2) x))
- x) =
- pred_set.UNION
- (pred_set.INTER (%x. SHD x = True)
- (q o ((%x. SDROP (length (alg_cover l1 x)) x) o STL)))
- (pred_set.INTER (%x. SHD x = False)
- (q o ((%x. SDROP (length (alg_cover l2 x)) x) o STL)))"
- by (import prob_indep ALG_COVER_TAIL_STEP)
-
-lemma ALG_COVER_TAIL_MEASURABLE: "alg_cover_set l
-==> measurable (q o (%x. SDROP (length (alg_cover l x)) x)) = measurable q"
- by (import prob_indep ALG_COVER_TAIL_MEASURABLE)
-
-lemma ALG_COVER_TAIL_PROB: "[| alg_cover_set l; measurable q |]
-==> prob (q o (%x. SDROP (length (alg_cover l x)) x)) = prob q"
- by (import prob_indep ALG_COVER_TAIL_PROB)
-
-lemma INDEP_INDEP_SET_LEMMA: "[| alg_cover_set l; measurable q; List.member l x |]
-==> prob
- (pred_set.INTER (alg_embed x)
- (q o (%x. SDROP (length (alg_cover l x)) x))) =
- (1 / 2) ^ length x * prob q"
- by (import prob_indep INDEP_INDEP_SET_LEMMA)
-
-lemma INDEP_SET_LIST: "alg_sorted l &
-alg_prefixfree l &
-measurable q & (ALL x. List.member l x --> indep_set (alg_embed x) q)
-==> indep_set (algebra_embed l) q"
- by (import prob_indep INDEP_SET_LIST)
-
-lemma INDEP_INDEP_SET: "indep f & measurable q ==> indep_set (p o (fst o f)) (q o (snd o f))"
- by (import prob_indep INDEP_INDEP_SET)
-
-lemma INDEP_UNIT: "indep (UNIT x)"
- by (import prob_indep INDEP_UNIT)
-
-lemma INDEP_SDEST: "indep SDEST"
- by (import prob_indep INDEP_SDEST)
-
-lemma BIND_STEP: "BIND SDEST (%k. f o SCONS k) = f"
- by (import prob_indep BIND_STEP)
-
-lemma INDEP_BIND_SDEST: "(!!x. indep (f x)) ==> indep (BIND SDEST f)"
- by (import prob_indep INDEP_BIND_SDEST)
-
-lemma INDEP_BIND: "indep f & (ALL x. indep (g x)) ==> indep (BIND f g)"
- by (import prob_indep INDEP_BIND)
-
-lemma INDEP_PROB: "indep f & measurable q
-==> prob (pred_set.INTER (p o (fst o f)) (q o (snd o f))) =
- prob (p o (fst o f)) * prob q"
- by (import prob_indep INDEP_PROB)
-
-lemma INDEP_MEASURABLE1: "indep f ==> measurable (p o (fst o f))"
- by (import prob_indep INDEP_MEASURABLE1)
-
-lemma INDEP_MEASURABLE2: "indep f & measurable q ==> measurable (q o (snd o f))"
- by (import prob_indep INDEP_MEASURABLE2)
-
-lemma PROB_INDEP_BOUND: "indep f
-==> prob (%s. fst (f s) < Suc n) =
- prob (%s. fst (f s) < n) + prob (%s. fst (f s) = n)"
- by (import prob_indep PROB_INDEP_BOUND)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" prob_uniform
-
-consts
- unif_bound :: "nat => nat"
-
-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))))"
-
-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))))"
- 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))"
- by (import prob_uniform unif_bound_def)
-
-lemma unif_bound_ind: "P 0 & (ALL v. P (Suc v div 2) --> P (Suc v)) ==> P x"
- by (import prob_uniform unif_bound_ind)
-
-definition
- unif_tupled :: "nat * (nat => bool) => nat * (nat => bool)" where
- "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'))"
-
-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'))"
- 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: "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'))"
- by (import prob_uniform unif_def)
-
-lemma unif_ind: "All ((P::nat => (nat => bool) => bool) (0::nat)) &
-(ALL (v2::nat) s::nat => bool. P (Suc v2 div (2::nat)) s --> P (Suc v2) s)
-==> P (v::nat) (x::nat => bool)"
- by (import prob_uniform unif_ind)
-
-definition
- uniform_tupled :: "nat * nat * (nat => bool) => nat * (nat => bool)" where
- "uniform_tupled ==
-WFREC
- (SOME R.
- WF R &
- (ALL t s n res s'.
- (res, s') = unif n s & ~ res < Suc n -->
- R (t, Suc n, s') (Suc t, Suc n, s)))
- (%uniform_tupled (v, v1).
- case v of 0 => case v1 of (0, v4) => ARB | (Suc v5, v4) => (0, v4)
- | Suc v2 =>
- case v1 of (0, v8) => ARB
- | (Suc v9, v8) =>
- let (res, s') = unif v9 v8
- in if res < Suc v9 then (res, s')
- else uniform_tupled (v2, Suc v9, s'))"
-
-lemma uniform_tupled_primitive_def: "uniform_tupled =
-WFREC
- (SOME R.
- WF R &
- (ALL t s n res s'.
- (res, s') = unif n s & ~ res < Suc n -->
- R (t, Suc n, s') (Suc t, Suc n, s)))
- (%uniform_tupled (v, v1).
- case v of 0 => case v1 of (0, v4) => ARB | (Suc v5, v4) => (0, v4)
- | Suc v2 =>
- case v1 of (0, v8) => ARB
- | (Suc v9, v8) =>
- let (res, s') = unif v9 v8
- in if res < Suc v9 then (res, s')
- else uniform_tupled (v2, Suc v9, s'))"
- by (import prob_uniform uniform_tupled_primitive_def)
-
-consts
- uniform :: "nat => nat => (nat => bool) => nat * (nat => bool)"
-
-defs
- uniform_primdef: "uniform == %x x1 x2. uniform_tupled (x, x1, x2)"
-
-lemma uniform_curried_def: "uniform x x1 x2 = uniform_tupled (x, x1, x2)"
- by (import prob_uniform uniform_curried_def)
-
-lemma uniform_ind: "(ALL x. All (P (Suc x) 0)) &
-All (P 0 0) &
-(ALL x. All (P 0 (Suc x))) &
-(ALL x xa xb.
- (ALL xc xd.
- (xc, xd) = unif xa xb & ~ xc < Suc xa --> P x (Suc xa) xd) -->
- P (Suc x) (Suc xa) xb)
-==> P x xa xb"
- 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
- 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: "(Suc n div 2 = 0) = (n = 0)"
- by (import prob_uniform SUC_DIV_TWO_ZERO)
-
-lemma UNIF_BOUND_LOWER: "n < 2 ^ unif_bound n"
- by (import prob_uniform UNIF_BOUND_LOWER)
-
-lemma UNIF_BOUND_LOWER_SUC: "Suc n <= 2 ^ unif_bound n"
- by (import prob_uniform UNIF_BOUND_LOWER_SUC)
-
-lemma UNIF_BOUND_UPPER: "n ~= 0 ==> 2 ^ unif_bound n <= 2 * n"
- by (import prob_uniform UNIF_BOUND_UPPER)
-
-lemma UNIF_BOUND_UPPER_SUC: "2 ^ unif_bound n <= Suc (2 * n)"
- by (import prob_uniform UNIF_BOUND_UPPER_SUC)
-
-lemma UNIF_DEF_MONAD: "unif 0 = UNIT 0 &
-(ALL n.
- unif (Suc n) =
- BIND (unif (Suc n div 2))
- (%m. BIND SDEST (%b. UNIT (if b then 2 * m + 1 else 2 * m))))"
- by (import prob_uniform UNIF_DEF_MONAD)
-
-lemma UNIFORM_DEF_MONAD: "(ALL x. uniform 0 (Suc x) = UNIT 0) &
-(ALL x xa.
- uniform (Suc x) (Suc xa) =
- BIND (unif xa) (%m. if m < Suc xa then UNIT m else uniform x (Suc xa)))"
- by (import prob_uniform UNIFORM_DEF_MONAD)
-
-lemma INDEP_UNIF: "indep (unif n)"
- by (import prob_uniform INDEP_UNIF)
-
-lemma INDEP_UNIFORM: "indep (uniform t (Suc n))"
- by (import prob_uniform INDEP_UNIFORM)
-
-lemma PROB_UNIF: "prob (%s. fst (unif n s) = k) =
-(if k < 2 ^ unif_bound n then (1 / 2) ^ unif_bound n else 0)"
- by (import prob_uniform PROB_UNIF)
-
-lemma UNIF_RANGE: "fst (unif n s) < 2 ^ unif_bound n"
- by (import prob_uniform UNIF_RANGE)
-
-lemma PROB_UNIF_PAIR: "(prob (%s. fst (unif n s) = k) = prob (%s. fst (unif n s) = k')) =
-((k < 2 ^ unif_bound n) = (k' < 2 ^ unif_bound n))"
- by (import prob_uniform PROB_UNIF_PAIR)
-
-lemma PROB_UNIF_BOUND: "k <= 2 ^ unif_bound n
-==> prob (%s. fst (unif n s) < k) = real k * (1 / 2) ^ unif_bound n"
- by (import prob_uniform PROB_UNIF_BOUND)
-
-lemma PROB_UNIF_GOOD: "1 / 2 <= prob (%s. fst (unif n s) < Suc n)"
- by (import prob_uniform PROB_UNIF_GOOD)
-
-lemma UNIFORM_RANGE: "fst (uniform t (Suc n) s) < Suc n"
- by (import prob_uniform UNIFORM_RANGE)
-
-lemma PROB_UNIFORM_LOWER_BOUND: "[| !!k. k < Suc n ==> prob (%s. fst (uniform t (Suc n) s) = k) < b;
- m < Suc n |]
-==> prob (%s. fst (uniform t (Suc n) s) < Suc m) < real (Suc m) * b"
- by (import prob_uniform PROB_UNIFORM_LOWER_BOUND)
-
-lemma PROB_UNIFORM_UPPER_BOUND: "[| !!k. k < Suc n ==> b < prob (%s. fst (uniform t (Suc n) s) = k);
- m < Suc n |]
-==> real (Suc m) * b < prob (%s. fst (uniform t (Suc n) s) < Suc m)"
- by (import prob_uniform PROB_UNIFORM_UPPER_BOUND)
-
-lemma PROB_UNIFORM_PAIR_SUC: "k < Suc n & k' < Suc n
-==> abs (prob (%s. fst (uniform t (Suc n) s) = k) -
- prob (%s. fst (uniform t (Suc n) s) = k'))
- <= (1 / 2) ^ t"
- by (import prob_uniform PROB_UNIFORM_PAIR_SUC)
-
-lemma PROB_UNIFORM_SUC: "k < Suc n
-==> abs (prob (%s. fst (uniform t (Suc n) s) = k) - 1 / real (Suc n))
- <= (1 / 2) ^ t"
- by (import prob_uniform PROB_UNIFORM_SUC)
-
-lemma PROB_UNIFORM: "k < n
-==> abs (prob (%s. fst (uniform t n s) = k) - 1 / real n) <= (1 / 2) ^ t"
- by (import prob_uniform PROB_UNIFORM)
-
-;end_setup
-
-end
-
--- a/src/HOL/Import/HOL4/Generated/HOL4Real.thy Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,2950 +0,0 @@
-(* AUTOMATICALLY GENERATED, DO NOT EDIT! *)
-
-theory HOL4Real imports HOL4Base begin
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" realax
-
-lemma HREAL_RDISTRIB: "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: "x ~= hreal_add x y"
- by (import realax HREAL_EQ_ADDL)
-
-lemma HREAL_EQ_LADD: "(hreal_add x y = hreal_add x z) = (y = z)"
- by (import realax HREAL_EQ_LADD)
-
-lemma HREAL_LT_REFL: "~ hreal_lt x x"
- by (import realax HREAL_LT_REFL)
-
-lemma HREAL_LT_ADDL: "hreal_lt x (hreal_add x y)"
- by (import realax HREAL_LT_ADDL)
-
-lemma HREAL_LT_NE: "hreal_lt x y ==> x ~= y"
- by (import realax HREAL_LT_NE)
-
-lemma HREAL_LT_ADDR: "~ hreal_lt (hreal_add x y) x"
- by (import realax HREAL_LT_ADDR)
-
-lemma HREAL_LT_GT: "hreal_lt x y ==> ~ hreal_lt y x"
- by (import realax HREAL_LT_GT)
-
-lemma HREAL_LT_ADD2: "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: "hreal_lt (hreal_add x y) (hreal_add x z) = hreal_lt y z"
- by (import realax HREAL_LT_LADD)
-
-definition
- treal_0 :: "hreal * hreal" where
- "treal_0 == (hreal_1, hreal_1)"
-
-lemma treal_0: "treal_0 = (hreal_1, hreal_1)"
- by (import realax treal_0)
-
-definition
- treal_1 :: "hreal * hreal" where
- "treal_1 == (hreal_add hreal_1 hreal_1, hreal_1)"
-
-lemma treal_1: "treal_1 = (hreal_add hreal_1 hreal_1, hreal_1)"
- by (import realax treal_1)
-
-definition
- treal_neg :: "hreal * hreal => hreal * hreal" where
- "treal_neg == %(x, y). (y, x)"
-
-lemma treal_neg: "treal_neg (x, y) = (y, x)"
- by (import realax treal_neg)
-
-definition
- treal_add :: "hreal * hreal => hreal * hreal => hreal * hreal" where
- "treal_add == %(x1, y1) (x2, y2). (hreal_add x1 x2, hreal_add y1 y2)"
-
-lemma treal_add: "treal_add (x1, y1) (x2, y2) = (hreal_add x1 x2, hreal_add y1 y2)"
- by (import realax treal_add)
-
-definition
- treal_mul :: "hreal * hreal => hreal * hreal => hreal * hreal" where
- "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))"
-
-lemma treal_mul: "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))"
- by (import realax treal_mul)
-
-definition
- treal_lt :: "hreal * hreal => hreal * hreal => bool" where
- "treal_lt == %(x1, y1) (x2, y2). hreal_lt (hreal_add x1 y2) (hreal_add x2 y1)"
-
-lemma treal_lt: "treal_lt (x1, y1) (x2, y2) = hreal_lt (hreal_add x1 y2) (hreal_add x2 y1)"
- by (import realax treal_lt)
-
-definition
- treal_inv :: "hreal * hreal => hreal * hreal" where
- "treal_inv ==
-%(x, y).
- 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: "treal_inv (x, y) =
-(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))"
- by (import realax treal_inv)
-
-definition
- treal_eq :: "hreal * hreal => hreal * hreal => bool" where
- "treal_eq == %(x1, y1) (x2, y2). hreal_add x1 y2 = hreal_add x2 y1"
-
-lemma treal_eq: "treal_eq (x1, y1) (x2, y2) = (hreal_add x1 y2 = hreal_add x2 y1)"
- by (import realax treal_eq)
-
-lemma TREAL_EQ_REFL: "treal_eq x x"
- by (import realax TREAL_EQ_REFL)
-
-lemma TREAL_EQ_SYM: "treal_eq x y = treal_eq y x"
- by (import realax TREAL_EQ_SYM)
-
-lemma TREAL_EQ_TRANS: "treal_eq x y & treal_eq y z ==> treal_eq x z"
- by (import realax TREAL_EQ_TRANS)
-
-lemma TREAL_EQ_EQUIV: "treal_eq p q = (treal_eq p = treal_eq q)"
- by (import realax TREAL_EQ_EQUIV)
-
-lemma TREAL_EQ_AP: "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: "treal_add x y = treal_add y x"
- by (import realax TREAL_ADD_SYM)
-
-lemma TREAL_MUL_SYM: "treal_mul x y = treal_mul y x"
- by (import realax TREAL_MUL_SYM)
-
-lemma TREAL_ADD_ASSOC: "treal_add x (treal_add y z) = treal_add (treal_add x y) z"
- by (import realax TREAL_ADD_ASSOC)
-
-lemma TREAL_MUL_ASSOC: "treal_mul x (treal_mul y z) = treal_mul (treal_mul x y) z"
- by (import realax TREAL_MUL_ASSOC)
-
-lemma TREAL_LDISTRIB: "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: "treal_eq (treal_add treal_0 x) x"
- by (import realax TREAL_ADD_LID)
-
-lemma TREAL_MUL_LID: "treal_eq (treal_mul treal_1 x) x"
- by (import realax TREAL_MUL_LID)
-
-lemma TREAL_ADD_LINV: "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: "~ 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: "treal_eq x y | treal_lt x y | treal_lt y x"
- by (import realax TREAL_LT_TOTAL)
-
-lemma TREAL_LT_REFL: "~ treal_lt x x"
- by (import realax TREAL_LT_REFL)
-
-lemma TREAL_LT_TRANS: "treal_lt x y & treal_lt y z ==> treal_lt x z"
- by (import realax TREAL_LT_TRANS)
-
-lemma TREAL_LT_ADD: "treal_lt y z ==> treal_lt (treal_add x y) (treal_add x z)"
- by (import realax TREAL_LT_ADD)
-
-lemma TREAL_LT_MUL: "treal_lt treal_0 x & treal_lt treal_0 y ==> treal_lt treal_0 (treal_mul x y)"
- by (import realax TREAL_LT_MUL)
-
-definition
- treal_of_hreal :: "hreal => hreal * hreal" where
- "treal_of_hreal == %x. (hreal_add x hreal_1, hreal_1)"
-
-lemma treal_of_hreal: "treal_of_hreal x = (hreal_add x hreal_1, hreal_1)"
- by (import realax treal_of_hreal)
-
-definition
- hreal_of_treal :: "hreal * hreal => hreal" where
- "hreal_of_treal == %(x, y). SOME d. x = hreal_add y d"
-
-lemma hreal_of_treal: "hreal_of_treal (x, y) = (SOME d. 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)"
- by (import realax TREAL_BIJ)
-
-lemma TREAL_ISO: "hreal_lt h i ==> treal_lt (treal_of_hreal h) (treal_of_hreal i)"
- by (import realax TREAL_ISO)
-
-lemma TREAL_BIJ_WELLDEF: "treal_eq h i ==> hreal_of_treal h = hreal_of_treal i"
- by (import realax TREAL_BIJ_WELLDEF)
-
-lemma TREAL_NEG_WELLDEF: "treal_eq x1 x2 ==> treal_eq (treal_neg x1) (treal_neg x2)"
- by (import realax TREAL_NEG_WELLDEF)
-
-lemma TREAL_ADD_WELLDEFR: "treal_eq x1 x2 ==> treal_eq (treal_add x1 y) (treal_add x2 y)"
- by (import realax TREAL_ADD_WELLDEFR)
-
-lemma TREAL_ADD_WELLDEF: "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: "treal_eq x1 x2 ==> treal_eq (treal_mul x1 y) (treal_mul x2 y)"
- by (import realax TREAL_MUL_WELLDEFR)
-
-lemma TREAL_MUL_WELLDEF: "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: "treal_eq x1 x2 ==> treal_lt x1 y = treal_lt x2 y"
- by (import realax TREAL_LT_WELLDEFR)
-
-lemma TREAL_LT_WELLDEFL: "treal_eq y1 y2 ==> treal_lt x y1 = treal_lt x y2"
- by (import realax TREAL_LT_WELLDEFL)
-
-lemma TREAL_LT_WELLDEF: "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: "treal_eq x1 x2 ==> treal_eq (treal_inv x1) (treal_inv x2)"
- by (import realax TREAL_INV_WELLDEF)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" real
-
-lemma REAL_0: "(0::real) = (0::real)"
- by (import real REAL_0)
-
-lemma REAL_1: "(1::real) = (1::real)"
- by (import real REAL_1)
-
-lemma REAL_ADD_LID_UNIQ: "((x::real) + (y::real) = y) = (x = (0::real))"
- by (import real REAL_ADD_LID_UNIQ)
-
-lemma REAL_ADD_RID_UNIQ: "((x::real) + (y::real) = x) = (y = (0::real))"
- by (import real REAL_ADD_RID_UNIQ)
-
-lemma REAL_LT_ANTISYM: "~ ((x::real) < (y::real) & y < x)"
- by (import real REAL_LT_ANTISYM)
-
-lemma REAL_LTE_TOTAL: "(x::real) < (y::real) | y <= x"
- by (import real REAL_LTE_TOTAL)
-
-lemma REAL_LET_ANTISYM: "~ ((x::real) < (y::real) & y <= x)"
- by (import real REAL_LET_ANTISYM)
-
-lemma REAL_LTE_ANTSYM: "~ ((x::real) <= (y::real) & y < x)"
- by (import real REAL_LTE_ANTSYM)
-
-lemma REAL_LT_NEGTOTAL: "(x::real) = (0::real) | (0::real) < x | (0::real) < - x"
- by (import real REAL_LT_NEGTOTAL)
-
-lemma REAL_LE_NEGTOTAL: "(0::real) <= (x::real) | (0::real) <= - x"
- by (import real REAL_LE_NEGTOTAL)
-
-lemma REAL_LT_ADDNEG: "((y::real) < (x::real) + - (z::real)) = (y + z < x)"
- by (import real REAL_LT_ADDNEG)
-
-lemma REAL_LT_ADDNEG2: "((x::real) + - (y::real) < (z::real)) = (x < z + y)"
- by (import real REAL_LT_ADDNEG2)
-
-lemma REAL_LT_ADD1: "(x::real) <= (y::real) ==> x < y + (1::real)"
- by (import real REAL_LT_ADD1)
-
-lemma REAL_SUB_ADD2: "(y::real) + ((x::real) - y) = x"
- by (import real REAL_SUB_ADD2)
-
-lemma REAL_SUB_LT: "((0::real) < (x::real) - (y::real)) = (y < x)"
- by (import real REAL_SUB_LT)
-
-lemma REAL_SUB_LE: "((0::real) <= (x::real) - (y::real)) = (y <= x)"
- by (import real REAL_SUB_LE)
-
-lemma REAL_ADD_SUB: "(x::real) + (y::real) - x = y"
- by (import real REAL_ADD_SUB)
-
-lemma REAL_NEG_EQ: "(- (x::real) = (y::real)) = (x = - y)"
- by (import real REAL_NEG_EQ)
-
-lemma REAL_LT_LMUL_0: "(0::real) < (x::real) ==> ((0::real) < x * (y::real)) = ((0::real) < y)"
- by (import real REAL_LT_LMUL_0)
-
-lemma REAL_LT_RMUL_0: "(0::real) < (y::real) ==> ((0::real) < (x::real) * y) = ((0::real) < x)"
- by (import real REAL_LT_RMUL_0)
-
-lemma REAL_LINV_UNIQ: "(x::real) * (y::real) = (1::real) ==> x = inverse y"
- by (import real REAL_LINV_UNIQ)
-
-lemma REAL_LE_INV: "(0::real) <= (x::real) ==> (0::real) <= inverse x"
- by (import real REAL_LE_INV)
-
-lemma REAL_LE_ADDR: "((x::real) <= x + (y::real)) = ((0::real) <= y)"
- by (import real REAL_LE_ADDR)
-
-lemma REAL_LE_ADDL: "((y::real) <= (x::real) + y) = ((0::real) <= x)"
- by (import real REAL_LE_ADDL)
-
-lemma REAL_LT_ADDR: "((x::real) < x + (y::real)) = ((0::real) < y)"
- by (import real REAL_LT_ADDR)
-
-lemma REAL_LT_ADDL: "((y::real) < (x::real) + y) = ((0::real) < x)"
- by (import real REAL_LT_ADDL)
-
-lemma REAL_LT_NZ: "(real (n::nat) ~= (0::real)) = ((0::real) < real n)"
- by (import real REAL_LT_NZ)
-
-lemma REAL_NZ_IMP_LT: "(n::nat) ~= (0::nat) ==> (0::real) < real n"
- by (import real REAL_NZ_IMP_LT)
-
-lemma REAL_LT_RDIV_0: "(0::real) < (z::real) ==> ((0::real) < (y::real) / z) = ((0::real) < y)"
- by (import real REAL_LT_RDIV_0)
-
-lemma REAL_LT_RDIV: "(0::real) < (z::real) ==> ((x::real) / z < (y::real) / z) = (x < y)"
- by (import real REAL_LT_RDIV)
-
-lemma REAL_LT_FRACTION_0: "(n::nat) ~= (0::nat) ==> ((0::real) < (d::real) / real n) = ((0::real) < d)"
- by (import real REAL_LT_FRACTION_0)
-
-lemma REAL_LT_MULTIPLE: "(1::nat) < (x::nat) ==> ((xa::real) < real x * xa) = ((0::real) < xa)"
- by (import real REAL_LT_MULTIPLE)
-
-lemma REAL_LT_FRACTION: "(1::nat) < (n::nat) ==> ((d::real) / real n < d) = ((0::real) < d)"
- by (import real REAL_LT_FRACTION)
-
-lemma REAL_LT_HALF2: "((d::real) / (2::real) < d) = ((0::real) < d)"
- by (import real REAL_LT_HALF2)
-
-lemma REAL_DIV_LMUL: "(y::real) ~= (0::real) ==> y * ((x::real) / y) = x"
- by (import real REAL_DIV_LMUL)
-
-lemma REAL_DIV_RMUL: "(y::real) ~= (0::real) ==> (x::real) / y * y = x"
- by (import real REAL_DIV_RMUL)
-
-lemma REAL_DOWN: "(0::real) < (x::real) ==> EX xa>0::real. xa < x"
- by (import real REAL_DOWN)
-
-lemma REAL_SUB_SUB: "(x::real) - (y::real) - x = - y"
- by (import real REAL_SUB_SUB)
-
-lemma REAL_SUB_LNEG: "- (x::real) - (y::real) = - (x + y)"
- by (import real REAL_SUB_LNEG)
-
-lemma REAL_SUB_NEG2: "- (x::real) - - (y::real) = y - x"
- by (import real REAL_SUB_NEG2)
-
-lemma REAL_SUB_TRIANGLE: "(a::real) - (b::real) + (b - (c::real)) = a - c"
- by (import real REAL_SUB_TRIANGLE)
-
-lemma REAL_INV_MUL: "(x::real) ~= (0::real) & (y::real) ~= (0::real)
-==> inverse (x * y) = inverse x * inverse y"
- by (import real REAL_INV_MUL)
-
-lemma REAL_SUB_INV2: "(x::real) ~= (0::real) & (y::real) ~= (0::real)
-==> inverse x - inverse y = (y - x) / (x * y)"
- by (import real REAL_SUB_INV2)
-
-lemma REAL_SUB_SUB2: "(x::real) - (x - (y::real)) = y"
- by (import real REAL_SUB_SUB2)
-
-lemma REAL_ADD_SUB2: "(x::real) - (x + (y::real)) = - y"
- by (import real REAL_ADD_SUB2)
-
-lemma REAL_LE_DIV: "(0::real) <= (x::real) & (0::real) <= (xa::real) ==> (0::real) <= x / xa"
- by (import real REAL_LE_DIV)
-
-lemma REAL_LT_1: "(0::real) <= (x::real) & x < (y::real) ==> x / y < (1::real)"
- by (import real REAL_LT_1)
-
-lemma REAL_POS_NZ: "(0::real) < (x::real) ==> x ~= (0::real)"
- by (import real REAL_POS_NZ)
-
-lemma REAL_EQ_RMUL_IMP: "(z::real) ~= (0::real) & (x::real) * z = (y::real) * z ==> x = y"
- by (import real REAL_EQ_RMUL_IMP)
-
-lemma REAL_EQ_LMUL_IMP: "(x::real) ~= (0::real) & x * (xa::real) = x * (xb::real) ==> xa = xb"
- by (import real REAL_EQ_LMUL_IMP)
-
-lemma REAL_FACT_NZ: "real (FACT n) ~= 0"
- by (import real REAL_FACT_NZ)
-
-lemma REAL_POASQ: "((0::real) < (x::real) * x) = (x ~= (0::real))"
- by (import real REAL_POASQ)
-
-lemma REAL_DIV_MUL2: "(x::real) ~= (0::real) & (z::real) ~= (0::real)
-==> (y::real) / z = x * y / (x * z)"
- by (import real REAL_DIV_MUL2)
-
-lemma REAL_MIDDLE1: "(a::real) <= (b::real) ==> a <= (a + b) / (2::real)"
- by (import real REAL_MIDDLE1)
-
-lemma REAL_MIDDLE2: "(a::real) <= (b::real) ==> (a + b) / (2::real) <= b"
- by (import real REAL_MIDDLE2)
-
-lemma ABS_LT_MUL2: "abs (w::real) < (y::real) & abs (x::real) < (z::real)
-==> abs (w * x) < y * z"
- by (import real ABS_LT_MUL2)
-
-lemma ABS_REFL: "(abs (x::real) = x) = ((0::real) <= x)"
- by (import real ABS_REFL)
-
-lemma ABS_BETWEEN: "((0::real) < (d::real) & (x::real) - d < (y::real) & y < x + d) =
-(abs (y - x) < d)"
- by (import real ABS_BETWEEN)
-
-lemma ABS_BOUND: "abs ((x::real) - (y::real)) < (d::real) ==> y < x + d"
- by (import real ABS_BOUND)
-
-lemma ABS_STILLNZ: "abs ((x::real) - (y::real)) < abs y ==> x ~= (0::real)"
- by (import real ABS_STILLNZ)
-
-lemma ABS_CASES: "(x::real) = (0::real) | (0::real) < abs x"
- by (import real ABS_CASES)
-
-lemma ABS_BETWEEN1: "(x::real) < (z::real) & abs ((y::real) - x) < z - x ==> y < z"
- by (import real ABS_BETWEEN1)
-
-lemma ABS_SIGN: "abs ((x::real) - (y::real)) < y ==> (0::real) < x"
- by (import real ABS_SIGN)
-
-lemma ABS_SIGN2: "abs ((x::real) - (y::real)) < - y ==> x < (0::real)"
- by (import real ABS_SIGN2)
-
-lemma ABS_CIRCLE: "abs (h::real) < abs (y::real) - abs (x::real) ==> abs (x + h) < abs y"
- by (import real ABS_CIRCLE)
-
-lemma ABS_BETWEEN2: "(x0::real) < (y0::real) &
-abs ((x::real) - x0) < (y0 - x0) / (2::real) &
-abs ((y::real) - y0) < (y0 - x0) / (2::real)
-==> x < y"
- by (import real ABS_BETWEEN2)
-
-lemma POW_PLUS1: "0 < e ==> 1 + real n * e <= (1 + e) ^ n"
- by (import real POW_PLUS1)
-
-lemma POW_M1: "abs ((- (1::real)) ^ (n::nat)) = (1::real)"
- by (import real POW_M1)
-
-lemma REAL_LE1_POW2: "(1::real) <= (x::real) ==> (1::real) <= x ^ (2::nat)"
- by (import real REAL_LE1_POW2)
-
-lemma REAL_LT1_POW2: "(1::real) < (x::real) ==> (1::real) < x ^ (2::nat)"
- by (import real REAL_LT1_POW2)
-
-lemma POW_POS_LT: "(0::real) < (x::real) ==> (0::real) < x ^ Suc (n::nat)"
- by (import real POW_POS_LT)
-
-lemma POW_LT: "(0::real) <= (x::real) & x < (y::real) ==> x ^ Suc (n::nat) < y ^ Suc n"
- by (import real POW_LT)
-
-lemma POW_ZERO: "(x::real) ^ (n::nat) = (0::real) ==> x = (0::real)"
- by (import real POW_ZERO)
-
-lemma POW_ZERO_EQ: "((x::real) ^ Suc (n::nat) = (0::real)) = (x = (0::real))"
- by (import real POW_ZERO_EQ)
-
-lemma REAL_POW_LT2: "(n::nat) ~= (0::nat) & (0::real) <= (x::real) & x < (y::real)
-==> x ^ n < y ^ n"
- by (import real REAL_POW_LT2)
-
-lemma REAL_POW_MONO_LT: "(1::real) < (x::real) & (m::nat) < (n::nat) ==> x ^ m < x ^ n"
- by (import real REAL_POW_MONO_LT)
-
-lemma REAL_SUP_SOMEPOS: "(EX x::real. (P::real => bool) x & (0::real) < x) &
-(EX z::real. ALL x::real. P x --> x < z)
-==> EX s::real. ALL y::real. (EX x::real. P x & y < x) = (y < s)"
- by (import real REAL_SUP_SOMEPOS)
-
-lemma SUP_LEMMA1: "(!!y::real.
- (EX x::real. (P::real => bool) (x + (d::real)) & y < x) =
- (y < (s::real)))
-==> (EX x::real. P x & (y::real) < x) = (y < s + d)"
- by (import real SUP_LEMMA1)
-
-lemma SUP_LEMMA2: "Ex (P::real => bool) ==> EX (d::real) x::real. P (x + d) & (0::real) < x"
- by (import real SUP_LEMMA2)
-
-lemma SUP_LEMMA3: "EX z::real. ALL x::real. (P::real => bool) x --> x < z
-==> EX x::real. ALL xa::real. P (xa + (d::real)) --> xa < x"
- by (import real SUP_LEMMA3)
-
-lemma REAL_SUP_EXISTS: "Ex (P::real => bool) & (EX z::real. ALL x::real. P x --> x < z)
-==> EX x::real. ALL y::real. (EX x::real. P x & y < x) = (y < x)"
- by (import real REAL_SUP_EXISTS)
-
-consts
- sup :: "(real => bool) => real"
-
-defs
- sup_def: "real.sup == %P. SOME s. ALL y. (EX x. P x & y < x) = (y < s)"
-
-lemma sup: "real.sup P = (SOME s. ALL y. (EX x. P x & y < x) = (y < s))"
- by (import real sup)
-
-lemma REAL_SUP: "Ex P & (EX z. ALL x. P x --> x < z)
-==> (EX x. P x & y < x) = (y < real.sup P)"
- by (import real REAL_SUP)
-
-lemma REAL_SUP_UBOUND: "[| Ex P & (EX z. ALL x. P x --> x < z); P y |] ==> y <= real.sup P"
- by (import real REAL_SUP_UBOUND)
-
-lemma SETOK_LE_LT: "(Ex (P::real => bool) & (EX z::real. ALL x::real. P x --> x <= z)) =
-(Ex P & (EX z::real. ALL x::real. P x --> x < z))"
- by (import real SETOK_LE_LT)
-
-lemma REAL_SUP_LE: "Ex P & (EX z. ALL x. P x --> x <= z)
-==> (EX x. P x & y < x) = (y < real.sup P)"
- by (import real REAL_SUP_LE)
-
-lemma REAL_SUP_UBOUND_LE: "[| Ex P & (EX z. ALL x. P x --> x <= z); P y |] ==> y <= real.sup P"
- by (import real REAL_SUP_UBOUND_LE)
-
-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))"
- by (import real sumc)
-
-consts
- sum :: "nat * nat => (nat => real) => real"
-
-defs
- sum_def: "real.sum == %(x, y). sumc x y"
-
-lemma SUM_DEF: "real.sum (m, n) f = sumc m n f"
- by (import real SUM_DEF)
-
-lemma sum: "real.sum (xa, 0) x = 0 &
-real.sum (xa, Suc xb) x = real.sum (xa, xb) x + x (xa + xb)"
- by (import real sum)
-
-lemma SUM_TWO: "real.sum (0, n) f + real.sum (n, p) f = real.sum (0, n + p) f"
- by (import real SUM_TWO)
-
-lemma SUM_DIFF: "real.sum (m, n) f = real.sum (0, m + n) f - real.sum (0, m) f"
- by (import real SUM_DIFF)
-
-lemma ABS_SUM: "abs (real.sum (m, n) f) <= real.sum (m, n) (%n. abs (f n))"
- by (import real ABS_SUM)
-
-lemma SUM_LE: "(!!r. 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: "(!!r. 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: "(!!n. 0 <= f n) ==> 0 <= real.sum (m, n) f"
- by (import real SUM_POS)
-
-lemma SUM_POS_GEN: "(!!n. m <= n ==> 0 <= f n) ==> 0 <= real.sum (m, n) f"
- by (import real SUM_POS_GEN)
-
-lemma SUM_ABS: "abs (real.sum (m, x) (%m. abs (f m))) = real.sum (m, x) (%m. abs (f m))"
- by (import real SUM_ABS)
-
-lemma SUM_ABS_LE: "abs (real.sum (m, n) f) <= real.sum (m, n) (%n. abs (f n))"
- by (import real SUM_ABS_LE)
-
-lemma SUM_ZERO: "[| !!n. N <= n ==> f n = 0; N <= m |] ==> real.sum (m, n) f = 0"
- by (import real SUM_ZERO)
-
-lemma SUM_ADD: "real.sum (m, n) (%n. f n + g n) = real.sum (m, n) f + real.sum (m, n) g"
- by (import real SUM_ADD)
-
-lemma SUM_CMUL: "real.sum (m, n) (%n. c * f n) = c * real.sum (m, n) f"
- by (import real SUM_CMUL)
-
-lemma SUM_NEG: "real.sum (n, d) (%n. - f n) = - real.sum (n, d) f"
- by (import real SUM_NEG)
-
-lemma SUM_SUB: "real.sum (m, n) (%x. f x - g x) = real.sum (m, n) f - real.sum (m, n) g"
- by (import real SUM_SUB)
-
-lemma SUM_SUBST: "(!!p. 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: "real.sum (0, n) f - real n * c = real.sum (0, n) (%p. f p - c)"
- by (import real SUM_NSUB)
-
-lemma SUM_BOUND: "(!!p. m <= p & p < m + n ==> f p <= k) ==> real.sum (m, n) f <= real n * k"
- by (import real SUM_BOUND)
-
-lemma SUM_GROUP: "real.sum (0, n) (%m. real.sum (m * k, k) f) = real.sum (0, n * k) f"
- by (import real SUM_GROUP)
-
-lemma SUM_1: "real.sum (n, 1) f = f n"
- by (import real SUM_1)
-
-lemma SUM_2: "real.sum (n, 2) f = f n + f (n + 1)"
- by (import real SUM_2)
-
-lemma SUM_OFFSET: "real.sum (0, n) (%m. f (m + k)) = real.sum (0, n + k) f - real.sum (0, k) f"
- by (import real SUM_OFFSET)
-
-lemma SUM_REINDEX: "real.sum (m + k, n) f = real.sum (m, n) (%r. f (r + k))"
- by (import real SUM_REINDEX)
-
-lemma SUM_0: "real.sum (m, n) (%r. 0) = 0"
- by (import real SUM_0)
-
-lemma SUM_PERMUTE_0: "(!!y. y < n ==> EX! x. x < n & p x = y)
-==> real.sum (0, n) (%n. f (p n)) = real.sum (0, n) f"
- by (import real SUM_PERMUTE_0)
-
-lemma SUM_CANCEL: "real.sum (n, d) (%n. f (Suc n) - f n) = f (n + d) - f n"
- by (import real SUM_CANCEL)
-
-lemma REAL_LE_RNEG: "((x::real) <= - (y::real)) = (x + y <= (0::real))"
- by (import real REAL_LE_RNEG)
-
-lemma REAL_EQ_RDIV_EQ: "(0::real) < (xb::real) ==> ((x::real) = (xa::real) / xb) = (x * xb = xa)"
- by (import real REAL_EQ_RDIV_EQ)
-
-lemma REAL_EQ_LDIV_EQ: "(0::real) < (xb::real) ==> ((x::real) / xb = (xa::real)) = (x = xa * xb)"
- by (import real REAL_EQ_LDIV_EQ)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" topology
-
-definition
- re_Union :: "(('a => bool) => bool) => 'a => bool" where
- "re_Union == %P x. EX s. P s & s x"
-
-lemma re_Union: "re_Union P = (%x. EX s. P s & s x)"
- by (import topology re_Union)
-
-definition
- re_union :: "('a => bool) => ('a => bool) => 'a => bool" where
- "re_union == %P Q x. P x | Q x"
-
-lemma re_union: "re_union P Q = (%x. P x | Q x)"
- by (import topology re_union)
-
-definition
- re_intersect :: "('a => bool) => ('a => bool) => 'a => bool" where
- "re_intersect == %P Q x. P x & Q x"
-
-lemma re_intersect: "re_intersect P Q = (%x. P x & Q x)"
- by (import topology re_intersect)
-
-definition
- re_null :: "'a => bool" where
- "re_null == %x. False"
-
-lemma re_null: "re_null = (%x. False)"
- by (import topology re_null)
-
-definition
- re_universe :: "'a => bool" where
- "re_universe == %x. True"
-
-lemma re_universe: "re_universe = (%x. True)"
- by (import topology re_universe)
-
-definition
- re_subset :: "('a => bool) => ('a => bool) => bool" where
- "re_subset == %P Q. ALL x. P x --> Q x"
-
-lemma re_subset: "re_subset P Q = (ALL x. P x --> Q x)"
- by (import topology re_subset)
-
-definition
- re_compl :: "('a => bool) => 'a => bool" where
- "re_compl == %P x. ~ P x"
-
-lemma re_compl: "re_compl P = (%x. ~ P x)"
- by (import topology re_compl)
-
-lemma SUBSET_REFL: "re_subset P P"
- by (import topology SUBSET_REFL)
-
-lemma COMPL_MEM: "P x = (~ re_compl P x)"
- by (import topology COMPL_MEM)
-
-lemma SUBSET_ANTISYM: "(re_subset P Q & re_subset Q P) = (P = Q)"
- by (import topology SUBSET_ANTISYM)
-
-lemma SUBSET_TRANS: "re_subset P Q & re_subset Q R ==> re_subset P R"
- by (import topology SUBSET_TRANS)
-
-definition
- istopology :: "(('a => bool) => bool) => bool" where
- "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: "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)))"
- by (import topology istopology)
-
-typedef (open) ('a) topology = "Collect istopology::(('a::type => bool) => bool) set"
- 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 (topology.open a) = a) &
-(ALL r::('a => bool) => bool.
- istopology r = (topology.open (topology r) = r))"
- by (import topology topology_tybij)
-
-lemma TOPOLOGY: "topology.open L re_null &
-topology.open L re_universe &
-(ALL a b.
- topology.open L a & topology.open L b -->
- topology.open L (re_intersect a b)) &
-(ALL P. re_subset P (topology.open L) --> topology.open L (re_Union P))"
- by (import topology TOPOLOGY)
-
-lemma TOPOLOGY_UNION: "re_subset xa (topology.open x) ==> topology.open x (re_Union xa)"
- by (import topology TOPOLOGY_UNION)
-
-definition
- neigh :: "'a topology => ('a => bool) * 'a => bool" where
- "neigh == %tp (N, x). EX P. topology.open tp P & re_subset P N & P x"
-
-lemma neigh: "neigh (tp::'a::type topology) (N::'a::type => bool, x::'a::type) =
-(EX P::'a::type => bool. topology.open tp P & re_subset P N & P x)"
- by (import topology neigh)
-
-lemma OPEN_OWN_NEIGH: "topology.open (tp::'a::type topology) (S'::'a::type => bool) &
-S' (x::'a::type)
-==> neigh tp (S', x)"
- by (import topology OPEN_OWN_NEIGH)
-
-lemma OPEN_UNOPEN: "topology.open (tp::'a::type topology) (S'::'a::type => bool) =
-(re_Union (%P::'a::type => bool. topology.open tp P & re_subset P S') = S')"
- by (import topology OPEN_UNOPEN)
-
-lemma OPEN_SUBOPEN: "topology.open (tp::'a::type topology) (S'::'a::type => bool) =
-(ALL x::'a::type.
- S' x -->
- (EX P::'a::type => bool. P x & topology.open tp P & re_subset P S'))"
- by (import topology OPEN_SUBOPEN)
-
-lemma OPEN_NEIGH: "topology.open (tp::'a::type topology) (S'::'a::type => bool) =
-(ALL x::'a::type.
- S' x --> (EX N::'a::type => bool. neigh tp (N, x) & re_subset N S'))"
- by (import topology OPEN_NEIGH)
-
-consts
- closed :: "'a topology => ('a => bool) => bool"
-
-defs
- closed_def: "topology.closed == %L S'. topology.open L (re_compl S')"
-
-lemma closed: "topology.closed L S' = topology.open L (re_compl S')"
- by (import topology closed)
-
-definition
- limpt :: "'a topology => 'a => ('a => bool) => bool" where
- "limpt == %tp x S'. ALL N. neigh tp (N, x) --> (EX y. x ~= y & S' y & N y)"
-
-lemma limpt: "limpt (tp::'a::type topology) (x::'a::type) (S'::'a::type => bool) =
-(ALL N::'a::type => bool.
- neigh tp (N, x) --> (EX y::'a::type. x ~= y & S' y & N y))"
- by (import topology limpt)
-
-lemma CLOSED_LIMPT: "topology.closed (tp::'a::type topology) (S'::'a::type => bool) =
-(ALL x::'a::type. limpt tp x S' --> S' x)"
- by (import topology CLOSED_LIMPT)
-
-definition
- ismet :: "('a * 'a => real) => bool" where
- "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: "ismet m =
-((ALL x y. (m (x, y) = 0) = (x = y)) &
- (ALL x y z. m (y, z) <= m (x, y) + m (x, z)))"
- by (import topology ismet)
-
-typedef (open) ('a) metric = "Collect ismet :: ('a::type * 'a::type => real) set"
- 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 (topology.dist a) = a) &
-(ALL r::'a * 'a => real. ismet r = (topology.dist (metric r) = r))"
- by (import topology metric_tybij)
-
-lemma METRIC_ISMET: "ismet (topology.dist m)"
- by (import topology METRIC_ISMET)
-
-lemma METRIC_ZERO: "(topology.dist m (x, y) = 0) = (x = y)"
- by (import topology METRIC_ZERO)
-
-lemma METRIC_SAME: "topology.dist m (x, x) = 0"
- by (import topology METRIC_SAME)
-
-lemma METRIC_POS: "0 <= topology.dist m (x, y)"
- by (import topology METRIC_POS)
-
-lemma METRIC_SYM: "topology.dist m (x, y) = topology.dist m (y, x)"
- by (import topology METRIC_SYM)
-
-lemma METRIC_TRIANGLE: "topology.dist m (x, z) <= topology.dist m (x, y) + topology.dist m (y, z)"
- by (import topology METRIC_TRIANGLE)
-
-lemma METRIC_NZ: "x ~= y ==> 0 < topology.dist m (x, y)"
- by (import topology METRIC_NZ)
-
-definition
- mtop :: "'a metric => 'a topology" where
- "mtop ==
-%m. topology
- (%S'. ALL x.
- S' x --> (EX e>0. ALL y. topology.dist m (x, y) < e --> S' y))"
-
-lemma mtop: "mtop m =
-topology
- (%S'. ALL x. S' x --> (EX e>0. ALL y. topology.dist m (x, y) < e --> S' y))"
- by (import topology mtop)
-
-lemma mtop_istopology: "istopology
- (%S'. ALL x. S' x --> (EX e>0. ALL y. topology.dist m (x, y) < e --> S' y))"
- by (import topology mtop_istopology)
-
-lemma MTOP_OPEN: "topology.open (mtop x) S' =
-(ALL xa. S' xa --> (EX e>0. ALL y. topology.dist x (xa, y) < e --> S' y))"
- by (import topology MTOP_OPEN)
-
-definition
- B :: "'a metric => 'a * real => 'a => bool" where
- "B == %m (x, e) y. topology.dist m (x, y) < e"
-
-lemma ball: "B m (x, e) = (%y. topology.dist m (x, y) < e)"
- by (import topology ball)
-
-lemma BALL_OPEN: "0 < e ==> topology.open (mtop m) (B m (x, e))"
- by (import topology BALL_OPEN)
-
-lemma BALL_NEIGH: "0 < e ==> neigh (mtop m) (B m (x, e), x)"
- by (import topology BALL_NEIGH)
-
-lemma MTOP_LIMPT: "limpt (mtop m) x S' =
-(ALL e>0. EX y. x ~= y & S' y & topology.dist m (x, y) < e)"
- by (import topology MTOP_LIMPT)
-
-lemma ISMET_R1: "ismet (%(x, y). abs (y - x))"
- by (import topology ISMET_R1)
-
-definition
- mr1 :: "real metric" where
- "mr1 == metric (%(x, y). abs (y - x))"
-
-lemma mr1: "mr1 = metric (%(x, y). abs (y - x))"
- by (import topology mr1)
-
-lemma MR1_DEF: "topology.dist mr1 (x, y) = abs (y - x)"
- by (import topology MR1_DEF)
-
-lemma MR1_ADD: "topology.dist mr1 (x, x + d) = abs d"
- by (import topology MR1_ADD)
-
-lemma MR1_SUB: "topology.dist mr1 (x, x - d) = abs d"
- by (import topology MR1_SUB)
-
-lemma MR1_ADD_POS: "0 <= d ==> topology.dist mr1 (x, x + d) = d"
- by (import topology MR1_ADD_POS)
-
-lemma MR1_SUB_LE: "0 <= d ==> topology.dist mr1 (x, x - d) = d"
- by (import topology MR1_SUB_LE)
-
-lemma MR1_ADD_LT: "0 < d ==> topology.dist mr1 (x, x + d) = d"
- by (import topology MR1_ADD_LT)
-
-lemma MR1_SUB_LT: "0 < d ==> topology.dist mr1 (x, x - d) = d"
- by (import topology MR1_SUB_LT)
-
-lemma MR1_BETWEEN1: "x < z & topology.dist mr1 (x, y) < z - x ==> y < z"
- by (import topology MR1_BETWEEN1)
-
-lemma MR1_LIMPT: "limpt (mtop mr1) x re_universe"
- by (import topology MR1_LIMPT)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" nets
-
-definition
- dorder :: "('a => 'a => bool) => bool" where
- "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: "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)))"
- by (import nets dorder)
-
-definition
- tends :: "('b => 'a) => 'a => 'a topology * ('b => 'b => bool) => bool" where
- "tends ==
-%(s::'b => 'a) (l::'a) (tp::'a topology, g::'b => 'b => bool).
- ALL N::'a => bool.
- neigh tp (N, l) -->
- (EX n::'b. g n n & (ALL m::'b. g m n --> N (s m)))"
-
-lemma tends: "tends (s::'b::type => 'a::type) (l::'a::type)
- (tp::'a::type topology, g::'b::type => 'b::type => bool) =
-(ALL N::'a::type => bool.
- neigh tp (N, l) -->
- (EX n::'b::type. g n n & (ALL m::'b::type. g m n --> N (s m))))"
- by (import nets tends)
-
-definition
- bounded :: "'a metric * ('b => 'b => bool) => ('b => 'a) => bool" where
- "bounded ==
-%(m, g) f. EX k x N. g N N & (ALL n. g n N --> topology.dist m (f n, x) < k)"
-
-lemma bounded: "bounded (m, g) f =
-(EX k x N. g N N & (ALL n. g n N --> topology.dist m (f n, x) < k))"
- by (import nets bounded)
-
-consts
- tendsto :: "'a metric * 'a => 'a => 'a => bool"
-
-defs
- tendsto_def: "nets.tendsto ==
-%(m, x) y z.
- 0 < topology.dist m (x, y) &
- topology.dist m (x, y) <= topology.dist m (x, z)"
-
-lemma tendsto: "nets.tendsto (m, x) y z =
-(0 < topology.dist m (x, y) &
- topology.dist m (x, y) <= topology.dist m (x, z))"
- by (import nets tendsto)
-
-lemma DORDER_LEMMA: "[| dorder g;
- (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)"
- by (import nets DORDER_LEMMA)
-
-lemma DORDER_NGE: "dorder nat_ge"
- by (import nets DORDER_NGE)
-
-lemma DORDER_TENDSTO: "dorder (nets.tendsto (m, x))"
- by (import nets DORDER_TENDSTO)
-
-lemma MTOP_TENDS: "tends (x::'b => 'a) (x0::'a) (mtop (d::'a metric), g::'b => 'b => bool) =
-(ALL e>0::real.
- EX n::'b. g n n & (ALL m::'b. g m n --> topology.dist d (x m, x0) < e))"
- by (import nets MTOP_TENDS)
-
-lemma MTOP_TENDS_UNIQ: "[| dorder (g::'b => 'b => bool);
- tends (x::'b => 'a) (x0::'a) (mtop (d::'a metric), g) &
- tends x (x1::'a) (mtop d, g) |]
-==> x0 = x1"
- by (import nets MTOP_TENDS_UNIQ)
-
-lemma SEQ_TENDS: "tends x x0 (mtop d, nat_ge) =
-(ALL xa>0. EX xb. ALL xc>=xb. topology.dist d (x xc, x0) < xa)"
- by (import nets SEQ_TENDS)
-
-lemma LIM_TENDS: "limpt (mtop m1) x0 re_universe
-==> tends f y0 (mtop m2, nets.tendsto (m1, x0)) =
- (ALL e>0.
- EX d>0.
- ALL x.
- 0 < topology.dist m1 (x, x0) &
- topology.dist m1 (x, x0) <= d -->
- topology.dist m2 (f x, y0) < e)"
- by (import nets LIM_TENDS)
-
-lemma LIM_TENDS2: "limpt (mtop m1) x0 re_universe
-==> tends f y0 (mtop m2, nets.tendsto (m1, x0)) =
- (ALL e>0.
- EX d>0.
- ALL x.
- 0 < topology.dist m1 (x, x0) &
- topology.dist m1 (x, x0) < d -->
- topology.dist m2 (f x, y0) < e)"
- by (import nets LIM_TENDS2)
-
-lemma MR1_BOUNDED: "bounded (mr1, g) f = (EX k N. g N N & (ALL n. g n N --> abs (f n) < k))"
- by (import nets MR1_BOUNDED)
-
-lemma NET_NULL: "tends x x0 (mtop mr1, g) = tends (%n. x n - x0) 0 (mtop mr1, g)"
- by (import nets NET_NULL)
-
-lemma NET_CONV_BOUNDED: "tends x x0 (mtop mr1, g) ==> bounded (mr1, g) x"
- by (import nets NET_CONV_BOUNDED)
-
-lemma NET_CONV_NZ: "tends x x0 (mtop mr1, g) & x0 ~= 0
-==> EX N. g N N & (ALL n. g n N --> x n ~= 0)"
- by (import nets NET_CONV_NZ)
-
-lemma NET_CONV_IBOUNDED: "tends x x0 (mtop mr1, g) & x0 ~= 0 ==> bounded (mr1, g) (%n. inverse (x n))"
- by (import nets NET_CONV_IBOUNDED)
-
-lemma NET_NULL_ADD: "[| dorder g; tends x 0 (mtop mr1, g) & tends y 0 (mtop mr1, g) |]
-==> tends (%n. x n + y n) 0 (mtop mr1, g)"
- by (import nets NET_NULL_ADD)
-
-lemma NET_NULL_MUL: "[| dorder g; bounded (mr1, g) x & tends y 0 (mtop mr1, g) |]
-==> tends (%n. x n * y n) 0 (mtop mr1, g)"
- by (import nets NET_NULL_MUL)
-
-lemma NET_NULL_CMUL: "tends x 0 (mtop mr1, g) ==> tends (%n. k * x n) 0 (mtop mr1, g)"
- by (import nets NET_NULL_CMUL)
-
-lemma NET_ADD: "[| dorder g; tends x x0 (mtop mr1, g) & tends y y0 (mtop mr1, g) |]
-==> tends (%n. x n + y n) (x0 + y0) (mtop mr1, g)"
- by (import nets NET_ADD)
-
-lemma NET_NEG: "dorder g
-==> tends x x0 (mtop mr1, g) = tends (%n. - x n) (- x0) (mtop mr1, g)"
- by (import nets NET_NEG)
-
-lemma NET_SUB: "[| dorder g; tends x x0 (mtop mr1, g) & tends y y0 (mtop mr1, g) |]
-==> tends (%xa. x xa - y xa) (x0 - y0) (mtop mr1, g)"
- by (import nets NET_SUB)
-
-lemma NET_MUL: "[| dorder g; tends x x0 (mtop mr1, g) & tends y y0 (mtop mr1, g) |]
-==> tends (%n. x n * y n) (x0 * y0) (mtop mr1, g)"
- by (import nets NET_MUL)
-
-lemma NET_INV: "[| dorder g; tends x x0 (mtop mr1, g) & x0 ~= 0 |]
-==> tends (%n. inverse (x n)) (inverse x0) (mtop mr1, g)"
- by (import nets NET_INV)
-
-lemma NET_DIV: "[| dorder g;
- 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)"
- by (import nets NET_DIV)
-
-lemma NET_ABS: "tends x x0 (mtop mr1, g) ==> tends (%n. abs (x n)) (abs x0) (mtop mr1, g)"
- by (import nets NET_ABS)
-
-lemma NET_LE: "[| dorder g;
- 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)) |]
-==> x0 <= y0"
- by (import nets NET_LE)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" seq
-
-consts
- "hol4-->" :: "(nat => real) => real => bool" ("hol4-->")
-
-defs
- "hol4-->_def": "hol4--> == %x x0. tends x x0 (mtop mr1, nat_ge)"
-
-lemma tends_num_real: "hol4--> x x0 = tends x x0 (mtop mr1, nat_ge)"
- by (import seq tends_num_real)
-
-lemma SEQ: "hol4--> x x0 = (ALL e>0. EX N. ALL n>=N. abs (x n - x0) < e)"
- by (import seq SEQ)
-
-lemma SEQ_CONST: "hol4--> (%x. k) k"
- by (import seq SEQ_CONST)
-
-lemma SEQ_ADD: "hol4--> x x0 & hol4--> y y0 ==> hol4--> (%n. x n + y n) (x0 + y0)"
- by (import seq SEQ_ADD)
-
-lemma SEQ_MUL: "hol4--> x x0 & hol4--> y y0 ==> hol4--> (%n. x n * y n) (x0 * y0)"
- by (import seq SEQ_MUL)
-
-lemma SEQ_NEG: "hol4--> x x0 = hol4--> (%n. - x n) (- x0)"
- by (import seq SEQ_NEG)
-
-lemma SEQ_INV: "hol4--> x x0 & x0 ~= 0 ==> hol4--> (%n. inverse (x n)) (inverse x0)"
- by (import seq SEQ_INV)
-
-lemma SEQ_SUB: "hol4--> x x0 & hol4--> y y0 ==> hol4--> (%n. x n - y n) (x0 - y0)"
- by (import seq SEQ_SUB)
-
-lemma SEQ_DIV: "hol4--> x x0 & hol4--> y y0 & y0 ~= 0 ==> hol4--> (%n. x n / y n) (x0 / y0)"
- by (import seq SEQ_DIV)
-
-lemma SEQ_UNIQ: "hol4--> x x1 & hol4--> x x2 ==> x1 = x2"
- by (import seq SEQ_UNIQ)
-
-consts
- convergent :: "(nat => real) => bool"
-
-defs
- convergent_def: "seq.convergent == %f. Ex (hol4--> f)"
-
-lemma convergent: "seq.convergent f = Ex (hol4--> f)"
- by (import seq convergent)
-
-definition
- cauchy :: "(nat => real) => bool" where
- "cauchy ==
-%f. ALL e>0. EX N. ALL m n. N <= m & N <= n --> abs (f m - f n) < e"
-
-lemma cauchy: "cauchy f = (ALL e>0. EX N. ALL m n. N <= m & N <= n --> abs (f m - f n) < e)"
- by (import seq cauchy)
-
-consts
- lim :: "(nat => real) => real"
-
-defs
- lim_def: "seq.lim == %f. Eps (hol4--> f)"
-
-lemma lim: "seq.lim f = Eps (hol4--> f)"
- by (import seq lim)
-
-lemma SEQ_LIM: "seq.convergent f = hol4--> f (seq.lim f)"
- by (import seq SEQ_LIM)
-
-consts
- subseq :: "(nat => nat) => bool"
-
-defs
- subseq_def: "seq.subseq == %f. ALL m n. m < n --> f m < f n"
-
-lemma subseq: "seq.subseq f = (ALL m n. m < n --> f m < f n)"
- by (import seq subseq)
-
-lemma SUBSEQ_SUC: "seq.subseq f = (ALL n. f n < f (Suc n))"
- by (import seq SUBSEQ_SUC)
-
-consts
- mono :: "(nat => real) => bool"
-
-defs
- mono_def: "seq.mono ==
-%f. (ALL m n. m <= n --> f m <= f n) | (ALL m n. m <= n --> f n <= f m)"
-
-lemma mono: "seq.mono f =
-((ALL m n. m <= n --> f m <= f n) | (ALL m n. m <= n --> f n <= f m))"
- by (import seq mono)
-
-lemma MONO_SUC: "seq.mono f = ((ALL x. f x <= f (Suc x)) | (ALL n. f (Suc n) <= f n))"
- by (import seq MONO_SUC)
-
-lemma MAX_LEMMA: "EX k::real. ALL n<N::nat. abs ((s::nat => real) n) < k"
- by (import seq MAX_LEMMA)
-
-lemma SEQ_BOUNDED: "bounded (mr1, nat_ge) s = (EX k. ALL n. abs (s n) < k)"
- by (import seq SEQ_BOUNDED)
-
-lemma SEQ_BOUNDED_2: "(!!n. k <= f n & f n <= k') ==> bounded (mr1, nat_ge) f"
- by (import seq SEQ_BOUNDED_2)
-
-lemma SEQ_CBOUNDED: "cauchy f ==> bounded (mr1, nat_ge) f"
- by (import seq SEQ_CBOUNDED)
-
-lemma SEQ_ICONV: "bounded (mr1, nat_ge) f & (ALL m n. n <= m --> f n <= f m)
-==> seq.convergent f"
- by (import seq SEQ_ICONV)
-
-lemma SEQ_NEG_CONV: "seq.convergent f = seq.convergent (%n. - f n)"
- by (import seq SEQ_NEG_CONV)
-
-lemma SEQ_NEG_BOUNDED: "bounded (mr1, nat_ge) (%n. - f n) = bounded (mr1, nat_ge) f"
- by (import seq SEQ_NEG_BOUNDED)
-
-lemma SEQ_BCONV: "bounded (mr1, nat_ge) f & seq.mono f ==> seq.convergent f"
- by (import seq SEQ_BCONV)
-
-lemma SEQ_MONOSUB: "EX f. seq.subseq f & seq.mono (%n. s (f n))"
- by (import seq SEQ_MONOSUB)
-
-lemma SEQ_SBOUNDED: "bounded (mr1, nat_ge) s ==> bounded (mr1, nat_ge) (%n. s (f n))"
- by (import seq SEQ_SBOUNDED)
-
-lemma SEQ_SUBLE: "seq.subseq f ==> n <= f n"
- by (import seq SEQ_SUBLE)
-
-lemma SEQ_DIRECT: "seq.subseq f ==> EX x>=N1. N2 <= f x"
- by (import seq SEQ_DIRECT)
-
-lemma SEQ_CAUCHY: "cauchy f = seq.convergent f"
- by (import seq SEQ_CAUCHY)
-
-lemma SEQ_LE: "hol4--> f l & hol4--> g m & (EX x. ALL xa>=x. f xa <= g xa) ==> l <= m"
- by (import seq SEQ_LE)
-
-lemma SEQ_SUC: "hol4--> f l = hol4--> (%n. f (Suc n)) l"
- by (import seq SEQ_SUC)
-
-lemma SEQ_ABS: "hol4--> (%n. abs (f n)) 0 = hol4--> f 0"
- by (import seq SEQ_ABS)
-
-lemma SEQ_ABS_IMP: "hol4--> f l ==> hol4--> (%n. abs (f n)) (abs l)"
- by (import seq SEQ_ABS_IMP)
-
-lemma SEQ_INV0: "(!!y. EX N. ALL n>=N. y < f n) ==> hol4--> (%n. inverse (f n)) 0"
- by (import seq SEQ_INV0)
-
-lemma SEQ_POWER_ABS: "abs c < 1 ==> hol4--> (op ^ (abs c)) 0"
- by (import seq SEQ_POWER_ABS)
-
-lemma SEQ_POWER: "abs c < 1 ==> hol4--> (op ^ c) 0"
- by (import seq SEQ_POWER)
-
-lemma NEST_LEMMA: "(ALL n. f n <= f (Suc n)) & (ALL n. g (Suc n) <= g n) & (ALL n. f n <= g n)
-==> EX l m.
- l <= m &
- ((ALL n. f n <= l) & hol4--> f l) & (ALL n. m <= g n) & hol4--> g m"
- by (import seq NEST_LEMMA)
-
-lemma NEST_LEMMA_UNIQ: "(ALL n. f n <= f (Suc n)) &
-(ALL n. g (Suc n) <= g n) & (ALL n. f n <= g n) & hol4--> (%n. f n - g n) 0
-==> EX x. ((ALL n. f n <= x) & hol4--> f x) &
- (ALL n. x <= g n) & hol4--> g x"
- by (import seq NEST_LEMMA_UNIQ)
-
-consts
- sums :: "(nat => real) => real => bool"
-
-defs
- sums_def: "seq.sums == %f. hol4--> (%n. real.sum (0, n) f)"
-
-lemma sums: "seq.sums f s = hol4--> (%n. real.sum (0, n) f) s"
- by (import seq sums)
-
-consts
- summable :: "(nat => real) => bool"
-
-defs
- summable_def: "seq.summable == %f. Ex (seq.sums f)"
-
-lemma summable: "seq.summable f = Ex (seq.sums f)"
- by (import seq summable)
-
-consts
- suminf :: "(nat => real) => real"
-
-defs
- suminf_def: "seq.suminf == %f. Eps (seq.sums f)"
-
-lemma suminf: "seq.suminf f = Eps (seq.sums f)"
- by (import seq suminf)
-
-lemma SUM_SUMMABLE: "seq.sums f l ==> seq.summable f"
- by (import seq SUM_SUMMABLE)
-
-lemma SUMMABLE_SUM: "seq.summable f ==> seq.sums f (seq.suminf f)"
- by (import seq SUMMABLE_SUM)
-
-lemma SUM_UNIQ: "seq.sums f x ==> x = seq.suminf f"
- by (import seq SUM_UNIQ)
-
-lemma SER_0: "(!!m. n <= m ==> f m = 0) ==> seq.sums f (real.sum (0, n) f)"
- by (import seq SER_0)
-
-lemma SER_POS_LE: "seq.summable f & (ALL m>=n. 0 <= f m) ==> real.sum (0, n) f <= seq.suminf f"
- by (import seq SER_POS_LE)
-
-lemma SER_POS_LT: "seq.summable f & (ALL m>=n. 0 < f m) ==> real.sum (0, n) f < seq.suminf f"
- by (import seq SER_POS_LT)
-
-lemma SER_GROUP: "seq.summable f & 0 < k
-==> seq.sums (%n. real.sum (n * k, k) f) (seq.suminf f)"
- by (import seq SER_GROUP)
-
-lemma SER_PAIR: "seq.summable f ==> seq.sums (%n. real.sum (2 * n, 2) f) (seq.suminf f)"
- by (import seq SER_PAIR)
-
-lemma SER_OFFSET: "seq.summable f
-==> seq.sums (%n. f (n + k)) (seq.suminf f - real.sum (0, k) f)"
- by (import seq SER_OFFSET)
-
-lemma SER_POS_LT_PAIR: "seq.summable f & (ALL d. 0 < f (n + 2 * d) + f (n + (2 * d + 1)))
-==> real.sum (0, n) f < seq.suminf f"
- by (import seq SER_POS_LT_PAIR)
-
-lemma SER_ADD: "seq.sums x x0 & seq.sums y y0 ==> seq.sums (%n. x n + y n) (x0 + y0)"
- by (import seq SER_ADD)
-
-lemma SER_CMUL: "seq.sums x x0 ==> seq.sums (%n. c * x n) (c * x0)"
- by (import seq SER_CMUL)
-
-lemma SER_NEG: "seq.sums x x0 ==> seq.sums (%xa. - x xa) (- x0)"
- by (import seq SER_NEG)
-
-lemma SER_SUB: "seq.sums x x0 & seq.sums y y0 ==> seq.sums (%xa. x xa - y xa) (x0 - y0)"
- by (import seq SER_SUB)
-
-lemma SER_CDIV: "seq.sums x x0 ==> seq.sums (%xa. x xa / c) (x0 / c)"
- by (import seq SER_CDIV)
-
-lemma SER_CAUCHY: "seq.summable f =
-(ALL e>0. EX N. ALL m n. N <= m --> abs (real.sum (m, n) f) < e)"
- by (import seq SER_CAUCHY)
-
-lemma SER_ZERO: "seq.summable f ==> hol4--> f 0"
- by (import seq SER_ZERO)
-
-lemma SER_COMPAR: "(EX x. ALL xa>=x. abs (f xa) <= g xa) & seq.summable g ==> seq.summable f"
- by (import seq SER_COMPAR)
-
-lemma SER_COMPARA: "(EX x. ALL xa>=x. abs (f xa) <= g xa) & seq.summable g
-==> seq.summable (%k. abs (f k))"
- by (import seq SER_COMPARA)
-
-lemma SER_LE: "(ALL n. f n <= g n) & seq.summable f & seq.summable g
-==> seq.suminf f <= seq.suminf g"
- by (import seq SER_LE)
-
-lemma SER_LE2: "(ALL n. abs (f n) <= g n) & seq.summable g
-==> seq.summable f & seq.suminf f <= seq.suminf g"
- by (import seq SER_LE2)
-
-lemma SER_ACONV: "seq.summable (%n. abs (f n)) ==> seq.summable f"
- by (import seq SER_ACONV)
-
-lemma SER_ABS: "seq.summable (%n. abs (f n))
-==> abs (seq.suminf f) <= seq.suminf (%n. abs (f n))"
- by (import seq SER_ABS)
-
-lemma GP_FINITE: "x ~= 1 ==> real.sum (0, n) (op ^ x) = (x ^ n - 1) / (x - 1)"
- by (import seq GP_FINITE)
-
-lemma GP: "abs x < 1 ==> seq.sums (op ^ x) (inverse (1 - x))"
- by (import seq GP)
-
-lemma SER_RATIO: "c < 1 & (ALL n>=N. abs (f (Suc n)) <= c * abs (f n)) ==> seq.summable f"
- by (import seq SER_RATIO)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" lim
-
-definition
- tends_real_real :: "(real => real) => real => real => bool" where
- "tends_real_real == %f l x0. tends f l (mtop mr1, nets.tendsto (mr1, x0))"
-
-lemma tends_real_real: "tends_real_real f l x0 = tends f l (mtop mr1, nets.tendsto (mr1, x0))"
- by (import lim tends_real_real)
-
-lemma LIM: "tends_real_real f y0 x0 =
-(ALL e>0.
- EX d>0.
- ALL x. 0 < abs (x - x0) & abs (x - x0) < d --> abs (f x - y0) < e)"
- by (import lim LIM)
-
-lemma LIM_CONST: "tends_real_real (%x. k) k x"
- by (import lim LIM_CONST)
-
-lemma LIM_ADD: "tends_real_real f l x & tends_real_real g m x
-==> tends_real_real (%x. f x + g x) (l + m) x"
- by (import lim LIM_ADD)
-
-lemma LIM_MUL: "tends_real_real f l x & tends_real_real g m x
-==> tends_real_real (%x. f x * g x) (l * m) x"
- by (import lim LIM_MUL)
-
-lemma LIM_NEG: "tends_real_real f l x = tends_real_real (%x. - f x) (- l) x"
- by (import lim LIM_NEG)
-
-lemma LIM_INV: "tends_real_real f l x & l ~= 0
-==> tends_real_real (%x. inverse (f x)) (inverse l) x"
- by (import lim LIM_INV)
-
-lemma LIM_SUB: "tends_real_real f l x & tends_real_real g m x
-==> tends_real_real (%x. f x - g x) (l - m) x"
- by (import lim LIM_SUB)
-
-lemma LIM_DIV: "tends_real_real f l x & tends_real_real g m x & m ~= 0
-==> tends_real_real (%x. f x / g x) (l / m) x"
- by (import lim LIM_DIV)
-
-lemma LIM_NULL: "tends_real_real f l x = tends_real_real (%x. f x - l) 0 x"
- by (import lim LIM_NULL)
-
-lemma LIM_X: "tends_real_real (%x. x) x0 x0"
- by (import lim LIM_X)
-
-lemma LIM_UNIQ: "tends_real_real f l x & tends_real_real f m x ==> l = m"
- by (import lim LIM_UNIQ)
-
-lemma LIM_EQUAL: "(!!x. x ~= x0 ==> f x = g x)
-==> tends_real_real f l x0 = tends_real_real g l x0"
- by (import lim LIM_EQUAL)
-
-lemma LIM_TRANSFORM: "tends_real_real (%x. f x - g x) 0 x0 & tends_real_real g l x0
-==> tends_real_real f l x0"
- by (import lim LIM_TRANSFORM)
-
-definition
- diffl :: "(real => real) => real => real => bool" where
- "diffl == %f l x. tends_real_real (%h. (f (x + h) - f x) / h) l 0"
-
-lemma diffl: "diffl f l x = tends_real_real (%h. (f (x + h) - f x) / h) l 0"
- by (import lim diffl)
-
-definition
- contl :: "(real => real) => real => bool" where
- "contl == %f x. tends_real_real (%h. f (x + h)) (f x) 0"
-
-lemma contl: "contl f x = tends_real_real (%h. f (x + h)) (f x) 0"
- by (import lim contl)
-
-consts
- differentiable :: "(real => real) => real => bool"
-
-defs
- differentiable_def: "lim.differentiable == %f x. EX l. diffl f l x"
-
-lemma differentiable: "lim.differentiable f x = (EX l. diffl f l x)"
- by (import lim differentiable)
-
-lemma DIFF_UNIQ: "diffl f l x & diffl f m x ==> l = m"
- by (import lim DIFF_UNIQ)
-
-lemma DIFF_CONT: "diffl f l x ==> contl f x"
- by (import lim DIFF_CONT)
-
-lemma CONTL_LIM: "contl f x = tends_real_real f (f x) x"
- by (import lim CONTL_LIM)
-
-lemma DIFF_CARAT: "diffl f l x =
-(EX g. (ALL z. f z - f x = g z * (z - x)) & contl g x & g x = l)"
- by (import lim DIFF_CARAT)
-
-lemma CONT_CONST: "contl (%x. k) x"
- by (import lim CONT_CONST)
-
-lemma CONT_ADD: "contl f x & contl g x ==> contl (%x. f x + g x) x"
- by (import lim CONT_ADD)
-
-lemma CONT_MUL: "contl f x & contl g x ==> contl (%x. f x * g x) x"
- by (import lim CONT_MUL)
-
-lemma CONT_NEG: "contl f x ==> contl (%x. - f x) x"
- by (import lim CONT_NEG)
-
-lemma CONT_INV: "contl f x & f x ~= 0 ==> contl (%x. inverse (f x)) x"
- by (import lim CONT_INV)
-
-lemma CONT_SUB: "contl f x & contl g x ==> contl (%x. f x - g x) x"
- by (import lim CONT_SUB)
-
-lemma CONT_DIV: "contl f x & contl g x & g x ~= 0 ==> contl (%x. f x / g x) x"
- by (import lim CONT_DIV)
-
-lemma CONT_COMPOSE: "contl f x & contl g (f x) ==> contl (%x. g (f x)) x"
- by (import lim CONT_COMPOSE)
-
-lemma IVT: "a <= b & (f a <= y & y <= f b) & (ALL x. a <= x & x <= b --> contl f x)
-==> EX x>=a. x <= b & f x = y"
- by (import lim IVT)
-
-lemma IVT2: "a <= b & (f b <= y & y <= f a) & (ALL x. a <= x & x <= b --> contl f x)
-==> EX x>=a. x <= b & f x = y"
- by (import lim IVT2)
-
-lemma DIFF_CONST: "diffl (%x. k) 0 x"
- by (import lim DIFF_CONST)
-
-lemma DIFF_ADD: "diffl f l x & diffl g m x ==> diffl (%x. f x + g x) (l + m) x"
- by (import lim DIFF_ADD)
-
-lemma DIFF_MUL: "diffl f l x & diffl g m x ==> diffl (%x. f x * g x) (l * g x + m * f x) x"
- by (import lim DIFF_MUL)
-
-lemma DIFF_CMUL: "diffl f l x ==> diffl (%x. c * f x) (c * l) x"
- by (import lim DIFF_CMUL)
-
-lemma DIFF_NEG: "diffl f l x ==> diffl (%x. - f x) (- l) x"
- by (import lim DIFF_NEG)
-
-lemma DIFF_SUB: "diffl f l x & diffl g m x ==> diffl (%x. f x - g x) (l - m) x"
- by (import lim DIFF_SUB)
-
-lemma DIFF_CHAIN: "diffl f l (g x) & diffl g m x ==> diffl (%x. f (g x)) (l * m) x"
- by (import lim DIFF_CHAIN)
-
-lemma DIFF_X: "diffl (%x. x) 1 x"
- by (import lim DIFF_X)
-
-lemma DIFF_POW: "diffl (%x. x ^ n) (real n * x ^ (n - 1)) x"
- by (import lim DIFF_POW)
-
-lemma DIFF_XM1: "x ~= 0 ==> diffl inverse (- (inverse x ^ 2)) x"
- by (import lim DIFF_XM1)
-
-lemma DIFF_INV: "diffl f l x & f x ~= 0 ==> diffl (%x. inverse (f x)) (- (l / f x ^ 2)) x"
- by (import lim DIFF_INV)
-
-lemma DIFF_DIV: "diffl f l x & diffl g m x & g x ~= 0
-==> diffl (%x. f x / g x) ((l * g x - m * f x) / g x ^ 2) x"
- by (import lim DIFF_DIV)
-
-lemma DIFF_SUM: "(!!r. m <= r & r < m + n ==> diffl (f r) (f' r x) x)
-==> diffl (%x. real.sum (m, n) (%n. f n x)) (real.sum (m, n) (%r. f' r x)) x"
- by (import lim DIFF_SUM)
-
-lemma CONT_BOUNDED: "a <= b & (ALL x. a <= x & x <= b --> contl f x)
-==> EX M. ALL x. a <= x & x <= b --> f x <= M"
- by (import lim CONT_BOUNDED)
-
-lemma CONT_HASSUP: "a <= b & (ALL x. a <= x & x <= b --> contl f x)
-==> EX M. (ALL x. a <= x & x <= b --> f x <= M) &
- (ALL N<M. EX x>=a. x <= b & N < f x)"
- by (import lim CONT_HASSUP)
-
-lemma CONT_ATTAINS: "a <= b & (ALL x. a <= x & x <= b --> contl f x)
-==> EX x. (ALL xa. a <= xa & xa <= b --> f xa <= x) &
- (EX xa>=a. xa <= b & f xa = x)"
- by (import lim CONT_ATTAINS)
-
-lemma CONT_ATTAINS2: "a <= b & (ALL x. a <= x & x <= b --> contl f x)
-==> EX x. (ALL xa. a <= xa & xa <= b --> x <= f xa) &
- (EX xa>=a. xa <= b & f xa = x)"
- by (import lim CONT_ATTAINS2)
-
-lemma CONT_ATTAINS_ALL: "a <= b & (ALL x. a <= x & x <= b --> contl f x)
-==> EX x M.
- x <= M &
- (ALL y. x <= y & y <= M --> (EX x>=a. x <= b & f x = y)) &
- (ALL xa. a <= xa & xa <= b --> x <= f xa & f xa <= M)"
- by (import lim CONT_ATTAINS_ALL)
-
-lemma DIFF_LINC: "diffl f l x & 0 < l ==> EX d>0. ALL h. 0 < h & h < d --> f x < f (x + h)"
- by (import lim DIFF_LINC)
-
-lemma DIFF_LDEC: "diffl f l x & l < 0 ==> EX d>0. ALL h. 0 < h & h < d --> f x < f (x - h)"
- by (import lim DIFF_LDEC)
-
-lemma DIFF_LMAX: "diffl f l x & (EX d>0. ALL y. abs (x - y) < d --> f y <= f x) ==> l = 0"
- by (import lim DIFF_LMAX)
-
-lemma DIFF_LMIN: "diffl f l x & (EX d>0. ALL y. abs (x - y) < d --> f x <= f y) ==> l = 0"
- by (import lim DIFF_LMIN)
-
-lemma DIFF_LCONST: "diffl f l x & (EX d>0. ALL y. abs (x - y) < d --> f y = f x) ==> l = 0"
- by (import lim DIFF_LCONST)
-
-lemma ROLLE: "a < b &
-f a = f b &
-(ALL x. a <= x & x <= b --> contl f x) &
-(ALL x. a < x & x < b --> lim.differentiable f x)
-==> EX z>a. z < b & diffl f 0 z"
- by (import lim ROLLE)
-
-lemma MVT: "a < b &
-(ALL x. a <= x & x <= b --> contl f x) &
-(ALL x. a < x & x < b --> lim.differentiable f x)
-==> EX l z. a < z & z < b & diffl f l z & f b - f a = (b - a) * l"
- by (import lim MVT)
-
-lemma DIFF_ISCONST_END: "a < b &
-(ALL x. a <= x & x <= b --> contl f x) &
-(ALL x. a < x & x < b --> diffl f 0 x)
-==> f b = f a"
- by (import lim DIFF_ISCONST_END)
-
-lemma DIFF_ISCONST: "[| a < b &
- (ALL x. a <= x & x <= b --> contl f x) &
- (ALL x. a < x & x < b --> diffl f 0 x);
- a <= x & x <= b |]
-==> f x = f a"
- by (import lim DIFF_ISCONST)
-
-lemma DIFF_ISCONST_ALL: "(!!x. diffl f 0 x) ==> f x = f y"
- by (import lim DIFF_ISCONST_ALL)
-
-lemma INTERVAL_ABS: "((x::real) - (d::real) <= (z::real) & z <= x + d) = (abs (z - x) <= d)"
- by (import lim INTERVAL_ABS)
-
-lemma CONT_INJ_LEMMA: "0 < d &
-(ALL z. abs (z - x) <= d --> g (f z) = z) &
-(ALL z. abs (z - x) <= d --> contl f z)
-==> ~ (ALL z. abs (z - x) <= d --> f z <= f x)"
- by (import lim CONT_INJ_LEMMA)
-
-lemma CONT_INJ_LEMMA2: "0 < d &
-(ALL z. abs (z - x) <= d --> g (f z) = z) &
-(ALL z. abs (z - x) <= d --> contl f z)
-==> ~ (ALL z. abs (z - x) <= d --> f x <= f z)"
- by (import lim CONT_INJ_LEMMA2)
-
-lemma CONT_INJ_RANGE: "0 < d &
-(ALL z. abs (z - x) <= d --> g (f z) = z) &
-(ALL z. abs (z - x) <= d --> contl f z)
-==> EX e>0. ALL y. abs (y - f x) <= e --> (EX z. abs (z - x) <= d & f z = y)"
- by (import lim CONT_INJ_RANGE)
-
-lemma CONT_INVERSE: "0 < d &
-(ALL z. abs (z - x) <= d --> g (f z) = z) &
-(ALL z. abs (z - x) <= d --> contl f z)
-==> contl g (f x)"
- by (import lim CONT_INVERSE)
-
-lemma DIFF_INVERSE: "0 < d &
-(ALL z. abs (z - x) <= d --> g (f z) = z) &
-(ALL z. abs (z - x) <= d --> contl f z) & diffl f l x & l ~= 0
-==> diffl g (inverse l) (f x)"
- by (import lim DIFF_INVERSE)
-
-lemma DIFF_INVERSE_LT: "0 < d &
-(ALL z. abs (z - x) < d --> g (f z) = z) &
-(ALL z. abs (z - x) < d --> contl f z) & diffl f l x & l ~= 0
-==> diffl g (inverse l) (f x)"
- by (import lim DIFF_INVERSE_LT)
-
-lemma INTERVAL_CLEMMA: "(a::real) < (x::real) & x < (b::real)
-==> EX d>0::real. ALL y::real. abs (y - x) <= d --> a < y & y < b"
- by (import lim INTERVAL_CLEMMA)
-
-lemma DIFF_INVERSE_OPEN: "a < x &
-x < b &
-(ALL z. a < z & z < b --> g (f z) = z & contl f z) & diffl f l x & l ~= 0
-==> diffl g (inverse l) (f x)"
- by (import lim DIFF_INVERSE_OPEN)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" powser
-
-lemma POWDIFF_LEMMA: "real.sum (0, Suc n) (%p. x ^ p * y ^ (Suc n - p)) =
-y * real.sum (0, Suc n) (%p. x ^ p * y ^ (n - p))"
- by (import powser POWDIFF_LEMMA)
-
-lemma POWDIFF: "x ^ Suc n - y ^ Suc n =
-(x - y) * real.sum (0, Suc n) (%p. x ^ p * y ^ (n - p))"
- by (import powser POWDIFF)
-
-lemma POWREV: "real.sum (0, Suc n) (%xa. x ^ xa * y ^ (n - xa)) =
-real.sum (0, Suc n) (%xa. x ^ (n - xa) * y ^ xa)"
- by (import powser POWREV)
-
-lemma POWSER_INSIDEA: "seq.summable (%n. f n * x ^ n) & abs z < abs x
-==> seq.summable (%n. abs (f n) * z ^ n)"
- by (import powser POWSER_INSIDEA)
-
-lemma POWSER_INSIDE: "seq.summable (%n. f n * x ^ n) & abs z < abs x
-==> seq.summable (%n. f n * z ^ n)"
- by (import powser POWSER_INSIDE)
-
-consts
- diffs :: "(nat => real) => nat => real"
-
-defs
- diffs_def: "powser.diffs == %c n. real (Suc n) * c (Suc n)"
-
-lemma diffs: "powser.diffs c = (%n. real (Suc n) * c (Suc n))"
- by (import powser diffs)
-
-lemma DIFFS_NEG: "powser.diffs (%n. - c n) = (%x. - powser.diffs c x)"
- by (import powser DIFFS_NEG)
-
-lemma DIFFS_LEMMA: "real.sum (0, n) (%n. powser.diffs c n * x ^ n) =
-real.sum (0, n) (%n. real n * (c n * x ^ (n - 1))) +
-real n * (c n * x ^ (n - 1))"
- by (import powser DIFFS_LEMMA)
-
-lemma DIFFS_LEMMA2: "real.sum (0, n) (%n. real n * (c n * x ^ (n - 1))) =
-real.sum (0, n) (%n. powser.diffs c n * x ^ n) -
-real n * (c n * x ^ (n - 1))"
- by (import powser DIFFS_LEMMA2)
-
-lemma DIFFS_EQUIV: "seq.summable (%n. powser.diffs c n * x ^ n)
-==> seq.sums (%n. real n * (c n * x ^ (n - 1)))
- (seq.suminf (%n. powser.diffs c n * x ^ n))"
- by (import powser DIFFS_EQUIV)
-
-lemma TERMDIFF_LEMMA1: "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)))"
- by (import powser TERMDIFF_LEMMA1)
-
-lemma TERMDIFF_LEMMA2: "h ~= 0
-==> ((z + h) ^ n - z ^ n) / h - real n * z ^ (n - 1) =
- h *
- real.sum (0, n - 1)
- (%p. z ^ p *
- real.sum (0, n - 1 - p) (%q. (z + h) ^ q * z ^ (n - 2 - p - q)))"
- by (import powser TERMDIFF_LEMMA2)
-
-lemma TERMDIFF_LEMMA3: "h ~= 0 & abs z <= k' & abs (z + h) <= k'
-==> abs (((z + h) ^ n - z ^ n) / h - real n * z ^ (n - 1))
- <= real n * (real (n - 1) * (k' ^ (n - 2) * abs h))"
- by (import powser TERMDIFF_LEMMA3)
-
-lemma TERMDIFF_LEMMA4: "0 < k & (ALL h. 0 < abs h & abs h < k --> abs (f h) <= k' * abs h)
-==> tends_real_real f 0 0"
- by (import powser TERMDIFF_LEMMA4)
-
-lemma TERMDIFF_LEMMA5: "0 < k &
-seq.summable f &
-(ALL h. 0 < abs h & abs h < k --> (ALL n. abs (g h n) <= f n * abs h))
-==> tends_real_real (%h. seq.suminf (g h)) 0 0"
- by (import powser TERMDIFF_LEMMA5)
-
-lemma TERMDIFF: "seq.summable (%n. c n * k' ^ n) &
-seq.summable (%n. powser.diffs c n * k' ^ n) &
-seq.summable (%n. powser.diffs (powser.diffs c) n * k' ^ n) & abs x < abs k'
-==> diffl (%x. seq.suminf (%n. c n * x ^ n))
- (seq.suminf (%n. powser.diffs c n * x ^ n)) x"
- by (import powser TERMDIFF)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" transc
-
-consts
- exp :: "real => real"
-
-defs
- exp_def: "transc.exp == %x. seq.suminf (%n. inverse (real (FACT n)) * x ^ n)"
-
-lemma exp: "transc.exp x = seq.suminf (%n. inverse (real (FACT n)) * x ^ n)"
- by (import transc exp)
-
-consts
- cos :: "real => real"
-
-defs
- cos_def: "transc.cos ==
-%x. seq.suminf
- (%n. (if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0) * x ^ n)"
-
-lemma cos: "transc.cos x =
-seq.suminf
- (%n. (if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0) * x ^ n)"
- by (import transc cos)
-
-consts
- sin :: "real => real"
-
-defs
- sin_def: "transc.sin ==
-%x. seq.suminf
- (%n. (if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) *
- x ^ n)"
-
-lemma sin: "transc.sin x =
-seq.suminf
- (%n. (if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) *
- x ^ n)"
- by (import transc sin)
-
-lemma EXP_CONVERGES: "seq.sums (%n. inverse (real (FACT n)) * x ^ n) (transc.exp x)"
- by (import transc EXP_CONVERGES)
-
-lemma SIN_CONVERGES: "seq.sums
- (%n. (if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) *
- x ^ n)
- (transc.sin x)"
- by (import transc SIN_CONVERGES)
-
-lemma COS_CONVERGES: "seq.sums
- (%n. (if EVEN n then (- 1) ^ (n div 2) / real (FACT n) else 0) * x ^ n)
- (transc.cos x)"
- by (import transc COS_CONVERGES)
-
-lemma EXP_FDIFF: "powser.diffs (%n. inverse (real (FACT n))) = (%n. inverse (real (FACT n)))"
- by (import transc EXP_FDIFF)
-
-lemma SIN_FDIFF: "powser.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)"
- by (import transc SIN_FDIFF)
-
-lemma COS_FDIFF: "powser.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)))"
- by (import transc COS_FDIFF)
-
-lemma SIN_NEGLEMMA: "- transc.sin x =
-seq.suminf
- (%n. - ((if EVEN n then 0 else (- 1) ^ ((n - 1) div 2) / real (FACT n)) *
- x ^ n))"
- by (import transc SIN_NEGLEMMA)
-
-lemma DIFF_EXP: "diffl transc.exp (transc.exp x) x"
- by (import transc DIFF_EXP)
-
-lemma DIFF_SIN: "diffl transc.sin (transc.cos x) x"
- by (import transc DIFF_SIN)
-
-lemma DIFF_COS: "diffl transc.cos (- transc.sin x) x"
- by (import transc DIFF_COS)
-
-lemma DIFF_COMPOSITE: "(diffl f l x & f x ~= 0 --> diffl (%x. inverse (f x)) (- (l / f x ^ 2)) x) &
-(diffl f l x & diffl g m x & g x ~= 0 -->
- diffl (%x. f x / g x) ((l * g x - m * f x) / g x ^ 2) x) &
-(diffl f l x & diffl g m x --> diffl (%x. f x + g x) (l + m) x) &
-(diffl f l x & diffl g m x -->
- diffl (%x. f x * g x) (l * g x + m * f x) x) &
-(diffl f l x & diffl g m x --> diffl (%x. f x - g x) (l - m) x) &
-(diffl f l x --> diffl (%x. - f x) (- l) x) &
-(diffl g m x --> diffl (%x. g x ^ n) (real n * g x ^ (n - 1) * m) x) &
-(diffl g m x --> diffl (%x. transc.exp (g x)) (transc.exp (g x) * m) x) &
-(diffl g m x --> diffl (%x. transc.sin (g x)) (transc.cos (g x) * m) x) &
-(diffl g m x --> diffl (%x. transc.cos (g x)) (- transc.sin (g x) * m) x)"
- by (import transc DIFF_COMPOSITE)
-
-lemma EXP_0: "transc.exp 0 = 1"
- by (import transc EXP_0)
-
-lemma EXP_LE_X: "0 <= x ==> 1 + x <= transc.exp x"
- by (import transc EXP_LE_X)
-
-lemma EXP_LT_1: "0 < x ==> 1 < transc.exp x"
- by (import transc EXP_LT_1)
-
-lemma EXP_ADD_MUL: "transc.exp (x + y) * transc.exp (- x) = transc.exp y"
- by (import transc EXP_ADD_MUL)
-
-lemma EXP_NEG_MUL: "transc.exp x * transc.exp (- x) = 1"
- by (import transc EXP_NEG_MUL)
-
-lemma EXP_NEG_MUL2: "transc.exp (- x) * transc.exp x = 1"
- by (import transc EXP_NEG_MUL2)
-
-lemma EXP_NEG: "transc.exp (- x) = inverse (transc.exp x)"
- by (import transc EXP_NEG)
-
-lemma EXP_ADD: "transc.exp (x + y) = transc.exp x * transc.exp y"
- by (import transc EXP_ADD)
-
-lemma EXP_POS_LE: "0 <= transc.exp x"
- by (import transc EXP_POS_LE)
-
-lemma EXP_NZ: "transc.exp x ~= 0"
- by (import transc EXP_NZ)
-
-lemma EXP_POS_LT: "0 < transc.exp x"
- by (import transc EXP_POS_LT)
-
-lemma EXP_N: "transc.exp (real n * x) = transc.exp x ^ n"
- by (import transc EXP_N)
-
-lemma EXP_SUB: "transc.exp (x - y) = transc.exp x / transc.exp y"
- by (import transc EXP_SUB)
-
-lemma EXP_MONO_IMP: "x < y ==> transc.exp x < transc.exp y"
- by (import transc EXP_MONO_IMP)
-
-lemma EXP_MONO_LT: "(transc.exp x < transc.exp y) = (x < y)"
- by (import transc EXP_MONO_LT)
-
-lemma EXP_MONO_LE: "(transc.exp x <= transc.exp y) = (x <= y)"
- by (import transc EXP_MONO_LE)
-
-lemma EXP_INJ: "(transc.exp x = transc.exp y) = (x = y)"
- by (import transc EXP_INJ)
-
-lemma EXP_TOTAL_LEMMA: "1 <= y ==> EX x>=0. x <= y - 1 & transc.exp x = y"
- by (import transc EXP_TOTAL_LEMMA)
-
-lemma EXP_TOTAL: "0 < y ==> EX x. transc.exp x = y"
- by (import transc EXP_TOTAL)
-
-consts
- ln :: "real => real"
-
-defs
- ln_def: "transc.ln == %x. SOME u. transc.exp u = x"
-
-lemma ln: "transc.ln x = (SOME u. transc.exp u = x)"
- by (import transc ln)
-
-lemma LN_EXP: "transc.ln (transc.exp x) = x"
- by (import transc LN_EXP)
-
-lemma EXP_LN: "(transc.exp (transc.ln x) = x) = (0 < x)"
- by (import transc EXP_LN)
-
-lemma LN_MUL: "0 < x & 0 < y ==> transc.ln (x * y) = transc.ln x + transc.ln y"
- by (import transc LN_MUL)
-
-lemma LN_INJ: "0 < x & 0 < y ==> (transc.ln x = transc.ln y) = (x = y)"
- by (import transc LN_INJ)
-
-lemma LN_1: "transc.ln 1 = 0"
- by (import transc LN_1)
-
-lemma LN_INV: "0 < x ==> transc.ln (inverse x) = - transc.ln x"
- by (import transc LN_INV)
-
-lemma LN_DIV: "0 < x & 0 < y ==> transc.ln (x / y) = transc.ln x - transc.ln y"
- by (import transc LN_DIV)
-
-lemma LN_MONO_LT: "0 < x & 0 < y ==> (transc.ln x < transc.ln y) = (x < y)"
- by (import transc LN_MONO_LT)
-
-lemma LN_MONO_LE: "0 < x & 0 < y ==> (transc.ln x <= transc.ln y) = (x <= y)"
- by (import transc LN_MONO_LE)
-
-lemma LN_POW: "0 < x ==> transc.ln (x ^ n) = real n * transc.ln x"
- by (import transc LN_POW)
-
-lemma LN_LE: "0 <= x ==> transc.ln (1 + x) <= x"
- by (import transc LN_LE)
-
-lemma LN_LT_X: "0 < x ==> transc.ln x < x"
- by (import transc LN_LT_X)
-
-lemma LN_POS: "1 <= x ==> 0 <= transc.ln x"
- by (import transc LN_POS)
-
-consts
- root :: "nat => real => real"
-
-defs
- root_def: "transc.root == %n x. SOME u. (0 < x --> 0 < u) & u ^ n = x"
-
-lemma root: "transc.root n x = (SOME u. (0 < x --> 0 < u) & u ^ n = x)"
- by (import transc root)
-
-consts
- sqrt :: "real => real"
-
-defs
- sqrt_def: "transc.sqrt == transc.root 2"
-
-lemma sqrt: "transc.sqrt x = transc.root 2 x"
- by (import transc sqrt)
-
-lemma ROOT_LT_LEMMA: "0 < x ==> transc.exp (transc.ln x / real (Suc n)) ^ Suc n = x"
- by (import transc ROOT_LT_LEMMA)
-
-lemma ROOT_LN: "0 < x ==> transc.root (Suc n) x = transc.exp (transc.ln x / real (Suc n))"
- by (import transc ROOT_LN)
-
-lemma ROOT_0: "transc.root (Suc n) 0 = 0"
- by (import transc ROOT_0)
-
-lemma ROOT_1: "transc.root (Suc n) 1 = 1"
- by (import transc ROOT_1)
-
-lemma ROOT_POS_LT: "0 < x ==> 0 < transc.root (Suc n) x"
- by (import transc ROOT_POS_LT)
-
-lemma ROOT_POW_POS: "0 <= x ==> transc.root (Suc n) x ^ Suc n = x"
- by (import transc ROOT_POW_POS)
-
-lemma POW_ROOT_POS: "0 <= x ==> transc.root (Suc n) (x ^ Suc n) = x"
- by (import transc POW_ROOT_POS)
-
-lemma ROOT_POS: "0 <= x ==> 0 <= transc.root (Suc n) x"
- by (import transc ROOT_POS)
-
-lemma ROOT_POS_UNIQ: "0 <= x & 0 <= y & y ^ Suc n = x ==> transc.root (Suc n) x = y"
- by (import transc ROOT_POS_UNIQ)
-
-lemma ROOT_MUL: "0 <= x & 0 <= y
-==> transc.root (Suc n) (x * y) =
- transc.root (Suc n) x * transc.root (Suc n) y"
- by (import transc ROOT_MUL)
-
-lemma ROOT_INV: "0 <= x ==> transc.root (Suc n) (inverse x) = inverse (transc.root (Suc n) x)"
- by (import transc ROOT_INV)
-
-lemma ROOT_DIV: "0 <= xa & 0 <= xb
-==> transc.root (Suc x) (xa / xb) =
- transc.root (Suc x) xa / transc.root (Suc x) xb"
- by (import transc ROOT_DIV)
-
-lemma ROOT_MONO_LE: "0 <= x & x <= y ==> transc.root (Suc n) x <= transc.root (Suc n) y"
- by (import transc ROOT_MONO_LE)
-
-lemma SQRT_0: "transc.sqrt 0 = 0"
- by (import transc SQRT_0)
-
-lemma SQRT_1: "transc.sqrt 1 = 1"
- by (import transc SQRT_1)
-
-lemma SQRT_POS_LT: "0 < x ==> 0 < transc.sqrt x"
- by (import transc SQRT_POS_LT)
-
-lemma SQRT_POS_LE: "0 <= x ==> 0 <= transc.sqrt x"
- by (import transc SQRT_POS_LE)
-
-lemma SQRT_POW2: "(transc.sqrt x ^ 2 = x) = (0 <= x)"
- by (import transc SQRT_POW2)
-
-lemma SQRT_POW_2: "0 <= x ==> transc.sqrt x ^ 2 = x"
- by (import transc SQRT_POW_2)
-
-lemma POW_2_SQRT: "0 <= x ==> transc.sqrt (x ^ 2) = x"
- by (import transc POW_2_SQRT)
-
-lemma SQRT_POS_UNIQ: "0 <= x & 0 <= xa & xa ^ 2 = x ==> transc.sqrt x = xa"
- by (import transc SQRT_POS_UNIQ)
-
-lemma SQRT_MUL: "0 <= x & 0 <= xa ==> transc.sqrt (x * xa) = transc.sqrt x * transc.sqrt xa"
- by (import transc SQRT_MUL)
-
-lemma SQRT_INV: "0 <= x ==> transc.sqrt (inverse x) = inverse (transc.sqrt x)"
- by (import transc SQRT_INV)
-
-lemma SQRT_DIV: "0 <= x & 0 <= xa ==> transc.sqrt (x / xa) = transc.sqrt x / transc.sqrt xa"
- by (import transc SQRT_DIV)
-
-lemma SQRT_MONO_LE: "0 <= x & x <= xa ==> transc.sqrt x <= transc.sqrt xa"
- by (import transc SQRT_MONO_LE)
-
-lemma SQRT_EVEN_POW2: "EVEN n ==> transc.sqrt (2 ^ n) = 2 ^ (n div 2)"
- by (import transc SQRT_EVEN_POW2)
-
-lemma REAL_DIV_SQRT: "0 <= x ==> x / transc.sqrt x = transc.sqrt x"
- by (import transc REAL_DIV_SQRT)
-
-lemma SQRT_EQ: "x ^ 2 = y & 0 <= x ==> x = transc.sqrt y"
- by (import transc SQRT_EQ)
-
-lemma SIN_0: "transc.sin 0 = 0"
- by (import transc SIN_0)
-
-lemma COS_0: "transc.cos 0 = 1"
- by (import transc COS_0)
-
-lemma SIN_CIRCLE: "transc.sin x ^ 2 + transc.cos x ^ 2 = 1"
- by (import transc SIN_CIRCLE)
-
-lemma SIN_BOUND: "abs (transc.sin x) <= 1"
- by (import transc SIN_BOUND)
-
-lemma SIN_BOUNDS: "- 1 <= transc.sin x & transc.sin x <= 1"
- by (import transc SIN_BOUNDS)
-
-lemma COS_BOUND: "abs (transc.cos x) <= 1"
- by (import transc COS_BOUND)
-
-lemma COS_BOUNDS: "- 1 <= transc.cos x & transc.cos x <= 1"
- by (import transc COS_BOUNDS)
-
-lemma SIN_COS_ADD: "(transc.sin (x + y) -
- (transc.sin x * transc.cos y + transc.cos x * transc.sin y)) ^
-2 +
-(transc.cos (x + y) -
- (transc.cos x * transc.cos y - transc.sin x * transc.sin y)) ^
-2 =
-0"
- by (import transc SIN_COS_ADD)
-
-lemma SIN_COS_NEG: "(transc.sin (- x) + transc.sin x) ^ 2 +
-(transc.cos (- x) - transc.cos x) ^ 2 =
-0"
- by (import transc SIN_COS_NEG)
-
-lemma SIN_ADD: "transc.sin (x + y) =
-transc.sin x * transc.cos y + transc.cos x * transc.sin y"
- by (import transc SIN_ADD)
-
-lemma COS_ADD: "transc.cos (x + y) =
-transc.cos x * transc.cos y - transc.sin x * transc.sin y"
- by (import transc COS_ADD)
-
-lemma SIN_NEG: "transc.sin (- x) = - transc.sin x"
- by (import transc SIN_NEG)
-
-lemma COS_NEG: "transc.cos (- x) = transc.cos x"
- by (import transc COS_NEG)
-
-lemma SIN_DOUBLE: "transc.sin (2 * x) = 2 * (transc.sin x * transc.cos x)"
- by (import transc SIN_DOUBLE)
-
-lemma COS_DOUBLE: "transc.cos (2 * x) = transc.cos x ^ 2 - transc.sin x ^ 2"
- by (import transc COS_DOUBLE)
-
-lemma SIN_PAIRED: "seq.sums (%n. (- 1) ^ n / real (FACT (2 * n + 1)) * x ^ (2 * n + 1))
- (transc.sin x)"
- by (import transc SIN_PAIRED)
-
-lemma SIN_POS: "0 < x & x < 2 ==> 0 < transc.sin x"
- by (import transc SIN_POS)
-
-lemma COS_PAIRED: "seq.sums (%n. (- 1) ^ n / real (FACT (2 * n)) * x ^ (2 * n)) (transc.cos x)"
- by (import transc COS_PAIRED)
-
-lemma COS_2: "transc.cos 2 < 0"
- by (import transc COS_2)
-
-lemma COS_ISZERO: "EX! x. 0 <= x & x <= 2 & transc.cos x = 0"
- by (import transc COS_ISZERO)
-
-consts
- pi :: "real"
-
-defs
- pi_def: "transc.pi == 2 * (SOME x. 0 <= x & x <= 2 & transc.cos x = 0)"
-
-lemma pi: "transc.pi = 2 * (SOME x. 0 <= x & x <= 2 & transc.cos x = 0)"
- by (import transc pi)
-
-lemma PI2: "transc.pi / 2 = (SOME x. 0 <= x & x <= 2 & transc.cos x = 0)"
- by (import transc PI2)
-
-lemma COS_PI2: "transc.cos (transc.pi / 2) = 0"
- by (import transc COS_PI2)
-
-lemma PI2_BOUNDS: "0 < transc.pi / 2 & transc.pi / 2 < 2"
- by (import transc PI2_BOUNDS)
-
-lemma PI_POS: "0 < transc.pi"
- by (import transc PI_POS)
-
-lemma SIN_PI2: "transc.sin (transc.pi / 2) = 1"
- by (import transc SIN_PI2)
-
-lemma COS_PI: "transc.cos transc.pi = - 1"
- by (import transc COS_PI)
-
-lemma SIN_PI: "transc.sin transc.pi = 0"
- by (import transc SIN_PI)
-
-lemma SIN_COS: "transc.sin x = transc.cos (transc.pi / 2 - x)"
- by (import transc SIN_COS)
-
-lemma COS_SIN: "transc.cos x = transc.sin (transc.pi / 2 - x)"
- by (import transc COS_SIN)
-
-lemma SIN_PERIODIC_PI: "transc.sin (x + transc.pi) = - transc.sin x"
- by (import transc SIN_PERIODIC_PI)
-
-lemma COS_PERIODIC_PI: "transc.cos (x + transc.pi) = - transc.cos x"
- by (import transc COS_PERIODIC_PI)
-
-lemma SIN_PERIODIC: "transc.sin (x + 2 * transc.pi) = transc.sin x"
- by (import transc SIN_PERIODIC)
-
-lemma COS_PERIODIC: "transc.cos (x + 2 * transc.pi) = transc.cos x"
- by (import transc COS_PERIODIC)
-
-lemma COS_NPI: "transc.cos (real n * transc.pi) = (- 1) ^ n"
- by (import transc COS_NPI)
-
-lemma SIN_NPI: "transc.sin (real (n::nat) * transc.pi) = (0::real)"
- by (import transc SIN_NPI)
-
-lemma SIN_POS_PI2: "0 < x & x < transc.pi / 2 ==> 0 < transc.sin x"
- by (import transc SIN_POS_PI2)
-
-lemma COS_POS_PI2: "0 < x & x < transc.pi / 2 ==> 0 < transc.cos x"
- by (import transc COS_POS_PI2)
-
-lemma COS_POS_PI: "- (transc.pi / 2) < x & x < transc.pi / 2 ==> 0 < transc.cos x"
- by (import transc COS_POS_PI)
-
-lemma SIN_POS_PI: "0 < x & x < transc.pi ==> 0 < transc.sin x"
- by (import transc SIN_POS_PI)
-
-lemma COS_POS_PI2_LE: "0 <= x & x <= transc.pi / 2 ==> 0 <= transc.cos x"
- by (import transc COS_POS_PI2_LE)
-
-lemma COS_POS_PI_LE: "- (transc.pi / 2) <= x & x <= transc.pi / 2 ==> 0 <= transc.cos x"
- by (import transc COS_POS_PI_LE)
-
-lemma SIN_POS_PI2_LE: "0 <= x & x <= transc.pi / 2 ==> 0 <= transc.sin x"
- by (import transc SIN_POS_PI2_LE)
-
-lemma SIN_POS_PI_LE: "0 <= x & x <= transc.pi ==> 0 <= transc.sin x"
- by (import transc SIN_POS_PI_LE)
-
-lemma COS_TOTAL: "- 1 <= y & y <= 1 ==> EX! x. 0 <= x & x <= transc.pi & transc.cos x = y"
- by (import transc COS_TOTAL)
-
-lemma SIN_TOTAL: "- 1 <= y & y <= 1
-==> EX! x. - (transc.pi / 2) <= x & x <= transc.pi / 2 & transc.sin x = y"
- by (import transc SIN_TOTAL)
-
-lemma COS_ZERO_LEMMA: "0 <= x & transc.cos x = 0 ==> EX n. ~ EVEN n & x = real n * (transc.pi / 2)"
- by (import transc COS_ZERO_LEMMA)
-
-lemma SIN_ZERO_LEMMA: "0 <= x & transc.sin x = 0 ==> EX n. EVEN n & x = real n * (transc.pi / 2)"
- by (import transc SIN_ZERO_LEMMA)
-
-lemma COS_ZERO: "(transc.cos x = 0) =
-((EX n. ~ EVEN n & x = real n * (transc.pi / 2)) |
- (EX n. ~ EVEN n & x = - (real n * (transc.pi / 2))))"
- by (import transc COS_ZERO)
-
-lemma SIN_ZERO: "(transc.sin x = 0) =
-((EX n. EVEN n & x = real n * (transc.pi / 2)) |
- (EX n. EVEN n & x = - (real n * (transc.pi / 2))))"
- by (import transc SIN_ZERO)
-
-consts
- tan :: "real => real"
-
-defs
- tan_def: "transc.tan == %x. transc.sin x / transc.cos x"
-
-lemma tan: "transc.tan x = transc.sin x / transc.cos x"
- by (import transc tan)
-
-lemma TAN_0: "transc.tan 0 = 0"
- by (import transc TAN_0)
-
-lemma TAN_PI: "transc.tan transc.pi = 0"
- by (import transc TAN_PI)
-
-lemma TAN_NPI: "transc.tan (real (n::nat) * transc.pi) = (0::real)"
- by (import transc TAN_NPI)
-
-lemma TAN_NEG: "transc.tan (- x) = - transc.tan x"
- by (import transc TAN_NEG)
-
-lemma TAN_PERIODIC: "transc.tan (x + 2 * transc.pi) = transc.tan x"
- by (import transc TAN_PERIODIC)
-
-lemma TAN_ADD: "transc.cos x ~= 0 & transc.cos y ~= 0 & transc.cos (x + y) ~= 0
-==> transc.tan (x + y) =
- (transc.tan x + transc.tan y) / (1 - transc.tan x * transc.tan y)"
- by (import transc TAN_ADD)
-
-lemma TAN_DOUBLE: "transc.cos x ~= 0 & transc.cos (2 * x) ~= 0
-==> transc.tan (2 * x) = 2 * transc.tan x / (1 - transc.tan x ^ 2)"
- by (import transc TAN_DOUBLE)
-
-lemma TAN_POS_PI2: "0 < x & x < transc.pi / 2 ==> 0 < transc.tan x"
- by (import transc TAN_POS_PI2)
-
-lemma DIFF_TAN: "transc.cos x ~= 0 ==> diffl transc.tan (inverse (transc.cos x ^ 2)) x"
- by (import transc DIFF_TAN)
-
-lemma TAN_TOTAL_LEMMA: "0 < y ==> EX x>0. x < transc.pi / 2 & y < transc.tan x"
- by (import transc TAN_TOTAL_LEMMA)
-
-lemma TAN_TOTAL_POS: "0 <= y ==> EX x>=0. x < transc.pi / 2 & transc.tan x = y"
- by (import transc TAN_TOTAL_POS)
-
-lemma TAN_TOTAL: "EX! x. - (transc.pi / 2) < x & x < transc.pi / 2 & transc.tan x = y"
- by (import transc TAN_TOTAL)
-
-definition
- asn :: "real => real" where
- "asn ==
-%y. SOME x. - (transc.pi / 2) <= x & x <= transc.pi / 2 & transc.sin x = y"
-
-lemma asn: "asn y =
-(SOME x. - (transc.pi / 2) <= x & x <= transc.pi / 2 & transc.sin x = y)"
- by (import transc asn)
-
-definition
- acs :: "real => real" where
- "acs == %y. SOME x. 0 <= x & x <= transc.pi & transc.cos x = y"
-
-lemma acs: "acs y = (SOME x. 0 <= x & x <= transc.pi & transc.cos x = y)"
- by (import transc acs)
-
-definition
- atn :: "real => real" where
- "atn ==
-%y. SOME x. - (transc.pi / 2) < x & x < transc.pi / 2 & transc.tan x = y"
-
-lemma atn: "atn y =
-(SOME x. - (transc.pi / 2) < x & x < transc.pi / 2 & transc.tan x = y)"
- by (import transc atn)
-
-lemma ASN: "- 1 <= y & y <= 1
-==> - (transc.pi / 2) <= asn y &
- asn y <= transc.pi / 2 & transc.sin (asn y) = y"
- by (import transc ASN)
-
-lemma ASN_SIN: "- 1 <= y & y <= 1 ==> transc.sin (asn y) = y"
- by (import transc ASN_SIN)
-
-lemma ASN_BOUNDS: "- 1 <= y & y <= 1 ==> - (transc.pi / 2) <= asn y & asn y <= transc.pi / 2"
- by (import transc ASN_BOUNDS)
-
-lemma ASN_BOUNDS_LT: "- 1 < y & y < 1 ==> - (transc.pi / 2) < asn y & asn y < transc.pi / 2"
- by (import transc ASN_BOUNDS_LT)
-
-lemma SIN_ASN: "- (transc.pi / 2) <= x & x <= transc.pi / 2 ==> asn (transc.sin x) = x"
- by (import transc SIN_ASN)
-
-lemma ACS: "- 1 <= y & y <= 1
-==> 0 <= acs y & acs y <= transc.pi & transc.cos (acs y) = y"
- by (import transc ACS)
-
-lemma ACS_COS: "- 1 <= y & y <= 1 ==> transc.cos (acs y) = y"
- by (import transc ACS_COS)
-
-lemma ACS_BOUNDS: "- 1 <= y & y <= 1 ==> 0 <= acs y & acs y <= transc.pi"
- by (import transc ACS_BOUNDS)
-
-lemma ACS_BOUNDS_LT: "- 1 < y & y < 1 ==> 0 < acs y & acs y < transc.pi"
- by (import transc ACS_BOUNDS_LT)
-
-lemma COS_ACS: "0 <= x & x <= transc.pi ==> acs (transc.cos x) = x"
- by (import transc COS_ACS)
-
-lemma ATN: "- (transc.pi / 2) < atn y & atn y < transc.pi / 2 & transc.tan (atn y) = y"
- by (import transc ATN)
-
-lemma ATN_TAN: "transc.tan (atn x) = x"
- by (import transc ATN_TAN)
-
-lemma ATN_BOUNDS: "- (transc.pi / 2) < atn x & atn x < transc.pi / 2"
- by (import transc ATN_BOUNDS)
-
-lemma TAN_ATN: "- (transc.pi / 2) < x & x < transc.pi / 2 ==> atn (transc.tan x) = x"
- by (import transc TAN_ATN)
-
-lemma TAN_SEC: "transc.cos x ~= 0 ==> 1 + transc.tan x ^ 2 = inverse (transc.cos x) ^ 2"
- by (import transc TAN_SEC)
-
-lemma SIN_COS_SQ: "0 <= x & x <= transc.pi
-==> transc.sin x = transc.sqrt (1 - transc.cos x ^ 2)"
- by (import transc SIN_COS_SQ)
-
-lemma COS_SIN_SQ: "- (transc.pi / 2) <= x & x <= transc.pi / 2
-==> transc.cos x = transc.sqrt (1 - transc.sin x ^ 2)"
- by (import transc COS_SIN_SQ)
-
-lemma COS_ATN_NZ: "transc.cos (atn x) ~= 0"
- by (import transc COS_ATN_NZ)
-
-lemma COS_ASN_NZ: "- 1 < x & x < 1 ==> transc.cos (asn x) ~= 0"
- by (import transc COS_ASN_NZ)
-
-lemma SIN_ACS_NZ: "- 1 < x & x < 1 ==> transc.sin (acs x) ~= 0"
- by (import transc SIN_ACS_NZ)
-
-lemma COS_SIN_SQRT: "0 <= transc.cos x ==> transc.cos x = transc.sqrt (1 - transc.sin x ^ 2)"
- by (import transc COS_SIN_SQRT)
-
-lemma SIN_COS_SQRT: "0 <= transc.sin x ==> transc.sin x = transc.sqrt (1 - transc.cos x ^ 2)"
- by (import transc SIN_COS_SQRT)
-
-lemma DIFF_LN: "0 < x ==> diffl transc.ln (inverse x) x"
- by (import transc DIFF_LN)
-
-lemma DIFF_ASN_LEMMA: "- 1 < x & x < 1 ==> diffl asn (inverse (transc.cos (asn x))) x"
- by (import transc DIFF_ASN_LEMMA)
-
-lemma DIFF_ASN: "- 1 < x & x < 1 ==> diffl asn (inverse (transc.sqrt (1 - x ^ 2))) x"
- by (import transc DIFF_ASN)
-
-lemma DIFF_ACS_LEMMA: "- 1 < x & x < 1 ==> diffl acs (inverse (- transc.sin (acs x))) x"
- by (import transc DIFF_ACS_LEMMA)
-
-lemma DIFF_ACS: "- 1 < x & x < 1 ==> diffl acs (- inverse (transc.sqrt (1 - x ^ 2))) x"
- by (import transc DIFF_ACS)
-
-lemma DIFF_ATN: "diffl atn (inverse (1 + x ^ 2)) x"
- by (import transc DIFF_ATN)
-
-definition
- division :: "real * real => (nat => real) => bool" where
- "division ==
-%(a, b) D.
- D 0 = a & (EX N. (ALL n<N. D n < D (Suc n)) & (ALL n>=N. D n = b))"
-
-lemma division: "division (a, b) D =
-(D 0 = a & (EX N. (ALL n<N. D n < D (Suc n)) & (ALL n>=N. D n = b)))"
- by (import transc division)
-
-definition
- dsize :: "(nat => real) => nat" where
- "dsize == %D. SOME N. (ALL n<N. D n < D (Suc n)) & (ALL n>=N. D n = D N)"
-
-lemma dsize: "dsize D = (SOME N. (ALL n<N. D n < D (Suc n)) & (ALL n>=N. D n = D N))"
- by (import transc dsize)
-
-definition
- tdiv :: "real * real => (nat => real) * (nat => real) => bool" where
- "tdiv ==
-%(a, b) (D, p). division (a, b) D & (ALL n. D n <= p n & p n <= D (Suc n))"
-
-lemma tdiv: "tdiv (a, b) (D, p) =
-(division (a, b) D & (ALL n. D n <= p n & p n <= D (Suc n)))"
- by (import transc tdiv)
-
-definition
- gauge :: "(real => bool) => (real => real) => bool" where
- "gauge == %E g. ALL x. E x --> 0 < g x"
-
-lemma gauge: "gauge E g = (ALL x. E x --> 0 < g x)"
- by (import transc gauge)
-
-definition
- fine :: "(real => real) => (nat => real) * (nat => real) => bool" where
- "fine == %g (D, p). ALL n<dsize D. D (Suc n) - D n < g (p n)"
-
-lemma fine: "fine g (D, p) = (ALL n<dsize D. D (Suc n) - D n < g (p n))"
- by (import transc fine)
-
-definition
- rsum :: "(nat => real) * (nat => real) => (real => real) => real" where
- "rsum == %(D, p) f. real.sum (0, dsize D) (%n. f (p n) * (D (Suc n) - D n))"
-
-lemma rsum: "rsum (D, p) f = real.sum (0, dsize D) (%n. f (p n) * (D (Suc n) - D n))"
- by (import transc rsum)
-
-definition
- Dint :: "real * real => (real => real) => real => bool" where
- "Dint ==
-%(a, b) f k.
- ALL e>0.
- EX g. gauge (%x. a <= x & x <= b) g &
- (ALL D p.
- tdiv (a, b) (D, p) & fine g (D, p) -->
- abs (rsum (D, p) f - k) < e)"
-
-lemma Dint: "Dint (a, b) f k =
-(ALL e>0.
- EX g. gauge (%x. a <= x & x <= b) g &
- (ALL D p.
- tdiv (a, b) (D, p) & fine g (D, p) -->
- abs (rsum (D, p) f - k) < e))"
- by (import transc Dint)
-
-lemma DIVISION_0: "a = b ==> dsize (%n. if n = 0 then a else b) = 0"
- by (import transc DIVISION_0)
-
-lemma DIVISION_1: "a < b ==> dsize (%n. if n = 0 then a else b) = 1"
- by (import transc DIVISION_1)
-
-lemma DIVISION_SINGLE: "a <= b ==> division (a, b) (%n. if n = 0 then a else b)"
- by (import transc DIVISION_SINGLE)
-
-lemma DIVISION_LHS: "division (a, b) D ==> D 0 = a"
- by (import transc DIVISION_LHS)
-
-lemma DIVISION_THM: "division (a, b) D =
-(D 0 = a & (ALL n<dsize D. D n < D (Suc n)) & (ALL n>=dsize D. D n = b))"
- by (import transc DIVISION_THM)
-
-lemma DIVISION_RHS: "division (a, b) D ==> D (dsize D) = b"
- by (import transc DIVISION_RHS)
-
-lemma DIVISION_LT_GEN: "division (a, b) D & m < n & n <= dsize D ==> D m < D n"
- by (import transc DIVISION_LT_GEN)
-
-lemma DIVISION_LT: "[| division (a, b) D; n < dsize D |] ==> D 0 < D (Suc n)"
- by (import transc DIVISION_LT)
-
-lemma DIVISION_LE: "division (a, b) D ==> a <= b"
- by (import transc DIVISION_LE)
-
-lemma DIVISION_GT: "[| division (a, b) D; n < dsize D |] ==> D n < D (dsize D)"
- by (import transc DIVISION_GT)
-
-lemma DIVISION_EQ: "division (a, b) D ==> (a = b) = (dsize D = 0)"
- by (import transc DIVISION_EQ)
-
-lemma DIVISION_LBOUND: "division (a, b) D ==> a <= D r"
- by (import transc DIVISION_LBOUND)
-
-lemma DIVISION_LBOUND_LT: "division (a, b) D & dsize D ~= 0 ==> a < D (Suc n)"
- by (import transc DIVISION_LBOUND_LT)
-
-lemma DIVISION_UBOUND: "division (a, b) D ==> D r <= b"
- by (import transc DIVISION_UBOUND)
-
-lemma DIVISION_UBOUND_LT: "division (a, b) D & n < dsize D ==> D n < b"
- by (import transc DIVISION_UBOUND_LT)
-
-lemma DIVISION_APPEND: "(EX D1 p1. tdiv (a, b) (D1, p1) & fine g (D1, p1)) &
-(EX D2 p2. tdiv (b, c) (D2, p2) & fine g (D2, p2))
-==> EX x p. tdiv (a, c) (x, p) & fine g (x, p)"
- by (import transc DIVISION_APPEND)
-
-lemma DIVISION_EXISTS: "a <= b & gauge (%x. a <= x & x <= b) g
-==> EX D p. tdiv (a, b) (D, p) & fine g (D, p)"
- by (import transc DIVISION_EXISTS)
-
-lemma GAUGE_MIN: "gauge E g1 & gauge E g2 ==> gauge E (%x. if g1 x < g2 x then g1 x else g2 x)"
- by (import transc GAUGE_MIN)
-
-lemma FINE_MIN: "fine (%x. if g1 x < g2 x then g1 x else g2 x) (D, p)
-==> fine g1 (D, p) & fine g2 (D, p)"
- by (import transc FINE_MIN)
-
-lemma DINT_UNIQ: "a <= b & Dint (a, b) f k1 & Dint (a, b) f k2 ==> k1 = k2"
- by (import transc DINT_UNIQ)
-
-lemma INTEGRAL_NULL: "Dint (a, a) f 0"
- by (import transc INTEGRAL_NULL)
-
-lemma FTC1: "a <= b & (ALL x. a <= x & x <= b --> diffl f (f' x) x)
-==> Dint (a, b) f' (f b - f a)"
- by (import transc FTC1)
-
-lemma MCLAURIN: "0 < h &
-0 < n &
-diff 0 = f &
-(ALL m t. m < n & 0 <= t & t <= h --> diffl (diff m) (diff (Suc m) t) t)
-==> EX t>0.
- t < h &
- f h =
- real.sum (0, n) (%m. diff m 0 / real (FACT m) * h ^ m) +
- diff n t / real (FACT n) * h ^ n"
- by (import transc MCLAURIN)
-
-lemma MCLAURIN_NEG: "h < 0 &
-0 < n &
-diff 0 = f &
-(ALL m t. m < n & h <= t & t <= 0 --> diffl (diff m) (diff (Suc m) t) t)
-==> EX t>h.
- t < 0 &
- f h =
- real.sum (0, n) (%m. diff m 0 / real (FACT m) * h ^ m) +
- diff n t / real (FACT n) * h ^ n"
- by (import transc MCLAURIN_NEG)
-
-lemma MCLAURIN_ALL_LT: "[| diff 0 = f & (ALL m x. diffl (diff m) (diff (Suc m) x) x);
- x ~= 0 & 0 < n |]
-==> EX t. 0 < abs t &
- abs t < abs x &
- f x =
- real.sum (0, n) (%m. diff m 0 / real (FACT m) * x ^ m) +
- diff n t / real (FACT n) * x ^ n"
- by (import transc MCLAURIN_ALL_LT)
-
-lemma MCLAURIN_ZERO: "(x::real) = (0::real) & (0::nat) < (n::nat)
-==> real.sum (0::nat, n)
- (%m::nat.
- (diff::nat => real => real) m (0::real) / real (FACT m) * x ^ m) =
- diff (0::nat) (0::real)"
- by (import transc MCLAURIN_ZERO)
-
-lemma MCLAURIN_ALL_LE: "diff 0 = f & (ALL m x. diffl (diff m) (diff (Suc m) x) x)
-==> EX t. abs t <= abs x &
- f x =
- real.sum (0, n) (%m. diff m 0 / real (FACT m) * x ^ m) +
- diff n t / real (FACT n) * x ^ n"
- by (import transc MCLAURIN_ALL_LE)
-
-lemma MCLAURIN_EXP_LT: "x ~= 0 & 0 < n
-==> EX xa.
- 0 < abs xa &
- abs xa < abs x &
- transc.exp x =
- real.sum (0, n) (%m. x ^ m / real (FACT m)) +
- transc.exp xa / real (FACT n) * x ^ n"
- by (import transc MCLAURIN_EXP_LT)
-
-lemma MCLAURIN_EXP_LE: "EX xa.
- abs xa <= abs x &
- transc.exp x =
- real.sum (0, n) (%m. x ^ m / real (FACT m)) +
- transc.exp xa / real (FACT n) * x ^ n"
- by (import transc MCLAURIN_EXP_LE)
-
-lemma DIFF_LN_COMPOSITE: "diffl g m x & 0 < g x ==> diffl (%x. transc.ln (g x)) (inverse (g x) * m) x"
- by (import transc DIFF_LN_COMPOSITE)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" poly
-
-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)"
- 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.
- 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)
-
-consts
- "##" :: "real => real list => real list" ("##")
-
-specification ("##") poly_cmul_def: "(ALL c. ## c [] = []) & (ALL c h t. ## 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)"
- 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.
- poly_mul (h # t) l2 =
- (if t = [] then ## h l2 else poly_add (## h l2) (0 # 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))"
- 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)"
- by (import poly poly_diff_aux_def)
-
-definition
- diff :: "real list => real list" where
- "diff == %l. if l = [] then [] else poly_diff_aux 1 (tl l)"
-
-lemma poly_diff_def: "diff l = (if l = [] then [] else poly_diff_aux 1 (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"
- by (import poly POLY_ADD_CLAUSES)
-
-lemma POLY_CMUL_CLAUSES: "## c [] = [] & ## c (h # t) = c * h # ## c t"
- by (import poly POLY_CMUL_CLAUSES)
-
-lemma POLY_NEG_CLAUSES: "poly_neg [] = [] & poly_neg (h # t) = - 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)"
- by (import poly POLY_MUL_CLAUSES)
-
-lemma POLY_DIFF_CLAUSES: "diff [] = [] & diff [c] = [] & diff (h # t) = poly_diff_aux 1 t"
- by (import poly POLY_DIFF_CLAUSES)
-
-lemma POLY_ADD: "poly (poly_add t p2) x = poly t x + poly p2 x"
- by (import poly POLY_ADD)
-
-lemma POLY_CMUL: "poly (## c t) x = c * poly t x"
- by (import poly POLY_CMUL)
-
-lemma POLY_NEG: "poly (poly_neg x) xa = - poly x xa"
- by (import poly POLY_NEG)
-
-lemma POLY_MUL: "poly (poly_mul t p2) x = poly t x * poly p2 x"
- by (import poly POLY_MUL)
-
-lemma POLY_EXP: "poly (poly_exp p n) x = poly p x ^ n"
- by (import poly POLY_EXP)
-
-lemma POLY_DIFF_LEMMA: "diffl (%x. 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: "diffl (poly t) (poly (diff t) x) x"
- by (import poly POLY_DIFF)
-
-lemma POLY_DIFFERENTIABLE: "lim.differentiable (poly l) x"
- by (import poly POLY_DIFFERENTIABLE)
-
-lemma POLY_CONT: "contl (poly l) x"
- by (import poly POLY_CONT)
-
-lemma POLY_IVT_POS: "xa < xb & poly x xa < 0 & 0 < poly x xb
-==> EX xc>xa. xc < xb & poly x xc = 0"
- by (import poly POLY_IVT_POS)
-
-lemma POLY_IVT_NEG: "a < b & 0 < poly p a & poly p b < 0 ==> EX x>a. x < b & poly p x = 0"
- by (import poly POLY_IVT_NEG)
-
-lemma POLY_MVT: "a < b ==> EX x>a. x < b & poly p b - poly p a = (b - a) * poly (diff p) x"
- by (import poly POLY_MVT)
-
-lemma POLY_ADD_RZERO: "poly (poly_add x []) = poly x"
- by (import poly POLY_ADD_RZERO)
-
-lemma POLY_MUL_ASSOC: "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: "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: "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: "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: "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: "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: "poly (diff (poly_add t p2)) = poly (poly_add (diff t) (diff p2))"
- by (import poly POLY_DIFF_ADD)
-
-lemma POLY_DIFF_CMUL: "poly (diff (## c t)) = poly (## c (diff t))"
- by (import poly POLY_DIFF_CMUL)
-
-lemma POLY_DIFF_NEG: "poly (diff (poly_neg x)) = poly (poly_neg (diff x))"
- by (import poly POLY_DIFF_NEG)
-
-lemma POLY_DIFF_MUL_LEMMA: "poly (diff (xa # x)) = poly (poly_add (0 # diff x) x)"
- by (import poly POLY_DIFF_MUL_LEMMA)
-
-lemma POLY_DIFF_MUL: "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: "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: "poly (diff (poly_exp [- a, 1] (Suc n))) =
-poly (## (real (Suc n)) (poly_exp [- a, 1] n))"
- by (import poly POLY_DIFF_EXP_PRIME)
-
-lemma POLY_LINEAR_REM: "EX q r. h # t = poly_add [r] (poly_mul [- a, 1] q)"
- by (import poly POLY_LINEAR_REM)
-
-lemma POLY_LINEAR_DIVIDES: "(poly t a = 0) = (t = [] | (EX q. t = poly_mul [- a, 1] q))"
- by (import poly POLY_LINEAR_DIVIDES)
-
-lemma POLY_LENGTH_MUL: "length (poly_mul [- a, 1] x) = Suc (length x)"
- by (import poly POLY_LENGTH_MUL)
-
-lemma POLY_ROOTS_INDEX_LEMMA: "poly p ~= poly [] & length p = n
-==> EX i. ALL x. poly p x = 0 --> (EX m<=n. x = i m)"
- by (import poly POLY_ROOTS_INDEX_LEMMA)
-
-lemma POLY_ROOTS_INDEX_LENGTH: "poly p ~= poly []
-==> EX i. ALL x. poly p x = 0 --> (EX n<=length p. x = i n)"
- by (import poly POLY_ROOTS_INDEX_LENGTH)
-
-lemma POLY_ROOTS_FINITE_LEMMA: "poly (p::real list) ~= poly []
-==> EX (N::nat) i::nat => real.
- ALL x::real. poly p x = (0::real) --> (EX n<N. x = i n)"
- by (import poly POLY_ROOTS_FINITE_LEMMA)
-
-lemma FINITE_LEMMA: "(!!xb::real. (xa::real => bool) xb ==> EX n<x::nat. xb = (i::nat => real) n)
-==> EX a::real. ALL x::real. xa x --> x < a"
- by (import poly FINITE_LEMMA)
-
-lemma POLY_ROOTS_FINITE: "(poly (p::real list) ~= poly []) =
-(EX (N::nat) i::nat => real.
- ALL x::real. poly p x = (0::real) --> (EX n<N. x = i n))"
- by (import poly POLY_ROOTS_FINITE)
-
-lemma POLY_ENTIRE_LEMMA: "poly p ~= poly [] & poly q ~= poly [] ==> poly (poly_mul p q) ~= poly []"
- by (import poly POLY_ENTIRE_LEMMA)
-
-lemma POLY_ENTIRE: "(poly (poly_mul p q) = poly []) = (poly p = poly [] | poly q = poly [])"
- by (import poly POLY_ENTIRE)
-
-lemma POLY_MUL_LCANCEL: "(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: "(poly (poly_exp p n) = poly []) = (poly p = poly [] & n ~= 0)"
- by (import poly POLY_EXP_EQ_0)
-
-lemma POLY_PRIME_EQ_0: "poly [a, 1] ~= poly []"
- by (import poly POLY_PRIME_EQ_0)
-
-lemma POLY_EXP_PRIME_EQ_0: "poly (poly_exp [a, 1] n) ~= poly []"
- by (import poly POLY_EXP_PRIME_EQ_0)
-
-lemma POLY_ZERO_LEMMA: "poly (h # t) = poly [] ==> h = 0 & poly t = poly []"
- by (import poly POLY_ZERO_LEMMA)
-
-lemma POLY_ZERO: "(poly t = poly []) = list_all (%c. c = 0) t"
- by (import poly POLY_ZERO)
-
-lemma POLY_DIFF_AUX_ISZERO: "list_all (%c. c = 0) (poly_diff_aux (Suc n) t) = list_all (%c. c = 0) t"
- by (import poly POLY_DIFF_AUX_ISZERO)
-
-lemma POLY_DIFF_ISZERO: "poly (diff x) = poly [] ==> EX h. poly x = poly [h]"
- by (import poly POLY_DIFF_ISZERO)
-
-lemma POLY_DIFF_ZERO: "poly x = poly [] ==> poly (diff x) = poly []"
- by (import poly POLY_DIFF_ZERO)
-
-lemma POLY_DIFF_WELLDEF: "poly p = poly q ==> poly (diff p) = poly (diff q)"
- by (import poly POLY_DIFF_WELLDEF)
-
-definition
- poly_divides :: "real list => real list => bool" where
- "poly_divides == %p1 p2. EX q. poly p2 = poly (poly_mul p1 q)"
-
-lemma poly_divides: "poly_divides p1 p2 = (EX q. poly p2 = poly (poly_mul p1 q))"
- by (import poly poly_divides)
-
-lemma POLY_PRIMES: "poly_divides [a, 1] (poly_mul p q) =
-(poly_divides [a, 1] p | poly_divides [a, 1] q)"
- by (import poly POLY_PRIMES)
-
-lemma POLY_DIVIDES_REFL: "poly_divides p p"
- by (import poly POLY_DIVIDES_REFL)
-
-lemma POLY_DIVIDES_TRANS: "poly_divides p q & poly_divides q r ==> poly_divides p r"
- by (import poly POLY_DIVIDES_TRANS)
-
-lemma POLY_DIVIDES_EXP: "m <= n ==> poly_divides (poly_exp p m) (poly_exp p n)"
- by (import poly POLY_DIVIDES_EXP)
-
-lemma POLY_EXP_DIVIDES: "poly_divides (poly_exp p n) q & m <= n ==> poly_divides (poly_exp p m) q"
- by (import poly POLY_EXP_DIVIDES)
-
-lemma POLY_DIVIDES_ADD: "poly_divides p q & poly_divides p r ==> poly_divides p (poly_add q r)"
- by (import poly POLY_DIVIDES_ADD)
-
-lemma POLY_DIVIDES_SUB: "poly_divides p q & poly_divides p (poly_add q r) ==> poly_divides p r"
- by (import poly POLY_DIVIDES_SUB)
-
-lemma POLY_DIVIDES_SUB2: "poly_divides p r & poly_divides p (poly_add q r) ==> poly_divides p q"
- by (import poly POLY_DIVIDES_SUB2)
-
-lemma POLY_DIVIDES_ZERO: "poly p = poly [] ==> poly_divides q p"
- by (import poly POLY_DIVIDES_ZERO)
-
-lemma POLY_ORDER_EXISTS: "length p = d & poly p ~= poly []
-==> EX x. poly_divides (poly_exp [- a, 1] x) p &
- ~ poly_divides (poly_exp [- a, 1] (Suc x)) p"
- by (import poly POLY_ORDER_EXISTS)
-
-lemma POLY_ORDER: "poly p ~= poly []
-==> EX! n.
- poly_divides (poly_exp [- a, 1] n) p &
- ~ poly_divides (poly_exp [- a, 1] (Suc n)) p"
- by (import poly POLY_ORDER)
-
-definition
- poly_order :: "real => real list => nat" where
- "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: "poly_order a p =
-(SOME n.
- poly_divides (poly_exp [- a, 1] n) p &
- ~ poly_divides (poly_exp [- a, 1] (Suc n)) p)"
- by (import poly poly_order)
-
-lemma ORDER: "(poly_divides (poly_exp [- a, 1] n) p &
- ~ poly_divides (poly_exp [- a, 1] (Suc n)) p) =
-(n = poly_order a p & poly p ~= poly [])"
- by (import poly ORDER)
-
-lemma ORDER_THM: "poly p ~= poly []
-==> poly_divides (poly_exp [- a, 1] (poly_order a p)) p &
- ~ poly_divides (poly_exp [- a, 1] (Suc (poly_order a p))) p"
- by (import poly ORDER_THM)
-
-lemma ORDER_UNIQUE: "poly p ~= poly [] &
-poly_divides (poly_exp [- a, 1] n) p &
-~ poly_divides (poly_exp [- a, 1] (Suc n)) p
-==> n = poly_order a p"
- by (import poly ORDER_UNIQUE)
-
-lemma ORDER_POLY: "poly p = poly q ==> poly_order a p = poly_order a q"
- by (import poly ORDER_POLY)
-
-lemma ORDER_ROOT: "(poly p a = 0) = (poly p = poly [] | poly_order a p ~= 0)"
- by (import poly ORDER_ROOT)
-
-lemma ORDER_DIVIDES: "poly_divides (poly_exp [- a, 1] n) p =
-(poly p = poly [] | n <= poly_order a p)"
- by (import poly ORDER_DIVIDES)
-
-lemma ORDER_DECOMP: "poly p ~= poly []
-==> EX x. poly p = poly (poly_mul (poly_exp [- a, 1] (poly_order a p)) x) &
- ~ poly_divides [- a, 1] x"
- by (import poly ORDER_DECOMP)
-
-lemma ORDER_MUL: "poly (poly_mul p q) ~= poly []
-==> poly_order a (poly_mul p q) = poly_order a p + poly_order a q"
- by (import poly ORDER_MUL)
-
-lemma ORDER_DIFF: "poly (diff p) ~= poly [] & poly_order a p ~= 0
-==> poly_order a p = Suc (poly_order a (diff p))"
- by (import poly ORDER_DIFF)
-
-lemma POLY_SQUAREFREE_DECOMP_ORDER: "poly (diff p) ~= poly [] &
-poly p = poly (poly_mul q d) &
-poly (diff p) = poly (poly_mul e d) &
-poly d = poly (poly_add (poly_mul r p) (poly_mul s (diff p)))
-==> poly_order a q = (if poly_order a p = 0 then 0 else 1)"
- by (import poly POLY_SQUAREFREE_DECOMP_ORDER)
-
-definition
- rsquarefree :: "real list => bool" where
- "rsquarefree ==
-%p. poly p ~= poly [] & (ALL a. poly_order a p = 0 | poly_order a p = 1)"
-
-lemma rsquarefree: "rsquarefree p =
-(poly p ~= poly [] & (ALL a. poly_order a p = 0 | poly_order a p = 1))"
- by (import poly rsquarefree)
-
-lemma RSQUAREFREE_ROOTS: "rsquarefree p = (ALL a. ~ (poly p a = 0 & poly (diff p) a = 0))"
- by (import poly RSQUAREFREE_ROOTS)
-
-lemma RSQUAREFREE_DECOMP: "rsquarefree p & poly p a = 0
-==> EX q. poly p = poly (poly_mul [- a, 1] q) & poly q a ~= 0"
- by (import poly RSQUAREFREE_DECOMP)
-
-lemma POLY_SQUAREFREE_DECOMP: "poly (diff p) ~= poly [] &
-poly p = poly (poly_mul q d) &
-poly (diff p) = poly (poly_mul e d) &
-poly d = poly (poly_add (poly_mul r p) (poly_mul s (diff p)))
-==> rsquarefree q & (ALL x. (poly q x = 0) = (poly p x = 0))"
- by (import poly POLY_SQUAREFREE_DECOMP)
-
-consts
- normalize :: "real list => real list"
-
-specification (normalize) normalize: "normalize [] = [] &
-(ALL h t.
- normalize (h # t) =
- (if normalize t = [] then if h = 0 then [] else [h]
- else h # normalize t))"
- by (import poly normalize)
-
-lemma POLY_NORMALIZE: "poly (normalize t) = poly t"
- by (import poly POLY_NORMALIZE)
-
-definition
- degree :: "real list => nat" where
- "degree == %p. PRE (length (normalize p))"
-
-lemma degree: "degree p = PRE (length (normalize p))"
- by (import poly degree)
-
-lemma DEGREE_ZERO: "poly p = poly [] ==> degree p = 0"
- by (import poly DEGREE_ZERO)
-
-lemma POLY_ROOTS_FINITE_SET: "poly p ~= poly [] ==> FINITE (GSPEC (%x. (x, poly p x = 0)))"
- by (import poly POLY_ROOTS_FINITE_SET)
-
-lemma POLY_MONO: "abs x <= k ==> abs (poly xa x) <= poly (map abs xa) k"
- by (import poly POLY_MONO)
-
-;end_setup
-
-end
-
--- a/src/HOL/Import/HOL4/Generated/HOL4Vec.thy Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1105 +0,0 @@
-(* AUTOMATICALLY GENERATED, DO NOT EDIT! *)
-
-theory HOL4Vec imports HOL4Base begin
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" res_quan
-
-lemma RES_FORALL_CONJ_DIST: "RES_FORALL P (%i. 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: "RES_FORALL (%j. 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: "RES_FORALL (op = xa) x = x xa"
- by (import res_quan RES_FORALL_UNIQUE)
-
-lemma RES_FORALL_FORALL: "(ALL x::'b.
- RES_FORALL (P::'a => bool) (%i::'a. (R::'a => 'b => bool) i x)) =
-RES_FORALL P (%i::'a. All (R i))"
- by (import res_quan RES_FORALL_FORALL)
-
-lemma RES_FORALL_REORDER: "RES_FORALL P (%i. RES_FORALL Q (R i)) =
-RES_FORALL Q (%j. RES_FORALL P (%i. R i j))"
- by (import res_quan RES_FORALL_REORDER)
-
-lemma RES_FORALL_EMPTY: "RES_FORALL EMPTY x"
- by (import res_quan RES_FORALL_EMPTY)
-
-lemma RES_FORALL_UNIV: "RES_FORALL pred_set.UNIV p = All p"
- by (import res_quan RES_FORALL_UNIV)
-
-lemma RES_FORALL_NULL: "RES_FORALL p (%x. m) = (p = EMPTY | m)"
- by (import res_quan RES_FORALL_NULL)
-
-lemma RES_EXISTS_DISJ_DIST: "RES_EXISTS P (%i. 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: "RES_EXISTS (%i. 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: "RES_EXISTS (op = xa) x = x xa"
- by (import res_quan RES_EXISTS_EQUAL)
-
-lemma RES_EXISTS_REORDER: "RES_EXISTS P (%i. RES_EXISTS Q (R i)) =
-RES_EXISTS Q (%j. RES_EXISTS P (%i. R i j))"
- by (import res_quan RES_EXISTS_REORDER)
-
-lemma RES_EXISTS_EMPTY: "~ RES_EXISTS EMPTY p"
- by (import res_quan RES_EXISTS_EMPTY)
-
-lemma RES_EXISTS_UNIV: "RES_EXISTS pred_set.UNIV p = Ex p"
- by (import res_quan RES_EXISTS_UNIV)
-
-lemma RES_EXISTS_NULL: "RES_EXISTS p (%x. m) = (p ~= EMPTY & m)"
- by (import res_quan RES_EXISTS_NULL)
-
-lemma RES_EXISTS_ALT: "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: "~ RES_EXISTS_UNIQUE EMPTY p"
- by (import res_quan RES_EXISTS_UNIQUE_EMPTY)
-
-lemma RES_EXISTS_UNIQUE_UNIV: "RES_EXISTS_UNIQUE pred_set.UNIV p = Ex1 p"
- by (import res_quan RES_EXISTS_UNIQUE_UNIV)
-
-lemma RES_EXISTS_UNIQUE_NULL: "RES_EXISTS_UNIQUE p (%x. m) = ((EX x. p = INSERT x EMPTY) & m)"
- by (import res_quan RES_EXISTS_UNIQUE_NULL)
-
-lemma RES_EXISTS_UNIQUE_ALT: "RES_EXISTS_UNIQUE p m =
-RES_EXISTS p (%x. m x & RES_FORALL p (%y. m y --> y = x))"
- by (import res_quan RES_EXISTS_UNIQUE_ALT)
-
-lemma RES_SELECT_EMPTY: "RES_SELECT EMPTY p = (SOME x. False)"
- by (import res_quan RES_SELECT_EMPTY)
-
-lemma RES_SELECT_UNIV: "RES_SELECT pred_set.UNIV p = Eps p"
- by (import res_quan RES_SELECT_UNIV)
-
-lemma RES_ABSTRACT: "IN x p ==> RES_ABSTRACT p m x = m x"
- by (import res_quan RES_ABSTRACT)
-
-lemma RES_ABSTRACT_EQUAL: "(!!x. 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: "RES_ABSTRACT p (RES_ABSTRACT p m) = RES_ABSTRACT p m"
- by (import res_quan RES_ABSTRACT_IDEMPOT)
-
-lemma RES_ABSTRACT_EQUAL_EQ: "(RES_ABSTRACT p m1 = RES_ABSTRACT p m2) = (ALL x. IN x p --> m1 x = m2 x)"
- by (import res_quan RES_ABSTRACT_EQUAL_EQ)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" word_base
-
-typedef (open) ('a) word = "{x. ALL word.
- (ALL a0. (EX a. a0 = CONSTR 0 a (%n. BOTTOM)) --> word a0) -->
- word x} :: ('a::type list recspace set)"
- by (rule typedef_helper,import word_base word_TY_DEF)
-
-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"
-
-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)) -->
- word a0) -->
- word r) =
- (dest_word (mk_word r) = r))"
- by (import word_base word_repfns)
-
-consts
- word_base0 :: "'a list => 'a word"
-
-defs
- word_base0_primdef: "word_base0 == %a. mk_word (CONSTR 0 a (%n. BOTTOM))"
-
-lemma word_base0_def: "word_base0 = (%a. mk_word (CONSTR 0 a (%n. BOTTOM)))"
- by (import word_base word_base0_def)
-
-definition
- WORD :: "'a list => 'a word" where
- "WORD == word_base0"
-
-lemma WORD: "WORD = word_base0"
- by (import word_base WORD)
-
-consts
- word_case :: "('a list => 'b) => 'a word => 'b"
-
-specification (word_case_primdef: word_case) word_case_def: "ALL f a. word_base.word_case f (WORD a) = f a"
- by (import word_base word_case_def)
-
-consts
- word_size :: "('a => nat) => 'a word => nat"
-
-specification (word_size_primdef: word_size) word_size_def: "ALL f a. word_base.word_size f (WORD a) = 1 + Compatibility.list_size f a"
- by (import word_base word_size_def)
-
-lemma word_11: "(WORD a = WORD a') = (a = a')"
- by (import word_base word_11)
-
-lemma word_case_cong: "M = M' & (ALL a. M' = WORD a --> f a = f' a)
-==> word_base.word_case f M = word_base.word_case f' M'"
- by (import word_base word_case_cong)
-
-lemma word_nchotomy: "EX l. x = WORD l"
- by (import word_base word_nchotomy)
-
-lemma word_Axiom: "EX fn. ALL a. fn (WORD a) = f a"
- by (import word_base word_Axiom)
-
-lemma word_induction: "(!!a. P (WORD a)) ==> P x"
- by (import word_base word_induction)
-
-lemma word_Ax: "EX fn. ALL a. fn (WORD a) = f a"
- by (import word_base word_Ax)
-
-lemma WORD_11: "(WORD x = WORD xa) = (x = xa)"
- by (import word_base WORD_11)
-
-lemma word_induct: "(!!l. x (WORD l)) ==> x xa"
- by (import word_base word_induct)
-
-lemma word_cases: "EX l. x = WORD l"
- by (import word_base word_cases)
-
-consts
- WORDLEN :: "'a word => nat"
-
-specification (WORDLEN) WORDLEN_DEF: "ALL l. WORDLEN (WORD l) = length l"
- by (import word_base WORDLEN_DEF)
-
-consts
- PWORDLEN :: "nat => 'a word => bool"
-
-defs
- PWORDLEN_primdef: "PWORDLEN == %n. GSPEC (%w. (w, WORDLEN w = n))"
-
-lemma PWORDLEN_def: "PWORDLEN n = GSPEC (%w. (w, WORDLEN w = n))"
- by (import word_base PWORDLEN_def)
-
-lemma IN_PWORDLEN: "IN (WORD l) (PWORDLEN n) = (length l = n)"
- by (import word_base IN_PWORDLEN)
-
-lemma PWORDLEN: "IN w (PWORDLEN n) = (WORDLEN w = n)"
- by (import word_base PWORDLEN)
-
-lemma PWORDLEN0: "IN w (PWORDLEN 0) ==> w = WORD []"
- by (import word_base PWORDLEN0)
-
-lemma PWORDLEN1: "IN (WORD [x]) (PWORDLEN 1)"
- by (import word_base PWORDLEN1)
-
-consts
- WSEG :: "nat => nat => 'a word => 'a word"
-
-specification (WSEG) WSEG_DEF: "ALL m k l. WSEG m k (WORD l) = WORD (LASTN m (BUTLASTN k l))"
- by (import word_base WSEG_DEF)
-
-lemma WSEG0: "WSEG 0 k w = WORD []"
- by (import word_base WSEG0)
-
-lemma WSEG_PWORDLEN: "RES_FORALL (PWORDLEN n)
- (%w. ALL m k. m + k <= n --> IN (WSEG m k w) (PWORDLEN m))"
- by (import word_base WSEG_PWORDLEN)
-
-lemma WSEG_WORDLEN: "RES_FORALL (PWORDLEN x)
- (%xa. ALL xb xc. xb + xc <= x --> WORDLEN (WSEG xb xc xa) = xb)"
- by (import word_base WSEG_WORDLEN)
-
-lemma WSEG_WORD_LENGTH: "RES_FORALL (PWORDLEN n) (%w. WSEG n 0 w = w)"
- by (import word_base WSEG_WORD_LENGTH)
-
-consts
- bit :: "nat => 'a word => 'a"
-
-specification (bit) BIT_DEF: "ALL k l. bit k (WORD l) = ELL k l"
- by (import word_base BIT_DEF)
-
-lemma BIT0: "bit 0 (WORD [x]) = x"
- by (import word_base BIT0)
-
-lemma WSEG_BIT: "RES_FORALL (PWORDLEN n) (%w. ALL k<n. WSEG 1 k w = WORD [bit k w])"
- by (import word_base WSEG_BIT)
-
-lemma BIT_WSEG: "RES_FORALL (PWORDLEN n)
- (%w. ALL m k j.
- 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"
-
-specification (MSB) MSB_DEF: "ALL l. MSB (WORD l) = hd l"
- by (import word_base MSB_DEF)
-
-lemma MSB: "RES_FORALL (PWORDLEN n) (%w. 0 < n --> MSB w = bit (PRE n) w)"
- by (import word_base MSB)
-
-consts
- LSB :: "'a word => 'a"
-
-specification (LSB) LSB_DEF: "ALL l. LSB (WORD l) = last l"
- by (import word_base LSB_DEF)
-
-lemma LSB: "RES_FORALL (PWORDLEN n) (%w. 0 < n --> LSB w = bit 0 w)"
- by (import word_base LSB)
-
-consts
- WSPLIT :: "nat => 'a word => 'a word * 'a word"
-
-specification (WSPLIT) WSPLIT_DEF: "ALL m l. 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"
-
-specification (WCAT) WCAT_DEF: "ALL l1 l2. WCAT (WORD l1, WORD l2) = WORD (l1 @ l2)"
- by (import word_base WCAT_DEF)
-
-lemma WORD_PARTITION: "(ALL n::nat.
- RES_FORALL (PWORDLEN n)
- (%w::'a word. ALL m<=n. WCAT (WSPLIT m w) = w)) &
-(ALL (n::nat) m::nat.
- RES_FORALL (PWORDLEN n)
- (%w1::'a word.
- RES_FORALL (PWORDLEN m)
- (%w2::'a word. WSPLIT m (WCAT (w1, w2)) = (w1, w2))))"
- by (import word_base WORD_PARTITION)
-
-lemma WCAT_ASSOC: "WCAT (w1, WCAT (w2, w3)) = WCAT (WCAT (w1, w2), w3)"
- by (import word_base WCAT_ASSOC)
-
-lemma WCAT0: "WCAT (WORD [], w) = w & WCAT (w, WORD []) = w"
- by (import word_base WCAT0)
-
-lemma WCAT_11: "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)))))"
- by (import word_base WCAT_11)
-
-lemma WSPLIT_PWORDLEN: "RES_FORALL (PWORDLEN n)
- (%w. ALL m<=n.
- IN (fst (WSPLIT m w)) (PWORDLEN (n - m)) &
- IN (snd (WSPLIT m w)) (PWORDLEN m))"
- by (import word_base WSPLIT_PWORDLEN)
-
-lemma WCAT_PWORDLEN: "RES_FORALL (PWORDLEN n1)
- (%w1. ALL n2.
- RES_FORALL (PWORDLEN n2)
- (%w2. IN (WCAT (w1, w2)) (PWORDLEN (n1 + n2))))"
- by (import word_base WCAT_PWORDLEN)
-
-lemma WORDLEN_SUC_WCAT: "IN w (PWORDLEN (Suc n))
-==> RES_EXISTS (PWORDLEN 1)
- (%b. RES_EXISTS (PWORDLEN n) (%w'. w = WCAT (b, w')))"
- by (import word_base WORDLEN_SUC_WCAT)
-
-lemma WSEG_WSEG: "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)"
- by (import word_base WSEG_WSEG)
-
-lemma WSPLIT_WSEG: "RES_FORALL (PWORDLEN n)
- (%w. ALL k<=n. WSPLIT k w = (WSEG (n - k) k w, WSEG k 0 w))"
- by (import word_base WSPLIT_WSEG)
-
-lemma WSPLIT_WSEG1: "RES_FORALL (PWORDLEN n) (%w. ALL k<=n. fst (WSPLIT k w) = WSEG (n - k) k w)"
- by (import word_base WSPLIT_WSEG1)
-
-lemma WSPLIT_WSEG2: "RES_FORALL (PWORDLEN n) (%w. ALL k<=n. snd (WSPLIT k w) = WSEG k 0 w)"
- by (import word_base WSPLIT_WSEG2)
-
-lemma WCAT_WSEG_WSEG: "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)"
- by (import word_base WCAT_WSEG_WSEG)
-
-lemma WORD_SPLIT: "RES_FORALL (PWORDLEN (x + xa)) (%w. w = WCAT (WSEG x xa w, WSEG xa 0 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))"
- 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))"
- by (import word_base WORDLEN_SUC_WCAT_WSEG_WSEG_RIGHT)
-
-lemma WORDLEN_SUC_WCAT_BIT_WSEG: "RES_FORALL (PWORDLEN (Suc n)) (%w. w = WCAT (WORD [bit n w], WSEG n 0 w))"
- by (import word_base WORDLEN_SUC_WCAT_BIT_WSEG)
-
-lemma WORDLEN_SUC_WCAT_BIT_WSEG_RIGHT: "RES_FORALL (PWORDLEN (Suc n)) (%w. w = WCAT (WSEG n 1 w, WORD [bit 0 w]))"
- by (import word_base WORDLEN_SUC_WCAT_BIT_WSEG_RIGHT)
-
-lemma WSEG_WCAT1: "RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2) (%w2. WSEG n1 n2 (WCAT (w1, w2)) = w1))"
- by (import word_base WSEG_WCAT1)
-
-lemma WSEG_WCAT2: "RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2) (%w2. WSEG n2 0 (WCAT (w1, w2)) = w2))"
- by (import word_base WSEG_WCAT2)
-
-lemma WSEG_SUC: "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))"
- by (import word_base WSEG_SUC)
-
-lemma WORD_CONS_WCAT: "WORD (x # l) = WCAT (WORD [x], WORD l)"
- by (import word_base WORD_CONS_WCAT)
-
-lemma WORD_SNOC_WCAT: "WORD (SNOC x l) = WCAT (WORD l, WORD [x])"
- by (import word_base WORD_SNOC_WCAT)
-
-lemma BIT_WCAT_FST: "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))"
- by (import word_base BIT_WCAT_FST)
-
-lemma BIT_WCAT_SND: "RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2)
- (%w2. ALL k<n2. bit k (WCAT (w1, w2)) = bit k w2))"
- by (import word_base BIT_WCAT_SND)
-
-lemma BIT_WCAT1: "RES_FORALL (PWORDLEN n) (%w. ALL b. bit n (WCAT (WORD [b], w)) = b)"
- by (import word_base BIT_WCAT1)
-
-lemma WSEG_WCAT_WSEG1: "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))"
- by (import word_base WSEG_WCAT_WSEG1)
-
-lemma WSEG_WCAT_WSEG2: "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))"
- by (import word_base WSEG_WCAT_WSEG2)
-
-lemma WSEG_WCAT_WSEG: "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)))"
- by (import word_base WSEG_WCAT_WSEG)
-
-lemma BIT_EQ_IMP_WORD_EQ: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. (ALL k<n. bit k w1 = bit k w2) --> w1 = w2))"
- by (import word_base BIT_EQ_IMP_WORD_EQ)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" word_num
-
-definition
- LVAL :: "('a => nat) => nat => 'a list => nat" where
- "LVAL == %f b. foldl (%e x. b * e + f x) 0"
-
-lemma LVAL_DEF: "LVAL f b l = foldl (%e x. b * e + f x) 0 l"
- by (import word_num LVAL_DEF)
-
-consts
- NVAL :: "('a => nat) => nat => 'a word => nat"
-
-specification (NVAL) NVAL_DEF: "ALL f b l. 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.
- LVAL xa xb (xc # x) = xa xc * xb ^ length x + LVAL xa xb x)"
- by (import word_num LVAL)
-
-lemma LVAL_SNOC: "LVAL f b (SNOC h l) = LVAL f b l * b + f h"
- by (import word_num LVAL_SNOC)
-
-lemma LVAL_MAX: "(!!x. f x < b) ==> LVAL f b l < b ^ length l"
- by (import word_num LVAL_MAX)
-
-lemma NVAL_MAX: "(!!x. f x < b) ==> RES_FORALL (PWORDLEN n) (%w. NVAL f b w < b ^ n)"
- by (import word_num NVAL_MAX)
-
-lemma NVAL0: "NVAL x xa (WORD []) = 0"
- by (import word_num NVAL0)
-
-lemma NVAL1: "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)"
- by (import word_num NVAL_WORDLEN_0)
-
-lemma NVAL_WCAT1: "NVAL f b (WCAT (w, WORD [x])) = NVAL f b w * b + f x"
- by (import word_num NVAL_WCAT1)
-
-lemma NVAL_WCAT2: "RES_FORALL (PWORDLEN n)
- (%w. ALL f b x. NVAL f b (WCAT (WORD [x], w)) = f x * b ^ n + NVAL f b w)"
- by (import word_num NVAL_WCAT2)
-
-lemma NVAL_WCAT: "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))"
- by (import word_num NVAL_WCAT)
-
-consts
- NLIST :: "nat => (nat => 'a) => nat => nat => 'a 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.
- NLIST (Suc n) frep b m =
- SNOC (frep (m mod b)) (NLIST n frep b (m div b)))"
- by (import word_num NLIST_DEF)
-
-definition
- NWORD :: "nat => (nat => 'a) => nat => nat => 'a word" where
- "NWORD == %n frep b m. WORD (NLIST n frep b m)"
-
-lemma NWORD_DEF: "NWORD n frep b m = WORD (NLIST n frep b m)"
- by (import word_num NWORD_DEF)
-
-lemma NWORD_LENGTH: "WORDLEN (NWORD x xa xb xc) = x"
- by (import word_num NWORD_LENGTH)
-
-lemma NWORD_PWORDLEN: "IN (NWORD x xa xb xc) (PWORDLEN x)"
- by (import word_num NWORD_PWORDLEN)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" word_bitop
-
-consts
- PBITOP :: "('a word => 'b word) => bool"
-
-defs
- PBITOP_primdef: "PBITOP ==
-GSPEC
- (%oper.
- (oper,
- ALL n.
- 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)))))"
-
-lemma PBITOP_def: "PBITOP =
-GSPEC
- (%oper.
- (oper,
- ALL n.
- 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)))))"
- by (import word_bitop PBITOP_def)
-
-lemma IN_PBITOP: "IN oper PBITOP =
-(ALL n.
- 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))))"
- 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)))"
- by (import word_bitop PBITOP_PWORDLEN)
-
-lemma PBITOP_WSEG: "RES_FORALL PBITOP
- (%oper.
- ALL n.
- RES_FORALL (PWORDLEN n)
- (%w. ALL m k.
- m + k <= n --> oper (WSEG m k w) = WSEG m k (oper w)))"
- by (import word_bitop PBITOP_WSEG)
-
-lemma PBITOP_BIT: "RES_FORALL PBITOP
- (%oper.
- ALL n.
- RES_FORALL (PWORDLEN n)
- (%w. ALL k<n. oper (WORD [bit k w]) = WORD [bit k (oper w)]))"
- by (import word_bitop PBITOP_BIT)
-
-consts
- PBITBOP :: "('a word => 'b word => 'c word) => bool"
-
-defs
- PBITBOP_primdef: "PBITBOP ==
-GSPEC
- (%oper.
- (oper,
- ALL n.
- 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))))))"
-
-lemma PBITBOP_def: "PBITBOP =
-GSPEC
- (%oper.
- (oper,
- ALL n.
- 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))))))"
- by (import word_bitop PBITBOP_def)
-
-lemma IN_PBITBOP: "IN oper PBITBOP =
-(ALL n.
- 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)))))"
- by (import word_bitop IN_PBITBOP)
-
-lemma PBITBOP_PWORDLEN: "RES_FORALL PBITBOP
- (%oper.
- ALL n.
- RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n) (%w2. IN (oper w1 w2) (PWORDLEN n))))"
- by (import word_bitop PBITBOP_PWORDLEN)
-
-lemma PBITBOP_WSEG: "RES_FORALL PBITBOP
- (%oper.
- ALL n.
- 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))))"
- by (import word_bitop PBITBOP_WSEG)
-
-lemma PBITBOP_EXISTS: "EX x. ALL l1 l2. x (WORD l1) (WORD l2) = WORD (map2 f l1 l2)"
- by (import word_bitop PBITBOP_EXISTS)
-
-consts
- WMAP :: "('a => 'b) => 'a word => 'b word"
-
-specification (WMAP) WMAP_DEF: "ALL f l. 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))"
- by (import word_bitop WMAP_PWORDLEN)
-
-lemma WMAP_0: "WMAP (x::'a => 'b) (WORD []) = WORD []"
- by (import word_bitop WMAP_0)
-
-lemma WMAP_BIT: "RES_FORALL (PWORDLEN n) (%w. ALL k<n. ALL f. bit k (WMAP f w) = f (bit k w))"
- by (import word_bitop WMAP_BIT)
-
-lemma WMAP_WSEG: "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)))"
- by (import word_bitop WMAP_WSEG)
-
-lemma WMAP_PBITOP: "IN (WMAP f) PBITOP"
- by (import word_bitop WMAP_PBITOP)
-
-lemma WMAP_WCAT: "WMAP (f::'a => 'b) (WCAT (w1::'a word, w2::'a word)) =
-WCAT (WMAP f w1, WMAP f w2)"
- by (import word_bitop WMAP_WCAT)
-
-lemma WMAP_o: "WMAP (g::'b => 'c) (WMAP (f::'a => 'b) (w::'a word)) = WMAP (g o f) w"
- by (import word_bitop WMAP_o)
-
-consts
- FORALLBITS :: "('a => bool) => 'a word => bool"
-
-specification (FORALLBITS) FORALLBITS_DEF: "ALL P l. FORALLBITS P (WORD l) = list_all P l"
- by (import word_bitop FORALLBITS_DEF)
-
-lemma FORALLBITS: "RES_FORALL (PWORDLEN n) (%w. ALL P. FORALLBITS P w = (ALL k<n. P (bit k w)))"
- by (import word_bitop FORALLBITS)
-
-lemma FORALLBITS_WSEG: "RES_FORALL (PWORDLEN n)
- (%w. ALL P.
- FORALLBITS P w -->
- (ALL m k. m + k <= n --> FORALLBITS P (WSEG m k w)))"
- by (import word_bitop FORALLBITS_WSEG)
-
-lemma FORALLBITS_WCAT: "FORALLBITS P (WCAT (w1, w2)) = (FORALLBITS P w1 & FORALLBITS P w2)"
- by (import word_bitop FORALLBITS_WCAT)
-
-consts
- EXISTSABIT :: "('a => bool) => 'a word => bool"
-
-specification (EXISTSABIT) EXISTSABIT_DEF: "ALL P l. EXISTSABIT P (WORD l) = list_ex P l"
- by (import word_bitop EXISTSABIT_DEF)
-
-lemma NOT_EXISTSABIT: "(~ EXISTSABIT P w) = FORALLBITS (Not o P) w"
- by (import word_bitop NOT_EXISTSABIT)
-
-lemma NOT_FORALLBITS: "(~ FORALLBITS P w) = EXISTSABIT (Not o P) w"
- by (import word_bitop NOT_FORALLBITS)
-
-lemma EXISTSABIT: "RES_FORALL (PWORDLEN n) (%w. ALL P. EXISTSABIT P w = (EX k<n. P (bit k w)))"
- by (import word_bitop EXISTSABIT)
-
-lemma EXISTSABIT_WSEG: "RES_FORALL (PWORDLEN n)
- (%w. ALL m k.
- m + k <= n -->
- (ALL P. EXISTSABIT P (WSEG m k w) --> EXISTSABIT P w))"
- by (import word_bitop EXISTSABIT_WSEG)
-
-lemma EXISTSABIT_WCAT: "EXISTSABIT P (WCAT (w1, w2)) = (EXISTSABIT P w1 | EXISTSABIT P w2)"
- by (import word_bitop EXISTSABIT_WCAT)
-
-definition
- SHR :: "bool => 'a => 'a word => 'a word * 'a" where
- "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)"
-
-lemma SHR_DEF: "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)"
- by (import word_bitop SHR_DEF)
-
-definition
- SHL :: "bool => 'a word => 'a => 'a * 'a word" where
- "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]))"
-
-lemma SHL_DEF: "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]))"
- by (import word_bitop SHL_DEF)
-
-lemma SHR_WSEG: "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)))"
- by (import word_bitop SHR_WSEG)
-
-lemma SHR_WSEG_1F: "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))"
- by (import word_bitop SHR_WSEG_1F)
-
-lemma SHR_WSEG_NF: "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))"
- by (import word_bitop SHR_WSEG_NF)
-
-lemma SHL_WSEG: "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]))))"
- by (import word_bitop SHL_WSEG)
-
-lemma SHL_WSEG_1F: "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])))"
- by (import word_bitop SHL_WSEG_1F)
-
-lemma SHL_WSEG_NF: "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))"
- by (import word_bitop SHL_WSEG_NF)
-
-lemma WSEG_SHL: "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))"
- by (import word_bitop WSEG_SHL)
-
-lemma WSEG_SHL_0: "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]))"
- by (import word_bitop WSEG_SHL_0)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" bword_num
-
-definition
- BV :: "bool => nat" where
- "BV == %b. if b then Suc 0 else 0"
-
-lemma BV_DEF: "BV b = (if b then Suc 0 else 0)"
- by (import bword_num BV_DEF)
-
-consts
- BNVAL :: "bool word => nat"
-
-specification (BNVAL) BNVAL_DEF: "ALL l. BNVAL (WORD l) = LVAL BV 2 l"
- by (import bword_num BNVAL_DEF)
-
-lemma BV_LESS_2: "BV x < 2"
- by (import bword_num BV_LESS_2)
-
-lemma BNVAL_NVAL: "BNVAL w = NVAL BV 2 w"
- by (import bword_num BNVAL_NVAL)
-
-lemma BNVAL0: "BNVAL (WORD []) = 0"
- by (import bword_num BNVAL0)
-
-lemma BNVAL_11: "[| WORDLEN w1 = WORDLEN w2; BNVAL w1 = BNVAL w2 |] ==> w1 = w2"
- by (import bword_num BNVAL_11)
-
-lemma BNVAL_ONTO: "Ex (op = (BNVAL w))"
- by (import bword_num BNVAL_ONTO)
-
-lemma BNVAL_MAX: "RES_FORALL (PWORDLEN n) (%w. BNVAL w < 2 ^ n)"
- by (import bword_num BNVAL_MAX)
-
-lemma BNVAL_WCAT1: "RES_FORALL (PWORDLEN n)
- (%w. ALL x. BNVAL (WCAT (w, WORD [x])) = BNVAL w * 2 + BV x)"
- by (import bword_num BNVAL_WCAT1)
-
-lemma BNVAL_WCAT2: "RES_FORALL (PWORDLEN n)
- (%w. ALL x. BNVAL (WCAT (WORD [x], w)) = BV x * 2 ^ n + BNVAL w)"
- by (import bword_num BNVAL_WCAT2)
-
-lemma BNVAL_WCAT: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN m)
- (%w2. BNVAL (WCAT (w1, w2)) = BNVAL w1 * 2 ^ m + BNVAL w2))"
- by (import bword_num BNVAL_WCAT)
-
-definition
- VB :: "nat => bool" where
- "VB == %n. n mod 2 ~= 0"
-
-lemma VB_DEF: "VB n = (n mod 2 ~= 0)"
- by (import bword_num VB_DEF)
-
-definition
- NBWORD :: "nat => nat => bool word" where
- "NBWORD == %n m. WORD (NLIST n VB 2 m)"
-
-lemma NBWORD_DEF: "NBWORD n m = WORD (NLIST n VB 2 m)"
- by (import bword_num NBWORD_DEF)
-
-lemma NBWORD0: "NBWORD 0 x = WORD []"
- by (import bword_num NBWORD0)
-
-lemma WORDLEN_NBWORD: "WORDLEN (NBWORD x xa) = x"
- by (import bword_num WORDLEN_NBWORD)
-
-lemma PWORDLEN_NBWORD: "IN (NBWORD x xa) (PWORDLEN x)"
- by (import bword_num PWORDLEN_NBWORD)
-
-lemma NBWORD_SUC: "NBWORD (Suc n) m = WCAT (NBWORD n (m div 2), WORD [VB (m mod 2)])"
- by (import bword_num NBWORD_SUC)
-
-lemma VB_BV: "VB (BV x) = x"
- by (import bword_num VB_BV)
-
-lemma BV_VB: "x < 2 ==> BV (VB x) = x"
- by (import bword_num BV_VB)
-
-lemma NBWORD_BNVAL: "RES_FORALL (PWORDLEN n) (%w. NBWORD n (BNVAL w) = w)"
- by (import bword_num NBWORD_BNVAL)
-
-lemma BNVAL_NBWORD: "m < 2 ^ 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))"
- by (import bword_num ZERO_WORD_VAL)
-
-lemma WCAT_NBWORD_0: "WCAT (NBWORD n1 0, NBWORD n2 0) = NBWORD (n1 + n2) 0"
- by (import bword_num WCAT_NBWORD_0)
-
-lemma WSPLIT_NBWORD_0: "m <= n ==> WSPLIT m (NBWORD n 0) = (NBWORD (n - m) 0, NBWORD m 0)"
- by (import bword_num WSPLIT_NBWORD_0)
-
-lemma EQ_NBWORD0_SPLIT: "RES_FORALL (PWORDLEN n)
- (%w. ALL m<=n.
- (w = NBWORD n 0) =
- (WSEG (n - m) m w = NBWORD (n - m) 0 & WSEG m 0 w = NBWORD m 0))"
- by (import bword_num EQ_NBWORD0_SPLIT)
-
-lemma NBWORD_MOD: "NBWORD n (m mod 2 ^ n) = NBWORD n m"
- by (import bword_num NBWORD_MOD)
-
-lemma WSEG_NBWORD_SUC: "WSEG n 0 (NBWORD (Suc n) m) = NBWORD n m"
- by (import bword_num WSEG_NBWORD_SUC)
-
-lemma NBWORD_SUC_WSEG: "RES_FORALL (PWORDLEN (Suc n)) (%w. NBWORD n (BNVAL w) = WSEG n 0 w)"
- by (import bword_num NBWORD_SUC_WSEG)
-
-lemma DOUBL_EQ_SHL: "0 < x
-==> RES_FORALL (PWORDLEN x)
- (%xa. ALL xb.
- NBWORD x (BNVAL xa + BNVAL xa + BV xb) =
- snd (SHL False xa xb))"
- by (import bword_num DOUBL_EQ_SHL)
-
-lemma MSB_NBWORD: "bit n (NBWORD (Suc n) m) = VB (m div 2 ^ n mod 2)"
- by (import bword_num MSB_NBWORD)
-
-lemma NBWORD_SPLIT: "NBWORD (n1 + n2) m = WCAT (NBWORD n1 (m div 2 ^ n2), NBWORD n2 m)"
- by (import bword_num NBWORD_SPLIT)
-
-lemma WSEG_NBWORD: "m + k <= n ==> WSEG m k (NBWORD n l) = NBWORD m (l div 2 ^ k)"
- by (import bword_num WSEG_NBWORD)
-
-lemma NBWORD_SUC_FST: "NBWORD (Suc n) x = WCAT (WORD [VB (x div 2 ^ n mod 2)], NBWORD n x)"
- by (import bword_num NBWORD_SUC_FST)
-
-lemma BIT_NBWORD0: "k < n ==> bit k (NBWORD n 0) = False"
- by (import bword_num BIT_NBWORD0)
-
-lemma ADD_BNVAL_LEFT: "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))))"
- by (import bword_num ADD_BNVAL_LEFT)
-
-lemma ADD_BNVAL_RIGHT: "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))))"
- by (import bword_num ADD_BNVAL_RIGHT)
-
-lemma ADD_BNVAL_SPLIT: "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))))"
- by (import bword_num ADD_BNVAL_SPLIT)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" bword_arith
-
-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.
- ACARRY (Suc n) w1 w2 cin =
- VB ((BV (bit n w1) + BV (bit n w2) + BV (ACARRY n w1 w2 cin)) div 2))"
- 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.
- 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: "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))"
- by (import bword_arith ACARRY_EQ_ICARRY)
-
-lemma BNVAL_LESS_EQ: "RES_FORALL (PWORDLEN n) (%w. BNVAL w <= 2 ^ n - 1)"
- by (import bword_arith BNVAL_LESS_EQ)
-
-lemma ADD_BNVAL_LESS_EQ1: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. (BNVAL w1 + (BNVAL w2 + BV cin)) div 2 ^ n <= Suc 0))"
- by (import bword_arith ADD_BNVAL_LESS_EQ1)
-
-lemma ADD_BV_BNVAL_DIV_LESS_EQ1: "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))"
- by (import bword_arith ADD_BV_BNVAL_DIV_LESS_EQ1)
-
-lemma ADD_BV_BNVAL_LESS_EQ: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. BV x1 + BV x2 + (BNVAL w1 + (BNVAL w2 + BV cin))
- <= Suc (2 ^ Suc n)))"
- by (import bword_arith ADD_BV_BNVAL_LESS_EQ)
-
-lemma ADD_BV_BNVAL_LESS_EQ1: "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))"
- by (import bword_arith ADD_BV_BNVAL_LESS_EQ1)
-
-lemma ACARRY_EQ_ADD_DIV: "RES_FORALL (PWORDLEN n)
- (%w1. RES_FORALL (PWORDLEN n)
- (%w2. ALL k<n.
- BV (ACARRY k w1 w2 cin) =
- (BNVAL (WSEG k 0 w1) + BNVAL (WSEG k 0 w2) + BV cin) div
- 2 ^ k))"
- by (import bword_arith ACARRY_EQ_ADD_DIV)
-
-lemma ADD_WORD_SPLIT: "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))))"
- by (import bword_arith ADD_WORD_SPLIT)
-
-lemma WSEG_NBWORD_ADD: "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))))"
- by (import bword_arith WSEG_NBWORD_ADD)
-
-lemma ADD_NBWORD_EQ0_SPLIT: "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)))"
- by (import bword_arith ADD_NBWORD_EQ0_SPLIT)
-
-lemma ACARRY_MSB: "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))))"
- by (import bword_arith ACARRY_MSB)
-
-lemma ACARRY_WSEG: "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))"
- by (import bword_arith ACARRY_WSEG)
-
-lemma ICARRY_WSEG: "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))"
- by (import bword_arith ICARRY_WSEG)
-
-lemma ACARRY_ACARRY_WSEG: "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))"
- by (import bword_arith ACARRY_ACARRY_WSEG)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" bword_bitop
-
-consts
- WNOT :: "bool word => bool word"
-
-specification (WNOT) WNOT_DEF: "ALL l. 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: "WNOT (WNOT w) = w"
- by (import bword_bitop WNOT_WNOT)
-
-lemma WCAT_WNOT: "RES_FORALL (PWORDLEN n1)
- (%w1. RES_FORALL (PWORDLEN n2)
- (%w2. 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)"
- by (import bword_bitop WAND_DEF)
-
-lemma PBITBOP_WAND: "IN WAND PBITBOP"
- by (import bword_bitop PBITBOP_WAND)
-
-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)"
- by (import bword_bitop WOR_DEF)
-
-lemma PBITBOP_WOR: "IN WOR PBITBOP"
- by (import bword_bitop PBITBOP_WOR)
-
-consts
- WXOR :: "bool word => bool word => bool word"
-
-specification (WXOR) WXOR_DEF: "ALL l1 l2. WXOR (WORD l1) (WORD l2) = WORD (map2 op ~= l1 l2)"
- by (import bword_bitop WXOR_DEF)
-
-lemma PBITBOP_WXOR: "IN WXOR PBITBOP"
- by (import bword_bitop PBITBOP_WXOR)
-
-;end_setup
-
-end
-
--- a/src/HOL/Import/HOL4/Generated/HOL4Word32.thy Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1382 +0,0 @@
-(* AUTOMATICALLY GENERATED, DO NOT EDIT! *)
-
-theory HOL4Word32 imports HOL4Base begin
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" bits
-
-consts
- DIV2 :: "nat => nat"
-
-defs
- DIV2_primdef: "DIV2 == %n. n div 2"
-
-lemma DIV2_def: "DIV2 n = n div 2"
- by (import bits DIV2_def)
-
-consts
- TIMES_2EXP :: "nat => nat => nat"
-
-defs
- TIMES_2EXP_primdef: "TIMES_2EXP == %x n. n * 2 ^ x"
-
-lemma TIMES_2EXP_def: "TIMES_2EXP x n = n * 2 ^ 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"
-
-lemma DIV_2EXP_def: "DIV_2EXP x n = n div 2 ^ 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"
-
-lemma MOD_2EXP_def: "MOD_2EXP x n = n mod 2 ^ 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)"
-
-lemma DIVMOD_2EXP_def: "DIVMOD_2EXP x n = (n div 2 ^ x, n mod 2 ^ 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"
-
-lemma SBIT_def: "SBIT b n = (if b then 2 ^ n else 0)"
- 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)"
-
-lemma BITS_def: "BITS h l n = MOD_2EXP (Suc h - l) (DIV_2EXP l n)"
- by (import bits BITS_def)
-
-definition
- bit :: "nat => nat => bool" where
- "bit == %b n. BITS b b n = 1"
-
-lemma BIT_def: "bit b n = (BITS b b n = 1)"
- 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"
-
-lemma SLICE_def: "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"
-
-lemma LSBn_def: "LSBn = bit 0"
- 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.
- 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)
-
-lemma SUC_SUB: "Suc a - a = 1"
- by (import bits SUC_SUB)
-
-lemma DIV_MULT_1: "(r::nat) < (n::nat) ==> (n + r) div n = (1::nat)"
- by (import bits DIV_MULT_1)
-
-lemma ZERO_LT_TWOEXP: "(0::nat) < (2::nat) ^ (n::nat)"
- by (import bits ZERO_LT_TWOEXP)
-
-lemma MOD_2EXP_LT: "(k::nat) mod (2::nat) ^ (n::nat) < (2::nat) ^ n"
- by (import bits MOD_2EXP_LT)
-
-lemma TWOEXP_DIVISION: "(k::nat) = k div (2::nat) ^ (n::nat) * (2::nat) ^ n + k mod (2::nat) ^ n"
- by (import bits TWOEXP_DIVISION)
-
-lemma TWOEXP_MONO: "(a::nat) < (b::nat) ==> (2::nat) ^ a < (2::nat) ^ b"
- by (import bits TWOEXP_MONO)
-
-lemma TWOEXP_MONO2: "(a::nat) <= (b::nat) ==> (2::nat) ^ a <= (2::nat) ^ b"
- by (import bits TWOEXP_MONO2)
-
-lemma EXP_SUB_LESS_EQ: "(2::nat) ^ ((a::nat) - (b::nat)) <= (2::nat) ^ a"
- by (import bits EXP_SUB_LESS_EQ)
-
-lemma BITS_THM: "BITS x xa xb = xb div 2 ^ xa mod 2 ^ (Suc x - xa)"
- by (import bits BITS_THM)
-
-lemma BITSLT_THM: "BITS h l n < 2 ^ (Suc h - l)"
- by (import bits BITSLT_THM)
-
-lemma DIV_MULT_LEM: "(0::nat) < (n::nat) ==> (m::nat) div n * n <= m"
- by (import bits DIV_MULT_LEM)
-
-lemma MOD_2EXP_LEM: "(n::nat) mod (2::nat) ^ (x::nat) = n - n div (2::nat) ^ x * (2::nat) ^ x"
- by (import bits MOD_2EXP_LEM)
-
-lemma BITS2_THM: "BITS h l n = n mod 2 ^ Suc h div 2 ^ l"
- by (import bits BITS2_THM)
-
-lemma BITS_COMP_THM: "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: "BITS h l x div 2 ^ n = BITS h (l + n) x"
- by (import bits BITS_DIV_THM)
-
-lemma BITS_LT_HIGH: "n < 2 ^ Suc h ==> BITS h l n = n div 2 ^ l"
- by (import bits BITS_LT_HIGH)
-
-lemma BITS_ZERO: "h < l ==> BITS h l n = 0"
- by (import bits BITS_ZERO)
-
-lemma BITS_ZERO2: "BITS h l 0 = 0"
- by (import bits BITS_ZERO2)
-
-lemma BITS_ZERO3: "BITS h 0 x = x mod 2 ^ Suc h"
- by (import bits BITS_ZERO3)
-
-lemma BITS_COMP_THM2: "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: "((n::nat) mod (2::nat) ~= (0::nat)) = (n mod (2::nat) = (1::nat))"
- by (import bits NOT_MOD2_LEM)
-
-lemma NOT_MOD2_LEM2: "((n::nat) mod (2::nat) ~= (1::nat)) = (n mod (2::nat) = (0::nat))"
- by (import bits NOT_MOD2_LEM2)
-
-lemma EVEN_MOD2_LEM: "EVEN n = (n mod 2 = 0)"
- by (import bits EVEN_MOD2_LEM)
-
-lemma ODD_MOD2_LEM: "ODD n = (n mod 2 = 1)"
- by (import bits ODD_MOD2_LEM)
-
-lemma LSB_ODD: "LSBn = ODD"
- by (import bits LSB_ODD)
-
-lemma DIV_MULT_THM: "(n::nat) div (2::nat) ^ (x::nat) * (2::nat) ^ x = n - n mod (2::nat) ^ x"
- by (import bits DIV_MULT_THM)
-
-lemma DIV_MULT_THM2: "(2::nat) * ((x::nat) div (2::nat)) = x - x mod (2::nat)"
- by (import bits DIV_MULT_THM2)
-
-lemma LESS_EQ_EXP_MULT: "(a::nat) <= (b::nat) ==> EX x::nat. (2::nat) ^ b = x * (2::nat) ^ a"
- by (import bits LESS_EQ_EXP_MULT)
-
-lemma SLICE_LEM1: "(a::nat) div (2::nat) ^ ((x::nat) + (y::nat)) * (2::nat) ^ (x + y) =
-a div (2::nat) ^ x * (2::nat) ^ x -
-a div (2::nat) ^ x mod (2::nat) ^ y * (2::nat) ^ x"
- by (import bits SLICE_LEM1)
-
-lemma SLICE_LEM2: "(n::nat) mod (2::nat) ^ ((x::nat) + (y::nat)) =
-n mod (2::nat) ^ x + n div (2::nat) ^ x mod (2::nat) ^ y * (2::nat) ^ x"
- by (import bits SLICE_LEM2)
-
-lemma SLICE_LEM3: "(l::nat) < (h::nat) ==> (n::nat) mod (2::nat) ^ Suc l <= n mod (2::nat) ^ h"
- by (import bits SLICE_LEM3)
-
-lemma SLICE_THM: "SLICE h l n = BITS h l n * 2 ^ l"
- by (import bits SLICE_THM)
-
-lemma SLICELT_THM: "SLICE h l n < 2 ^ Suc h"
- by (import bits SLICELT_THM)
-
-lemma BITS_SLICE_THM: "BITS h l (SLICE h l n) = BITS h l n"
- by (import bits BITS_SLICE_THM)
-
-lemma BITS_SLICE_THM2: "h <= h2 ==> BITS h2 l (SLICE h l n) = BITS h l n"
- by (import bits BITS_SLICE_THM2)
-
-lemma MOD_2EXP_MONO: "(l::nat) <= (h::nat) ==> (n::nat) mod (2::nat) ^ l <= n mod (2::nat) ^ Suc h"
- by (import bits MOD_2EXP_MONO)
-
-lemma SLICE_COMP_THM: "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: "h < l ==> SLICE h l n = 0"
- by (import bits SLICE_ZERO)
-
-lemma BIT_COMP_THM3: "Suc m <= h & l <= m
-==> BITS h (Suc m) n * 2 ^ (Suc m - l) + BITS m l n = BITS h l n"
- by (import bits BIT_COMP_THM3)
-
-lemma NOT_BIT: "(~ bit n a) = (BITS n n a = 0)"
- by (import bits NOT_BIT)
-
-lemma NOT_BITS: "(BITS n n a ~= 0) = (BITS n n a = 1)"
- by (import bits NOT_BITS)
-
-lemma NOT_BITS2: "(BITS n n a ~= 1) = (BITS n n a = 0)"
- by (import bits NOT_BITS2)
-
-lemma BIT_SLICE: "(bit n a = bit n b) = (SLICE n n a = SLICE n n b)"
- by (import bits BIT_SLICE)
-
-lemma BIT_SLICE_LEM: "SBIT (bit x n) (x + y) = SLICE x x n * 2 ^ y"
- by (import bits BIT_SLICE_LEM)
-
-lemma BIT_SLICE_THM: "SBIT (bit x xa) x = SLICE x x xa"
- by (import bits BIT_SLICE_THM)
-
-lemma SBIT_DIV: "n < m ==> SBIT b (m - n) = SBIT b m div 2 ^ n"
- by (import bits SBIT_DIV)
-
-lemma BITS_SUC: "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: "BITS (Suc h) l n =
-(if Suc h < l then 0 else SBIT (bit (Suc h) n) (Suc h - l) + BITS h l n)"
- by (import bits BITS_SUC_THM)
-
-lemma BIT_BITS_THM: "(ALL x. 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: "BITWISE n oper a b < 2 ^ n"
- by (import bits BITWISE_LT_2EXP)
-
-lemma LESS_EXP_MULT2: "(a::nat) < (b::nat)
-==> EX x::nat. (2::nat) ^ b = (2::nat) ^ (x + (1::nat)) * (2::nat) ^ a"
- by (import bits LESS_EXP_MULT2)
-
-lemma BITWISE_THM: "x < n ==> bit x (BITWISE n oper a b) = oper (bit x a) (bit x b)"
- by (import bits BITWISE_THM)
-
-lemma BITWISE_COR: "[| x < n; oper (bit x a) (bit x b) |]
-==> BITWISE n oper a b div 2 ^ x mod 2 = 1"
- by (import bits BITWISE_COR)
-
-lemma BITWISE_NOT_COR: "[| x < n; ~ oper (bit x a) (bit x b) |]
-==> BITWISE n oper a b div 2 ^ x mod 2 = 0"
- by (import bits BITWISE_NOT_COR)
-
-lemma MOD_PLUS_RIGHT: "(0::nat) < (n::nat) ==> ((j::nat) + (k::nat) mod n) mod n = (j + k) mod n"
- by (import bits MOD_PLUS_RIGHT)
-
-lemma MOD_PLUS_1: "(0::nat) < (n::nat)
-==> (((x::nat) + (1::nat)) mod n = (0::nat)) = (x mod n + (1::nat) = n)"
- by (import bits MOD_PLUS_1)
-
-lemma MOD_ADD_1: "[| (0::nat) < (n::nat); ((x::nat) + (1::nat)) mod n ~= (0::nat) |]
-==> (x + (1::nat)) mod n = x mod n + (1::nat)"
- by (import bits MOD_ADD_1)
-
-;end_setup
-
-setup_theory "~~/src/HOL/Import/HOL4/Generated" word32
-
-consts
- HB :: "nat"
-
-defs
- HB_primdef: "HB ==
-NUMERAL
- (NUMERAL_BIT1
- (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))"
-
-lemma HB_def: "HB =
-NUMERAL
- (NUMERAL_BIT1
- (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))"
- by (import word32 HB_def)
-
-consts
- WL :: "nat"
-
-defs
- WL_primdef: "WL == Suc HB"
-
-lemma WL_def: "WL = Suc HB"
- by (import word32 WL_def)
-
-consts
- MODw :: "nat => nat"
-
-defs
- MODw_primdef: "MODw == %n. n mod 2 ^ WL"
-
-lemma MODw_def: "MODw n = n mod 2 ^ WL"
- by (import word32 MODw_def)
-
-consts
- INw :: "nat => bool"
-
-defs
- INw_primdef: "INw == %n. n < 2 ^ WL"
-
-lemma INw_def: "INw n = (n < 2 ^ WL)"
- by (import word32 INw_def)
-
-consts
- EQUIV :: "nat => nat => bool"
-
-defs
- EQUIV_primdef: "EQUIV == %x y. MODw x = MODw y"
-
-lemma EQUIV_def: "EQUIV x y = (MODw x = MODw y)"
- by (import word32 EQUIV_def)
-
-lemma EQUIV_QT: "EQUIV x y = (EQUIV x = EQUIV y)"
- by (import word32 EQUIV_QT)
-
-lemma FUNPOW_THM2: "(f ^^ Suc n) x = f ((f ^^ n) x)"
- by (import word32 FUNPOW_THM2)
-
-lemma FUNPOW_COMP: "(f ^^ m) ((f ^^ n) a) = (f ^^ (m + n)) a"
- by (import word32 FUNPOW_COMP)
-
-lemma INw_MODw: "INw (MODw n)"
- by (import word32 INw_MODw)
-
-lemma TOw_IDEM: "INw a ==> MODw a = a"
- by (import word32 TOw_IDEM)
-
-lemma MODw_IDEM2: "MODw (MODw a) = MODw a"
- by (import word32 MODw_IDEM2)
-
-lemma TOw_QT: "EQUIV (MODw a) a"
- by (import word32 TOw_QT)
-
-lemma MODw_THM: "MODw = BITS HB 0"
- by (import word32 MODw_THM)
-
-lemma MOD_ADD: "MODw (a + b) = MODw (MODw a + MODw b)"
- by (import word32 MOD_ADD)
-
-lemma MODw_MULT: "MODw (a * b) = MODw (MODw a * MODw b)"
- by (import word32 MODw_MULT)
-
-consts
- AONE :: "nat"
-
-defs
- AONE_primdef: "AONE == 1"
-
-lemma AONE_def: "AONE = 1"
- by (import word32 AONE_def)
-
-lemma ADD_QT: "(ALL n. EQUIV (0 + n) n) & (ALL m n. EQUIV (Suc m + n) (Suc (m + n)))"
- by (import word32 ADD_QT)
-
-lemma ADD_0_QT: "EQUIV (a + 0) a"
- by (import word32 ADD_0_QT)
-
-lemma ADD_COMM_QT: "EQUIV (a + b) (b + a)"
- by (import word32 ADD_COMM_QT)
-
-lemma ADD_ASSOC_QT: "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))"
- by (import word32 MULT_QT)
-
-lemma ADD1_QT: "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)))"
- by (import word32 ADD_CLAUSES_QT)
-
-lemma SUC_EQUIV_COMP: "EQUIV (Suc a) b ==> EQUIV a (b + (2 ^ WL - 1))"
- by (import word32 SUC_EQUIV_COMP)
-
-lemma INV_SUC_EQ_QT: "EQUIV (Suc m) (Suc n) = EQUIV m n"
- by (import word32 INV_SUC_EQ_QT)
-
-lemma ADD_INV_0_QT: "EQUIV (m + n) m ==> EQUIV n 0"
- by (import word32 ADD_INV_0_QT)
-
-lemma ADD_INV_0_EQ_QT: "EQUIV (m + n) m = EQUIV n 0"
- by (import word32 ADD_INV_0_EQ_QT)
-
-lemma EQ_ADD_LCANCEL_QT: "EQUIV (m + n) (m + p) = EQUIV n p"
- by (import word32 EQ_ADD_LCANCEL_QT)
-
-lemma EQ_ADD_RCANCEL_QT: "EQUIV (x + xb) (xa + xb) = EQUIV x xa"
- by (import word32 EQ_ADD_RCANCEL_QT)
-
-lemma LEFT_ADD_DISTRIB_QT: "EQUIV (p * (m + n)) (p * m + p * n)"
- by (import word32 LEFT_ADD_DISTRIB_QT)
-
-lemma MULT_ASSOC_QT: "EQUIV (m * (n * p)) (m * n * p)"
- by (import word32 MULT_ASSOC_QT)
-
-lemma MULT_COMM_QT: "EQUIV (m * n) (n * m)"
- by (import word32 MULT_COMM_QT)
-
-lemma MULT_CLAUSES_QT: "EQUIV (0 * m) 0 &
-EQUIV (m * 0) 0 &
-EQUIV (AONE * m) m &
-EQUIV (m * AONE) m &
-EQUIV (Suc m * n) (m * n + n) & EQUIV (m * Suc n) (m + m * n)"
- by (import word32 MULT_CLAUSES_QT)
-
-consts
- MSBn :: "nat => bool"
-
-defs
- MSBn_primdef: "MSBn == bit HB"
-
-lemma MSBn_def: "MSBn = bit HB"
- by (import word32 MSBn_def)
-
-consts
- ONE_COMP :: "nat => nat"
-
-defs
- ONE_COMP_primdef: "ONE_COMP == %x. 2 ^ WL - 1 - MODw x"
-
-lemma ONE_COMP_def: "ONE_COMP x = 2 ^ WL - 1 - MODw x"
- by (import word32 ONE_COMP_def)
-
-consts
- TWO_COMP :: "nat => nat"
-
-defs
- TWO_COMP_primdef: "TWO_COMP == %x. 2 ^ WL - MODw x"
-
-lemma TWO_COMP_def: "TWO_COMP x = 2 ^ WL - MODw x"
- by (import word32 TWO_COMP_def)
-
-lemma ADD_TWO_COMP_QT: "EQUIV (MODw a + TWO_COMP a) 0"
- by (import word32 ADD_TWO_COMP_QT)
-
-lemma TWO_COMP_ONE_COMP_QT: "EQUIV (TWO_COMP a) (ONE_COMP a + AONE)"
- by (import word32 TWO_COMP_ONE_COMP_QT)
-
-lemma BIT_EQUIV_THM: "(ALL xb<WL. bit xb x = bit xb xa) = EQUIV x xa"
- by (import word32 BIT_EQUIV_THM)
-
-lemma BITS_SUC2: "BITS (Suc n) 0 a = SLICE (Suc n) (Suc n) a + BITS n 0 a"
- by (import word32 BITS_SUC2)
-
-lemma BITWISE_ONE_COMP_THM: "BITWISE WL (%x y. ~ x) a b = ONE_COMP a"
- by (import word32 BITWISE_ONE_COMP_THM)
-
-lemma ONE_COMP_THM: "xa < WL ==> bit xa (ONE_COMP x) = (~ bit xa x)"
- by (import word32 ONE_COMP_THM)
-
-consts
- OR :: "nat => nat => nat"
-
-defs
- OR_primdef: "OR == BITWISE WL op |"
-
-lemma OR_def: "OR = BITWISE WL op |"
- by (import word32 OR_def)
-
-consts
- AND :: "nat => nat => nat"
-
-defs
- AND_primdef: "AND == BITWISE WL op &"
-
-lemma AND_def: "AND = BITWISE WL op &"
- by (import word32 AND_def)
-
-consts
- EOR :: "nat => nat => nat"
-
-defs
- EOR_primdef: "EOR == BITWISE WL op ~="
-
-lemma EOR_def: "EOR = BITWISE WL op ~="
- by (import word32 EOR_def)
-
-consts
- COMP0 :: "nat"
-
-defs
- COMP0_primdef: "COMP0 == ONE_COMP 0"
-
-lemma COMP0_def: "COMP0 = ONE_COMP 0"
- by (import word32 COMP0_def)
-
-lemma BITWISE_THM2: "(ALL x<WL. oper (bit x a) (bit x b) = bit x y) =
-EQUIV (BITWISE WL oper a b) y"
- by (import word32 BITWISE_THM2)
-
-lemma OR_ASSOC_QT: "EQUIV (OR a (OR b c)) (OR (OR a b) c)"
- by (import word32 OR_ASSOC_QT)
-
-lemma OR_COMM_QT: "EQUIV (OR a b) (OR b a)"
- by (import word32 OR_COMM_QT)
-
-lemma OR_ABSORB_QT: "EQUIV (AND a (OR a b)) a"
- by (import word32 OR_ABSORB_QT)
-
-lemma OR_IDEM_QT: "EQUIV (OR a a) a"
- by (import word32 OR_IDEM_QT)
-
-lemma AND_ASSOC_QT: "EQUIV (AND a (AND b c)) (AND (AND a b) c)"
- by (import word32 AND_ASSOC_QT)
-
-lemma AND_COMM_QT: "EQUIV (AND a b) (AND b a)"
- by (import word32 AND_COMM_QT)
-
-lemma AND_ABSORB_QT: "EQUIV (OR a (AND a b)) a"
- by (import word32 AND_ABSORB_QT)
-
-lemma AND_IDEM_QT: "EQUIV (AND a a) a"
- by (import word32 AND_IDEM_QT)
-
-lemma OR_COMP_QT: "EQUIV (OR a (ONE_COMP a)) COMP0"
- by (import word32 OR_COMP_QT)
-
-lemma AND_COMP_QT: "EQUIV (AND a (ONE_COMP a)) 0"
- by (import word32 AND_COMP_QT)
-
-lemma ONE_COMP_QT: "EQUIV (ONE_COMP (ONE_COMP a)) a"
- by (import word32 ONE_COMP_QT)
-
-lemma RIGHT_AND_OVER_OR_QT: "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: "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: "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: "[| n < WL; EQUIV a b |] ==> bit n a = bit n b"
- by (import word32 BIT_EQUIV)
-
-lemma LSB_WELLDEF: "EQUIV a b ==> LSBn a = LSBn b"
- by (import word32 LSB_WELLDEF)
-
-lemma MSB_WELLDEF: "EQUIV a b ==> MSBn a = MSBn b"
- by (import word32 MSB_WELLDEF)
-
-lemma BITWISE_ISTEP: "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)"
- by (import word32 BITWISE_ISTEP)
-
-lemma BITWISE_EVAL: "BITWISE (Suc n) oper a b =
-2 * BITWISE n oper (a div 2) (b div 2) + SBIT (oper (LSBn a) (LSBn b)) 0"
- by (import word32 BITWISE_EVAL)
-
-lemma BITWISE_WELLDEF: "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: "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: "EQUIV a b ==> EQUIV (Suc a) (Suc b)"
- by (import word32 SUC_WELLDEF)
-
-lemma ADD_WELLDEF: "EQUIV a b & EQUIV c d ==> EQUIV (a + c) (b + d)"
- by (import word32 ADD_WELLDEF)
-
-lemma MUL_WELLDEF: "EQUIV a b & EQUIV c d ==> EQUIV (a * c) (b * d)"
- by (import word32 MUL_WELLDEF)
-
-lemma ONE_COMP_WELLDEF: "EQUIV a b ==> EQUIV (ONE_COMP a) (ONE_COMP b)"
- by (import word32 ONE_COMP_WELLDEF)
-
-lemma TWO_COMP_WELLDEF: "EQUIV a b ==> EQUIV (TWO_COMP a) (TWO_COMP b)"
- by (import word32 TWO_COMP_WELLDEF)
-
-lemma TOw_WELLDEF: "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"
-
-lemma LSR_ONE_def: "LSR_ONE a = MODw a div 2"
- 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"
-
-lemma ASR_ONE_def: "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"
-
-lemma ROR_ONE_def: "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"
-
-lemma RRXn_def: "RRXn c a = LSR_ONE a + SBIT c HB"
- by (import word32 RRXn_def)
-
-lemma LSR_ONE_WELLDEF: "EQUIV a b ==> EQUIV (LSR_ONE a) (LSR_ONE b)"
- by (import word32 LSR_ONE_WELLDEF)
-
-lemma ASR_ONE_WELLDEF: "EQUIV a b ==> EQUIV (ASR_ONE a) (ASR_ONE b)"
- by (import word32 ASR_ONE_WELLDEF)
-
-lemma ROR_ONE_WELLDEF: "EQUIV a b ==> EQUIV (ROR_ONE a) (ROR_ONE b)"
- by (import word32 ROR_ONE_WELLDEF)
-
-lemma RRX_WELLDEF: "EQUIV a b ==> EQUIV (RRXn c a) (RRXn c b)"
- by (import word32 RRX_WELLDEF)
-
-lemma LSR_ONE: "LSR_ONE = BITS HB 1"
- by (import word32 LSR_ONE)
-
-typedef (open) word32 = "{x::nat => bool. EX xa. x = EQUIV xa}"
- by (rule typedef_helper,import word32 word32_TY_DEF)
-
-lemmas word32_TY_DEF = typedef_hol2hol4 [OF type_definition_word32]
-
-consts
- 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))"
- by (import word32 word32_tybij)
-
-consts
- w_0 :: "word32"
-
-defs
- w_0_primdef: "w_0 == mk_word32 (EQUIV 0)"
-
-lemma w_0_def: "w_0 = mk_word32 (EQUIV 0)"
- by (import word32 w_0_def)
-
-consts
- w_1 :: "word32"
-
-defs
- w_1_primdef: "w_1 == mk_word32 (EQUIV AONE)"
-
-lemma w_1_def: "w_1 = mk_word32 (EQUIV AONE)"
- by (import word32 w_1_def)
-
-consts
- w_T :: "word32"
-
-defs
- w_T_primdef: "w_T == mk_word32 (EQUIV COMP0)"
-
-lemma w_T_def: "w_T = mk_word32 (EQUIV COMP0)"
- by (import word32 w_T_def)
-
-definition
- word_suc :: "word32 => word32" where
- "word_suc == %T1. mk_word32 (EQUIV (Suc (Eps (dest_word32 T1))))"
-
-lemma word_suc: "word_suc T1 = mk_word32 (EQUIV (Suc (Eps (dest_word32 T1))))"
- by (import word32 word_suc)
-
-definition
- word_add :: "word32 => word32 => word32" where
- "word_add ==
-%T1 T2. mk_word32 (EQUIV (Eps (dest_word32 T1) + Eps (dest_word32 T2)))"
-
-lemma word_add: "word_add T1 T2 =
-mk_word32 (EQUIV (Eps (dest_word32 T1) + Eps (dest_word32 T2)))"
- by (import word32 word_add)
-
-definition
- word_mul :: "word32 => word32 => word32" where
- "word_mul ==
-%T1 T2. mk_word32 (EQUIV (Eps (dest_word32 T1) * Eps (dest_word32 T2)))"
-
-lemma word_mul: "word_mul T1 T2 =
-mk_word32 (EQUIV (Eps (dest_word32 T1) * Eps (dest_word32 T2)))"
- by (import word32 word_mul)
-
-definition
- word_1comp :: "word32 => word32" where
- "word_1comp == %T1. mk_word32 (EQUIV (ONE_COMP (Eps (dest_word32 T1))))"
-
-lemma word_1comp: "word_1comp T1 = mk_word32 (EQUIV (ONE_COMP (Eps (dest_word32 T1))))"
- by (import word32 word_1comp)
-
-definition
- word_2comp :: "word32 => word32" where
- "word_2comp == %T1. mk_word32 (EQUIV (TWO_COMP (Eps (dest_word32 T1))))"
-
-lemma word_2comp: "word_2comp T1 = mk_word32 (EQUIV (TWO_COMP (Eps (dest_word32 T1))))"
- by (import word32 word_2comp)
-
-definition
- word_lsr1 :: "word32 => word32" where
- "word_lsr1 == %T1. mk_word32 (EQUIV (LSR_ONE (Eps (dest_word32 T1))))"
-
-lemma word_lsr1: "word_lsr1 T1 = mk_word32 (EQUIV (LSR_ONE (Eps (dest_word32 T1))))"
- by (import word32 word_lsr1)
-
-definition
- word_asr1 :: "word32 => word32" where
- "word_asr1 == %T1. mk_word32 (EQUIV (ASR_ONE (Eps (dest_word32 T1))))"
-
-lemma word_asr1: "word_asr1 T1 = mk_word32 (EQUIV (ASR_ONE (Eps (dest_word32 T1))))"
- by (import word32 word_asr1)
-
-definition
- word_ror1 :: "word32 => word32" where
- "word_ror1 == %T1. mk_word32 (EQUIV (ROR_ONE (Eps (dest_word32 T1))))"
-
-lemma word_ror1: "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))))"
-
-lemma RRX_def: "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))"
-
-lemma LSB_def: "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))"
-
-lemma MSB_def: "MSB T1 = MSBn (Eps (dest_word32 T1))"
- by (import word32 MSB_def)
-
-definition
- bitwise_or :: "word32 => word32 => word32" where
- "bitwise_or ==
-%T1 T2. mk_word32 (EQUIV (OR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
-
-lemma bitwise_or: "bitwise_or T1 T2 =
-mk_word32 (EQUIV (OR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
- by (import word32 bitwise_or)
-
-definition
- bitwise_eor :: "word32 => word32 => word32" where
- "bitwise_eor ==
-%T1 T2.
- mk_word32 (EQUIV (EOR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
-
-lemma bitwise_eor: "bitwise_eor T1 T2 =
-mk_word32 (EQUIV (EOR (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
- by (import word32 bitwise_eor)
-
-definition
- bitwise_and :: "word32 => word32 => word32" where
- "bitwise_and ==
-%T1 T2.
- mk_word32 (EQUIV (AND (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
-
-lemma bitwise_and: "bitwise_and T1 T2 =
-mk_word32 (EQUIV (AND (Eps (dest_word32 T1)) (Eps (dest_word32 T2))))"
- by (import word32 bitwise_and)
-
-consts
- TOw :: "word32 => word32"
-
-defs
- TOw_primdef: "TOw == %T1. mk_word32 (EQUIV (MODw (Eps (dest_word32 T1))))"
-
-lemma TOw_def: "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)"
-
-lemma n2w_def: "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))"
-
-lemma w2n_def: "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))"
- by (import word32 ADDw)
-
-lemma ADD_0w: "word_add x w_0 = x"
- by (import word32 ADD_0w)
-
-lemma ADD1w: "word_suc x = word_add x w_1"
- by (import word32 ADD1w)
-
-lemma ADD_ASSOCw: "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))"
- by (import word32 ADD_CLAUSESw)
-
-lemma ADD_COMMw: "word_add x xa = word_add xa x"
- by (import word32 ADD_COMMw)
-
-lemma ADD_INV_0_EQw: "(word_add x xa = x) = (xa = w_0)"
- by (import word32 ADD_INV_0_EQw)
-
-lemma EQ_ADD_LCANCELw: "(word_add x xa = word_add x xb) = (xa = xb)"
- by (import word32 EQ_ADD_LCANCELw)
-
-lemma EQ_ADD_RCANCELw: "(word_add x xb = word_add xa xb) = (x = xa)"
- by (import word32 EQ_ADD_RCANCELw)
-
-lemma LEFT_ADD_DISTRIBw: "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: "word_mul x (word_mul xa xb) = word_mul (word_mul x xa) xb"
- by (import word32 MULT_ASSOCw)
-
-lemma MULT_COMMw: "word_mul x xa = word_mul xa x"
- by (import word32 MULT_COMMw)
-
-lemma MULT_CLAUSESw: "word_mul w_0 x = w_0 &
-word_mul x w_0 = w_0 &
-word_mul w_1 x = x &
-word_mul x w_1 = x &
-word_mul (word_suc x) xa = word_add (word_mul x xa) xa &
-word_mul x (word_suc xa) = word_add x (word_mul x xa)"
- by (import word32 MULT_CLAUSESw)
-
-lemma TWO_COMP_ONE_COMP: "word_2comp x = word_add (word_1comp x) w_1"
- by (import word32 TWO_COMP_ONE_COMP)
-
-lemma OR_ASSOCw: "bitwise_or x (bitwise_or xa xb) = bitwise_or (bitwise_or x xa) xb"
- by (import word32 OR_ASSOCw)
-
-lemma OR_COMMw: "bitwise_or x xa = bitwise_or xa x"
- by (import word32 OR_COMMw)
-
-lemma OR_IDEMw: "bitwise_or x x = x"
- by (import word32 OR_IDEMw)
-
-lemma OR_ABSORBw: "bitwise_and x (bitwise_or x xa) = x"
- by (import word32 OR_ABSORBw)
-
-lemma AND_ASSOCw: "bitwise_and x (bitwise_and xa xb) = bitwise_and (bitwise_and x xa) xb"
- by (import word32 AND_ASSOCw)
-
-lemma AND_COMMw: "bitwise_and x xa = bitwise_and xa x"
- by (import word32 AND_COMMw)
-
-lemma AND_IDEMw: "bitwise_and x x = x"
- by (import word32 AND_IDEMw)
-
-lemma AND_ABSORBw: "bitwise_or x (bitwise_and x xa) = x"
- by (import word32 AND_ABSORBw)
-
-lemma ONE_COMPw: "word_1comp (word_1comp x) = x"
- by (import word32 ONE_COMPw)
-
-lemma RIGHT_AND_OVER_ORw: "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: "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: "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"
- by (import word32 w_0)
-
-lemma w_1: "w_1 = n2w 1"
- by (import word32 w_1)
-
-lemma w_T: "w_T =
-n2w (NUMERAL
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
-(NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- ALT_ZERO)))))))))))))))))))))))))))))))))"
- by (import word32 w_T)
-
-lemma ADD_TWO_COMP: "word_add x (word_2comp x) = w_0"
- by (import word32 ADD_TWO_COMP)
-
-lemma ADD_TWO_COMP2: "word_add (word_2comp x) x = w_0"
- by (import word32 ADD_TWO_COMP2)
-
-definition
- word_sub :: "word32 => word32 => word32" where
- "word_sub == %a b. word_add a (word_2comp b)"
-
-lemma word_sub: "word_sub a b = word_add a (word_2comp b)"
- by (import word32 word_sub)
-
-definition
- word_lsl :: "word32 => nat => word32" where
- "word_lsl == %a n. word_mul a (n2w (2 ^ n))"
-
-lemma word_lsl: "word_lsl a n = word_mul a (n2w (2 ^ n))"
- by (import word32 word_lsl)
-
-definition
- word_lsr :: "word32 => nat => word32" where
- "word_lsr == %a n. (word_lsr1 ^^ n) a"
-
-lemma word_lsr: "word_lsr a n = (word_lsr1 ^^ n) a"
- by (import word32 word_lsr)
-
-definition
- word_asr :: "word32 => nat => word32" where
- "word_asr == %a n. (word_asr1 ^^ n) a"
-
-lemma word_asr: "word_asr a n = (word_asr1 ^^ n) a"
- by (import word32 word_asr)
-
-definition
- word_ror :: "word32 => nat => word32" where
- "word_ror == %a n. (word_ror1 ^^ n) a"
-
-lemma word_ror: "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)"
-
-lemma BITw_def: "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)"
-
-lemma BITSw_def: "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)"
-
-lemma SLICEw_def: "SLICEw h l n = SLICE h l (w2n n)"
- by (import word32 SLICEw_def)
-
-lemma TWO_COMP_ADD: "word_2comp (word_add a b) = word_add (word_2comp a) (word_2comp b)"
- by (import word32 TWO_COMP_ADD)
-
-lemma TWO_COMP_ELIM: "word_2comp (word_2comp a) = a"
- by (import word32 TWO_COMP_ELIM)
-
-lemma ADD_SUB_ASSOC: "word_sub (word_add a b) c = word_add a (word_sub b c)"
- by (import word32 ADD_SUB_ASSOC)
-
-lemma ADD_SUB_SYM: "word_sub (word_add a b) c = word_add (word_sub a c) b"
- by (import word32 ADD_SUB_SYM)
-
-lemma SUB_EQUALw: "word_sub a a = w_0"
- by (import word32 SUB_EQUALw)
-
-lemma ADD_SUBw: "word_sub (word_add a b) b = a"
- by (import word32 ADD_SUBw)
-
-lemma SUB_SUBw: "word_sub a (word_sub b c) = word_sub (word_add a c) b"
- by (import word32 SUB_SUBw)
-
-lemma ONE_COMP_TWO_COMP: "word_1comp a = word_sub (word_2comp a) w_1"
- by (import word32 ONE_COMP_TWO_COMP)
-
-lemma SUBw: "word_sub (word_suc m) n = word_suc (word_sub m n)"
- by (import word32 SUBw)
-
-lemma ADD_EQ_SUBw: "(word_add m n = p) = (m = word_sub p n)"
- by (import word32 ADD_EQ_SUBw)
-
-lemma CANCEL_SUBw: "(word_sub n p = word_sub m p) = (n = m)"
- by (import word32 CANCEL_SUBw)
-
-lemma SUB_PLUSw: "word_sub a (word_add b c) = word_sub (word_sub a b) c"
- by (import word32 SUB_PLUSw)
-
-lemma word_nchotomy: "EX n. w = n2w n"
- by (import word32 word_nchotomy)
-
-lemma dest_word_mk_word_eq3: "dest_word32 (mk_word32 (EQUIV a)) = EQUIV a"
- by (import word32 dest_word_mk_word_eq3)
-
-lemma MODw_ELIM: "n2w (MODw n) = n2w n"
- by (import word32 MODw_ELIM)
-
-lemma w2n_EVAL: "w2n (n2w n) = MODw n"
- by (import word32 w2n_EVAL)
-
-lemma w2n_ELIM: "n2w (w2n a) = a"
- by (import word32 w2n_ELIM)
-
-lemma n2w_11: "(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)"
- by (import word32 ADD_EVAL)
-
-lemma MUL_EVAL: "word_mul (n2w a) (n2w b) = n2w (a * b)"
- by (import word32 MUL_EVAL)
-
-lemma ONE_COMP_EVAL: "word_1comp (n2w a) = n2w (ONE_COMP a)"
- by (import word32 ONE_COMP_EVAL)
-
-lemma TWO_COMP_EVAL: "word_2comp (n2w a) = n2w (TWO_COMP a)"
- by (import word32 TWO_COMP_EVAL)
-
-lemma LSR_ONE_EVAL: "word_lsr1 (n2w a) = n2w (LSR_ONE a)"
- by (import word32 LSR_ONE_EVAL)
-
-lemma ASR_ONE_EVAL: "word_asr1 (n2w a) = n2w (ASR_ONE a)"
- by (import word32 ASR_ONE_EVAL)
-
-lemma ROR_ONE_EVAL: "word_ror1 (n2w a) = n2w (ROR_ONE a)"
- by (import word32 ROR_ONE_EVAL)
-
-lemma RRX_EVAL: "RRX c (n2w a) = n2w (RRXn c a)"
- by (import word32 RRX_EVAL)
-
-lemma LSB_EVAL: "LSB (n2w a) = LSBn a"
- by (import word32 LSB_EVAL)
-
-lemma MSB_EVAL: "MSB (n2w a) = MSBn a"
- by (import word32 MSB_EVAL)
-
-lemma OR_EVAL: "bitwise_or (n2w a) (n2w b) = n2w (OR a b)"
- by (import word32 OR_EVAL)
-
-lemma EOR_EVAL: "bitwise_eor (n2w a) (n2w b) = n2w (EOR a b)"
- by (import word32 EOR_EVAL)
-
-lemma AND_EVAL: "bitwise_and (n2w a) (n2w b) = n2w (AND a b)"
- by (import word32 AND_EVAL)
-
-lemma BITS_EVAL: "BITSw h l (n2w a) = BITS h l (MODw a)"
- by (import word32 BITS_EVAL)
-
-lemma BIT_EVAL: "BITw b (n2w a) = bit b (MODw a)"
- by (import word32 BIT_EVAL)
-
-lemma SLICE_EVAL: "SLICEw h l (n2w a) = SLICE h l (MODw a)"
- by (import word32 SLICE_EVAL)
-
-lemma LSL_ADD: "word_lsl (word_lsl a m) n = word_lsl a (m + n)"
- by (import word32 LSL_ADD)
-
-lemma LSR_ADD: "word_lsr (word_lsr x xa) xb = word_lsr x (xa + xb)"
- by (import word32 LSR_ADD)
-
-lemma ASR_ADD: "word_asr (word_asr x xa) xb = word_asr x (xa + xb)"
- by (import word32 ASR_ADD)
-
-lemma ROR_ADD: "word_ror (word_ror x xa) xb = word_ror x (xa + xb)"
- by (import word32 ROR_ADD)
-
-lemma LSL_LIMIT: "HB < n ==> word_lsl w n = w_0"
- by (import word32 LSL_LIMIT)
-
-lemma MOD_MOD_DIV: "INw (MODw a div 2 ^ b)"
- by (import word32 MOD_MOD_DIV)
-
-lemma MOD_MOD_DIV_2EXP: "MODw (MODw a div 2 ^ n) div 2 = MODw a div 2 ^ Suc n"
- by (import word32 MOD_MOD_DIV_2EXP)
-
-lemma LSR_EVAL: "word_lsr (n2w a) n = n2w (MODw a div 2 ^ n)"
- by (import word32 LSR_EVAL)
-
-lemma LSR_THM: "word_lsr (n2w n) x = n2w (BITS HB (min WL x) n)"
- by (import word32 LSR_THM)
-
-lemma LSR_LIMIT: "HB < x ==> word_lsr w x = w_0"
- by (import word32 LSR_LIMIT)
-
-lemma LEFT_SHIFT_LESS: "(a::nat) < (2::nat) ^ (m::nat)
-==> (2::nat) ^ (n::nat) + a * (2::nat) ^ n <= (2::nat) ^ (m + n)"
- by (import word32 LEFT_SHIFT_LESS)
-
-lemma ROR_THM: "word_ror (n2w n) x =
-(let x' = x mod WL
- in n2w (BITS HB x' n + BITS (x' - 1) 0 n * 2 ^ (WL - x')))"
- by (import word32 ROR_THM)
-
-lemma ROR_CYCLE: "word_ror w (x * WL) = w"
- by (import word32 ROR_CYCLE)
-
-lemma ASR_THM: "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))"
- by (import word32 ASR_THM)
-
-lemma ASR_LIMIT: "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)"
- 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)"
- by (import word32 ZERO_SHIFT2)
-
-lemma ASR_w_T: "word_asr w_T n = w_T"
- by (import word32 ASR_w_T)
-
-lemma ROR_w_T: "word_ror w_T n = w_T"
- by (import word32 ROR_w_T)
-
-lemma MODw_EVAL: "MODw x =
-x mod
-NUMERAL
- (NUMERAL_BIT2
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- ALT_ZERO))))))))))))))))))))))))))))))))"
- by (import word32 MODw_EVAL)
-
-lemma ADD_EVAL2: "word_add (n2w a) (n2w b) = n2w (MODw (a + b))"
- by (import word32 ADD_EVAL2)
-
-lemma MUL_EVAL2: "word_mul (n2w a) (n2w b) = n2w (MODw (a * b))"
- by (import word32 MUL_EVAL2)
-
-lemma ONE_COMP_EVAL2: "word_1comp (n2w a) =
-n2w (2 ^
- NUMERAL
- (NUMERAL_BIT2
- (NUMERAL_BIT1
- (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))) -
- 1 -
- MODw a)"
- by (import word32 ONE_COMP_EVAL2)
-
-lemma TWO_COMP_EVAL2: "word_2comp (n2w a) =
-n2w (MODw
- (2 ^
- NUMERAL
- (NUMERAL_BIT2
- (NUMERAL_BIT1
- (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))) -
- MODw a))"
- by (import word32 TWO_COMP_EVAL2)
-
-lemma LSR_ONE_EVAL2: "word_lsr1 (n2w a) = n2w (MODw a div 2)"
- by (import word32 LSR_ONE_EVAL2)
-
-lemma ASR_ONE_EVAL2: "word_asr1 (n2w a) =
-n2w (MODw a div 2 +
- SBIT (MSBn a)
- (NUMERAL
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))))"
- by (import word32 ASR_ONE_EVAL2)
-
-lemma ROR_ONE_EVAL2: "word_ror1 (n2w a) =
-n2w (MODw a div 2 +
- SBIT (LSBn a)
- (NUMERAL
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))))"
- by (import word32 ROR_ONE_EVAL2)
-
-lemma RRX_EVAL2: "RRX c (n2w a) =
-n2w (MODw a div 2 +
- SBIT c
- (NUMERAL
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO)))))))"
- by (import word32 RRX_EVAL2)
-
-lemma LSB_EVAL2: "LSB (n2w a) = ODD a"
- by (import word32 LSB_EVAL2)
-
-lemma MSB_EVAL2: "MSB (n2w a) =
-bit (NUMERAL
- (NUMERAL_BIT1
- (NUMERAL_BIT1
- (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))))
- a"
- by (import word32 MSB_EVAL2)
-
-lemma OR_EVAL2: "bitwise_or (n2w a) (n2w b) =
-n2w (BITWISE
- (NUMERAL
- (NUMERAL_BIT2
- (NUMERAL_BIT1
- (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))))
- op | a b)"
- by (import word32 OR_EVAL2)
-
-lemma AND_EVAL2: "bitwise_and (n2w a) (n2w b) =
-n2w (BITWISE
- (NUMERAL
- (NUMERAL_BIT2
- (NUMERAL_BIT1
- (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))))
- op & a b)"
- by (import word32 AND_EVAL2)
-
-lemma EOR_EVAL2: "bitwise_eor (n2w a) (n2w b) =
-n2w (BITWISE
- (NUMERAL
- (NUMERAL_BIT2
- (NUMERAL_BIT1
- (NUMERAL_BIT1 (NUMERAL_BIT1 (NUMERAL_BIT1 ALT_ZERO))))))
- op ~= a b)"
- by (import word32 EOR_EVAL2)
-
-lemma BITWISE_EVAL2: "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))"
- by (import word32 BITWISE_EVAL2)
-
-lemma BITSwLT_THM: "BITSw h l n < 2 ^ (Suc h - l)"
- by (import word32 BITSwLT_THM)
-
-lemma BITSw_COMP_THM: "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: "BITSw h l x div 2 ^ n = BITSw h (l + n) x"
- by (import word32 BITSw_DIV_THM)
-
-lemma BITw_THM: "BITw b n = (BITSw b b n = 1)"
- by (import word32 BITw_THM)
-
-lemma SLICEw_THM: "SLICEw h l n = BITSw h l n * 2 ^ l"
- by (import word32 SLICEw_THM)
-
-lemma BITS_SLICEw_THM: "BITS h l (SLICEw h l n) = BITSw h l n"
- by (import word32 BITS_SLICEw_THM)
-
-lemma SLICEw_ZERO_THM: "SLICEw h 0 n = BITSw h 0 n"
- by (import word32 SLICEw_ZERO_THM)
-
-lemma SLICEw_COMP_THM: "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: "h < l ==> BITSw h l n = 0"
- by (import word32 BITSw_ZERO)
-
-lemma SLICEw_ZERO: "h < l ==> SLICEw h l n = 0"
- by (import word32 SLICEw_ZERO)
-
-;end_setup
-
-end
-
--- a/src/HOL/Import/HOL4/Generated/arithmetic.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,271 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "nat_elim__magic" > "nat_elim__magic_def"
- "ODD" > "ODD_def"
- "FACT" > "FACT_def"
- "EVEN" > "EVEN_def"
-
-const_maps
- "num_case" > "Nat.nat.nat_case"
- "nat_elim__magic" > "HOL4Base.arithmetic.nat_elim__magic"
- "NUMERAL_BIT2" > "Compatibility.NUMERAL_BIT2"
- "NUMERAL_BIT1" > "Compatibility.NUMERAL_BIT1"
- "NUMERAL" > "Compatibility.NUMERAL"
- "MOD" > "Divides.div_class.mod" :: "nat => nat => nat"
- "MIN" > "Orderings.ord_class.min" :: "nat => nat => nat"
- "MAX" > "Orderings.ord_class.max" :: "nat => nat => nat"
- "FUNPOW" > "Compatibility.FUNPOW"
- "EXP" > "Power.power_class.power" :: "nat => nat => nat"
- "DIV" > "Divides.div_class.div" :: "nat => nat => nat"
- "ALT_ZERO" > "Compatibility.ALT_ZERO"
- ">=" > "Compatibility.nat_ge"
- ">" > "Compatibility.nat_gt"
- "<=" > "Orderings.ord_class.less_eq" :: "nat => nat => bool"
- "-" > "Groups.minus_class.minus" :: "nat => nat => nat"
- "+" > "Groups.plus_class.plus" :: "nat => nat => nat"
- "*" > "Groups.times_class.times" :: "nat => nat => nat"
-
-thm_maps
- "num_case_def" > "Compatibility.num_case_def"
- "num_case_cong" > "HOL4Base.arithmetic.num_case_cong"
- "num_case_compute" > "HOL4Base.arithmetic.num_case_compute"
- "num_CASES" > "Nat.nat.nchotomy"
- "nat_elim__magic_def" > "HOL4Base.arithmetic.nat_elim__magic_def"
- "nat_elim__magic" > "HOL4Base.arithmetic.nat_elim__magic"
- "ZERO_MOD" > "HOL4Base.arithmetic.ZERO_MOD"
- "ZERO_LESS_EXP" > "HOL4Base.arithmetic.ZERO_LESS_EXP"
- "ZERO_LESS_EQ" > "Nat.le0"
- "ZERO_DIV" > "HOL4Base.arithmetic.ZERO_DIV"
- "WOP" > "HOL4Base.arithmetic.WOP"
- "TWO" > "HOL4Base.arithmetic.TWO"
- "TIMES2" > "Int.semiring_mult_2"
- "SUC_SUB1" > "Nat.diff_Suc_1"
- "SUC_ONE_ADD" > "Nat_Numeral.Suc_eq_plus1_left"
- "SUC_NOT" > "Nat.Zero_not_Suc"
- "SUC_ELIM_THM" > "HOL4Base.arithmetic.SUC_ELIM_THM"
- "SUC_ADD_SYM" > "HOL4Base.arithmetic.SUC_ADD_SYM"
- "SUB_SUB" > "Nat.diff_diff_right"
- "SUB_RIGHT_SUB" > "Nat.diff_diff_left"
- "SUB_RIGHT_LESS_EQ" > "HOL4Base.arithmetic.SUB_RIGHT_LESS_EQ"
- "SUB_RIGHT_LESS" > "HOL4Base.arithmetic.SUB_RIGHT_LESS"
- "SUB_RIGHT_GREATER_EQ" > "HOL4Base.arithmetic.SUB_RIGHT_GREATER_EQ"
- "SUB_RIGHT_GREATER" > "HOL4Base.arithmetic.SUB_RIGHT_GREATER"
- "SUB_RIGHT_EQ" > "HOL4Base.arithmetic.SUB_RIGHT_EQ"
- "SUB_RIGHT_ADD" > "HOL4Base.arithmetic.SUB_RIGHT_ADD"
- "SUB_PLUS" > "Nat.diff_diff_left"
- "SUB_MONO_EQ" > "Nat.diff_Suc_Suc"
- "SUB_LESS_OR" > "HOL4Base.arithmetic.SUB_LESS_OR"
- "SUB_LESS_EQ_ADD" > "HOL4Base.arithmetic.SUB_LESS_EQ_ADD"
- "SUB_LESS_EQ" > "Nat.diff_le_self"
- "SUB_LESS_0" > "Nat.zero_less_diff"
- "SUB_LEFT_SUC" > "HOL4Base.arithmetic.SUB_LEFT_SUC"
- "SUB_LEFT_SUB" > "HOL4Base.arithmetic.SUB_LEFT_SUB"
- "SUB_LEFT_LESS_EQ" > "HOL4Base.arithmetic.SUB_LEFT_LESS_EQ"
- "SUB_LEFT_LESS" > "Nat.less_diff_conv"
- "SUB_LEFT_GREATER_EQ" > "Nat.le_diff_conv"
- "SUB_LEFT_GREATER" > "HOL4Base.arithmetic.SUB_LEFT_GREATER"
- "SUB_LEFT_EQ" > "HOL4Base.arithmetic.SUB_LEFT_EQ"
- "SUB_LEFT_ADD" > "HOL4Base.arithmetic.SUB_LEFT_ADD"
- "SUB_EQ_EQ_0" > "HOL4Base.arithmetic.SUB_EQ_EQ_0"
- "SUB_EQ_0" > "Nat.diff_is_0_eq"
- "SUB_EQUAL_0" > "Nat.diff_self_eq_0"
- "SUB_ELIM_THM" > "HOL4Base.arithmetic.SUB_ELIM_THM"
- "SUB_CANCEL" > "HOL4Base.arithmetic.SUB_CANCEL"
- "SUB_ADD" > "Nat.le_add_diff_inverse2"
- "SUB_0" > "HOL4Base.arithmetic.SUB_0"
- "SUB" > "Compatibility.SUB"
- "RIGHT_SUB_DISTRIB" > "Nat.diff_mult_distrib"
- "RIGHT_ADD_DISTRIB" > "Fields.linordered_field_class.sign_simps_26"
- "PRE_SUC_EQ" > "HOL4Base.arithmetic.PRE_SUC_EQ"
- "PRE_SUB1" > "HOL4Base.arithmetic.PRE_SUB1"
- "PRE_SUB" > "HOL4Base.arithmetic.PRE_SUB"
- "PRE_ELIM_THM" > "HOL4Base.arithmetic.PRE_ELIM_THM"
- "OR_LESS" > "Nat.Suc_le_lessD"
- "ONE" > "Nat.One_nat_def"
- "ODD_OR_EVEN" > "HOL4Base.arithmetic.ODD_OR_EVEN"
- "ODD_MULT" > "HOL4Base.arithmetic.ODD_MULT"
- "ODD_EXISTS" > "HOL4Base.arithmetic.ODD_EXISTS"
- "ODD_EVEN" > "HOL4Base.arithmetic.ODD_EVEN"
- "ODD_DOUBLE" > "HOL4Base.arithmetic.ODD_DOUBLE"
- "ODD_ADD" > "HOL4Base.arithmetic.ODD_ADD"
- "ODD" > "HOL4Base.arithmetic.ODD"
- "NUMERAL_DEF" > "Compatibility.NUMERAL_def"
- "NUMERAL_BIT2" > "Compatibility.NUMERAL_BIT2_def"
- "NUMERAL_BIT1" > "Compatibility.NUMERAL_BIT1_def"
- "NOT_ZERO_LT_ZERO" > "Nat.neq0_conv"
- "NOT_SUC_LESS_EQ_0" > "HOL4Base.arithmetic.NOT_SUC_LESS_EQ_0"
- "NOT_SUC_LESS_EQ" > "HOL4Base.arithmetic.NOT_SUC_LESS_EQ"
- "NOT_SUC_ADD_LESS_EQ" > "HOL4Base.arithmetic.NOT_SUC_ADD_LESS_EQ"
- "NOT_ODD_EQ_EVEN" > "HOL4Base.arithmetic.NOT_ODD_EQ_EVEN"
- "NOT_NUM_EQ" > "HOL4Base.arithmetic.NOT_NUM_EQ"
- "NOT_LESS_EQUAL" > "Orderings.linorder_class.not_le"
- "NOT_LESS" > "Orderings.linorder_class.not_less"
- "NOT_LEQ" > "Nat.not_less_eq_eq"
- "NOT_GREATER_EQ" > "Nat.not_less_eq_eq"
- "NOT_GREATER" > "Orderings.linorder_class.not_less"
- "NOT_EXP_0" > "HOL4Base.arithmetic.NOT_EXP_0"
- "NORM_0" > "HOL4Base.arithmetic.NORM_0"
- "MULT_SYM" > "Fields.linordered_field_class.sign_simps_40"
- "MULT_SUC_EQ" > "HOL4Base.arithmetic.MULT_SUC_EQ"
- "MULT_SUC" > "Nat.mult_Suc_right"
- "MULT_RIGHT_1" > "Divides.arithmetic_simps_43"
- "MULT_MONO_EQ" > "Nat.Suc_mult_cancel1"
- "MULT_LESS_EQ_SUC" > "Nat.Suc_mult_le_cancel1"
- "MULT_LEFT_1" > "Divides.arithmetic_simps_42"
- "MULT_INCREASES" > "HOL4Base.arithmetic.MULT_INCREASES"
- "MULT_EXP_MONO" > "HOL4Base.arithmetic.MULT_EXP_MONO"
- "MULT_EQ_1" > "Nat.nat_mult_eq_1_iff"
- "MULT_EQ_0" > "Nat.mult_is_0"
- "MULT_DIV" > "Divides.div_mult_self_is_m"
- "MULT_COMM" > "Fields.linordered_field_class.sign_simps_40"
- "MULT_CLAUSES" > "HOL4Base.arithmetic.MULT_CLAUSES"
- "MULT_ASSOC" > "Fields.linordered_field_class.sign_simps_41"
- "MULT_0" > "Divides.arithmetic_simps_41"
- "MULT" > "Compatibility.MULT"
- "MOD_UNIQUE" > "HOL4Base.arithmetic.MOD_UNIQUE"
- "MOD_TIMES2" > "HOL4Base.arithmetic.MOD_TIMES2"
- "MOD_TIMES" > "HOL4Base.arithmetic.MOD_TIMES"
- "MOD_PLUS" > "HOL4Base.arithmetic.MOD_PLUS"
- "MOD_P" > "HOL4Base.arithmetic.MOD_P"
- "MOD_ONE" > "Divides.mod_1"
- "MOD_MULT_MOD" > "HOL4Base.arithmetic.MOD_MULT_MOD"
- "MOD_MULT" > "HOL4Base.arithmetic.MOD_MULT"
- "MOD_MOD" > "HOL4Base.arithmetic.MOD_MOD"
- "MOD_EQ_0" > "HOL4Base.arithmetic.MOD_EQ_0"
- "MOD_COMMON_FACTOR" > "HOL4Base.arithmetic.MOD_COMMON_FACTOR"
- "MIN_MAX_PRED" > "HOL4Base.arithmetic.MIN_MAX_PRED"
- "MIN_MAX_LT" > "HOL4Base.arithmetic.MIN_MAX_LT"
- "MIN_MAX_EQ" > "HOL4Base.arithmetic.MIN_MAX_EQ"
- "MIN_LT" > "HOL4Base.arithmetic.MIN_LT"
- "MIN_LE" > "HOL4Base.arithmetic.MIN_LE"
- "MIN_IDEM" > "Big_Operators.linorder_class.Min.idem"
- "MIN_DEF" > "Compatibility.MIN_DEF"
- "MIN_COMM" > "Lattices.linorder_class.min_max.inf.commute"
- "MIN_ASSOC" > "Lattices.linorder_class.min_max.inf.assoc"
- "MIN_0" > "HOL4Base.arithmetic.MIN_0"
- "MAX_LT" > "HOL4Base.arithmetic.MAX_LT"
- "MAX_LE" > "HOL4Base.arithmetic.MAX_LE"
- "MAX_IDEM" > "Big_Operators.linorder_class.Max.idem"
- "MAX_DEF" > "Compatibility.MAX_DEF"
- "MAX_COMM" > "Lattices.linorder_class.min_max.inf_sup_aci_5"
- "MAX_ASSOC" > "Lattices.linorder_class.min_max.inf_sup_aci_6"
- "MAX_0" > "HOL4Base.arithmetic.MAX_0"
- "LESS_TRANS" > "Orderings.order_less_trans"
- "LESS_SUC_NOT" > "HOL4Base.arithmetic.LESS_SUC_NOT"
- "LESS_SUC_EQ_COR" > "Nat.Suc_lessI"
- "LESS_SUB_ADD_LESS" > "HOL4Base.arithmetic.LESS_SUB_ADD_LESS"
- "LESS_OR_EQ_ADD" > "HOL4Base.arithmetic.LESS_OR_EQ_ADD"
- "LESS_OR_EQ" > "Compatibility.LESS_OR_EQ"
- "LESS_OR" > "Nat.Suc_leI"
- "LESS_NOT_SUC" > "HOL4Base.arithmetic.LESS_NOT_SUC"
- "LESS_MULT_MONO" > "Nat.Suc_mult_less_cancel1"
- "LESS_MULT2" > "Rings.linordered_semiring_strict_class.mult_pos_pos"
- "LESS_MONO_REV" > "Nat.Suc_less_SucD"
- "LESS_MONO_MULT" > "Nat.mult_le_mono1"
- "LESS_MONO_EQ" > "Nat.Suc_less_eq"
- "LESS_MONO_ADD_INV" > "Groups.ordered_ab_semigroup_add_imp_le_class.add_less_imp_less_right"
- "LESS_MONO_ADD_EQ" > "Groups.ordered_ab_semigroup_add_imp_le_class.add_less_cancel_right"
- "LESS_MONO_ADD" > "Groups.ordered_cancel_ab_semigroup_add_class.add_strict_right_mono"
- "LESS_MOD" > "Divides.mod_less"
- "LESS_LESS_SUC" > "HOL4Base.arithmetic.LESS_LESS_SUC"
- "LESS_LESS_EQ_TRANS" > "Orderings.order_less_le_trans"
- "LESS_LESS_CASES" > "HOL4Base.arithmetic.LESS_LESS_CASES"
- "LESS_IMP_LESS_OR_EQ" > "FunDef.termination_basic_simps_5"
- "LESS_IMP_LESS_ADD" > "FunDef.termination_basic_simps_1"
- "LESS_EXP_SUC_MONO" > "HOL4Base.arithmetic.LESS_EXP_SUC_MONO"
- "LESS_EQ_TRANS" > "Nat.le_trans"
- "LESS_EQ_SUC_REFL" > "HOL4Base.arithmetic.LESS_EQ_SUC_REFL"
- "LESS_EQ_SUB_LESS" > "HOL4Base.arithmetic.LESS_EQ_SUB_LESS"
- "LESS_EQ_REFL" > "Nat.le_refl"
- "LESS_EQ_MONO_ADD_EQ" > "Groups.ordered_ab_semigroup_add_imp_le_class.add_le_cancel_right"
- "LESS_EQ_MONO" > "Nat.Suc_le_mono"
- "LESS_EQ_LESS_TRANS" > "Orderings.order_le_less_trans"
- "LESS_EQ_LESS_EQ_MONO" > "Groups.add_mono_thms_linordered_semiring_1"
- "LESS_EQ_IMP_LESS_SUC" > "Nat.le_imp_less_Suc"
- "LESS_EQ_EXISTS" > "Nat.le_iff_add"
- "LESS_EQ_CASES" > "Nat.nat_le_linear"
- "LESS_EQ_ANTISYM" > "HOL4Base.arithmetic.LESS_EQ_ANTISYM"
- "LESS_EQ_ADD_SUB" > "Nat.add_diff_assoc"
- "LESS_EQ_ADD" > "Nat.le_add1"
- "LESS_EQ_0" > "Nat.le_0_eq"
- "LESS_EQUAL_ANTISYM" > "Nat.le_antisym"
- "LESS_EQUAL_ADD" > "Series.le_Suc_ex"
- "LESS_EQ" > "Nat.Suc_le_eq"
- "LESS_DIV_EQ_ZERO" > "Divides.div_less"
- "LESS_CASES_IMP" > "HOL4Base.arithmetic.LESS_CASES_IMP"
- "LESS_CASES" > "HOL4Base.arithmetic.LESS_CASES"
- "LESS_ANTISYM" > "HOL4Base.arithmetic.LESS_ANTISYM"
- "LESS_ADD_SUC" > "HOL4Base.arithmetic.LESS_ADD_SUC"
- "LESS_ADD_NONZERO" > "HOL4Base.arithmetic.LESS_ADD_NONZERO"
- "LESS_ADD_1" > "HOL4Base.arithmetic.LESS_ADD_1"
- "LESS_ADD" > "HOL4Base.arithmetic.LESS_ADD"
- "LESS_0_CASES" > "HOL4Base.arithmetic.LESS_0_CASES"
- "LEFT_SUB_DISTRIB" > "Nat.diff_mult_distrib2"
- "LEFT_ADD_DISTRIB" > "Fields.linordered_field_class.sign_simps_25"
- "LE" > "HOL4Base.arithmetic.LE"
- "INV_PRE_LESS_EQ" > "HOL4Base.arithmetic.INV_PRE_LESS_EQ"
- "INV_PRE_LESS" > "HOL4Base.arithmetic.INV_PRE_LESS"
- "INV_PRE_EQ" > "HOL4Base.arithmetic.INV_PRE_EQ"
- "GREATER_OR_EQ" > "Compatibility.GREATER_OR_EQ"
- "GREATER_EQ" > "Compatibility.real_ge"
- "GREATER_DEF" > "Compatibility.GREATER_DEF"
- "FUN_EQ_LEMMA" > "HOL4Base.arithmetic.FUN_EQ_LEMMA"
- "FUNPOW" > "Compatibility.FUNPOW"
- "FACT_LESS" > "HOL4Base.arithmetic.FACT_LESS"
- "FACT" > "HOL4Base.arithmetic.FACT"
- "EXP_INJECTIVE" > "Power.linordered_semidom_class.power_inject_exp"
- "EXP_EQ_1" > "Primes.exp_eq_1"
- "EXP_EQ_0" > "HOL4Base.arithmetic.EXP_EQ_0"
- "EXP_ALWAYS_BIG_ENOUGH" > "HOL4Base.arithmetic.EXP_ALWAYS_BIG_ENOUGH"
- "EXP_ADD" > "Power.monoid_mult_class.power_add"
- "EXP_1" > "HOL4Base.arithmetic.EXP_1"
- "EXP" > "Compatibility.EXP"
- "EXISTS_GREATEST" > "HOL4Base.arithmetic.EXISTS_GREATEST"
- "EVEN_OR_ODD" > "HOL4Base.arithmetic.EVEN_OR_ODD"
- "EVEN_ODD_EXISTS" > "HOL4Base.arithmetic.EVEN_ODD_EXISTS"
- "EVEN_ODD" > "HOL4Base.arithmetic.EVEN_ODD"
- "EVEN_MULT" > "HOL4Base.arithmetic.EVEN_MULT"
- "EVEN_EXISTS" > "HOL4Base.arithmetic.EVEN_EXISTS"
- "EVEN_DOUBLE" > "HOL4Base.arithmetic.EVEN_DOUBLE"
- "EVEN_AND_ODD" > "HOL4Base.arithmetic.EVEN_AND_ODD"
- "EVEN_ADD" > "HOL4Base.arithmetic.EVEN_ADD"
- "EVEN" > "HOL4Base.arithmetic.EVEN"
- "EQ_MULT_LCANCEL" > "Numeral_Simprocs.nat_mult_eq_cancel_disj"
- "EQ_MONO_ADD_EQ" > "Groups.cancel_semigroup_add_class.add_right_cancel"
- "EQ_LESS_EQ" > "Orderings.order_class.eq_iff"
- "EQ_ADD_RCANCEL" > "Groups.cancel_semigroup_add_class.add_right_cancel"
- "EQ_ADD_LCANCEL" > "Groups.cancel_semigroup_add_class.add_left_cancel"
- "DIV_UNIQUE" > "HOL4Base.arithmetic.DIV_UNIQUE"
- "DIV_P" > "HOL4Base.arithmetic.DIV_P"
- "DIV_ONE" > "Divides.div_1"
- "DIV_MULT" > "HOL4Base.arithmetic.DIV_MULT"
- "DIV_LESS_EQ" > "HOL4Base.arithmetic.DIV_LESS_EQ"
- "DIV_LESS" > "Divides.div_less_dividend"
- "DIV_DIV_DIV_MULT" > "HOL4Base.arithmetic.DIV_DIV_DIV_MULT"
- "DIVMOD_ID" > "HOL4Base.arithmetic.DIVMOD_ID"
- "DIVISION" > "Compatibility.DIVISION"
- "DA" > "HOL4Base.arithmetic.DA"
- "COMPLETE_INDUCTION" > "Nat.nat_less_induct"
- "CANCEL_SUB" > "Nat.eq_diff_iff"
- "ALT_ZERO" > "Compatibility.ALT_ZERO_def"
- "ADD_SYM" > "Fields.linordered_field_class.sign_simps_43"
- "ADD_SUC" > "Nat.add_Suc_right"
- "ADD_SUB" > "Nat.diff_add_inverse2"
- "ADD_MONO_LESS_EQ" > "Groups.ordered_ab_semigroup_add_imp_le_class.add_le_cancel_left"
- "ADD_INV_0_EQ" > "HOL4Base.arithmetic.ADD_INV_0_EQ"
- "ADD_INV_0" > "Nat.add_eq_self_zero"
- "ADD_EQ_SUB" > "HOL4Base.arithmetic.ADD_EQ_SUB"
- "ADD_EQ_1" > "HOL4Base.arithmetic.ADD_EQ_1"
- "ADD_EQ_0" > "Nat.add_is_0"
- "ADD_DIV_ADD_DIV" > "HOL4Base.arithmetic.ADD_DIV_ADD_DIV"
- "ADD_COMM" > "Fields.linordered_field_class.sign_simps_43"
- "ADD_CLAUSES" > "HOL4Base.arithmetic.ADD_CLAUSES"
- "ADD_ASSOC" > "Fields.linordered_field_class.sign_simps_44"
- "ADD_0" > "Divides.arithmetic_simps_39"
- "ADD1" > "Nat_Numeral.Suc_eq_plus1"
- "ADD" > "Compatibility.ADD"
-
-end
--- a/src/HOL/Import/HOL4/Generated/bits.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,115 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "bit" > "bit_def"
- "TIMES_2EXP" > "TIMES_2EXP_primdef"
- "SLICE" > "SLICE_primdef"
- "SBIT" > "SBIT_primdef"
- "MOD_2EXP" > "MOD_2EXP_primdef"
- "LSBn" > "LSBn_primdef"
- "DIV_2EXP" > "DIV_2EXP_primdef"
- "DIVMOD_2EXP" > "DIVMOD_2EXP_primdef"
- "DIV2" > "DIV2_primdef"
- "BITWISE" > "BITWISE_primdef"
- "BITS" > "BITS_primdef"
-
-const_maps
- "bit" > "HOL4Word32.bits.bit"
- "TIMES_2EXP" > "HOL4Word32.bits.TIMES_2EXP"
- "SLICE" > "HOL4Word32.bits.SLICE"
- "SBIT" > "HOL4Word32.bits.SBIT"
- "MOD_2EXP" > "HOL4Word32.bits.MOD_2EXP"
- "LSBn" > "HOL4Word32.bits.LSBn"
- "DIV_2EXP" > "HOL4Word32.bits.DIV_2EXP"
- "DIVMOD_2EXP" > "HOL4Word32.bits.DIVMOD_2EXP"
- "DIV2" > "HOL4Word32.bits.DIV2"
- "BITS" > "HOL4Word32.bits.BITS"
-
-const_renames
- "BIT" > "bit"
-
-thm_maps
- "bit_def" > "HOL4Word32.bits.bit_def"
- "ZERO_LT_TWOEXP" > "HOL4Word32.bits.ZERO_LT_TWOEXP"
- "TWOEXP_MONO2" > "HOL4Word32.bits.TWOEXP_MONO2"
- "TWOEXP_MONO" > "HOL4Word32.bits.TWOEXP_MONO"
- "TWOEXP_DIVISION" > "HOL4Word32.bits.TWOEXP_DIVISION"
- "TIMES_2EXP_primdef" > "HOL4Word32.bits.TIMES_2EXP_primdef"
- "TIMES_2EXP_def" > "HOL4Word32.bits.TIMES_2EXP_def"
- "SUC_SUB" > "HOL4Word32.bits.SUC_SUB"
- "SLICE_primdef" > "HOL4Word32.bits.SLICE_primdef"
- "SLICE_def" > "HOL4Word32.bits.SLICE_def"
- "SLICE_ZERO" > "HOL4Word32.bits.SLICE_ZERO"
- "SLICE_THM" > "HOL4Word32.bits.SLICE_THM"
- "SLICE_LEM3" > "HOL4Word32.bits.SLICE_LEM3"
- "SLICE_LEM2" > "HOL4Word32.bits.SLICE_LEM2"
- "SLICE_LEM1" > "HOL4Word32.bits.SLICE_LEM1"
- "SLICE_COMP_THM" > "HOL4Word32.bits.SLICE_COMP_THM"
- "SLICELT_THM" > "HOL4Word32.bits.SLICELT_THM"
- "SBIT_primdef" > "HOL4Word32.bits.SBIT_primdef"
- "SBIT_def" > "HOL4Word32.bits.SBIT_def"
- "SBIT_DIV" > "HOL4Word32.bits.SBIT_DIV"
- "ODD_MOD2_LEM" > "HOL4Word32.bits.ODD_MOD2_LEM"
- "NOT_ZERO_ADD1" > "Nat.not0_implies_Suc"
- "NOT_MOD2_LEM2" > "HOL4Word32.bits.NOT_MOD2_LEM2"
- "NOT_MOD2_LEM" > "HOL4Word32.bits.NOT_MOD2_LEM"
- "NOT_BITS2" > "HOL4Word32.bits.NOT_BITS2"
- "NOT_BITS" > "HOL4Word32.bits.NOT_BITS"
- "NOT_BIT" > "HOL4Word32.bits.NOT_BIT"
- "MOD_PLUS_RIGHT" > "HOL4Word32.bits.MOD_PLUS_RIGHT"
- "MOD_PLUS_1" > "HOL4Word32.bits.MOD_PLUS_1"
- "MOD_ADD_1" > "HOL4Word32.bits.MOD_ADD_1"
- "MOD_2EXP_primdef" > "HOL4Word32.bits.MOD_2EXP_primdef"
- "MOD_2EXP_def" > "HOL4Word32.bits.MOD_2EXP_def"
- "MOD_2EXP_MONO" > "HOL4Word32.bits.MOD_2EXP_MONO"
- "MOD_2EXP_LT" > "HOL4Word32.bits.MOD_2EXP_LT"
- "MOD_2EXP_LEM" > "HOL4Word32.bits.MOD_2EXP_LEM"
- "LSBn_primdef" > "HOL4Word32.bits.LSBn_primdef"
- "LSBn_def" > "HOL4Word32.bits.LSBn_def"
- "LSB_ODD" > "HOL4Word32.bits.LSB_ODD"
- "LESS_EXP_MULT2" > "HOL4Word32.bits.LESS_EXP_MULT2"
- "LESS_EQ_EXP_MULT" > "HOL4Word32.bits.LESS_EQ_EXP_MULT"
- "EXP_SUB_LESS_EQ" > "HOL4Word32.bits.EXP_SUB_LESS_EQ"
- "EVEN_MOD2_LEM" > "HOL4Word32.bits.EVEN_MOD2_LEM"
- "DIV_MULT_THM2" > "HOL4Word32.bits.DIV_MULT_THM2"
- "DIV_MULT_THM" > "HOL4Word32.bits.DIV_MULT_THM"
- "DIV_MULT_LEM" > "HOL4Word32.bits.DIV_MULT_LEM"
- "DIV_MULT_1" > "HOL4Word32.bits.DIV_MULT_1"
- "DIV_2EXP_primdef" > "HOL4Word32.bits.DIV_2EXP_primdef"
- "DIV_2EXP_def" > "HOL4Word32.bits.DIV_2EXP_def"
- "DIVMOD_2EXP_primdef" > "HOL4Word32.bits.DIVMOD_2EXP_primdef"
- "DIVMOD_2EXP_def" > "HOL4Word32.bits.DIVMOD_2EXP_def"
- "DIV2_primdef" > "HOL4Word32.bits.DIV2_primdef"
- "DIV2_def" > "HOL4Word32.bits.DIV2_def"
- "DIV1" > "Divides.semiring_div_class.div_by_1"
- "BIT_def" > "HOL4Word32.bits.BIT_def"
- "BIT_SLICE_THM" > "HOL4Word32.bits.BIT_SLICE_THM"
- "BIT_SLICE_LEM" > "HOL4Word32.bits.BIT_SLICE_LEM"
- "BIT_SLICE" > "HOL4Word32.bits.BIT_SLICE"
- "BIT_COMP_THM3" > "HOL4Word32.bits.BIT_COMP_THM3"
- "BIT_BITS_THM" > "HOL4Word32.bits.BIT_BITS_THM"
- "BITWISE_def" > "HOL4Word32.bits.BITWISE_def"
- "BITWISE_THM" > "HOL4Word32.bits.BITWISE_THM"
- "BITWISE_NOT_COR" > "HOL4Word32.bits.BITWISE_NOT_COR"
- "BITWISE_LT_2EXP" > "HOL4Word32.bits.BITWISE_LT_2EXP"
- "BITWISE_COR" > "HOL4Word32.bits.BITWISE_COR"
- "BITS_primdef" > "HOL4Word32.bits.BITS_primdef"
- "BITS_def" > "HOL4Word32.bits.BITS_def"
- "BITS_ZERO3" > "HOL4Word32.bits.BITS_ZERO3"
- "BITS_ZERO2" > "HOL4Word32.bits.BITS_ZERO2"
- "BITS_ZERO" > "HOL4Word32.bits.BITS_ZERO"
- "BITS_THM" > "HOL4Word32.bits.BITS_THM"
- "BITS_SUC_THM" > "HOL4Word32.bits.BITS_SUC_THM"
- "BITS_SUC" > "HOL4Word32.bits.BITS_SUC"
- "BITS_SLICE_THM2" > "HOL4Word32.bits.BITS_SLICE_THM2"
- "BITS_SLICE_THM" > "HOL4Word32.bits.BITS_SLICE_THM"
- "BITS_LT_HIGH" > "HOL4Word32.bits.BITS_LT_HIGH"
- "BITS_DIV_THM" > "HOL4Word32.bits.BITS_DIV_THM"
- "BITS_COMP_THM2" > "HOL4Word32.bits.BITS_COMP_THM2"
- "BITS_COMP_THM" > "HOL4Word32.bits.BITS_COMP_THM"
- "BITSLT_THM" > "HOL4Word32.bits.BITSLT_THM"
- "BITS2_THM" > "HOL4Word32.bits.BITS2_THM"
-
-end
--- a/src/HOL/Import/HOL4/Generated/bool.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,198 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "RES_SELECT" > "RES_SELECT_def"
- "RES_FORALL" > "RES_FORALL_def"
- "RES_EXISTS_UNIQUE" > "RES_EXISTS_UNIQUE_def"
- "RES_EXISTS" > "RES_EXISTS_def"
- "RES_ABSTRACT" > "RES_ABSTRACT_def"
- "IN" > "IN_def"
- "ARB" > "ARB_def"
-
-type_maps
- "bool" > "HOL.bool"
-
-const_maps
- "~" > "HOL.Not"
- "bool_case" > "Product_Type.bool.bool_case"
- "\\/" > "HOL.disj"
- "TYPE_DEFINITION" > "Importer.TYPE_DEFINITION"
- "T" > "HOL.True"
- "RES_SELECT" > "HOL4Base.bool.RES_SELECT"
- "RES_FORALL" > "HOL4Base.bool.RES_FORALL"
- "RES_EXISTS_UNIQUE" > "HOL4Base.bool.RES_EXISTS_UNIQUE"
- "RES_EXISTS" > "HOL4Base.bool.RES_EXISTS"
- "ONTO" > "Fun.surj"
- "ONE_ONE" > "Importer.ONE_ONE"
- "LET" > "Compatibility.LET"
- "IN" > "HOL4Base.bool.IN"
- "F" > "HOL.False"
- "COND" > "HOL.If"
- "ARB" > "HOL4Base.bool.ARB"
- "?!" > "HOL.Ex1"
- "?" > "HOL.Ex"
- "/\\" > "HOL.conj"
- "!" > "HOL.All"
-
-thm_maps
- "bool_case_thm" > "HOL4Base.bool.bool_case_thm"
- "bool_case_ID" > "HOL4Base.bool.bool_case_ID"
- "bool_case_DEF" > "Compatibility.bool_case_DEF"
- "bool_INDUCT" > "Product_Type.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_THM1" > "HOL.simp_thms_42"
- "UEXISTS_SIMP" > "HOL4Base.bool.UEXISTS_SIMP"
- "UEXISTS_OR_THM" > "HOL4Base.bool.UEXISTS_OR_THM"
- "T_DEF" > "HOL.True_def"
- "TYPE_DEFINITION_THM" > "Importer.TYPE_DEFINITION"
- "TYPE_DEFINITION" > "Importer.TYPE_DEFINITION"
- "TRUTH" > "HOL.TrueI"
- "SWAP_FORALL_THM" > "HOL.all_comm"
- "SWAP_EXISTS_THM" > "HOL.ex_comm"
- "SKOLEM_THM" > "HOL4Base.bool.SKOLEM_THM"
- "SELECT_UNIQUE" > "HOL4Base.bool.SELECT_UNIQUE"
- "SELECT_THM" > "Importer.EXISTS_DEF"
- "SELECT_REFL_2" > "Hilbert_Choice.some_sym_eq_trivial"
- "SELECT_REFL" > "Hilbert_Choice.some_eq_trivial"
- "SELECT_AX" > "Hilbert_Choice.someI"
- "RIGHT_OR_OVER_AND" > "HOL.disj_conj_distribR"
- "RIGHT_OR_EXISTS_THM" > "HOL.ex_simps_4"
- "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_OVER_OR" > "Groebner_Basis.dnf_2"
- "RIGHT_AND_FORALL_THM" > "HOL.all_simps_2"
- "RES_SELECT_def" > "HOL4Base.bool.RES_SELECT_def"
- "RES_SELECT_DEF" > "HOL4Base.bool.RES_SELECT_DEF"
- "RES_FORALL_def" > "HOL4Base.bool.RES_FORALL_def"
- "RES_FORALL_DEF" > "HOL4Base.bool.RES_FORALL_DEF"
- "RES_EXISTS_def" > "HOL4Base.bool.RES_EXISTS_def"
- "RES_EXISTS_UNIQUE_def" > "HOL4Base.bool.RES_EXISTS_UNIQUE_def"
- "RES_EXISTS_UNIQUE_DEF" > "HOL4Base.bool.RES_EXISTS_UNIQUE_DEF"
- "RES_EXISTS_DEF" > "HOL4Base.bool.RES_EXISTS_DEF"
- "RES_ABSTRACT_DEF" > "HOL4Base.bool.RES_ABSTRACT_DEF"
- "REFL_CLAUSE" > "Groebner_Basis.bool_simps_6"
- "OR_INTRO_THM2" > "HOL.disjI2"
- "OR_INTRO_THM1" > "HOL.disjI1"
- "OR_IMP_THM" > "HOL4Base.bool.OR_IMP_THM"
- "OR_ELIM_THM" > "HOL.disjE"
- "OR_DEF" > "HOL.or_def"
- "OR_CONG" > "HOL4Base.bool.OR_CONG"
- "OR_CLAUSES" > "HOL4Base.bool.OR_CLAUSES"
- "ONTO_THM" > "Fun.surj_def"
- "ONTO_DEF" > "Fun.surj_def"
- "ONE_ONE_THM" > "HOL4Base.bool.ONE_ONE_THM"
- "ONE_ONE_DEF" > "Importer.ONE_ONE_DEF"
- "NOT_IMP" > "HOL.not_imp"
- "NOT_FORALL_THM" > "HOL.not_all"
- "NOT_F" > "Groebner_Basis.PFalse_2"
- "NOT_EXISTS_THM" > "HOL.not_ex"
- "NOT_DEF" > "Groebner_Basis.bool_simps_19"
- "NOT_CLAUSES" > "HOL4Base.bool.NOT_CLAUSES"
- "NOT_AND" > "HOL4Base.bool.NOT_AND"
- "MONO_OR" > "Inductive.basic_monos_3"
- "MONO_NOT" > "HOL.contrapos_nn"
- "MONO_IMP" > "Set.imp_mono"
- "MONO_EXISTS" > "Inductive.basic_monos_5"
- "MONO_COND" > "HOL4Base.bool.MONO_COND"
- "MONO_AND" > "Inductive.basic_monos_4"
- "MONO_ALL" > "Inductive.basic_monos_6"
- "LET_THM" > "HOL.Let_def"
- "LET_RATOR" > "HOL4Base.bool.LET_RATOR"
- "LET_RAND" > "HOL4Base.bool.LET_RAND"
- "LET_DEF" > "Compatibility.LET_def"
- "LET_CONG" > "FunDef.let_cong"
- "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.all_simps_5"
- "LEFT_EXISTS_IMP_THM" > "HOL.ex_simps_5"
- "LEFT_EXISTS_AND_THM" > "HOL.ex_simps_1"
- "LEFT_AND_OVER_OR" > "Groebner_Basis.dnf_1"
- "LEFT_AND_FORALL_THM" > "HOL.all_simps_1"
- "IN_def" > "HOL4Base.bool.IN_def"
- "IN_DEF" > "HOL4Base.bool.IN_DEF"
- "INFINITY_AX" > "Importer.INFINITY_AX"
- "IMP_F_EQ_F" > "HOL4Base.bool.IMP_F_EQ_F"
- "IMP_F" > "HOL.notI"
- "IMP_DISJ_THM" > "Groebner_Basis.nnf_simps_3"
- "IMP_CONG" > "HOL.imp_cong"
- "IMP_CLAUSES" > "HOL4Base.bool.IMP_CLAUSES"
- "IMP_ANTISYM_AX" > "HOL.iff"
- "F_IMP" > "HOL4Base.bool.F_IMP"
- "F_DEF" > "HOL.False_def"
- "FUN_EQ_THM" > "HOL.fun_eq_iff"
- "FORALL_THM" > "HOL4Base.bool.FORALL_THM"
- "FORALL_SIMP" > "HOL.simp_thms_35"
- "FORALL_DEF" > "HOL.All_def"
- "FORALL_AND_THM" > "HOL.all_conj_distrib"
- "FALSITY" > "HOL.FalseE"
- "EXISTS_UNIQUE_THM" > "Compatibility.EXISTS_UNIQUE_DEF"
- "EXISTS_UNIQUE_REFL" > "HOL.ex1_eq_1"
- "EXISTS_UNIQUE_DEF" > "Compatibility.EXISTS_UNIQUE_DEF"
- "EXISTS_THM" > "HOL4Base.bool.EXISTS_THM"
- "EXISTS_SIMP" > "HOL.simp_thms_36"
- "EXISTS_REFL" > "HOL.simp_thms_37"
- "EXISTS_OR_THM" > "HOL.ex_disj_distrib"
- "EXISTS_DEF" > "Importer.EXISTS_DEF"
- "EXCLUDED_MIDDLE" > "HOL4Base.bool.EXCLUDED_MIDDLE"
- "ETA_THM" > "HOL.eta_contract_eq"
- "ETA_AX" > "HOL.eta_contract_eq"
- "EQ_TRANS" > "HOL.trans"
- "EQ_SYM_EQ" > "HOL.eq_ac_1"
- "EQ_SYM" > "HOL.eq_reflection"
- "EQ_REFL" > "HOL.refl"
- "EQ_IMP_THM" > "HOL.iff_conv_conj_imp"
- "EQ_EXT" > "HOL.eq_reflection"
- "EQ_EXPAND" > "Groebner_Basis.nnf_simps_4"
- "EQ_CLAUSES" > "HOL4Base.bool.EQ_CLAUSES"
- "DISJ_SYM" > "Groebner_Basis.dnf_4"
- "DISJ_IMP_THM" > "HOL.imp_disjL"
- "DISJ_COMM" > "Groebner_Basis.dnf_4"
- "DISJ_ASSOC" > "HOL.disj_ac_3"
- "DE_MORGAN_THM" > "HOL4Base.bool.DE_MORGAN_THM"
- "CONJ_SYM" > "Groebner_Basis.dnf_3"
- "CONJ_COMM" > "Groebner_Basis.dnf_3"
- "CONJ_ASSOC" > "HOL.conj_ac_3"
- "COND_RATOR" > "HOL4Base.bool.COND_RATOR"
- "COND_RAND" > "HOL.if_distrib"
- "COND_ID" > "HOL.if_cancel"
- "COND_EXPAND" > "HOL4Base.bool.COND_EXPAND"
- "COND_DEF" > "Compatibility.COND_DEF"
- "COND_CONG" > "HOL4Base.bool.COND_CONG"
- "COND_CLAUSES" > "HOL4Base.bool.COND_CLAUSES"
- "COND_ABS" > "HOL4Base.bool.COND_ABS"
- "BOTH_FORALL_OR_THM" > "HOL4Base.bool.BOTH_FORALL_OR_THM"
- "BOTH_FORALL_IMP_THM" > "HOL4Base.bool.BOTH_FORALL_IMP_THM"
- "BOTH_EXISTS_IMP_THM" > "HOL4Base.bool.BOTH_EXISTS_IMP_THM"
- "BOTH_EXISTS_AND_THM" > "HOL4Base.bool.BOTH_EXISTS_AND_THM"
- "BOOL_FUN_INDUCT" > "HOL4Base.bool.BOOL_FUN_INDUCT"
- "BOOL_FUN_CASES_THM" > "HOL4Base.bool.BOOL_FUN_CASES_THM"
- "BOOL_EQ_DISTINCT" > "HOL4Base.bool.BOOL_EQ_DISTINCT"
- "BOOL_CASES_AX" > "HOL.True_or_False"
- "BETA_THM" > "HOL.eta_contract_eq"
- "ARB_def" > "HOL4Base.bool.ARB_def"
- "ARB_DEF" > "HOL4Base.bool.ARB_DEF"
- "AND_INTRO_THM" > "HOL.conjI"
- "AND_IMP_INTRO" > "HOL.imp_conjL"
- "AND_DEF" > "HOL.and_def"
- "AND_CONG" > "HOL4Base.bool.AND_CONG"
- "AND_CLAUSES" > "HOL4Base.bool.AND_CLAUSES"
- "AND2_THM" > "HOL.conjunct2"
- "AND1_THM" > "HOL.conjunct1"
- "ABS_SIMP" > "HOL.refl"
- "ABS_REP_THM" > "HOL4Base.bool.ABS_REP_THM"
-
-ignore_thms
- "UNBOUNDED_THM"
- "UNBOUNDED_DEF"
- "BOUNDED_THM"
- "BOUNDED_DEF"
-
-end
--- a/src/HOL/Import/HOL4/Generated/boolean_sequence.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,39 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "STL" > "STL_primdef"
- "STAKE" > "STAKE_primdef"
- "SHD" > "SHD_primdef"
- "SDROP" > "SDROP_primdef"
- "SDEST" > "SDEST_primdef"
- "SCONST" > "SCONST_primdef"
- "SCONS" > "SCONS_primdef"
-
-const_maps
- "STL" > "HOL4Prob.boolean_sequence.STL"
- "SHD" > "HOL4Prob.boolean_sequence.SHD"
- "SDEST" > "HOL4Prob.boolean_sequence.SDEST"
- "SCONST" > "HOL4Prob.boolean_sequence.SCONST"
-
-thm_maps
- "STL_primdef" > "HOL4Prob.boolean_sequence.STL_primdef"
- "STL_def" > "HOL4Prob.boolean_sequence.STL_def"
- "STL_SCONST" > "HOL4Prob.boolean_sequence.STL_SCONST"
- "STL_SCONS" > "HOL4Prob.boolean_sequence.STL_SCONS"
- "STAKE_def" > "HOL4Prob.boolean_sequence.STAKE_def"
- "SHD_primdef" > "HOL4Prob.boolean_sequence.SHD_primdef"
- "SHD_def" > "HOL4Prob.boolean_sequence.SHD_def"
- "SHD_STL_ISO" > "HOL4Prob.boolean_sequence.SHD_STL_ISO"
- "SHD_SCONST" > "HOL4Prob.boolean_sequence.SHD_SCONST"
- "SHD_SCONS" > "HOL4Prob.boolean_sequence.SHD_SCONS"
- "SDROP_def" > "HOL4Prob.boolean_sequence.SDROP_def"
- "SDEST_primdef" > "HOL4Prob.boolean_sequence.SDEST_primdef"
- "SDEST_def" > "HOL4Prob.boolean_sequence.SDEST_def"
- "SCONS_def" > "HOL4Prob.boolean_sequence.SCONS_def"
- "SCONS_SURJ" > "HOL4Prob.boolean_sequence.SCONS_SURJ"
- "SCONST_primdef" > "HOL4Prob.boolean_sequence.SCONST_primdef"
- "SCONST_def" > "HOL4Prob.boolean_sequence.SCONST_def"
-
-end
--- a/src/HOL/Import/HOL4/Generated/bword_arith.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,27 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "ICARRY" > "ICARRY_def"
- "ACARRY" > "ACARRY_def"
-
-thm_maps
- "WSEG_NBWORD_ADD" > "HOL4Vec.bword_arith.WSEG_NBWORD_ADD"
- "ICARRY_WSEG" > "HOL4Vec.bword_arith.ICARRY_WSEG"
- "ICARRY_DEF" > "HOL4Vec.bword_arith.ICARRY_DEF"
- "BNVAL_LESS_EQ" > "HOL4Vec.bword_arith.BNVAL_LESS_EQ"
- "ADD_WORD_SPLIT" > "HOL4Vec.bword_arith.ADD_WORD_SPLIT"
- "ADD_NBWORD_EQ0_SPLIT" > "HOL4Vec.bword_arith.ADD_NBWORD_EQ0_SPLIT"
- "ADD_BV_BNVAL_LESS_EQ1" > "HOL4Vec.bword_arith.ADD_BV_BNVAL_LESS_EQ1"
- "ADD_BV_BNVAL_LESS_EQ" > "HOL4Vec.bword_arith.ADD_BV_BNVAL_LESS_EQ"
- "ADD_BV_BNVAL_DIV_LESS_EQ1" > "HOL4Vec.bword_arith.ADD_BV_BNVAL_DIV_LESS_EQ1"
- "ADD_BNVAL_LESS_EQ1" > "HOL4Vec.bword_arith.ADD_BNVAL_LESS_EQ1"
- "ACARRY_WSEG" > "HOL4Vec.bword_arith.ACARRY_WSEG"
- "ACARRY_MSB" > "HOL4Vec.bword_arith.ACARRY_MSB"
- "ACARRY_EQ_ICARRY" > "HOL4Vec.bword_arith.ACARRY_EQ_ICARRY"
- "ACARRY_EQ_ADD_DIV" > "HOL4Vec.bword_arith.ACARRY_EQ_ADD_DIV"
- "ACARRY_DEF" > "HOL4Vec.bword_arith.ACARRY_DEF"
- "ACARRY_ACARRY_WSEG" > "HOL4Vec.bword_arith.ACARRY_ACARRY_WSEG"
-
-end
--- a/src/HOL/Import/HOL4/Generated/bword_bitop.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,23 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "WXOR" > "WXOR_def"
- "WOR" > "WOR_def"
- "WNOT" > "WNOT_def"
- "WAND" > "WAND_def"
-
-thm_maps
- "WXOR_DEF" > "HOL4Vec.bword_bitop.WXOR_DEF"
- "WOR_DEF" > "HOL4Vec.bword_bitop.WOR_DEF"
- "WNOT_WNOT" > "HOL4Vec.bword_bitop.WNOT_WNOT"
- "WNOT_DEF" > "HOL4Vec.bword_bitop.WNOT_DEF"
- "WCAT_WNOT" > "HOL4Vec.bword_bitop.WCAT_WNOT"
- "WAND_DEF" > "HOL4Vec.bword_bitop.WAND_DEF"
- "PBITOP_WNOT" > "HOL4Vec.bword_bitop.PBITOP_WNOT"
- "PBITBOP_WXOR" > "HOL4Vec.bword_bitop.PBITBOP_WXOR"
- "PBITBOP_WOR" > "HOL4Vec.bword_bitop.PBITBOP_WOR"
- "PBITBOP_WAND" > "HOL4Vec.bword_bitop.PBITBOP_WAND"
-
-end
--- a/src/HOL/Import/HOL4/Generated/bword_num.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,58 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "VB" > "VB_def"
- "NBWORD" > "NBWORD_def"
- "BV" > "BV_def"
- "BNVAL" > "BNVAL_def"
-
-const_maps
- "VB" > "HOL4Vec.bword_num.VB"
- "NBWORD" > "HOL4Vec.bword_num.NBWORD"
- "BV" > "HOL4Vec.bword_num.BV"
-
-thm_maps
- "ZERO_WORD_VAL" > "HOL4Vec.bword_num.ZERO_WORD_VAL"
- "WSPLIT_NBWORD_0" > "HOL4Vec.bword_num.WSPLIT_NBWORD_0"
- "WSEG_NBWORD_SUC" > "HOL4Vec.bword_num.WSEG_NBWORD_SUC"
- "WSEG_NBWORD" > "HOL4Vec.bword_num.WSEG_NBWORD"
- "WORDLEN_NBWORD" > "HOL4Vec.bword_num.WORDLEN_NBWORD"
- "WCAT_NBWORD_0" > "HOL4Vec.bword_num.WCAT_NBWORD_0"
- "VB_def" > "HOL4Vec.bword_num.VB_def"
- "VB_DEF" > "HOL4Vec.bword_num.VB_DEF"
- "VB_BV" > "HOL4Vec.bword_num.VB_BV"
- "PWORDLEN_NBWORD" > "HOL4Vec.bword_num.PWORDLEN_NBWORD"
- "NBWORD_def" > "HOL4Vec.bword_num.NBWORD_def"
- "NBWORD_SUC_WSEG" > "HOL4Vec.bword_num.NBWORD_SUC_WSEG"
- "NBWORD_SUC_FST" > "HOL4Vec.bword_num.NBWORD_SUC_FST"
- "NBWORD_SUC" > "HOL4Vec.bword_num.NBWORD_SUC"
- "NBWORD_SPLIT" > "HOL4Vec.bword_num.NBWORD_SPLIT"
- "NBWORD_MOD" > "HOL4Vec.bword_num.NBWORD_MOD"
- "NBWORD_DEF" > "HOL4Vec.bword_num.NBWORD_DEF"
- "NBWORD_BNVAL" > "HOL4Vec.bword_num.NBWORD_BNVAL"
- "NBWORD0" > "HOL4Vec.bword_num.NBWORD0"
- "MSB_NBWORD" > "HOL4Vec.bword_num.MSB_NBWORD"
- "EQ_NBWORD0_SPLIT" > "HOL4Vec.bword_num.EQ_NBWORD0_SPLIT"
- "DOUBL_EQ_SHL" > "HOL4Vec.bword_num.DOUBL_EQ_SHL"
- "BV_def" > "HOL4Vec.bword_num.BV_def"
- "BV_VB" > "HOL4Vec.bword_num.BV_VB"
- "BV_LESS_2" > "HOL4Vec.bword_num.BV_LESS_2"
- "BV_DEF" > "HOL4Vec.bword_num.BV_DEF"
- "BNVAL_WCAT2" > "HOL4Vec.bword_num.BNVAL_WCAT2"
- "BNVAL_WCAT1" > "HOL4Vec.bword_num.BNVAL_WCAT1"
- "BNVAL_WCAT" > "HOL4Vec.bword_num.BNVAL_WCAT"
- "BNVAL_ONTO" > "HOL4Vec.bword_num.BNVAL_ONTO"
- "BNVAL_NVAL" > "HOL4Vec.bword_num.BNVAL_NVAL"
- "BNVAL_NBWORD" > "HOL4Vec.bword_num.BNVAL_NBWORD"
- "BNVAL_MAX" > "HOL4Vec.bword_num.BNVAL_MAX"
- "BNVAL_DEF" > "HOL4Vec.bword_num.BNVAL_DEF"
- "BNVAL_11" > "HOL4Vec.bword_num.BNVAL_11"
- "BNVAL0" > "HOL4Vec.bword_num.BNVAL0"
- "BIT_NBWORD0" > "HOL4Vec.bword_num.BIT_NBWORD0"
- "ADD_BNVAL_SPLIT" > "HOL4Vec.bword_num.ADD_BNVAL_SPLIT"
- "ADD_BNVAL_RIGHT" > "HOL4Vec.bword_num.ADD_BNVAL_RIGHT"
- "ADD_BNVAL_LEFT" > "HOL4Vec.bword_num.ADD_BNVAL_LEFT"
-
-end
--- a/src/HOL/Import/HOL4/Generated/combin.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,41 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "W" > "W_def"
- "S" > "S_def"
- "K" > "K_def"
- "I" > "I_def"
- "C" > "C_def"
-
-const_maps
- "o" > "Fun.comp"
- "W" > "HOL4Base.combin.W"
- "S" > "HOL4Base.combin.S"
- "K" > "HOL4Base.combin.K"
- "I" > "HOL4Base.combin.I"
- "C" > "HOL4Base.combin.C"
-
-thm_maps
- "o_THM" > "Fun.comp_def"
- "o_DEF" > "Fun.comp_def"
- "o_ASSOC" > "Fun.o_assoc"
- "W_def" > "HOL4Base.combin.W_def"
- "W_THM" > "HOL4Base.combin.W_def"
- "W_DEF" > "HOL4Base.combin.W_DEF"
- "S_def" > "HOL4Base.combin.S_def"
- "S_THM" > "HOL4Base.combin.S_def"
- "S_DEF" > "HOL4Base.combin.S_DEF"
- "K_def" > "HOL4Base.combin.K_def"
- "K_THM" > "HOL4Base.combin.K_def"
- "K_DEF" > "HOL4Base.combin.K_DEF"
- "I_o_ID" > "HOL4Base.combin.I_o_ID"
- "I_def" > "HOL4Base.combin.I_def"
- "I_THM" > "HOL4Base.combin.I_THM"
- "I_DEF" > "HOL4Base.combin.I_DEF"
- "C_def" > "HOL4Base.combin.C_def"
- "C_THM" > "HOL4Base.combin.C_def"
- "C_DEF" > "HOL4Base.combin.C_DEF"
-
-end
--- a/src/HOL/Import/HOL4/Generated/divides.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,24 +0,0 @@
-import
-
-import_segment "hol4"
-
-const_maps
- "divides" > "Rings.dvd_class.dvd" :: "nat => nat => bool"
-
-thm_maps
- "divides_def" > "Compatibility.divides_def"
- "ONE_DIVIDES_ALL" > "GCD.gcd_lcm_complete_lattice_nat.bot_least"
- "NOT_LT_DIV" > "Nat.nat_dvd_not_less"
- "DIVIDES_TRANS" > "Nat.dvd.order_trans"
- "DIVIDES_SUB" > "Nat.dvd_diff_nat"
- "DIVIDES_REFL" > "Nat.dvd.order_refl"
- "DIVIDES_MULT_LEFT" > "HOL4Base.divides.DIVIDES_MULT_LEFT"
- "DIVIDES_MULT" > "Rings.comm_semiring_1_class.dvd_mult2"
- "DIVIDES_LE" > "Nat.dvd_imp_le"
- "DIVIDES_FACT" > "HOL4Base.divides.DIVIDES_FACT"
- "DIVIDES_ANTISYM" > "Nat.dvd.antisym"
- "DIVIDES_ADD_2" > "Primes.divides_add_revr"
- "DIVIDES_ADD_1" > "Rings.comm_semiring_1_class.dvd_add"
- "ALL_DIVIDES_0" > "GCD.gcd_lcm_complete_lattice_nat.top_greatest"
-
-end
--- a/src/HOL/Import/HOL4/Generated/hrat.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,95 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "trat_sucint" > "trat_sucint_def"
- "trat_mul" > "trat_mul_def"
- "trat_inv" > "trat_inv_def"
- "trat_eq" > "trat_eq_def"
- "trat_add" > "trat_add_def"
- "trat_1" > "trat_1_def"
- "mk_hrat" > "mk_hrat_def"
- "hrat_sucint" > "hrat_sucint_def"
- "hrat_mul" > "hrat_mul_def"
- "hrat_inv" > "hrat_inv_def"
- "hrat_add" > "hrat_add_def"
- "hrat_1" > "hrat_1_def"
- "dest_hrat" > "dest_hrat_def"
-
-type_maps
- "hrat" > "HOL4Base.hrat.hrat"
-
-const_maps
- "trat_mul" > "HOL4Base.hrat.trat_mul"
- "trat_inv" > "HOL4Base.hrat.trat_inv"
- "trat_eq" > "HOL4Base.hrat.trat_eq"
- "trat_add" > "HOL4Base.hrat.trat_add"
- "trat_1" > "HOL4Base.hrat.trat_1"
- "hrat_sucint" > "HOL4Base.hrat.hrat_sucint"
- "hrat_mul" > "HOL4Base.hrat.hrat_mul"
- "hrat_inv" > "HOL4Base.hrat.hrat_inv"
- "hrat_add" > "HOL4Base.hrat.hrat_add"
- "hrat_1" > "HOL4Base.hrat.hrat_1"
-
-thm_maps
- "trat_sucint" > "HOL4Base.hrat.trat_sucint"
- "trat_mul_def" > "HOL4Base.hrat.trat_mul_def"
- "trat_mul" > "HOL4Base.hrat.trat_mul"
- "trat_inv_def" > "HOL4Base.hrat.trat_inv_def"
- "trat_inv" > "HOL4Base.hrat.trat_inv"
- "trat_eq_def" > "HOL4Base.hrat.trat_eq_def"
- "trat_eq" > "HOL4Base.hrat.trat_eq"
- "trat_add_def" > "HOL4Base.hrat.trat_add_def"
- "trat_add" > "HOL4Base.hrat.trat_add"
- "trat_1_def" > "HOL4Base.hrat.trat_1_def"
- "trat_1" > "HOL4Base.hrat.trat_1"
- "hrat_tybij" > "HOL4Base.hrat.hrat_tybij"
- "hrat_sucint_def" > "HOL4Base.hrat.hrat_sucint_def"
- "hrat_sucint" > "HOL4Base.hrat.hrat_sucint"
- "hrat_mul_def" > "HOL4Base.hrat.hrat_mul_def"
- "hrat_mul" > "HOL4Base.hrat.hrat_mul"
- "hrat_inv_def" > "HOL4Base.hrat.hrat_inv_def"
- "hrat_inv" > "HOL4Base.hrat.hrat_inv"
- "hrat_add_def" > "HOL4Base.hrat.hrat_add_def"
- "hrat_add" > "HOL4Base.hrat.hrat_add"
- "hrat_TY_DEF" > "HOL4Base.hrat.hrat_TY_DEF"
- "hrat_1_def" > "HOL4Base.hrat.hrat_1_def"
- "hrat_1" > "HOL4Base.hrat.hrat_1"
- "TRAT_SUCINT_0" > "HOL4Base.hrat.TRAT_SUCINT_0"
- "TRAT_SUCINT" > "HOL4Base.hrat.TRAT_SUCINT"
- "TRAT_NOZERO" > "HOL4Base.hrat.TRAT_NOZERO"
- "TRAT_MUL_WELLDEFINED2" > "HOL4Base.hrat.TRAT_MUL_WELLDEFINED2"
- "TRAT_MUL_WELLDEFINED" > "HOL4Base.hrat.TRAT_MUL_WELLDEFINED"
- "TRAT_MUL_SYM_EQ" > "HOL4Base.hrat.TRAT_MUL_SYM_EQ"
- "TRAT_MUL_SYM" > "HOL4Base.hrat.TRAT_MUL_SYM"
- "TRAT_MUL_LINV" > "HOL4Base.hrat.TRAT_MUL_LINV"
- "TRAT_MUL_LID" > "HOL4Base.hrat.TRAT_MUL_LID"
- "TRAT_MUL_ASSOC" > "HOL4Base.hrat.TRAT_MUL_ASSOC"
- "TRAT_LDISTRIB" > "HOL4Base.hrat.TRAT_LDISTRIB"
- "TRAT_INV_WELLDEFINED" > "HOL4Base.hrat.TRAT_INV_WELLDEFINED"
- "TRAT_EQ_TRANS" > "HOL4Base.hrat.TRAT_EQ_TRANS"
- "TRAT_EQ_SYM" > "HOL4Base.hrat.TRAT_EQ_SYM"
- "TRAT_EQ_REFL" > "HOL4Base.hrat.TRAT_EQ_REFL"
- "TRAT_EQ_EQUIV" > "HOL4Base.hrat.TRAT_EQ_EQUIV"
- "TRAT_EQ_AP" > "HOL4Base.hrat.TRAT_EQ_AP"
- "TRAT_ARCH" > "HOL4Base.hrat.TRAT_ARCH"
- "TRAT_ADD_WELLDEFINED2" > "HOL4Base.hrat.TRAT_ADD_WELLDEFINED2"
- "TRAT_ADD_WELLDEFINED" > "HOL4Base.hrat.TRAT_ADD_WELLDEFINED"
- "TRAT_ADD_TOTAL" > "HOL4Base.hrat.TRAT_ADD_TOTAL"
- "TRAT_ADD_SYM_EQ" > "HOL4Base.hrat.TRAT_ADD_SYM_EQ"
- "TRAT_ADD_SYM" > "HOL4Base.hrat.TRAT_ADD_SYM"
- "TRAT_ADD_ASSOC" > "HOL4Base.hrat.TRAT_ADD_ASSOC"
- "HRAT_SUCINT" > "HOL4Base.hrat.HRAT_SUCINT"
- "HRAT_NOZERO" > "HOL4Base.hrat.HRAT_NOZERO"
- "HRAT_MUL_SYM" > "HOL4Base.hrat.HRAT_MUL_SYM"
- "HRAT_MUL_LINV" > "HOL4Base.hrat.HRAT_MUL_LINV"
- "HRAT_MUL_LID" > "HOL4Base.hrat.HRAT_MUL_LID"
- "HRAT_MUL_ASSOC" > "HOL4Base.hrat.HRAT_MUL_ASSOC"
- "HRAT_LDISTRIB" > "HOL4Base.hrat.HRAT_LDISTRIB"
- "HRAT_ARCH" > "HOL4Base.hrat.HRAT_ARCH"
- "HRAT_ADD_TOTAL" > "HOL4Base.hrat.HRAT_ADD_TOTAL"
- "HRAT_ADD_SYM" > "HOL4Base.hrat.HRAT_ADD_SYM"
- "HRAT_ADD_ASSOC" > "HOL4Base.hrat.HRAT_ADD_ASSOC"
-
-end
--- a/src/HOL/Import/HOL4/Generated/hreal.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,118 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "isacut" > "isacut_def"
- "hreal_sup" > "hreal_sup_def"
- "hreal_sub" > "hreal_sub_def"
- "hreal_mul" > "hreal_mul_def"
- "hreal_lt" > "hreal_lt_def"
- "hreal_inv" > "hreal_inv_def"
- "hreal_add" > "hreal_add_def"
- "hreal_1" > "hreal_1_def"
- "hreal" > "hreal_def"
- "hrat_lt" > "hrat_lt_def"
- "cut_of_hrat" > "cut_of_hrat_def"
- "cut" > "cut_def"
-
-type_maps
- "hreal" > "HOL4Base.hreal.hreal"
-
-const_maps
- "isacut" > "HOL4Base.hreal.isacut"
- "hreal_sup" > "HOL4Base.hreal.hreal_sup"
- "hreal_sub" > "HOL4Base.hreal.hreal_sub"
- "hreal_mul" > "HOL4Base.hreal.hreal_mul"
- "hreal_lt" > "HOL4Base.hreal.hreal_lt"
- "hreal_inv" > "HOL4Base.hreal.hreal_inv"
- "hreal_add" > "HOL4Base.hreal.hreal_add"
- "hreal_1" > "HOL4Base.hreal.hreal_1"
- "hrat_lt" > "HOL4Base.hreal.hrat_lt"
- "cut_of_hrat" > "HOL4Base.hreal.cut_of_hrat"
-
-thm_maps
- "isacut_def" > "HOL4Base.hreal.isacut_def"
- "isacut" > "HOL4Base.hreal.isacut"
- "hreal_tybij" > "HOL4Base.hreal.hreal_tybij"
- "hreal_sup_def" > "HOL4Base.hreal.hreal_sup_def"
- "hreal_sup" > "HOL4Base.hreal.hreal_sup"
- "hreal_sub_def" > "HOL4Base.hreal.hreal_sub_def"
- "hreal_sub" > "HOL4Base.hreal.hreal_sub"
- "hreal_mul_def" > "HOL4Base.hreal.hreal_mul_def"
- "hreal_mul" > "HOL4Base.hreal.hreal_mul"
- "hreal_lt_def" > "HOL4Base.hreal.hreal_lt_def"
- "hreal_lt" > "HOL4Base.hreal.hreal_lt"
- "hreal_inv_def" > "HOL4Base.hreal.hreal_inv_def"
- "hreal_inv" > "HOL4Base.hreal.hreal_inv"
- "hreal_add_def" > "HOL4Base.hreal.hreal_add_def"
- "hreal_add" > "HOL4Base.hreal.hreal_add"
- "hreal_TY_DEF" > "HOL4Base.hreal.hreal_TY_DEF"
- "hreal_1_def" > "HOL4Base.hreal.hreal_1_def"
- "hreal_1" > "HOL4Base.hreal.hreal_1"
- "hrat_lt_def" > "HOL4Base.hreal.hrat_lt_def"
- "hrat_lt" > "HOL4Base.hreal.hrat_lt"
- "cut_of_hrat_def" > "HOL4Base.hreal.cut_of_hrat_def"
- "cut_of_hrat" > "HOL4Base.hreal.cut_of_hrat"
- "ISACUT_HRAT" > "HOL4Base.hreal.ISACUT_HRAT"
- "HREAL_SUP_ISACUT" > "HOL4Base.hreal.HREAL_SUP_ISACUT"
- "HREAL_SUP" > "HOL4Base.hreal.HREAL_SUP"
- "HREAL_SUB_ISACUT" > "HOL4Base.hreal.HREAL_SUB_ISACUT"
- "HREAL_SUB_ADD" > "HOL4Base.hreal.HREAL_SUB_ADD"
- "HREAL_NOZERO" > "HOL4Base.hreal.HREAL_NOZERO"
- "HREAL_MUL_SYM" > "HOL4Base.hreal.HREAL_MUL_SYM"
- "HREAL_MUL_LINV" > "HOL4Base.hreal.HREAL_MUL_LINV"
- "HREAL_MUL_LID" > "HOL4Base.hreal.HREAL_MUL_LID"
- "HREAL_MUL_ISACUT" > "HOL4Base.hreal.HREAL_MUL_ISACUT"
- "HREAL_MUL_ASSOC" > "HOL4Base.hreal.HREAL_MUL_ASSOC"
- "HREAL_LT_TOTAL" > "HOL4Base.hreal.HREAL_LT_TOTAL"
- "HREAL_LT_LEMMA" > "HOL4Base.hreal.HREAL_LT_LEMMA"
- "HREAL_LT" > "HOL4Base.hreal.HREAL_LT"
- "HREAL_LDISTRIB" > "HOL4Base.hreal.HREAL_LDISTRIB"
- "HREAL_INV_ISACUT" > "HOL4Base.hreal.HREAL_INV_ISACUT"
- "HREAL_ADD_TOTAL" > "HOL4Base.hreal.HREAL_ADD_TOTAL"
- "HREAL_ADD_SYM" > "HOL4Base.hreal.HREAL_ADD_SYM"
- "HREAL_ADD_ISACUT" > "HOL4Base.hreal.HREAL_ADD_ISACUT"
- "HREAL_ADD_ASSOC" > "HOL4Base.hreal.HREAL_ADD_ASSOC"
- "HRAT_UP" > "HOL4Base.hreal.HRAT_UP"
- "HRAT_RDISTRIB" > "HOL4Base.hreal.HRAT_RDISTRIB"
- "HRAT_MUL_RINV" > "HOL4Base.hreal.HRAT_MUL_RINV"
- "HRAT_MUL_RID" > "HOL4Base.hreal.HRAT_MUL_RID"
- "HRAT_MEAN" > "HOL4Base.hreal.HRAT_MEAN"
- "HRAT_LT_TRANS" > "HOL4Base.hreal.HRAT_LT_TRANS"
- "HRAT_LT_TOTAL" > "HOL4Base.hreal.HRAT_LT_TOTAL"
- "HRAT_LT_RMUL1" > "HOL4Base.hreal.HRAT_LT_RMUL1"
- "HRAT_LT_RMUL" > "HOL4Base.hreal.HRAT_LT_RMUL"
- "HRAT_LT_REFL" > "HOL4Base.hreal.HRAT_LT_REFL"
- "HRAT_LT_RADD" > "HOL4Base.hreal.HRAT_LT_RADD"
- "HRAT_LT_R1" > "HOL4Base.hreal.HRAT_LT_R1"
- "HRAT_LT_NE" > "HOL4Base.hreal.HRAT_LT_NE"
- "HRAT_LT_MUL2" > "HOL4Base.hreal.HRAT_LT_MUL2"
- "HRAT_LT_LMUL1" > "HOL4Base.hreal.HRAT_LT_LMUL1"
- "HRAT_LT_LMUL" > "HOL4Base.hreal.HRAT_LT_LMUL"
- "HRAT_LT_LADD" > "HOL4Base.hreal.HRAT_LT_LADD"
- "HRAT_LT_L1" > "HOL4Base.hreal.HRAT_LT_L1"
- "HRAT_LT_GT" > "HOL4Base.hreal.HRAT_LT_GT"
- "HRAT_LT_ANTISYM" > "HOL4Base.hreal.HRAT_LT_ANTISYM"
- "HRAT_LT_ADDR" > "HOL4Base.hreal.HRAT_LT_ADDR"
- "HRAT_LT_ADDL" > "HOL4Base.hreal.HRAT_LT_ADDL"
- "HRAT_LT_ADD2" > "HOL4Base.hreal.HRAT_LT_ADD2"
- "HRAT_INV_MUL" > "HOL4Base.hreal.HRAT_INV_MUL"
- "HRAT_GT_LMUL1" > "HOL4Base.hreal.HRAT_GT_LMUL1"
- "HRAT_GT_L1" > "HOL4Base.hreal.HRAT_GT_L1"
- "HRAT_EQ_LMUL" > "HOL4Base.hreal.HRAT_EQ_LMUL"
- "HRAT_EQ_LADD" > "HOL4Base.hreal.HRAT_EQ_LADD"
- "HRAT_DOWN2" > "HOL4Base.hreal.HRAT_DOWN2"
- "HRAT_DOWN" > "HOL4Base.hreal.HRAT_DOWN"
- "EQUAL_CUTS" > "HOL4Base.hreal.EQUAL_CUTS"
- "CUT_UP" > "HOL4Base.hreal.CUT_UP"
- "CUT_UBOUND" > "HOL4Base.hreal.CUT_UBOUND"
- "CUT_STRADDLE" > "HOL4Base.hreal.CUT_STRADDLE"
- "CUT_NONEMPTY" > "HOL4Base.hreal.CUT_NONEMPTY"
- "CUT_NEARTOP_MUL" > "HOL4Base.hreal.CUT_NEARTOP_MUL"
- "CUT_NEARTOP_ADD" > "HOL4Base.hreal.CUT_NEARTOP_ADD"
- "CUT_ISACUT" > "HOL4Base.hreal.CUT_ISACUT"
- "CUT_DOWN" > "HOL4Base.hreal.CUT_DOWN"
- "CUT_BOUNDED" > "HOL4Base.hreal.CUT_BOUNDED"
-
-end
--- a/src/HOL/Import/HOL4/Generated/ind_type.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,99 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "mk_rec" > "mk_rec_def"
- "dest_rec" > "dest_rec_def"
- "ZRECSPACE" > "ZRECSPACE_def"
- "ZCONSTR" > "ZCONSTR_def"
- "ZBOT" > "ZBOT_def"
- "NUMSUM" > "NUMSUM_def"
- "NUMSND" > "NUMSND_def"
- "NUMRIGHT" > "NUMRIGHT_def"
- "NUMPAIR" > "NUMPAIR_def"
- "NUMLEFT" > "NUMLEFT_def"
- "NUMFST" > "NUMFST_def"
- "ISO" > "ISO_def"
- "INJP" > "INJP_def"
- "INJN" > "INJN_def"
- "INJF" > "INJF_def"
- "INJA" > "INJA_def"
- "FNIL" > "FNIL_def"
- "FCONS" > "FCONS_def"
- "CONSTR" > "CONSTR_def"
- "BOTTOM" > "BOTTOM_def"
-
-type_maps
- "recspace" > "HOL4Base.ind_type.recspace"
-
-const_maps
- "ZRECSPACE" > "HOL4Base.ind_type.ZRECSPACE"
- "ZCONSTR" > "HOL4Base.ind_type.ZCONSTR"
- "ZBOT" > "HOL4Base.ind_type.ZBOT"
- "NUMSUM" > "HOL4Base.ind_type.NUMSUM"
- "NUMPAIR" > "HOL4Base.ind_type.NUMPAIR"
- "ISO" > "HOL4Base.ind_type.ISO"
- "INJP" > "HOL4Base.ind_type.INJP"
- "INJN" > "HOL4Base.ind_type.INJN"
- "INJF" > "HOL4Base.ind_type.INJF"
- "INJA" > "HOL4Base.ind_type.INJA"
- "FNIL" > "HOL4Base.ind_type.FNIL"
- "CONSTR" > "HOL4Base.ind_type.CONSTR"
- "BOTTOM" > "HOL4Base.ind_type.BOTTOM"
-
-thm_maps
- "recspace_repfns" > "HOL4Base.ind_type.recspace_repfns"
- "recspace_TY_DEF" > "HOL4Base.ind_type.recspace_TY_DEF"
- "ZRECSPACE_rules" > "HOL4Base.ind_type.ZRECSPACE_rules"
- "ZRECSPACE_ind" > "HOL4Base.ind_type.ZRECSPACE_ind"
- "ZRECSPACE_def" > "HOL4Base.ind_type.ZRECSPACE_def"
- "ZRECSPACE_cases" > "HOL4Base.ind_type.ZRECSPACE_cases"
- "ZRECSPACE" > "HOL4Base.ind_type.ZRECSPACE"
- "ZCONSTR_def" > "HOL4Base.ind_type.ZCONSTR_def"
- "ZCONSTR_ZBOT" > "HOL4Base.ind_type.ZCONSTR_ZBOT"
- "ZCONSTR" > "HOL4Base.ind_type.ZCONSTR"
- "ZBOT_def" > "HOL4Base.ind_type.ZBOT_def"
- "ZBOT" > "HOL4Base.ind_type.ZBOT"
- "NUMSUM_def" > "HOL4Base.ind_type.NUMSUM_def"
- "NUMSUM_INJ" > "HOL4Base.ind_type.NUMSUM_INJ"
- "NUMSUM_DEST" > "HOL4Base.ind_type.NUMSUM_DEST"
- "NUMSUM" > "HOL4Base.ind_type.NUMSUM"
- "NUMPAIR_def" > "HOL4Base.ind_type.NUMPAIR_def"
- "NUMPAIR_INJ_LEMMA" > "HOL4Base.ind_type.NUMPAIR_INJ_LEMMA"
- "NUMPAIR_INJ" > "HOL4Base.ind_type.NUMPAIR_INJ"
- "NUMPAIR_DEST" > "HOL4Base.ind_type.NUMPAIR_DEST"
- "NUMPAIR" > "HOL4Base.ind_type.NUMPAIR"
- "MK_REC_INJ" > "HOL4Base.ind_type.MK_REC_INJ"
- "ISO_def" > "HOL4Base.ind_type.ISO_def"
- "ISO_USAGE" > "HOL4Base.ind_type.ISO_USAGE"
- "ISO_REFL" > "HOL4Base.ind_type.ISO_REFL"
- "ISO_FUN" > "HOL4Base.ind_type.ISO_FUN"
- "ISO" > "HOL4Base.ind_type.ISO"
- "INJ_INVERSE2" > "HOL4Base.ind_type.INJ_INVERSE2"
- "INJP_def" > "HOL4Base.ind_type.INJP_def"
- "INJP_INJ" > "HOL4Base.ind_type.INJP_INJ"
- "INJP" > "HOL4Base.ind_type.INJP"
- "INJN_def" > "HOL4Base.ind_type.INJN_def"
- "INJN_INJ" > "HOL4Base.ind_type.INJN_INJ"
- "INJN" > "HOL4Base.ind_type.INJN"
- "INJF_def" > "HOL4Base.ind_type.INJF_def"
- "INJF_INJ" > "HOL4Base.ind_type.INJF_INJ"
- "INJF" > "HOL4Base.ind_type.INJF"
- "INJA_def" > "HOL4Base.ind_type.INJA_def"
- "INJA_INJ" > "HOL4Base.ind_type.INJA_INJ"
- "INJA" > "HOL4Base.ind_type.INJA"
- "FNIL_def" > "HOL4Base.ind_type.FNIL_def"
- "FNIL" > "HOL4Base.ind_type.FNIL"
- "FCONS" > "HOL4Base.ind_type.FCONS"
- "DEST_REC_INJ" > "HOL4Base.ind_type.DEST_REC_INJ"
- "CONSTR_def" > "HOL4Base.ind_type.CONSTR_def"
- "CONSTR_REC" > "HOL4Base.ind_type.CONSTR_REC"
- "CONSTR_INJ" > "HOL4Base.ind_type.CONSTR_INJ"
- "CONSTR_IND" > "HOL4Base.ind_type.CONSTR_IND"
- "CONSTR_BOT" > "HOL4Base.ind_type.CONSTR_BOT"
- "CONSTR" > "HOL4Base.ind_type.CONSTR"
- "BOTTOM_def" > "HOL4Base.ind_type.BOTTOM_def"
- "BOTTOM" > "HOL4Base.ind_type.BOTTOM"
-
-end
--- a/src/HOL/Import/HOL4/Generated/lim.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,93 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "tends_real_real" > "tends_real_real_def"
- "diffl" > "diffl_def"
- "differentiable" > "differentiable_def"
- "contl" > "contl_def"
-
-const_maps
- "tends_real_real" > "HOL4Real.lim.tends_real_real"
- "diffl" > "HOL4Real.lim.diffl"
- "differentiable" > "HOL4Real.lim.differentiable"
- "contl" > "HOL4Real.lim.contl"
-
-thm_maps
- "tends_real_real_def" > "HOL4Real.lim.tends_real_real_def"
- "tends_real_real" > "HOL4Real.lim.tends_real_real"
- "diffl_def" > "HOL4Real.lim.diffl_def"
- "diffl" > "HOL4Real.lim.diffl"
- "differentiable_def" > "HOL4Real.lim.differentiable_def"
- "differentiable" > "HOL4Real.lim.differentiable"
- "contl_def" > "HOL4Real.lim.contl_def"
- "contl" > "HOL4Real.lim.contl"
- "ROLLE" > "HOL4Real.lim.ROLLE"
- "MVT_LEMMA" > "Deriv.lemma_MVT"
- "MVT" > "HOL4Real.lim.MVT"
- "LIM_X" > "HOL4Real.lim.LIM_X"
- "LIM_UNIQ" > "HOL4Real.lim.LIM_UNIQ"
- "LIM_TRANSFORM" > "HOL4Real.lim.LIM_TRANSFORM"
- "LIM_SUB" > "HOL4Real.lim.LIM_SUB"
- "LIM_NULL" > "HOL4Real.lim.LIM_NULL"
- "LIM_NEG" > "HOL4Real.lim.LIM_NEG"
- "LIM_MUL" > "HOL4Real.lim.LIM_MUL"
- "LIM_INV" > "HOL4Real.lim.LIM_INV"
- "LIM_EQUAL" > "HOL4Real.lim.LIM_EQUAL"
- "LIM_DIV" > "HOL4Real.lim.LIM_DIV"
- "LIM_CONST" > "HOL4Real.lim.LIM_CONST"
- "LIM_ADD" > "HOL4Real.lim.LIM_ADD"
- "LIM" > "HOL4Real.lim.LIM"
- "IVT2" > "HOL4Real.lim.IVT2"
- "IVT" > "HOL4Real.lim.IVT"
- "INTERVAL_LEMMA" > "Deriv.lemma_interval"
- "INTERVAL_CLEMMA" > "HOL4Real.lim.INTERVAL_CLEMMA"
- "INTERVAL_ABS" > "HOL4Real.lim.INTERVAL_ABS"
- "DIFF_XM1" > "HOL4Real.lim.DIFF_XM1"
- "DIFF_X" > "HOL4Real.lim.DIFF_X"
- "DIFF_UNIQ" > "HOL4Real.lim.DIFF_UNIQ"
- "DIFF_SUM" > "HOL4Real.lim.DIFF_SUM"
- "DIFF_SUB" > "HOL4Real.lim.DIFF_SUB"
- "DIFF_POW" > "HOL4Real.lim.DIFF_POW"
- "DIFF_NEG" > "HOL4Real.lim.DIFF_NEG"
- "DIFF_MUL" > "HOL4Real.lim.DIFF_MUL"
- "DIFF_LMIN" > "HOL4Real.lim.DIFF_LMIN"
- "DIFF_LMAX" > "HOL4Real.lim.DIFF_LMAX"
- "DIFF_LINC" > "HOL4Real.lim.DIFF_LINC"
- "DIFF_LDEC" > "HOL4Real.lim.DIFF_LDEC"
- "DIFF_LCONST" > "HOL4Real.lim.DIFF_LCONST"
- "DIFF_ISCONST_END" > "HOL4Real.lim.DIFF_ISCONST_END"
- "DIFF_ISCONST_ALL" > "HOL4Real.lim.DIFF_ISCONST_ALL"
- "DIFF_ISCONST" > "HOL4Real.lim.DIFF_ISCONST"
- "DIFF_INVERSE_OPEN" > "HOL4Real.lim.DIFF_INVERSE_OPEN"
- "DIFF_INVERSE_LT" > "HOL4Real.lim.DIFF_INVERSE_LT"
- "DIFF_INVERSE" > "HOL4Real.lim.DIFF_INVERSE"
- "DIFF_INV" > "HOL4Real.lim.DIFF_INV"
- "DIFF_DIV" > "HOL4Real.lim.DIFF_DIV"
- "DIFF_CONT" > "HOL4Real.lim.DIFF_CONT"
- "DIFF_CONST" > "HOL4Real.lim.DIFF_CONST"
- "DIFF_CMUL" > "HOL4Real.lim.DIFF_CMUL"
- "DIFF_CHAIN" > "HOL4Real.lim.DIFF_CHAIN"
- "DIFF_CARAT" > "HOL4Real.lim.DIFF_CARAT"
- "DIFF_ADD" > "HOL4Real.lim.DIFF_ADD"
- "CONT_SUB" > "HOL4Real.lim.CONT_SUB"
- "CONT_NEG" > "HOL4Real.lim.CONT_NEG"
- "CONT_MUL" > "HOL4Real.lim.CONT_MUL"
- "CONT_INVERSE" > "HOL4Real.lim.CONT_INVERSE"
- "CONT_INV" > "HOL4Real.lim.CONT_INV"
- "CONT_INJ_RANGE" > "HOL4Real.lim.CONT_INJ_RANGE"
- "CONT_INJ_LEMMA2" > "HOL4Real.lim.CONT_INJ_LEMMA2"
- "CONT_INJ_LEMMA" > "HOL4Real.lim.CONT_INJ_LEMMA"
- "CONT_HASSUP" > "HOL4Real.lim.CONT_HASSUP"
- "CONT_DIV" > "HOL4Real.lim.CONT_DIV"
- "CONT_CONST" > "HOL4Real.lim.CONT_CONST"
- "CONT_COMPOSE" > "HOL4Real.lim.CONT_COMPOSE"
- "CONT_BOUNDED" > "HOL4Real.lim.CONT_BOUNDED"
- "CONT_ATTAINS_ALL" > "HOL4Real.lim.CONT_ATTAINS_ALL"
- "CONT_ATTAINS2" > "HOL4Real.lim.CONT_ATTAINS2"
- "CONT_ATTAINS" > "HOL4Real.lim.CONT_ATTAINS"
- "CONT_ADD" > "HOL4Real.lim.CONT_ADD"
- "CONTL_LIM" > "HOL4Real.lim.CONTL_LIM"
-
-end
--- a/src/HOL/Import/HOL4/Generated/list.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,135 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "EL" > "EL_def"
-
-type_maps
- "list" > "List.list"
-
-const_maps
- "list_size" > "Compatibility.list_size"
- "list_case" > "List.list.list_case"
- "ZIP" > "Compatibility.ZIP"
- "UNZIP" > "Compatibility.unzip"
- "TL" > "List.tl"
- "SUM" > "Compatibility.sum"
- "REVERSE" > "List.rev"
- "REPLICATE" > "List.replicate"
- "NULL" > "List.null"
- "NIL" > "List.list.Nil"
- "MEM" > "Compatibility.list_mem"
- "MAP2" > "Compatibility.map2"
- "MAP" > "List.map"
- "LENGTH" > "Nat.size_class.size"
- "LAST" > "List.last"
- "HD" > "List.hd"
- "FRONT" > "List.butlast"
- "FOLDR" > "Compatibility.FOLDR"
- "FOLDL" > "List.foldl"
- "FLAT" > "List.concat"
- "FILTER" > "List.filter"
- "EXISTS" > "List.list_ex"
- "EVERY" > "List.list_all"
- "CONS" > "List.list.Cons"
- "APPEND" > "List.append"
-
-thm_maps
- "list_size_def" > "Compatibility.list_size_def'"
- "list_size_cong" > "HOL4Base.list.list_size_cong"
- "list_nchotomy" > "Compatibility.list_CASES"
- "list_induction" > "Compatibility.list_INDUCT"
- "list_distinct" > "List.list.distinct_1"
- "list_case_def" > "Compatibility.list_case_def"
- "list_case_cong" > "Compatibility.list_case_cong"
- "list_case_compute" > "HOL4Base.list.list_case_compute"
- "list_INDUCT" > "Compatibility.list_INDUCT"
- "list_CASES" > "Compatibility.list_CASES"
- "list_Axiom_old" > "Compatibility.list_Axiom_old"
- "list_Axiom" > "Compatibility.list_Axiom"
- "list_11" > "List.list.inject"
- "ZIP_UNZIP" > "HOL4Base.list.ZIP_UNZIP"
- "ZIP_MAP" > "HOL4Base.list.ZIP_MAP"
- "ZIP" > "Compatibility.ZIP"
- "WF_LIST_PRED" > "HOL4Base.list.WF_LIST_PRED"
- "UNZIP_ZIP" > "HOL4Base.list.UNZIP_ZIP"
- "UNZIP" > "Compatibility.UNZIP"
- "TL" > "List.tl.simps_2"
- "SUM" > "Compatibility.SUM"
- "REVERSE_REVERSE" > "List.rev_rev_ident"
- "REVERSE_DEF" > "Compatibility.REVERSE"
- "REVERSE_APPEND" > "List.rev_append"
- "NULL_DEF" > "Compatibility.NULL_DEF"
- "NULL" > "HOL4Base.list.NULL"
- "NOT_NIL_CONS" > "List.list.distinct_1"
- "NOT_EXISTS" > "HOL4Base.list.NOT_EXISTS"
- "NOT_EVERY" > "HOL4Base.list.NOT_EVERY"
- "NOT_EQ_LIST" > "HOL4Base.list.NOT_EQ_LIST"
- "NOT_CONS_NIL" > "List.list.distinct_2"
- "MEM_ZIP" > "HOL4Base.list.MEM_ZIP"
- "MEM_MAP" > "HOL4Base.list.MEM_MAP"
- "MEM_EL" > "HOL4Base.list.MEM_EL"
- "MEM_APPEND" > "HOL4Base.list.MEM_APPEND"
- "MEM" > "Compatibility.MEM"
- "MAP_EQ_NIL" > "HOL4Base.list.MAP_EQ_NIL"
- "MAP_CONG" > "HOL4Base.list.MAP_CONG"
- "MAP_APPEND" > "List.map_append"
- "MAP2_ZIP" > "HOL4Base.list.MAP2_ZIP"
- "MAP2" > "Compatibility.MAP2"
- "MAP" > "Compatibility.MAP"
- "LIST_NOT_EQ" > "HOL4Base.list.LIST_NOT_EQ"
- "LENGTH_ZIP" > "HOL4Base.list.LENGTH_ZIP"
- "LENGTH_UNZIP" > "HOL4Base.list.LENGTH_UNZIP"
- "LENGTH_NIL" > "List.length_0_conv"
- "LENGTH_MAP" > "List.length_map"
- "LENGTH_EQ_NIL" > "HOL4Base.list.LENGTH_EQ_NIL"
- "LENGTH_EQ_CONS" > "HOL4Base.list.LENGTH_EQ_CONS"
- "LENGTH_CONS" > "HOL4Base.list.LENGTH_CONS"
- "LENGTH_APPEND" > "List.length_append"
- "LENGTH" > "Compatibility.LENGTH"
- "LAST_DEF" > "List.last.simps"
- "LAST_CONS" > "HOL4Base.list.LAST_CONS"
- "HD" > "List.hd.simps"
- "FRONT_DEF" > "List.butlast.simps_2"
- "FRONT_CONS" > "HOL4Base.list.FRONT_CONS"
- "FOLDR_CONG" > "HOL4Base.list.FOLDR_CONG"
- "FOLDR" > "Compatibility.FOLDR"
- "FOLDL_CONG" > "HOL4Base.list.FOLDL_CONG"
- "FOLDL" > "Compatibility.FOLDL"
- "FLAT" > "Compatibility.FLAT"
- "FILTER" > "Compatibility.FILTER"
- "EXISTS_MEM" > "HOL4Base.list.EXISTS_MEM"
- "EXISTS_DEF" > "Compatibility.list_exists_DEF"
- "EXISTS_CONG" > "HOL4Base.list.EXISTS_CONG"
- "EXISTS_APPEND" > "List.list_ex_append"
- "EVERY_MONOTONIC" > "HOL4Base.list.EVERY_MONOTONIC"
- "EVERY_MEM" > "HOL4Base.list.EVERY_MEM"
- "EVERY_EL" > "HOL4Base.list.EVERY_EL"
- "EVERY_DEF" > "Compatibility.EVERY_DEF"
- "EVERY_CONJ" > "HOL4Base.list.EVERY_CONJ"
- "EVERY_CONG" > "HOL4Base.list.EVERY_CONG"
- "EVERY_APPEND" > "List.list_all_append"
- "EQ_LIST" > "HOL4Base.list.EQ_LIST"
- "EL_compute" > "HOL4Base.list.EL_compute"
- "EL_ZIP" > "HOL4Base.list.EL_ZIP"
- "EL" > "HOL4Base.list.EL"
- "CONS_ACYCLIC" > "HOL4Base.list.CONS_ACYCLIC"
- "CONS_11" > "List.list.inject"
- "CONS" > "HOL4Base.list.CONS"
- "APPEND_eq_NIL" > "HOL4Base.list.APPEND_eq_NIL"
- "APPEND_NIL" > "List.append_Nil2"
- "APPEND_FRONT_LAST" > "List.append_butlast_last_id"
- "APPEND_ASSOC" > "List.append_assoc"
- "APPEND_11" > "HOL4Base.list.APPEND_11"
- "APPEND" > "Compatibility.APPEND"
-
-ignore_thms
- "list_repfns"
- "list_TY_DEF"
- "list1_def"
- "list0_def"
- "NIL"
- "CONS_def"
-
-end
--- a/src/HOL/Import/HOL4/Generated/marker.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,19 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "stmarker" > "stmarker_primdef"
-
-const_maps
- "stmarker" > "HOL4Base.marker.stmarker"
-
-thm_maps
- "stmarker_primdef" > "HOL4Base.marker.stmarker_primdef"
- "stmarker_def" > "HOL4Base.marker.stmarker_def"
- "move_right_disj" > "HOL4Base.marker.move_right_disj"
- "move_right_conj" > "HOL4Base.marker.move_right_conj"
- "move_left_disj" > "HOL4Base.marker.move_left_disj"
- "move_left_conj" > "HOL4Base.marker.move_left_conj"
-
-end
--- a/src/HOL/Import/HOL4/Generated/nets.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,51 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "tendsto" > "tendsto_def"
- "tends" > "tends_def"
- "dorder" > "dorder_def"
- "bounded" > "bounded_def"
-
-const_maps
- "tendsto" > "HOL4Real.nets.tendsto"
- "tends" > "HOL4Real.nets.tends"
- "dorder" > "HOL4Real.nets.dorder"
- "bounded" > "HOL4Real.nets.bounded"
-
-thm_maps
- "tendsto_def" > "HOL4Real.nets.tendsto_def"
- "tendsto" > "HOL4Real.nets.tendsto"
- "tends_def" > "HOL4Real.nets.tends_def"
- "tends" > "HOL4Real.nets.tends"
- "dorder_def" > "HOL4Real.nets.dorder_def"
- "dorder" > "HOL4Real.nets.dorder"
- "bounded_def" > "HOL4Real.nets.bounded_def"
- "bounded" > "HOL4Real.nets.bounded"
- "SEQ_TENDS" > "HOL4Real.nets.SEQ_TENDS"
- "NET_SUB" > "HOL4Real.nets.NET_SUB"
- "NET_NULL_MUL" > "HOL4Real.nets.NET_NULL_MUL"
- "NET_NULL_CMUL" > "HOL4Real.nets.NET_NULL_CMUL"
- "NET_NULL_ADD" > "HOL4Real.nets.NET_NULL_ADD"
- "NET_NULL" > "HOL4Real.nets.NET_NULL"
- "NET_NEG" > "HOL4Real.nets.NET_NEG"
- "NET_MUL" > "HOL4Real.nets.NET_MUL"
- "NET_LE" > "HOL4Real.nets.NET_LE"
- "NET_INV" > "HOL4Real.nets.NET_INV"
- "NET_DIV" > "HOL4Real.nets.NET_DIV"
- "NET_CONV_NZ" > "HOL4Real.nets.NET_CONV_NZ"
- "NET_CONV_IBOUNDED" > "HOL4Real.nets.NET_CONV_IBOUNDED"
- "NET_CONV_BOUNDED" > "HOL4Real.nets.NET_CONV_BOUNDED"
- "NET_ADD" > "HOL4Real.nets.NET_ADD"
- "NET_ABS" > "HOL4Real.nets.NET_ABS"
- "MTOP_TENDS_UNIQ" > "HOL4Real.nets.MTOP_TENDS_UNIQ"
- "MTOP_TENDS" > "HOL4Real.nets.MTOP_TENDS"
- "MR1_BOUNDED" > "HOL4Real.nets.MR1_BOUNDED"
- "LIM_TENDS2" > "HOL4Real.nets.LIM_TENDS2"
- "LIM_TENDS" > "HOL4Real.nets.LIM_TENDS"
- "DORDER_TENDSTO" > "HOL4Real.nets.DORDER_TENDSTO"
- "DORDER_NGE" > "HOL4Real.nets.DORDER_NGE"
- "DORDER_LEMMA" > "HOL4Real.nets.DORDER_LEMMA"
-
-end
--- a/src/HOL/Import/HOL4/Generated/num.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,26 +0,0 @@
-import
-
-import_segment "hol4"
-
-type_maps
- "num" > "Nat.nat"
-
-const_maps
- "SUC" > "Nat.Suc"
- "0" > "Groups.zero_class.zero" :: "nat"
-
-thm_maps
- "NOT_SUC" > "Nat.Suc_not_Zero"
- "INV_SUC" > "Nat.Suc_inject"
- "INDUCTION" > "Fact.fact_nat.induct"
-
-ignore_thms
- "num_TY_DEF"
- "num_ISO_DEF"
- "ZERO_REP_DEF"
- "ZERO_DEF"
- "SUC_REP_DEF"
- "SUC_DEF"
- "IS_NUM_REP"
-
-end
--- a/src/HOL/Import/HOL4/Generated/numeral.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,49 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "iiSUC" > "iiSUC_def"
- "iZ" > "iZ_def"
- "iSUB" > "iSUB_def"
- "iSQR" > "iSQR_def"
- "iDUB" > "iDUB_def"
- "iBIT_cases" > "iBIT_cases_def"
-
-const_maps
- "iiSUC" > "HOL4Base.numeral.iiSUC"
- "iZ" > "HOL4Base.numeral.iZ"
- "iSQR" > "HOL4Base.numeral.iSQR"
- "iDUB" > "HOL4Base.numeral.iDUB"
-
-thm_maps
- "numeral_suc" > "HOL4Base.numeral.numeral_suc"
- "numeral_sub" > "HOL4Base.numeral.numeral_sub"
- "numeral_pre" > "HOL4Base.numeral.numeral_pre"
- "numeral_mult" > "HOL4Base.numeral.numeral_mult"
- "numeral_lte" > "HOL4Base.numeral.numeral_lte"
- "numeral_lt" > "HOL4Base.numeral.numeral_lt"
- "numeral_iisuc" > "HOL4Base.numeral.numeral_iisuc"
- "numeral_funpow" > "HOL4Base.numeral.numeral_funpow"
- "numeral_fact" > "HOL4Base.numeral.numeral_fact"
- "numeral_exp" > "HOL4Base.numeral.numeral_exp"
- "numeral_evenodd" > "HOL4Base.numeral.numeral_evenodd"
- "numeral_eq" > "HOL4Base.numeral.numeral_eq"
- "numeral_distrib" > "HOL4Base.numeral.numeral_distrib"
- "numeral_add" > "HOL4Base.numeral.numeral_add"
- "iiSUC_def" > "HOL4Base.numeral.iiSUC_def"
- "iiSUC" > "HOL4Base.numeral.iiSUC"
- "iZ_def" > "HOL4Base.numeral.iZ_def"
- "iZ" > "HOL4Base.numeral.iZ"
- "iSUB_THM" > "HOL4Base.numeral.iSUB_THM"
- "iSUB_DEF" > "HOL4Base.numeral.iSUB_DEF"
- "iSQR_def" > "HOL4Base.numeral.iSQR_def"
- "iSQR" > "HOL4Base.numeral.iSQR"
- "iDUB_removal" > "HOL4Base.numeral.iDUB_removal"
- "iDUB_def" > "HOL4Base.numeral.iDUB_def"
- "iDUB" > "HOL4Base.numeral.iDUB"
- "iBIT_cases" > "HOL4Base.numeral.iBIT_cases"
- "bit_initiality" > "HOL4Base.numeral.bit_initiality"
- "bit_induction" > "HOL4Base.numeral.bit_induction"
-
-end
--- a/src/HOL/Import/HOL4/Generated/one.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,20 +0,0 @@
-import
-
-import_segment "hol4"
-
-type_maps
- "one" > "Product_Type.unit"
-
-const_maps
- "one" > "Product_Type.Unity"
-
-thm_maps
- "one" > "Compatibility.one"
-
-ignore_thms
- "one_axiom"
- "one_TY_DEF"
- "one_DEF"
- "one_Axiom"
-
-end
--- a/src/HOL/Import/HOL4/Generated/operator.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,40 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "RIGHT_ID" > "RIGHT_ID_def"
- "MONOID" > "MONOID_def"
- "LEFT_ID" > "LEFT_ID_def"
- "FCOMM" > "FCOMM_def"
- "COMM" > "COMM_def"
- "ASSOC" > "ASSOC_def"
-
-const_maps
- "RIGHT_ID" > "HOL4Base.operator.RIGHT_ID"
- "MONOID" > "HOL4Base.operator.MONOID"
- "LEFT_ID" > "HOL4Base.operator.LEFT_ID"
- "FCOMM" > "HOL4Base.operator.FCOMM"
- "COMM" > "HOL4Base.operator.COMM"
- "ASSOC" > "HOL4Base.operator.ASSOC"
-
-thm_maps
- "RIGHT_ID_def" > "HOL4Base.operator.RIGHT_ID_def"
- "RIGHT_ID_DEF" > "HOL4Base.operator.RIGHT_ID_DEF"
- "MONOID_def" > "HOL4Base.operator.MONOID_def"
- "MONOID_DISJ_F" > "HOL4Base.operator.MONOID_DISJ_F"
- "MONOID_DEF" > "HOL4Base.operator.MONOID_DEF"
- "MONOID_CONJ_T" > "HOL4Base.operator.MONOID_CONJ_T"
- "LEFT_ID_def" > "HOL4Base.operator.LEFT_ID_def"
- "LEFT_ID_DEF" > "HOL4Base.operator.LEFT_ID_DEF"
- "FCOMM_def" > "HOL4Base.operator.FCOMM_def"
- "FCOMM_DEF" > "HOL4Base.operator.FCOMM_DEF"
- "FCOMM_ASSOC" > "HOL4Base.operator.FCOMM_ASSOC"
- "COMM_def" > "HOL4Base.operator.COMM_def"
- "COMM_DEF" > "HOL4Base.operator.COMM_DEF"
- "ASSOC_def" > "HOL4Base.operator.ASSOC_def"
- "ASSOC_DISJ" > "HOL4Base.operator.ASSOC_DISJ"
- "ASSOC_DEF" > "HOL4Base.operator.ASSOC_DEF"
- "ASSOC_CONJ" > "HOL4Base.operator.ASSOC_CONJ"
-
-end
--- a/src/HOL/Import/HOL4/Generated/option.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,45 +0,0 @@
-import
-
-import_segment "hol4"
-
-type_maps
- "option" > "Option.option"
-
-const_maps
- "option_case" > "Option.option.option_case"
- "THE" > "Option.the"
- "SOME" > "Option.option.Some"
- "OPTION_MAP" > "Option.map"
- "OPTION_JOIN" > "Compatibility.OPTION_JOIN"
- "NONE" > "Option.option.None"
- "IS_SOME" > "Compatibility.IS_SOME"
- "IS_NONE" > "Compatibility.IS_NONE"
-
-thm_maps
- "option_nchotomy" > "Option.option.nchotomy"
- "option_induction" > "Option.option.induct"
- "option_case_def" > "Compatibility.option_case_def"
- "option_case_cong" > "HOL4Base.option.option_case_cong"
- "option_case_compute" > "HOL4Base.option.option_case_compute"
- "option_CLAUSES" > "HOL4Base.option.option_CLAUSES"
- "THE_DEF" > "Option.the.simps"
- "SOME_11" > "Option.option.inject"
- "OPTION_MAP_EQ_SOME" > "HOL4Base.option.OPTION_MAP_EQ_SOME"
- "OPTION_MAP_EQ_NONE" > "Option.option_map_is_None"
- "OPTION_MAP_DEF" > "Compatibility.OPTION_MAP_DEF"
- "OPTION_JOIN_EQ_SOME" > "HOL4Base.option.OPTION_JOIN_EQ_SOME"
- "OPTION_JOIN_DEF" > "Compatibility.OPTION_JOIN_DEF"
- "NOT_SOME_NONE" > "Option.option.distinct_2"
- "NOT_NONE_SOME" > "Option.option.distinct_1"
- "IS_SOME_DEF" > "Compatibility.IS_SOME_DEF"
- "IS_NONE_DEF" > "Compatibility.IS_NONE_DEF"
-
-ignore_thms
- "option_axiom"
- "option_TY_DEF"
- "option_REP_ABS_DEF"
- "option_Axiom"
- "SOME_DEF"
- "NONE_DEF"
-
-end
--- a/src/HOL/Import/HOL4/Generated/pair.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,70 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "RPROD" > "RPROD_def"
- "LEX" > "LEX_def"
-
-type_maps
- "prod" > "Product_Type.prod"
-
-const_maps
- "pair_case" > "Product_Type.prod.prod_case"
- "UNCURRY" > "Product_Type.prod.prod_case"
- "SND" > "Product_Type.snd"
- "RPROD" > "HOL4Base.pair.RPROD"
- "LEX" > "HOL4Base.pair.LEX"
- "FST" > "Product_Type.fst"
- "CURRY" > "Product_Type.curry"
- "," > "Product_Type.Pair"
- "##" > "Product_Type.map_pair"
-
-thm_maps
- "pair_induction" > "Product_Type.prod.induct"
- "pair_case_thm" > "Product_Type.prod.cases"
- "pair_case_def" > "Compatibility.pair_case_def"
- "pair_case_cong" > "HOL4Base.pair.pair_case_cong"
- "pair_Axiom" > "HOL4Base.pair.pair_Axiom"
- "WF_RPROD" > "HOL4Base.pair.WF_RPROD"
- "WF_LEX" > "HOL4Base.pair.WF_LEX"
- "UNCURRY_VAR" > "Product_Type.prod_case_beta"
- "UNCURRY_ONE_ONE_THM" > "HOL4Base.pair.UNCURRY_ONE_ONE_THM"
- "UNCURRY_DEF" > "Product_Type.prod.cases"
- "UNCURRY_CURRY_THM" > "Product_Type.split_curry"
- "UNCURRY_CONG" > "HOL4Base.pair.UNCURRY_CONG"
- "UNCURRY" > "Product_Type.prod_case_beta"
- "SND" > "Product_Type.snd_conv"
- "RPROD_def" > "HOL4Base.pair.RPROD_def"
- "RPROD_DEF" > "HOL4Base.pair.RPROD_DEF"
- "PFORALL_THM" > "HOL4Base.pair.PFORALL_THM"
- "PEXISTS_THM" > "HOL4Base.pair.PEXISTS_THM"
- "PAIR_MAP_THM" > "Product_Type.map_pair_simp"
- "PAIR_MAP" > "Compatibility.PAIR_MAP"
- "PAIR_EQ" > "Product_Type.Pair_eq"
- "PAIR" > "Compatibility.PAIR"
- "LEX_def" > "HOL4Base.pair.LEX_def"
- "LEX_DEF" > "HOL4Base.pair.LEX_DEF"
- "LET2_RATOR" > "HOL4Base.pair.LET2_RATOR"
- "LET2_RAND" > "HOL4Base.pair.LET2_RAND"
- "LAMBDA_PROD" > "Product_Type.split_eta"
- "FST" > "Product_Type.fst_conv"
- "FORALL_PROD" > "Product_Type.split_paired_All"
- "EXISTS_PROD" > "Product_Type.split_paired_Ex"
- "ELIM_UNCURRY" > "Product_Type.prod_case_beta"
- "ELIM_PFORALL" > "HOL4Base.pair.ELIM_PFORALL"
- "ELIM_PEXISTS" > "HOL4Base.pair.ELIM_PEXISTS"
- "CURRY_UNCURRY_THM" > "Product_Type.curry_split"
- "CURRY_ONE_ONE_THM" > "HOL4Base.pair.CURRY_ONE_ONE_THM"
- "CURRY_DEF" > "Product_Type.curry_conv"
- "CLOSED_PAIR_EQ" > "Product_Type.Pair_eq"
- "ABS_PAIR_THM" > "Product_Type.prod.nchotomy"
-
-ignore_thms
- "prod_TY_DEF"
- "MK_PAIR_DEF"
- "IS_PAIR_DEF"
- "COMMA_DEF"
- "ABS_REP_prod"
-
-end
--- a/src/HOL/Import/HOL4/Generated/poly.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,128 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "rsquarefree" > "rsquarefree_def"
- "poly_order" > "poly_order_def"
- "poly_neg" > "poly_neg_primdef"
- "poly_mul" > "poly_mul_primdef"
- "poly_exp" > "poly_exp_primdef"
- "poly_divides" > "poly_divides_def"
- "poly_diff_aux" > "poly_diff_aux_primdef"
- "poly_add" > "poly_add_primdef"
- "poly" > "poly_primdef"
- "normalize" > "normalize_def"
- "diff" > "diff_def"
- "degree" > "degree_def"
- "##" > "##_def"
-
-const_maps
- "rsquarefree" > "HOL4Real.poly.rsquarefree"
- "poly_order" > "HOL4Real.poly.poly_order"
- "poly_neg" > "HOL4Real.poly.poly_neg"
- "poly_divides" > "HOL4Real.poly.poly_divides"
- "diff" > "HOL4Real.poly.diff"
- "degree" > "HOL4Real.poly.degree"
-
-thm_maps
- "rsquarefree_def" > "HOL4Real.poly.rsquarefree_def"
- "rsquarefree" > "HOL4Real.poly.rsquarefree"
- "poly_order_def" > "HOL4Real.poly.poly_order_def"
- "poly_order" > "HOL4Real.poly.poly_order"
- "poly_neg_primdef" > "HOL4Real.poly.poly_neg_primdef"
- "poly_neg_def" > "HOL4Real.poly.poly_neg_def"
- "poly_mul_def" > "HOL4Real.poly.poly_mul_def"
- "poly_exp_def" > "HOL4Real.poly.poly_exp_def"
- "poly_divides_def" > "HOL4Real.poly.poly_divides_def"
- "poly_divides" > "HOL4Real.poly.poly_divides"
- "poly_diff_def" > "HOL4Real.poly.poly_diff_def"
- "poly_diff_aux_def" > "HOL4Real.poly.poly_diff_aux_def"
- "poly_def" > "HOL4Real.poly.poly_def"
- "poly_cmul_def" > "HOL4Real.poly.poly_cmul_def"
- "poly_add_def" > "HOL4Real.poly.poly_add_def"
- "normalize" > "HOL4Real.poly.normalize"
- "diff_def" > "HOL4Real.poly.diff_def"
- "degree_def" > "HOL4Real.poly.degree_def"
- "degree" > "HOL4Real.poly.degree"
- "RSQUAREFREE_ROOTS" > "HOL4Real.poly.RSQUAREFREE_ROOTS"
- "RSQUAREFREE_DECOMP" > "HOL4Real.poly.RSQUAREFREE_DECOMP"
- "POLY_ZERO_LEMMA" > "HOL4Real.poly.POLY_ZERO_LEMMA"
- "POLY_ZERO" > "HOL4Real.poly.POLY_ZERO"
- "POLY_SQUAREFREE_DECOMP_ORDER" > "HOL4Real.poly.POLY_SQUAREFREE_DECOMP_ORDER"
- "POLY_SQUAREFREE_DECOMP" > "HOL4Real.poly.POLY_SQUAREFREE_DECOMP"
- "POLY_ROOTS_INDEX_LENGTH" > "HOL4Real.poly.POLY_ROOTS_INDEX_LENGTH"
- "POLY_ROOTS_INDEX_LEMMA" > "HOL4Real.poly.POLY_ROOTS_INDEX_LEMMA"
- "POLY_ROOTS_FINITE_SET" > "HOL4Real.poly.POLY_ROOTS_FINITE_SET"
- "POLY_ROOTS_FINITE_LEMMA" > "HOL4Real.poly.POLY_ROOTS_FINITE_LEMMA"
- "POLY_ROOTS_FINITE" > "HOL4Real.poly.POLY_ROOTS_FINITE"
- "POLY_PRIME_EQ_0" > "HOL4Real.poly.POLY_PRIME_EQ_0"
- "POLY_PRIMES" > "HOL4Real.poly.POLY_PRIMES"
- "POLY_ORDER_EXISTS" > "HOL4Real.poly.POLY_ORDER_EXISTS"
- "POLY_ORDER" > "HOL4Real.poly.POLY_ORDER"
- "POLY_NORMALIZE" > "HOL4Real.poly.POLY_NORMALIZE"
- "POLY_NEG_CLAUSES" > "HOL4Real.poly.POLY_NEG_CLAUSES"
- "POLY_NEG" > "HOL4Real.poly.POLY_NEG"
- "POLY_MVT" > "HOL4Real.poly.POLY_MVT"
- "POLY_MUL_LCANCEL" > "HOL4Real.poly.POLY_MUL_LCANCEL"
- "POLY_MUL_CLAUSES" > "HOL4Real.poly.POLY_MUL_CLAUSES"
- "POLY_MUL_ASSOC" > "HOL4Real.poly.POLY_MUL_ASSOC"
- "POLY_MUL" > "HOL4Real.poly.POLY_MUL"
- "POLY_MONO" > "HOL4Real.poly.POLY_MONO"
- "POLY_LINEAR_REM" > "HOL4Real.poly.POLY_LINEAR_REM"
- "POLY_LINEAR_DIVIDES" > "HOL4Real.poly.POLY_LINEAR_DIVIDES"
- "POLY_LENGTH_MUL" > "HOL4Real.poly.POLY_LENGTH_MUL"
- "POLY_IVT_POS" > "HOL4Real.poly.POLY_IVT_POS"
- "POLY_IVT_NEG" > "HOL4Real.poly.POLY_IVT_NEG"
- "POLY_EXP_PRIME_EQ_0" > "HOL4Real.poly.POLY_EXP_PRIME_EQ_0"
- "POLY_EXP_EQ_0" > "HOL4Real.poly.POLY_EXP_EQ_0"
- "POLY_EXP_DIVIDES" > "HOL4Real.poly.POLY_EXP_DIVIDES"
- "POLY_EXP_ADD" > "HOL4Real.poly.POLY_EXP_ADD"
- "POLY_EXP" > "HOL4Real.poly.POLY_EXP"
- "POLY_ENTIRE_LEMMA" > "HOL4Real.poly.POLY_ENTIRE_LEMMA"
- "POLY_ENTIRE" > "HOL4Real.poly.POLY_ENTIRE"
- "POLY_DIVIDES_ZERO" > "HOL4Real.poly.POLY_DIVIDES_ZERO"
- "POLY_DIVIDES_TRANS" > "HOL4Real.poly.POLY_DIVIDES_TRANS"
- "POLY_DIVIDES_SUB2" > "HOL4Real.poly.POLY_DIVIDES_SUB2"
- "POLY_DIVIDES_SUB" > "HOL4Real.poly.POLY_DIVIDES_SUB"
- "POLY_DIVIDES_REFL" > "HOL4Real.poly.POLY_DIVIDES_REFL"
- "POLY_DIVIDES_EXP" > "HOL4Real.poly.POLY_DIVIDES_EXP"
- "POLY_DIVIDES_ADD" > "HOL4Real.poly.POLY_DIVIDES_ADD"
- "POLY_DIFF_ZERO" > "HOL4Real.poly.POLY_DIFF_ZERO"
- "POLY_DIFF_WELLDEF" > "HOL4Real.poly.POLY_DIFF_WELLDEF"
- "POLY_DIFF_NEG" > "HOL4Real.poly.POLY_DIFF_NEG"
- "POLY_DIFF_MUL_LEMMA" > "HOL4Real.poly.POLY_DIFF_MUL_LEMMA"
- "POLY_DIFF_MUL" > "HOL4Real.poly.POLY_DIFF_MUL"
- "POLY_DIFF_LEMMA" > "HOL4Real.poly.POLY_DIFF_LEMMA"
- "POLY_DIFF_ISZERO" > "HOL4Real.poly.POLY_DIFF_ISZERO"
- "POLY_DIFF_EXP_PRIME" > "HOL4Real.poly.POLY_DIFF_EXP_PRIME"
- "POLY_DIFF_EXP" > "HOL4Real.poly.POLY_DIFF_EXP"
- "POLY_DIFF_CMUL" > "HOL4Real.poly.POLY_DIFF_CMUL"
- "POLY_DIFF_CLAUSES" > "HOL4Real.poly.POLY_DIFF_CLAUSES"
- "POLY_DIFF_AUX_NEG" > "HOL4Real.poly.POLY_DIFF_AUX_NEG"
- "POLY_DIFF_AUX_MUL_LEMMA" > "HOL4Real.poly.POLY_DIFF_AUX_MUL_LEMMA"
- "POLY_DIFF_AUX_ISZERO" > "HOL4Real.poly.POLY_DIFF_AUX_ISZERO"
- "POLY_DIFF_AUX_CMUL" > "HOL4Real.poly.POLY_DIFF_AUX_CMUL"
- "POLY_DIFF_AUX_ADD" > "HOL4Real.poly.POLY_DIFF_AUX_ADD"
- "POLY_DIFF_ADD" > "HOL4Real.poly.POLY_DIFF_ADD"
- "POLY_DIFFERENTIABLE" > "HOL4Real.poly.POLY_DIFFERENTIABLE"
- "POLY_DIFF" > "HOL4Real.poly.POLY_DIFF"
- "POLY_CONT" > "HOL4Real.poly.POLY_CONT"
- "POLY_CMUL_CLAUSES" > "HOL4Real.poly.POLY_CMUL_CLAUSES"
- "POLY_CMUL" > "HOL4Real.poly.POLY_CMUL"
- "POLY_ADD_RZERO" > "HOL4Real.poly.POLY_ADD_RZERO"
- "POLY_ADD_CLAUSES" > "HOL4Real.poly.POLY_ADD_CLAUSES"
- "POLY_ADD" > "HOL4Real.poly.POLY_ADD"
- "ORDER_UNIQUE" > "HOL4Real.poly.ORDER_UNIQUE"
- "ORDER_THM" > "HOL4Real.poly.ORDER_THM"
- "ORDER_ROOT" > "HOL4Real.poly.ORDER_ROOT"
- "ORDER_POLY" > "HOL4Real.poly.ORDER_POLY"
- "ORDER_MUL" > "HOL4Real.poly.ORDER_MUL"
- "ORDER_DIVIDES" > "HOL4Real.poly.ORDER_DIVIDES"
- "ORDER_DIFF" > "HOL4Real.poly.ORDER_DIFF"
- "ORDER_DECOMP" > "HOL4Real.poly.ORDER_DECOMP"
- "ORDER" > "HOL4Real.poly.ORDER"
- "FINITE_LEMMA" > "HOL4Real.poly.FINITE_LEMMA"
- "DEGREE_ZERO" > "HOL4Real.poly.DEGREE_ZERO"
-
-end
--- a/src/HOL/Import/HOL4/Generated/powser.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,30 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "diffs" > "diffs_def"
-
-const_maps
- "diffs" > "HOL4Real.powser.diffs"
-
-thm_maps
- "diffs_def" > "HOL4Real.powser.diffs_def"
- "diffs" > "HOL4Real.powser.diffs"
- "TERMDIFF_LEMMA5" > "HOL4Real.powser.TERMDIFF_LEMMA5"
- "TERMDIFF_LEMMA4" > "HOL4Real.powser.TERMDIFF_LEMMA4"
- "TERMDIFF_LEMMA3" > "HOL4Real.powser.TERMDIFF_LEMMA3"
- "TERMDIFF_LEMMA2" > "HOL4Real.powser.TERMDIFF_LEMMA2"
- "TERMDIFF_LEMMA1" > "HOL4Real.powser.TERMDIFF_LEMMA1"
- "TERMDIFF" > "HOL4Real.powser.TERMDIFF"
- "POWSER_INSIDEA" > "HOL4Real.powser.POWSER_INSIDEA"
- "POWSER_INSIDE" > "HOL4Real.powser.POWSER_INSIDE"
- "POWREV" > "HOL4Real.powser.POWREV"
- "POWDIFF_LEMMA" > "HOL4Real.powser.POWDIFF_LEMMA"
- "POWDIFF" > "HOL4Real.powser.POWDIFF"
- "DIFFS_NEG" > "HOL4Real.powser.DIFFS_NEG"
- "DIFFS_LEMMA2" > "HOL4Real.powser.DIFFS_LEMMA2"
- "DIFFS_LEMMA" > "HOL4Real.powser.DIFFS_LEMMA"
- "DIFFS_EQUIV" > "HOL4Real.powser.DIFFS_EQUIV"
-
-end
--- a/src/HOL/Import/HOL4/Generated/pred_set.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,322 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "count" > "count_primdef"
- "UNIV" > "UNIV_def"
- "UNION" > "UNION_def"
- "SURJ" > "SURJ_def"
- "SUBSET" > "SUBSET_def"
- "SING" > "SING_def"
- "RINV" > "RINV_def"
- "REST" > "REST_def"
- "PSUBSET" > "PSUBSET_def"
- "LINV" > "LINV_def"
- "ITSET_tupled" > "ITSET_tupled_def"
- "ITSET" > "ITSET_def"
- "INTER" > "INTER_def"
- "INSERT" > "INSERT_def"
- "INJ" > "INJ_def"
- "INFINITE" > "INFINITE_def"
- "IMAGE" > "IMAGE_def"
- "GSPEC" > "GSPEC_def"
- "FINITE" > "FINITE_def"
- "EMPTY" > "EMPTY_def"
- "DISJOINT" > "DISJOINT_def"
- "DIFF" > "DIFF_def"
- "DELETE" > "DELETE_def"
- "CROSS" > "CROSS_def"
- "COMPL" > "COMPL_def"
- "CHOICE" > "CHOICE_def"
- "CARD" > "CARD_def"
- "BIJ" > "BIJ_def"
- "BIGUNION" > "BIGUNION_def"
- "BIGINTER" > "BIGINTER_def"
-
-const_maps
- "count" > "HOL4Base.pred_set.count"
- "UNIV" > "HOL4Base.pred_set.UNIV"
- "UNION" > "HOL4Base.pred_set.UNION"
- "SURJ" > "HOL4Base.pred_set.SURJ"
- "SUBSET" > "HOL4Base.pred_set.SUBSET"
- "SING" > "HOL4Base.pred_set.SING"
- "REST" > "HOL4Base.pred_set.REST"
- "PSUBSET" > "HOL4Base.pred_set.PSUBSET"
- "ITSET_tupled" > "HOL4Base.pred_set.ITSET_tupled"
- "ITSET" > "HOL4Base.pred_set.ITSET"
- "INTER" > "HOL4Base.pred_set.INTER"
- "INSERT" > "HOL4Base.pred_set.INSERT"
- "INJ" > "HOL4Base.pred_set.INJ"
- "INFINITE" > "HOL4Base.pred_set.INFINITE"
- "IMAGE" > "HOL4Base.pred_set.IMAGE"
- "FINITE" > "HOL4Base.pred_set.FINITE"
- "EMPTY" > "HOL4Base.pred_set.EMPTY"
- "DISJOINT" > "HOL4Base.pred_set.DISJOINT"
- "DIFF" > "HOL4Base.pred_set.DIFF"
- "DELETE" > "HOL4Base.pred_set.DELETE"
- "CROSS" > "HOL4Base.pred_set.CROSS"
- "COMPL" > "HOL4Base.pred_set.COMPL"
- "BIJ" > "HOL4Base.pred_set.BIJ"
- "BIGUNION" > "HOL4Base.pred_set.BIGUNION"
- "BIGINTER" > "HOL4Base.pred_set.BIGINTER"
-
-thm_maps
- "count_primdef" > "HOL4Base.pred_set.count_primdef"
- "count_def" > "HOL4Base.pred_set.count_def"
- "UNIV_def" > "HOL4Base.pred_set.UNIV_def"
- "UNIV_SUBSET" > "HOL4Base.pred_set.UNIV_SUBSET"
- "UNIV_NOT_EMPTY" > "HOL4Base.pred_set.UNIV_NOT_EMPTY"
- "UNIV_DEF" > "HOL4Base.pred_set.UNIV_DEF"
- "UNION_def" > "HOL4Base.pred_set.UNION_def"
- "UNION_UNIV" > "HOL4Base.pred_set.UNION_UNIV"
- "UNION_SUBSET" > "HOL4Base.pred_set.UNION_SUBSET"
- "UNION_OVER_INTER" > "HOL4Base.pred_set.UNION_OVER_INTER"
- "UNION_IDEMPOT" > "HOL4Base.pred_set.UNION_IDEMPOT"
- "UNION_EMPTY" > "HOL4Base.pred_set.UNION_EMPTY"
- "UNION_DEF" > "HOL4Base.pred_set.UNION_DEF"
- "UNION_COMM" > "HOL4Base.pred_set.UNION_COMM"
- "UNION_ASSOC" > "HOL4Base.pred_set.UNION_ASSOC"
- "SURJ_def" > "HOL4Base.pred_set.SURJ_def"
- "SURJ_ID" > "HOL4Base.pred_set.SURJ_ID"
- "SURJ_EMPTY" > "HOL4Base.pred_set.SURJ_EMPTY"
- "SURJ_DEF" > "HOL4Base.pred_set.SURJ_DEF"
- "SURJ_COMPOSE" > "HOL4Base.pred_set.SURJ_COMPOSE"
- "SUBSET_def" > "HOL4Base.pred_set.SUBSET_def"
- "SUBSET_UNIV" > "HOL4Base.pred_set.SUBSET_UNIV"
- "SUBSET_UNION_ABSORPTION" > "HOL4Base.pred_set.SUBSET_UNION_ABSORPTION"
- "SUBSET_UNION" > "HOL4Base.pred_set.SUBSET_UNION"
- "SUBSET_TRANS" > "HOL4Base.pred_set.SUBSET_TRANS"
- "SUBSET_REFL" > "HOL4Base.pred_set.SUBSET_REFL"
- "SUBSET_INTER_ABSORPTION" > "HOL4Base.pred_set.SUBSET_INTER_ABSORPTION"
- "SUBSET_INTER" > "HOL4Base.pred_set.SUBSET_INTER"
- "SUBSET_INSERT_DELETE" > "HOL4Base.pred_set.SUBSET_INSERT_DELETE"
- "SUBSET_INSERT" > "HOL4Base.pred_set.SUBSET_INSERT"
- "SUBSET_FINITE" > "HOL4Base.pred_set.SUBSET_FINITE"
- "SUBSET_EMPTY" > "HOL4Base.pred_set.SUBSET_EMPTY"
- "SUBSET_DELETE" > "HOL4Base.pred_set.SUBSET_DELETE"
- "SUBSET_DEF" > "HOL4Base.pred_set.SUBSET_DEF"
- "SUBSET_BIGINTER" > "HOL4Base.pred_set.SUBSET_BIGINTER"
- "SUBSET_ANTISYM" > "HOL4Base.pred_set.SUBSET_ANTISYM"
- "SPECIFICATION" > "HOL4Base.bool.IN_DEF"
- "SING_def" > "HOL4Base.pred_set.SING_def"
- "SING_IFF_EMPTY_REST" > "HOL4Base.pred_set.SING_IFF_EMPTY_REST"
- "SING_IFF_CARD1" > "HOL4Base.pred_set.SING_IFF_CARD1"
- "SING_FINITE" > "HOL4Base.pred_set.SING_FINITE"
- "SING_DELETE" > "HOL4Base.pred_set.SING_DELETE"
- "SING_DEF" > "HOL4Base.pred_set.SING_DEF"
- "SING" > "HOL4Base.pred_set.SING"
- "SET_MINIMUM" > "HOL4Base.pred_set.SET_MINIMUM"
- "SET_CASES" > "HOL4Base.pred_set.SET_CASES"
- "RINV_DEF" > "HOL4Base.pred_set.RINV_DEF"
- "REST_def" > "HOL4Base.pred_set.REST_def"
- "REST_SUBSET" > "HOL4Base.pred_set.REST_SUBSET"
- "REST_SING" > "HOL4Base.pred_set.REST_SING"
- "REST_PSUBSET" > "HOL4Base.pred_set.REST_PSUBSET"
- "REST_DEF" > "HOL4Base.pred_set.REST_DEF"
- "PSUBSET_def" > "HOL4Base.pred_set.PSUBSET_def"
- "PSUBSET_UNIV" > "HOL4Base.pred_set.PSUBSET_UNIV"
- "PSUBSET_TRANS" > "HOL4Base.pred_set.PSUBSET_TRANS"
- "PSUBSET_MEMBER" > "HOL4Base.pred_set.PSUBSET_MEMBER"
- "PSUBSET_IRREFL" > "HOL4Base.pred_set.PSUBSET_IRREFL"
- "PSUBSET_INSERT_SUBSET" > "HOL4Base.pred_set.PSUBSET_INSERT_SUBSET"
- "PSUBSET_FINITE" > "HOL4Base.pred_set.PSUBSET_FINITE"
- "PSUBSET_DEF" > "HOL4Base.pred_set.PSUBSET_DEF"
- "NUM_SET_WOP" > "HOL4Base.pred_set.NUM_SET_WOP"
- "NOT_UNIV_PSUBSET" > "HOL4Base.pred_set.NOT_UNIV_PSUBSET"
- "NOT_SING_EMPTY" > "HOL4Base.pred_set.NOT_SING_EMPTY"
- "NOT_PSUBSET_EMPTY" > "HOL4Base.pred_set.NOT_PSUBSET_EMPTY"
- "NOT_IN_FINITE" > "HOL4Base.pred_set.NOT_IN_FINITE"
- "NOT_IN_EMPTY" > "HOL4Base.pred_set.NOT_IN_EMPTY"
- "NOT_INSERT_EMPTY" > "HOL4Base.pred_set.NOT_INSERT_EMPTY"
- "NOT_EQUAL_SETS" > "HOL4Base.pred_set.NOT_EQUAL_SETS"
- "NOT_EMPTY_SING" > "HOL4Base.pred_set.NOT_EMPTY_SING"
- "NOT_EMPTY_INSERT" > "HOL4Base.pred_set.NOT_EMPTY_INSERT"
- "MEMBER_NOT_EMPTY" > "HOL4Base.pred_set.MEMBER_NOT_EMPTY"
- "LINV_DEF" > "HOL4Base.pred_set.LINV_DEF"
- "LESS_CARD_DIFF" > "HOL4Base.pred_set.LESS_CARD_DIFF"
- "ITSET_tupled_primitive_def" > "HOL4Base.pred_set.ITSET_tupled_primitive_def"
- "ITSET_tupled_def" > "HOL4Base.pred_set.ITSET_tupled_def"
- "ITSET_def" > "HOL4Base.pred_set.ITSET_def"
- "ITSET_curried_def" > "HOL4Base.pred_set.ITSET_curried_def"
- "ITSET_THM" > "HOL4Base.pred_set.ITSET_THM"
- "ITSET_IND" > "HOL4Base.pred_set.ITSET_IND"
- "ITSET_EMPTY" > "HOL4Base.pred_set.ITSET_EMPTY"
- "IN_UNIV" > "HOL4Base.pred_set.IN_UNIV"
- "IN_UNION" > "HOL4Base.pred_set.IN_UNION"
- "IN_SING" > "HOL4Base.pred_set.IN_SING"
- "IN_INTER" > "HOL4Base.pred_set.IN_INTER"
- "IN_INSERT" > "HOL4Base.pred_set.IN_INSERT"
- "IN_INFINITE_NOT_FINITE" > "HOL4Base.pred_set.IN_INFINITE_NOT_FINITE"
- "IN_IMAGE" > "HOL4Base.pred_set.IN_IMAGE"
- "IN_DISJOINT" > "HOL4Base.pred_set.IN_DISJOINT"
- "IN_DIFF" > "HOL4Base.pred_set.IN_DIFF"
- "IN_DELETE_EQ" > "HOL4Base.pred_set.IN_DELETE_EQ"
- "IN_DELETE" > "HOL4Base.pred_set.IN_DELETE"
- "IN_CROSS" > "HOL4Base.pred_set.IN_CROSS"
- "IN_COUNT" > "HOL4Base.pred_set.IN_COUNT"
- "IN_COMPL" > "HOL4Base.pred_set.IN_COMPL"
- "IN_BIGUNION" > "HOL4Base.pred_set.IN_BIGUNION"
- "IN_BIGINTER" > "HOL4Base.pred_set.IN_BIGINTER"
- "INTER_def" > "HOL4Base.pred_set.INTER_def"
- "INTER_UNIV" > "HOL4Base.pred_set.INTER_UNIV"
- "INTER_UNION_COMPL" > "HOL4Base.pred_set.INTER_UNION_COMPL"
- "INTER_SUBSET" > "HOL4Base.pred_set.INTER_SUBSET"
- "INTER_OVER_UNION" > "HOL4Base.pred_set.INTER_OVER_UNION"
- "INTER_IDEMPOT" > "HOL4Base.pred_set.INTER_IDEMPOT"
- "INTER_FINITE" > "HOL4Base.pred_set.INTER_FINITE"
- "INTER_EMPTY" > "HOL4Base.pred_set.INTER_EMPTY"
- "INTER_DEF" > "HOL4Base.pred_set.INTER_DEF"
- "INTER_COMM" > "HOL4Base.pred_set.INTER_COMM"
- "INTER_ASSOC" > "HOL4Base.pred_set.INTER_ASSOC"
- "INSERT_def" > "HOL4Base.pred_set.INSERT_def"
- "INSERT_UNIV" > "HOL4Base.pred_set.INSERT_UNIV"
- "INSERT_UNION_EQ" > "HOL4Base.pred_set.INSERT_UNION_EQ"
- "INSERT_UNION" > "HOL4Base.pred_set.INSERT_UNION"
- "INSERT_SUBSET" > "HOL4Base.pred_set.INSERT_SUBSET"
- "INSERT_SING_UNION" > "HOL4Base.pred_set.INSERT_SING_UNION"
- "INSERT_INTER" > "HOL4Base.pred_set.INSERT_INTER"
- "INSERT_INSERT" > "HOL4Base.pred_set.INSERT_INSERT"
- "INSERT_DIFF" > "HOL4Base.pred_set.INSERT_DIFF"
- "INSERT_DELETE" > "HOL4Base.pred_set.INSERT_DELETE"
- "INSERT_DEF" > "HOL4Base.pred_set.INSERT_DEF"
- "INSERT_COMM" > "HOL4Base.pred_set.INSERT_COMM"
- "INJ_def" > "HOL4Base.pred_set.INJ_def"
- "INJ_ID" > "HOL4Base.pred_set.INJ_ID"
- "INJ_EMPTY" > "HOL4Base.pred_set.INJ_EMPTY"
- "INJ_DEF" > "HOL4Base.pred_set.INJ_DEF"
- "INJ_COMPOSE" > "HOL4Base.pred_set.INJ_COMPOSE"
- "INFINITE_def" > "HOL4Base.pred_set.INFINITE_def"
- "INFINITE_UNIV" > "HOL4Base.pred_set.INFINITE_UNIV"
- "INFINITE_SUBSET" > "HOL4Base.pred_set.INFINITE_SUBSET"
- "INFINITE_INHAB" > "HOL4Base.pred_set.INFINITE_INHAB"
- "INFINITE_DIFF_FINITE" > "HOL4Base.pred_set.INFINITE_DIFF_FINITE"
- "INFINITE_DEF" > "HOL4Base.pred_set.INFINITE_DEF"
- "IMAGE_def" > "HOL4Base.pred_set.IMAGE_def"
- "IMAGE_UNION" > "HOL4Base.pred_set.IMAGE_UNION"
- "IMAGE_SURJ" > "HOL4Base.pred_set.IMAGE_SURJ"
- "IMAGE_SUBSET" > "HOL4Base.pred_set.IMAGE_SUBSET"
- "IMAGE_INTER" > "HOL4Base.pred_set.IMAGE_INTER"
- "IMAGE_INSERT" > "HOL4Base.pred_set.IMAGE_INSERT"
- "IMAGE_IN" > "HOL4Base.pred_set.IMAGE_IN"
- "IMAGE_ID" > "HOL4Base.pred_set.IMAGE_ID"
- "IMAGE_FINITE" > "HOL4Base.pred_set.IMAGE_FINITE"
- "IMAGE_EQ_EMPTY" > "HOL4Base.pred_set.IMAGE_EQ_EMPTY"
- "IMAGE_EMPTY" > "HOL4Base.pred_set.IMAGE_EMPTY"
- "IMAGE_DELETE" > "HOL4Base.pred_set.IMAGE_DELETE"
- "IMAGE_DEF" > "HOL4Base.pred_set.IMAGE_DEF"
- "IMAGE_COMPOSE" > "HOL4Base.pred_set.IMAGE_COMPOSE"
- "IMAGE_11_INFINITE" > "HOL4Base.pred_set.IMAGE_11_INFINITE"
- "GSPECIFICATION" > "HOL4Base.pred_set.GSPECIFICATION"
- "FINITE_def" > "HOL4Base.pred_set.FINITE_def"
- "FINITE_WEAK_ENUMERATE" > "HOL4Base.pred_set.FINITE_WEAK_ENUMERATE"
- "FINITE_UNION" > "HOL4Base.pred_set.FINITE_UNION"
- "FINITE_SING" > "HOL4Base.pred_set.FINITE_SING"
- "FINITE_PSUBSET_UNIV" > "HOL4Base.pred_set.FINITE_PSUBSET_UNIV"
- "FINITE_PSUBSET_INFINITE" > "HOL4Base.pred_set.FINITE_PSUBSET_INFINITE"
- "FINITE_ISO_NUM" > "HOL4Base.pred_set.FINITE_ISO_NUM"
- "FINITE_INSERT" > "HOL4Base.pred_set.FINITE_INSERT"
- "FINITE_INDUCT" > "HOL4Base.pred_set.FINITE_INDUCT"
- "FINITE_EMPTY" > "HOL4Base.pred_set.FINITE_EMPTY"
- "FINITE_DIFF" > "HOL4Base.pred_set.FINITE_DIFF"
- "FINITE_DELETE" > "HOL4Base.pred_set.FINITE_DELETE"
- "FINITE_DEF" > "HOL4Base.pred_set.FINITE_DEF"
- "FINITE_CROSS_EQ" > "HOL4Base.pred_set.FINITE_CROSS_EQ"
- "FINITE_CROSS" > "HOL4Base.pred_set.FINITE_CROSS"
- "FINITE_COUNT" > "HOL4Base.pred_set.FINITE_COUNT"
- "FINITE_COMPLETE_INDUCTION" > "HOL4Base.pred_set.FINITE_COMPLETE_INDUCTION"
- "FINITE_BIGUNION" > "HOL4Base.pred_set.FINITE_BIGUNION"
- "EXTENSION" > "HOL4Base.pred_set.EXTENSION"
- "EQ_UNIV" > "HOL4Base.pred_set.EQ_UNIV"
- "EQUAL_SING" > "HOL4Base.pred_set.EQUAL_SING"
- "EMPTY_def" > "HOL4Base.pred_set.EMPTY_def"
- "EMPTY_UNION" > "HOL4Base.pred_set.EMPTY_UNION"
- "EMPTY_SUBSET" > "HOL4Base.pred_set.EMPTY_SUBSET"
- "EMPTY_NOT_UNIV" > "HOL4Base.pred_set.EMPTY_NOT_UNIV"
- "EMPTY_DIFF" > "HOL4Base.pred_set.EMPTY_DIFF"
- "EMPTY_DELETE" > "HOL4Base.pred_set.EMPTY_DELETE"
- "EMPTY_DEF" > "HOL4Base.pred_set.EMPTY_DEF"
- "DISJOINT_def" > "HOL4Base.pred_set.DISJOINT_def"
- "DISJOINT_UNION_BOTH" > "HOL4Base.pred_set.DISJOINT_UNION_BOTH"
- "DISJOINT_UNION" > "HOL4Base.pred_set.DISJOINT_UNION"
- "DISJOINT_SYM" > "HOL4Base.pred_set.DISJOINT_SYM"
- "DISJOINT_SING_EMPTY" > "HOL4Base.pred_set.DISJOINT_SING_EMPTY"
- "DISJOINT_INSERT" > "HOL4Base.pred_set.DISJOINT_INSERT"
- "DISJOINT_EMPTY_REFL" > "HOL4Base.pred_set.DISJOINT_EMPTY_REFL"
- "DISJOINT_EMPTY" > "HOL4Base.pred_set.DISJOINT_EMPTY"
- "DISJOINT_DELETE_SYM" > "HOL4Base.pred_set.DISJOINT_DELETE_SYM"
- "DISJOINT_DEF" > "HOL4Base.pred_set.DISJOINT_DEF"
- "DISJOINT_BIGUNION" > "HOL4Base.pred_set.DISJOINT_BIGUNION"
- "DISJOINT_BIGINTER" > "HOL4Base.pred_set.DISJOINT_BIGINTER"
- "DIFF_def" > "HOL4Base.pred_set.DIFF_def"
- "DIFF_UNIV" > "HOL4Base.pred_set.DIFF_UNIV"
- "DIFF_INSERT" > "HOL4Base.pred_set.DIFF_INSERT"
- "DIFF_EQ_EMPTY" > "HOL4Base.pred_set.DIFF_EQ_EMPTY"
- "DIFF_EMPTY" > "HOL4Base.pred_set.DIFF_EMPTY"
- "DIFF_DIFF" > "HOL4Base.pred_set.DIFF_DIFF"
- "DIFF_DEF" > "HOL4Base.pred_set.DIFF_DEF"
- "DELETE_def" > "HOL4Base.pred_set.DELETE_def"
- "DELETE_SUBSET" > "HOL4Base.pred_set.DELETE_SUBSET"
- "DELETE_NON_ELEMENT" > "HOL4Base.pred_set.DELETE_NON_ELEMENT"
- "DELETE_INTER" > "HOL4Base.pred_set.DELETE_INTER"
- "DELETE_INSERT" > "HOL4Base.pred_set.DELETE_INSERT"
- "DELETE_EQ_SING" > "HOL4Base.pred_set.DELETE_EQ_SING"
- "DELETE_DELETE" > "HOL4Base.pred_set.DELETE_DELETE"
- "DELETE_DEF" > "HOL4Base.pred_set.DELETE_DEF"
- "DELETE_COMM" > "HOL4Base.pred_set.DELETE_COMM"
- "DECOMPOSITION" > "HOL4Base.pred_set.DECOMPOSITION"
- "CROSS_def" > "HOL4Base.pred_set.CROSS_def"
- "CROSS_SUBSET" > "HOL4Base.pred_set.CROSS_SUBSET"
- "CROSS_SINGS" > "HOL4Base.pred_set.CROSS_SINGS"
- "CROSS_INSERT_RIGHT" > "HOL4Base.pred_set.CROSS_INSERT_RIGHT"
- "CROSS_INSERT_LEFT" > "HOL4Base.pred_set.CROSS_INSERT_LEFT"
- "CROSS_EMPTY" > "HOL4Base.pred_set.CROSS_EMPTY"
- "CROSS_DEF" > "HOL4Base.pred_set.CROSS_DEF"
- "COUNT_ZERO" > "HOL4Base.pred_set.COUNT_ZERO"
- "COUNT_SUC" > "HOL4Base.pred_set.COUNT_SUC"
- "COMPONENT" > "HOL4Base.pred_set.COMPONENT"
- "COMPL_def" > "HOL4Base.pred_set.COMPL_def"
- "COMPL_SPLITS" > "HOL4Base.pred_set.COMPL_SPLITS"
- "COMPL_EMPTY" > "HOL4Base.pred_set.COMPL_EMPTY"
- "COMPL_DEF" > "HOL4Base.pred_set.COMPL_DEF"
- "COMPL_COMPL" > "HOL4Base.pred_set.COMPL_COMPL"
- "COMPL_CLAUSES" > "HOL4Base.pred_set.COMPL_CLAUSES"
- "CHOICE_SING" > "HOL4Base.pred_set.CHOICE_SING"
- "CHOICE_NOT_IN_REST" > "HOL4Base.pred_set.CHOICE_NOT_IN_REST"
- "CHOICE_INSERT_REST" > "HOL4Base.pred_set.CHOICE_INSERT_REST"
- "CHOICE_DEF" > "HOL4Base.pred_set.CHOICE_DEF"
- "CARD_UNION" > "HOL4Base.pred_set.CARD_UNION"
- "CARD_SUBSET" > "HOL4Base.pred_set.CARD_SUBSET"
- "CARD_SING_CROSS" > "HOL4Base.pred_set.CARD_SING_CROSS"
- "CARD_SING" > "HOL4Base.pred_set.CARD_SING"
- "CARD_PSUBSET" > "HOL4Base.pred_set.CARD_PSUBSET"
- "CARD_INTER_LESS_EQ" > "HOL4Base.pred_set.CARD_INTER_LESS_EQ"
- "CARD_INSERT" > "HOL4Base.pred_set.CARD_INSERT"
- "CARD_EQ_0" > "HOL4Base.pred_set.CARD_EQ_0"
- "CARD_EMPTY" > "HOL4Base.pred_set.CARD_EMPTY"
- "CARD_DIFF" > "HOL4Base.pred_set.CARD_DIFF"
- "CARD_DELETE" > "HOL4Base.pred_set.CARD_DELETE"
- "CARD_DEF" > "HOL4Base.pred_set.CARD_DEF"
- "CARD_CROSS" > "HOL4Base.pred_set.CARD_CROSS"
- "CARD_COUNT" > "HOL4Base.pred_set.CARD_COUNT"
- "BIJ_def" > "HOL4Base.pred_set.BIJ_def"
- "BIJ_ID" > "HOL4Base.pred_set.BIJ_ID"
- "BIJ_EMPTY" > "HOL4Base.pred_set.BIJ_EMPTY"
- "BIJ_DEF" > "HOL4Base.pred_set.BIJ_DEF"
- "BIJ_COMPOSE" > "HOL4Base.pred_set.BIJ_COMPOSE"
- "BIGUNION_def" > "HOL4Base.pred_set.BIGUNION_def"
- "BIGUNION_UNION" > "HOL4Base.pred_set.BIGUNION_UNION"
- "BIGUNION_SUBSET" > "HOL4Base.pred_set.BIGUNION_SUBSET"
- "BIGUNION_SING" > "HOL4Base.pred_set.BIGUNION_SING"
- "BIGUNION_INSERT" > "HOL4Base.pred_set.BIGUNION_INSERT"
- "BIGUNION_EMPTY" > "HOL4Base.pred_set.BIGUNION_EMPTY"
- "BIGUNION" > "HOL4Base.pred_set.BIGUNION"
- "BIGINTER_def" > "HOL4Base.pred_set.BIGINTER_def"
- "BIGINTER_SING" > "HOL4Base.pred_set.BIGINTER_SING"
- "BIGINTER_INTER" > "HOL4Base.pred_set.BIGINTER_INTER"
- "BIGINTER_INSERT" > "HOL4Base.pred_set.BIGINTER_INSERT"
- "BIGINTER_EMPTY" > "HOL4Base.pred_set.BIGINTER_EMPTY"
- "BIGINTER" > "HOL4Base.pred_set.BIGINTER"
- "ABSORPTION" > "HOL4Base.pred_set.ABSORPTION"
-
-end
--- a/src/HOL/Import/HOL4/Generated/prim_rec.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,72 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "wellfounded" > "wellfounded_primdef"
- "measure" > "measure_primdef"
- "SIMP_REC_REL" > "SIMP_REC_REL_def"
- "SIMP_REC" > "SIMP_REC_def"
- "PRIM_REC_FUN" > "PRIM_REC_FUN_def"
- "PRIM_REC" > "PRIM_REC_def"
- "PRE" > "PRE_def"
-
-const_maps
- "wellfounded" > "HOL4Base.prim_rec.wellfounded"
- "measure" > "HOL4Base.prim_rec.measure"
- "SIMP_REC_REL" > "HOL4Base.prim_rec.SIMP_REC_REL"
- "PRIM_REC_FUN" > "HOL4Base.prim_rec.PRIM_REC_FUN"
- "PRIM_REC" > "HOL4Base.prim_rec.PRIM_REC"
- "PRE" > "HOL4Base.prim_rec.PRE"
- "<" > "Orderings.ord_class.less" :: "nat => nat => bool"
-
-thm_maps
- "wellfounded_primdef" > "HOL4Base.prim_rec.wellfounded_primdef"
- "wellfounded_def" > "HOL4Base.prim_rec.wellfounded_def"
- "num_Axiom_old" > "HOL4Base.prim_rec.num_Axiom_old"
- "num_Axiom" > "HOL4Base.prim_rec.num_Axiom"
- "measure_thm" > "HOL4Base.prim_rec.measure_thm"
- "measure_primdef" > "HOL4Base.prim_rec.measure_primdef"
- "measure_def" > "HOL4Base.prim_rec.measure_def"
- "WF_measure" > "HOL4Base.prim_rec.WF_measure"
- "WF_PRED" > "HOL4Base.prim_rec.WF_PRED"
- "WF_LESS" > "HOL4Base.prim_rec.WF_LESS"
- "WF_IFF_WELLFOUNDED" > "HOL4Base.prim_rec.WF_IFF_WELLFOUNDED"
- "SUC_LESS" > "Nat.Suc_lessD"
- "SUC_ID" > "Nat.Suc_n_not_n"
- "SIMP_REC_THM" > "HOL4Base.prim_rec.SIMP_REC_THM"
- "SIMP_REC_REL_def" > "HOL4Base.prim_rec.SIMP_REC_REL_def"
- "SIMP_REC_REL_UNIQUE_RESULT" > "HOL4Base.prim_rec.SIMP_REC_REL_UNIQUE_RESULT"
- "SIMP_REC_REL_UNIQUE" > "HOL4Base.prim_rec.SIMP_REC_REL_UNIQUE"
- "SIMP_REC_REL" > "HOL4Base.prim_rec.SIMP_REC_REL"
- "SIMP_REC_EXISTS" > "HOL4Base.prim_rec.SIMP_REC_EXISTS"
- "SIMP_REC" > "HOL4Base.prim_rec.SIMP_REC"
- "PRIM_REC_def" > "HOL4Base.prim_rec.PRIM_REC_def"
- "PRIM_REC_THM" > "HOL4Base.prim_rec.PRIM_REC_THM"
- "PRIM_REC_FUN_def" > "HOL4Base.prim_rec.PRIM_REC_FUN_def"
- "PRIM_REC_FUN" > "HOL4Base.prim_rec.PRIM_REC_FUN"
- "PRIM_REC_EQN" > "HOL4Base.prim_rec.PRIM_REC_EQN"
- "PRIM_REC" > "HOL4Base.prim_rec.PRIM_REC"
- "PRE_def" > "HOL4Base.prim_rec.PRE_def"
- "PRE_DEF" > "HOL4Base.prim_rec.PRE_DEF"
- "PRE" > "HOL4Base.prim_rec.PRE"
- "NOT_LESS_EQ" > "HOL4Base.prim_rec.NOT_LESS_EQ"
- "NOT_LESS_0" > "Nat.not_less0"
- "LESS_THM" > "HOL4Base.prim_rec.LESS_THM"
- "LESS_SUC_SUC" > "HOL4Base.prim_rec.LESS_SUC_SUC"
- "LESS_SUC_REFL" > "Nat.lessI"
- "LESS_SUC_IMP" > "HOL4Base.prim_rec.LESS_SUC_IMP"
- "LESS_SUC" > "Nat.less_SucI"
- "LESS_REFL" > "Nat.less_not_refl"
- "LESS_NOT_EQ" > "Nat.less_not_refl3"
- "LESS_MONO" > "Nat.Suc_mono"
- "LESS_LEMMA2" > "HOL4Base.prim_rec.LESS_LEMMA2"
- "LESS_LEMMA1" > "HOL4Base.prim_rec.LESS_LEMMA1"
- "LESS_DEF" > "Compatibility.LESS_DEF"
- "LESS_0_0" > "HOL4Base.prim_rec.LESS_0_0"
- "LESS_0" > "Nat.zero_less_Suc"
- "INV_SUC_EQ" > "Nat.nat.inject"
- "EQ_LESS" > "HOL4Base.prim_rec.EQ_LESS"
- "DC" > "HOL4Base.prim_rec.DC"
-
-end
--- a/src/HOL/Import/HOL4/Generated/prime.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,17 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "prime" > "prime_primdef"
-
-const_maps
- "prime" > "HOL4Base.prime.prime"
-
-thm_maps
- "prime_primdef" > "HOL4Base.prime.prime_primdef"
- "prime_def" > "HOL4Base.prime.prime_def"
- "NOT_PRIME_1" > "HOL4Base.prime.NOT_PRIME_1"
- "NOT_PRIME_0" > "HOL4Base.prime.NOT_PRIME_0"
-
-end
--- a/src/HOL/Import/HOL4/Generated/prob.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,61 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "prob" > "prob_primdef"
- "algebra_measure" > "algebra_measure_primdef"
- "alg_measure" > "alg_measure_primdef"
-
-const_maps
- "prob" > "HOL4Prob.prob.prob"
- "algebra_measure" > "HOL4Prob.prob.algebra_measure"
-
-thm_maps
- "prob_primdef" > "HOL4Prob.prob.prob_primdef"
- "prob_def" > "HOL4Prob.prob.prob_def"
- "algebra_measure_primdef" > "HOL4Prob.prob.algebra_measure_primdef"
- "algebra_measure_def" > "HOL4Prob.prob.algebra_measure_def"
- "alg_measure_def" > "HOL4Prob.prob.alg_measure_def"
- "X_LE_PROB" > "HOL4Prob.prob.X_LE_PROB"
- "PROB_SUP_EXISTS2" > "HOL4Prob.prob.PROB_SUP_EXISTS2"
- "PROB_SUP_EXISTS1" > "HOL4Prob.prob.PROB_SUP_EXISTS1"
- "PROB_SUBSET_MONO" > "HOL4Prob.prob.PROB_SUBSET_MONO"
- "PROB_STL" > "HOL4Prob.prob.PROB_STL"
- "PROB_SHD" > "HOL4Prob.prob.PROB_SHD"
- "PROB_SDROP" > "HOL4Prob.prob.PROB_SDROP"
- "PROB_RANGE" > "HOL4Prob.prob.PROB_RANGE"
- "PROB_POS" > "HOL4Prob.prob.PROB_POS"
- "PROB_MAX" > "HOL4Prob.prob.PROB_MAX"
- "PROB_LE_X" > "HOL4Prob.prob.PROB_LE_X"
- "PROB_INTER_SHD" > "HOL4Prob.prob.PROB_INTER_SHD"
- "PROB_INTER_HALVES" > "HOL4Prob.prob.PROB_INTER_HALVES"
- "PROB_COMPL_LE1" > "HOL4Prob.prob.PROB_COMPL_LE1"
- "PROB_COMPL" > "HOL4Prob.prob.PROB_COMPL"
- "PROB_BASIC" > "HOL4Prob.prob.PROB_BASIC"
- "PROB_ALGEBRA" > "HOL4Prob.prob.PROB_ALGEBRA"
- "PROB_ALG" > "HOL4Prob.prob.PROB_ALG"
- "PROB_ADDITIVE" > "HOL4Prob.prob.PROB_ADDITIVE"
- "ALG_TWINS_MEASURE" > "HOL4Prob.prob.ALG_TWINS_MEASURE"
- "ALG_MEASURE_TLS" > "HOL4Prob.prob.ALG_MEASURE_TLS"
- "ALG_MEASURE_POS" > "HOL4Prob.prob.ALG_MEASURE_POS"
- "ALG_MEASURE_COMPL" > "HOL4Prob.prob.ALG_MEASURE_COMPL"
- "ALG_MEASURE_BASIC" > "HOL4Prob.prob.ALG_MEASURE_BASIC"
- "ALG_MEASURE_APPEND" > "HOL4Prob.prob.ALG_MEASURE_APPEND"
- "ALG_MEASURE_ADDITIVE" > "HOL4Prob.prob.ALG_MEASURE_ADDITIVE"
- "ALG_CANON_PREFS_MONO" > "HOL4Prob.prob.ALG_CANON_PREFS_MONO"
- "ALG_CANON_MONO" > "HOL4Prob.prob.ALG_CANON_MONO"
- "ALG_CANON_MERGE_MONO" > "HOL4Prob.prob.ALG_CANON_MERGE_MONO"
- "ALG_CANON_FIND_MONO" > "HOL4Prob.prob.ALG_CANON_FIND_MONO"
- "ALG_CANON2_MONO" > "HOL4Prob.prob.ALG_CANON2_MONO"
- "ALG_CANON1_MONO" > "HOL4Prob.prob.ALG_CANON1_MONO"
- "ALGEBRA_MEASURE_RANGE" > "HOL4Prob.prob.ALGEBRA_MEASURE_RANGE"
- "ALGEBRA_MEASURE_POS" > "HOL4Prob.prob.ALGEBRA_MEASURE_POS"
- "ALGEBRA_MEASURE_MONO_EMBED" > "HOL4Prob.prob.ALGEBRA_MEASURE_MONO_EMBED"
- "ALGEBRA_MEASURE_MAX" > "HOL4Prob.prob.ALGEBRA_MEASURE_MAX"
- "ALGEBRA_MEASURE_DEF_ALT" > "HOL4Prob.prob.ALGEBRA_MEASURE_DEF_ALT"
- "ALGEBRA_MEASURE_BASIC" > "HOL4Prob.prob.ALGEBRA_MEASURE_BASIC"
- "ALGEBRA_CANON_MEASURE_MAX" > "HOL4Prob.prob.ALGEBRA_CANON_MEASURE_MAX"
- "ABS_PROB" > "HOL4Prob.prob.ABS_PROB"
-
-end
--- a/src/HOL/Import/HOL4/Generated/prob_algebra.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,54 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "measurable" > "measurable_primdef"
- "algebra_embed" > "algebra_embed_primdef"
- "alg_embed" > "alg_embed_primdef"
-
-const_maps
- "measurable" > "HOL4Prob.prob_algebra.measurable"
-
-thm_maps
- "measurable_primdef" > "HOL4Prob.prob_algebra.measurable_primdef"
- "measurable_def" > "HOL4Prob.prob_algebra.measurable_def"
- "algebra_embed_def" > "HOL4Prob.prob_algebra.algebra_embed_def"
- "alg_embed_def" > "HOL4Prob.prob_algebra.alg_embed_def"
- "MEASURABLE_UNION" > "HOL4Prob.prob_algebra.MEASURABLE_UNION"
- "MEASURABLE_STL" > "HOL4Prob.prob_algebra.MEASURABLE_STL"
- "MEASURABLE_SHD" > "HOL4Prob.prob_algebra.MEASURABLE_SHD"
- "MEASURABLE_SDROP" > "HOL4Prob.prob_algebra.MEASURABLE_SDROP"
- "MEASURABLE_INTER_SHD" > "HOL4Prob.prob_algebra.MEASURABLE_INTER_SHD"
- "MEASURABLE_INTER_HALVES" > "HOL4Prob.prob_algebra.MEASURABLE_INTER_HALVES"
- "MEASURABLE_INTER" > "HOL4Prob.prob_algebra.MEASURABLE_INTER"
- "MEASURABLE_HALVES" > "HOL4Prob.prob_algebra.MEASURABLE_HALVES"
- "MEASURABLE_COMPL" > "HOL4Prob.prob_algebra.MEASURABLE_COMPL"
- "MEASURABLE_BASIC" > "HOL4Prob.prob_algebra.MEASURABLE_BASIC"
- "MEASURABLE_ALGEBRA" > "HOL4Prob.prob_algebra.MEASURABLE_ALGEBRA"
- "INTER_STL" > "HOL4Prob.prob_algebra.INTER_STL"
- "HALVES_INTER" > "HOL4Prob.prob_algebra.HALVES_INTER"
- "COMPL_SHD" > "HOL4Prob.prob_algebra.COMPL_SHD"
- "ALG_EMBED_TWINS" > "HOL4Prob.prob_algebra.ALG_EMBED_TWINS"
- "ALG_EMBED_PREFIX_SUBSET" > "HOL4Prob.prob_algebra.ALG_EMBED_PREFIX_SUBSET"
- "ALG_EMBED_PREFIX" > "HOL4Prob.prob_algebra.ALG_EMBED_PREFIX"
- "ALG_EMBED_POPULATED" > "HOL4Prob.prob_algebra.ALG_EMBED_POPULATED"
- "ALG_EMBED_NIL" > "HOL4Prob.prob_algebra.ALG_EMBED_NIL"
- "ALG_EMBED_BASIC" > "HOL4Prob.prob_algebra.ALG_EMBED_BASIC"
- "ALG_CANON_REP" > "HOL4Prob.prob_algebra.ALG_CANON_REP"
- "ALG_CANON_PREFS_EMBED" > "HOL4Prob.prob_algebra.ALG_CANON_PREFS_EMBED"
- "ALG_CANON_MERGE_EMBED" > "HOL4Prob.prob_algebra.ALG_CANON_MERGE_EMBED"
- "ALG_CANON_FIND_EMBED" > "HOL4Prob.prob_algebra.ALG_CANON_FIND_EMBED"
- "ALG_CANON_EMBED" > "HOL4Prob.prob_algebra.ALG_CANON_EMBED"
- "ALG_CANON2_EMBED" > "HOL4Prob.prob_algebra.ALG_CANON2_EMBED"
- "ALG_CANON1_EMBED" > "HOL4Prob.prob_algebra.ALG_CANON1_EMBED"
- "ALGEBRA_EMBED_TLS" > "HOL4Prob.prob_algebra.ALGEBRA_EMBED_TLS"
- "ALGEBRA_EMBED_MEM" > "HOL4Prob.prob_algebra.ALGEBRA_EMBED_MEM"
- "ALGEBRA_EMBED_COMPL" > "HOL4Prob.prob_algebra.ALGEBRA_EMBED_COMPL"
- "ALGEBRA_EMBED_BASIC" > "HOL4Prob.prob_algebra.ALGEBRA_EMBED_BASIC"
- "ALGEBRA_EMBED_APPEND" > "HOL4Prob.prob_algebra.ALGEBRA_EMBED_APPEND"
- "ALGEBRA_CANON_UNIV" > "HOL4Prob.prob_algebra.ALGEBRA_CANON_UNIV"
- "ALGEBRA_CANON_EMBED_UNIV" > "HOL4Prob.prob_algebra.ALGEBRA_CANON_EMBED_UNIV"
- "ALGEBRA_CANON_EMBED_EMPTY" > "HOL4Prob.prob_algebra.ALGEBRA_CANON_EMBED_EMPTY"
-
-end
--- a/src/HOL/Import/HOL4/Generated/prob_canon.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,147 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "algebra_canon" > "algebra_canon_primdef"
- "alg_twinfree" > "alg_twinfree_primdef"
- "alg_twin" > "alg_twin_primdef"
- "alg_sorted" > "alg_sorted_primdef"
- "alg_prefixfree" > "alg_prefixfree_primdef"
- "alg_order_tupled" > "alg_order_tupled_def"
- "alg_order" > "alg_order_primdef"
- "alg_longest" > "alg_longest_primdef"
- "alg_canon_prefs" > "alg_canon_prefs_primdef"
- "alg_canon_merge" > "alg_canon_merge_primdef"
- "alg_canon_find" > "alg_canon_find_primdef"
- "alg_canon2" > "alg_canon2_primdef"
- "alg_canon1" > "alg_canon1_primdef"
- "alg_canon" > "alg_canon_primdef"
-
-const_maps
- "algebra_canon" > "HOL4Prob.prob_canon.algebra_canon"
- "alg_twinfree" > "HOL4Prob.prob_canon.alg_twinfree"
- "alg_twin" > "HOL4Prob.prob_canon.alg_twin"
- "alg_sorted" > "HOL4Prob.prob_canon.alg_sorted"
- "alg_prefixfree" > "HOL4Prob.prob_canon.alg_prefixfree"
- "alg_order_tupled" > "HOL4Prob.prob_canon.alg_order_tupled"
- "alg_order" > "HOL4Prob.prob_canon.alg_order"
- "alg_longest" > "HOL4Prob.prob_canon.alg_longest"
- "alg_canon2" > "HOL4Prob.prob_canon.alg_canon2"
- "alg_canon1" > "HOL4Prob.prob_canon.alg_canon1"
- "alg_canon" > "HOL4Prob.prob_canon.alg_canon"
-
-thm_maps
- "algebra_canon_primdef" > "HOL4Prob.prob_canon.algebra_canon_primdef"
- "algebra_canon_def" > "HOL4Prob.prob_canon.algebra_canon_def"
- "alg_twinfree_primitive_def" > "HOL4Prob.prob_canon.alg_twinfree_primitive_def"
- "alg_twinfree_primdef" > "HOL4Prob.prob_canon.alg_twinfree_primdef"
- "alg_twinfree_ind" > "HOL4Prob.prob_canon.alg_twinfree_ind"
- "alg_twinfree_def" > "HOL4Prob.prob_canon.alg_twinfree_def"
- "alg_twin_primdef" > "HOL4Prob.prob_canon.alg_twin_primdef"
- "alg_twin_def" > "HOL4Prob.prob_canon.alg_twin_def"
- "alg_sorted_primitive_def" > "HOL4Prob.prob_canon.alg_sorted_primitive_def"
- "alg_sorted_primdef" > "HOL4Prob.prob_canon.alg_sorted_primdef"
- "alg_sorted_ind" > "HOL4Prob.prob_canon.alg_sorted_ind"
- "alg_sorted_def" > "HOL4Prob.prob_canon.alg_sorted_def"
- "alg_prefixfree_primitive_def" > "HOL4Prob.prob_canon.alg_prefixfree_primitive_def"
- "alg_prefixfree_primdef" > "HOL4Prob.prob_canon.alg_prefixfree_primdef"
- "alg_prefixfree_ind" > "HOL4Prob.prob_canon.alg_prefixfree_ind"
- "alg_prefixfree_def" > "HOL4Prob.prob_canon.alg_prefixfree_def"
- "alg_order_tupled_primitive_def" > "HOL4Prob.prob_canon.alg_order_tupled_primitive_def"
- "alg_order_tupled_def" > "HOL4Prob.prob_canon.alg_order_tupled_def"
- "alg_order_primdef" > "HOL4Prob.prob_canon.alg_order_primdef"
- "alg_order_ind" > "HOL4Prob.prob_canon.alg_order_ind"
- "alg_order_def" > "HOL4Prob.prob_canon.alg_order_def"
- "alg_order_curried_def" > "HOL4Prob.prob_canon.alg_order_curried_def"
- "alg_longest_primdef" > "HOL4Prob.prob_canon.alg_longest_primdef"
- "alg_longest_def" > "HOL4Prob.prob_canon.alg_longest_def"
- "alg_canon_primdef" > "HOL4Prob.prob_canon.alg_canon_primdef"
- "alg_canon_prefs_def" > "HOL4Prob.prob_canon.alg_canon_prefs_def"
- "alg_canon_merge_def" > "HOL4Prob.prob_canon.alg_canon_merge_def"
- "alg_canon_find_def" > "HOL4Prob.prob_canon.alg_canon_find_def"
- "alg_canon_def" > "HOL4Prob.prob_canon.alg_canon_def"
- "alg_canon2_primdef" > "HOL4Prob.prob_canon.alg_canon2_primdef"
- "alg_canon2_def" > "HOL4Prob.prob_canon.alg_canon2_def"
- "alg_canon1_primdef" > "HOL4Prob.prob_canon.alg_canon1_primdef"
- "alg_canon1_def" > "HOL4Prob.prob_canon.alg_canon1_def"
- "MEM_NIL_STEP" > "HOL4Prob.prob_canon.MEM_NIL_STEP"
- "ALG_TWIN_SING" > "HOL4Prob.prob_canon.ALG_TWIN_SING"
- "ALG_TWIN_REDUCE" > "HOL4Prob.prob_canon.ALG_TWIN_REDUCE"
- "ALG_TWIN_NIL" > "HOL4Prob.prob_canon.ALG_TWIN_NIL"
- "ALG_TWIN_CONS" > "HOL4Prob.prob_canon.ALG_TWIN_CONS"
- "ALG_TWINS_PREFIX" > "HOL4Prob.prob_canon.ALG_TWINS_PREFIX"
- "ALG_TWINFREE_TLS" > "HOL4Prob.prob_canon.ALG_TWINFREE_TLS"
- "ALG_TWINFREE_TL" > "HOL4Prob.prob_canon.ALG_TWINFREE_TL"
- "ALG_TWINFREE_STEP2" > "HOL4Prob.prob_canon.ALG_TWINFREE_STEP2"
- "ALG_TWINFREE_STEP1" > "HOL4Prob.prob_canon.ALG_TWINFREE_STEP1"
- "ALG_TWINFREE_STEP" > "HOL4Prob.prob_canon.ALG_TWINFREE_STEP"
- "ALG_SORTED_TLS" > "HOL4Prob.prob_canon.ALG_SORTED_TLS"
- "ALG_SORTED_TL" > "HOL4Prob.prob_canon.ALG_SORTED_TL"
- "ALG_SORTED_STEP" > "HOL4Prob.prob_canon.ALG_SORTED_STEP"
- "ALG_SORTED_PREFIXFREE_MEM_NIL" > "HOL4Prob.prob_canon.ALG_SORTED_PREFIXFREE_MEM_NIL"
- "ALG_SORTED_PREFIXFREE_EQUALITY" > "HOL4Prob.prob_canon.ALG_SORTED_PREFIXFREE_EQUALITY"
- "ALG_SORTED_MONO" > "HOL4Prob.prob_canon.ALG_SORTED_MONO"
- "ALG_SORTED_MIN" > "HOL4Prob.prob_canon.ALG_SORTED_MIN"
- "ALG_SORTED_FILTER" > "HOL4Prob.prob_canon.ALG_SORTED_FILTER"
- "ALG_SORTED_DEF_ALT" > "HOL4Prob.prob_canon.ALG_SORTED_DEF_ALT"
- "ALG_SORTED_APPEND" > "HOL4Prob.prob_canon.ALG_SORTED_APPEND"
- "ALG_PREFIXFREE_TLS" > "HOL4Prob.prob_canon.ALG_PREFIXFREE_TLS"
- "ALG_PREFIXFREE_TL" > "HOL4Prob.prob_canon.ALG_PREFIXFREE_TL"
- "ALG_PREFIXFREE_STEP" > "HOL4Prob.prob_canon.ALG_PREFIXFREE_STEP"
- "ALG_PREFIXFREE_MONO" > "HOL4Prob.prob_canon.ALG_PREFIXFREE_MONO"
- "ALG_PREFIXFREE_FILTER" > "HOL4Prob.prob_canon.ALG_PREFIXFREE_FILTER"
- "ALG_PREFIXFREE_ELT" > "HOL4Prob.prob_canon.ALG_PREFIXFREE_ELT"
- "ALG_PREFIXFREE_APPEND" > "HOL4Prob.prob_canon.ALG_PREFIXFREE_APPEND"
- "ALG_ORDER_TRANS" > "HOL4Prob.prob_canon.ALG_ORDER_TRANS"
- "ALG_ORDER_TOTAL" > "HOL4Prob.prob_canon.ALG_ORDER_TOTAL"
- "ALG_ORDER_SNOC" > "HOL4Prob.prob_canon.ALG_ORDER_SNOC"
- "ALG_ORDER_REFL" > "HOL4Prob.prob_canon.ALG_ORDER_REFL"
- "ALG_ORDER_PREFIX_TRANS" > "HOL4Prob.prob_canon.ALG_ORDER_PREFIX_TRANS"
- "ALG_ORDER_PREFIX_MONO" > "HOL4Prob.prob_canon.ALG_ORDER_PREFIX_MONO"
- "ALG_ORDER_PREFIX_ANTI" > "HOL4Prob.prob_canon.ALG_ORDER_PREFIX_ANTI"
- "ALG_ORDER_PREFIX" > "HOL4Prob.prob_canon.ALG_ORDER_PREFIX"
- "ALG_ORDER_NIL" > "HOL4Prob.prob_canon.ALG_ORDER_NIL"
- "ALG_ORDER_ANTISYM" > "HOL4Prob.prob_canon.ALG_ORDER_ANTISYM"
- "ALG_LONGEST_TLS" > "HOL4Prob.prob_canon.ALG_LONGEST_TLS"
- "ALG_LONGEST_TL" > "HOL4Prob.prob_canon.ALG_LONGEST_TL"
- "ALG_LONGEST_HD" > "HOL4Prob.prob_canon.ALG_LONGEST_HD"
- "ALG_LONGEST_APPEND" > "HOL4Prob.prob_canon.ALG_LONGEST_APPEND"
- "ALG_CANON_SORTED_PREFIXFREE_TWINFREE" > "HOL4Prob.prob_canon.ALG_CANON_SORTED_PREFIXFREE_TWINFREE"
- "ALG_CANON_PREFS_SORTED" > "HOL4Prob.prob_canon.ALG_CANON_PREFS_SORTED"
- "ALG_CANON_PREFS_PREFIXFREE" > "HOL4Prob.prob_canon.ALG_CANON_PREFS_PREFIXFREE"
- "ALG_CANON_PREFS_HD" > "HOL4Prob.prob_canon.ALG_CANON_PREFS_HD"
- "ALG_CANON_PREFS_DELETES" > "HOL4Prob.prob_canon.ALG_CANON_PREFS_DELETES"
- "ALG_CANON_PREFS_CONSTANT" > "HOL4Prob.prob_canon.ALG_CANON_PREFS_CONSTANT"
- "ALG_CANON_MERGE_SORTED_PREFIXFREE_TWINFREE" > "HOL4Prob.prob_canon.ALG_CANON_MERGE_SORTED_PREFIXFREE_TWINFREE"
- "ALG_CANON_MERGE_SHORTENS" > "HOL4Prob.prob_canon.ALG_CANON_MERGE_SHORTENS"
- "ALG_CANON_MERGE_PREFIXFREE_PRESERVE" > "HOL4Prob.prob_canon.ALG_CANON_MERGE_PREFIXFREE_PRESERVE"
- "ALG_CANON_MERGE_CONSTANT" > "HOL4Prob.prob_canon.ALG_CANON_MERGE_CONSTANT"
- "ALG_CANON_IDEMPOT" > "HOL4Prob.prob_canon.ALG_CANON_IDEMPOT"
- "ALG_CANON_FIND_SORTED" > "HOL4Prob.prob_canon.ALG_CANON_FIND_SORTED"
- "ALG_CANON_FIND_PREFIXFREE" > "HOL4Prob.prob_canon.ALG_CANON_FIND_PREFIXFREE"
- "ALG_CANON_FIND_HD" > "HOL4Prob.prob_canon.ALG_CANON_FIND_HD"
- "ALG_CANON_FIND_DELETES" > "HOL4Prob.prob_canon.ALG_CANON_FIND_DELETES"
- "ALG_CANON_FIND_CONSTANT" > "HOL4Prob.prob_canon.ALG_CANON_FIND_CONSTANT"
- "ALG_CANON_CONSTANT" > "HOL4Prob.prob_canon.ALG_CANON_CONSTANT"
- "ALG_CANON_BASIC" > "HOL4Prob.prob_canon.ALG_CANON_BASIC"
- "ALG_CANON2_SORTED_PREFIXFREE_TWINFREE" > "HOL4Prob.prob_canon.ALG_CANON2_SORTED_PREFIXFREE_TWINFREE"
- "ALG_CANON2_SHORTENS" > "HOL4Prob.prob_canon.ALG_CANON2_SHORTENS"
- "ALG_CANON2_PREFIXFREE_PRESERVE" > "HOL4Prob.prob_canon.ALG_CANON2_PREFIXFREE_PRESERVE"
- "ALG_CANON2_CONSTANT" > "HOL4Prob.prob_canon.ALG_CANON2_CONSTANT"
- "ALG_CANON1_SORTED" > "HOL4Prob.prob_canon.ALG_CANON1_SORTED"
- "ALG_CANON1_PREFIXFREE" > "HOL4Prob.prob_canon.ALG_CANON1_PREFIXFREE"
- "ALG_CANON1_CONSTANT" > "HOL4Prob.prob_canon.ALG_CANON1_CONSTANT"
- "ALGEBRA_CANON_TLS" > "HOL4Prob.prob_canon.ALGEBRA_CANON_TLS"
- "ALGEBRA_CANON_TL" > "HOL4Prob.prob_canon.ALGEBRA_CANON_TL"
- "ALGEBRA_CANON_STEP2" > "HOL4Prob.prob_canon.ALGEBRA_CANON_STEP2"
- "ALGEBRA_CANON_STEP1" > "HOL4Prob.prob_canon.ALGEBRA_CANON_STEP1"
- "ALGEBRA_CANON_STEP" > "HOL4Prob.prob_canon.ALGEBRA_CANON_STEP"
- "ALGEBRA_CANON_NIL_MEM" > "HOL4Prob.prob_canon.ALGEBRA_CANON_NIL_MEM"
- "ALGEBRA_CANON_INDUCTION" > "HOL4Prob.prob_canon.ALGEBRA_CANON_INDUCTION"
- "ALGEBRA_CANON_DEF_ALT" > "HOL4Prob.prob_canon.ALGEBRA_CANON_DEF_ALT"
- "ALGEBRA_CANON_CASES_THM" > "HOL4Prob.prob_canon.ALGEBRA_CANON_CASES_THM"
- "ALGEBRA_CANON_CASES" > "HOL4Prob.prob_canon.ALGEBRA_CANON_CASES"
- "ALGEBRA_CANON_BASIC" > "HOL4Prob.prob_canon.ALGEBRA_CANON_BASIC"
-
-end
--- a/src/HOL/Import/HOL4/Generated/prob_extra.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,96 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "inf" > "inf_primdef"
-
-const_maps
- "inf" > "HOL4Prob.prob_extra.inf"
- "COMPL" > "HOL4Base.pred_set.COMPL"
-
-thm_maps
- "inf_primdef" > "HOL4Prob.prob_extra.inf_primdef"
- "inf_def" > "HOL4Prob.prob_extra.inf_def"
- "X_HALF_HALF" > "HOL4Prob.prob_extra.X_HALF_HALF"
- "UNION_DISJOINT_SPLIT" > "HOL4Prob.prob_extra.UNION_DISJOINT_SPLIT"
- "UNION_DEF_ALT" > "HOL4Prob.prob_extra.UNION_DEF_ALT"
- "SUBSET_EQ_DECOMP" > "HOL4Base.pred_set.SUBSET_ANTISYM"
- "SUBSET_EQ" > "HOL4Prob.prob_extra.SUBSET_EQ"
- "SET_EQ_EXT" > "HOL4Base.pred_set.EXTENSION"
- "REAL_X_LE_SUP" > "HOL4Prob.prob_extra.REAL_X_LE_SUP"
- "REAL_SUP_MAX" > "HOL4Prob.prob_extra.REAL_SUP_MAX"
- "REAL_SUP_LE_X" > "HOL4Prob.prob_extra.REAL_SUP_LE_X"
- "REAL_SUP_EXISTS_UNIQUE" > "HOL4Prob.prob_extra.REAL_SUP_EXISTS_UNIQUE"
- "REAL_POW" > "RealDef.power_real_of_nat"
- "REAL_LE_INV_LE" > "Fields.linordered_field_class.le_imp_inverse_le"
- "REAL_LE_EQ" > "Orderings.order_antisym"
- "REAL_INVINV_ALL" > "Fields.division_ring_inverse_zero_class.inverse_inverse_eq"
- "REAL_INF_MIN" > "HOL4Prob.prob_extra.REAL_INF_MIN"
- "RAND_THM" > "HOL.arg_cong"
- "POW_HALF_TWICE" > "HOL4Prob.prob_extra.POW_HALF_TWICE"
- "POW_HALF_POS" > "HOL4Prob.prob_extra.POW_HALF_POS"
- "POW_HALF_MONO" > "HOL4Prob.prob_extra.POW_HALF_MONO"
- "POW_HALF_EXP" > "HOL4Prob.prob_extra.POW_HALF_EXP"
- "ONE_MINUS_HALF" > "HOL4Prob.prob_extra.ONE_MINUS_HALF"
- "MOD_TWO" > "HOL4Prob.prob_extra.MOD_TWO"
- "MEM_NIL_MAP_CONS" > "HOL4Prob.prob_extra.MEM_NIL_MAP_CONS"
- "MEM_NIL" > "HOL4Prob.prob_extra.MEM_NIL"
- "MEM_FILTER" > "HOL4Prob.prob_extra.MEM_FILTER"
- "MAP_MEM" > "HOL4Prob.prob_extra.MAP_MEM"
- "MAP_ID" > "List.map_ident"
- "LENGTH_FILTER" > "List.length_filter_le"
- "LAST_MEM" > "HOL4Prob.prob_extra.LAST_MEM"
- "LAST_MAP_CONS" > "HOL4Prob.prob_extra.LAST_MAP_CONS"
- "IS_PREFIX_TRANS" > "HOL4Prob.prob_extra.IS_PREFIX_TRANS"
- "IS_PREFIX_SNOC" > "HOL4Prob.prob_extra.IS_PREFIX_SNOC"
- "IS_PREFIX_REFL" > "HOL4Prob.prob_extra.IS_PREFIX_REFL"
- "IS_PREFIX_NIL" > "HOL4Prob.prob_extra.IS_PREFIX_NIL"
- "IS_PREFIX_LENGTH_ANTI" > "HOL4Prob.prob_extra.IS_PREFIX_LENGTH_ANTI"
- "IS_PREFIX_LENGTH" > "HOL4Prob.prob_extra.IS_PREFIX_LENGTH"
- "IS_PREFIX_BUTLAST" > "HOL4Prob.prob_extra.IS_PREFIX_BUTLAST"
- "IS_PREFIX_ANTISYM" > "HOL4Prob.prob_extra.IS_PREFIX_ANTISYM"
- "IN_EMPTY" > "HOL4Base.pred_set.NOT_IN_EMPTY"
- "IN_COMPL" > "HOL4Base.pred_set.IN_COMPL"
- "INV_SUC_POS" > "HOL4Prob.prob_extra.INV_SUC_POS"
- "INV_SUC_MAX" > "HOL4Prob.prob_extra.INV_SUC_MAX"
- "INV_SUC" > "HOL4Prob.prob_extra.INV_SUC"
- "INTER_UNION_RDISTRIB" > "HOL4Prob.prob_extra.INTER_UNION_RDISTRIB"
- "INTER_UNION_COMPL" > "HOL4Base.pred_set.INTER_UNION_COMPL"
- "INTER_IS_EMPTY" > "HOL4Prob.prob_extra.INTER_IS_EMPTY"
- "INF_DEF_ALT" > "HOL4Prob.prob_extra.INF_DEF_ALT"
- "HALF_POS" > "Series.half"
- "HALF_LT_1" > "HOL4Prob.prob_extra.HALF_LT_1"
- "HALF_CANCEL" > "HOL4Prob.prob_extra.HALF_CANCEL"
- "GSPEC_DEF_ALT" > "HOL4Prob.prob_extra.GSPEC_DEF_ALT"
- "FOLDR_MAP" > "HOL4Prob.prob_extra.FOLDR_MAP"
- "FILTER_TRUE" > "HOL4Prob.prob_extra.FILTER_TRUE"
- "FILTER_OUT_ELT" > "HOL4Prob.prob_extra.FILTER_OUT_ELT"
- "FILTER_MEM" > "HOL4Prob.prob_extra.FILTER_MEM"
- "FILTER_FALSE" > "HOL4Prob.prob_extra.FILTER_FALSE"
- "EXP_DIV_TWO" > "HOL4Prob.prob_extra.EXP_DIV_TWO"
- "EXISTS_LONGEST" > "HOL4Prob.prob_extra.EXISTS_LONGEST"
- "EVEN_ODD_EXISTS_EQ" > "HOL4Prob.prob_extra.EVEN_ODD_EXISTS_EQ"
- "EVEN_ODD_BASIC" > "HOL4Prob.prob_extra.EVEN_ODD_BASIC"
- "EVEN_EXP_TWO" > "HOL4Prob.prob_extra.EVEN_EXP_TWO"
- "EQ_EXT_EQ" > "HOL.fun_eq_iff"
- "DIV_TWO_UNIQUE" > "HOL4Prob.prob_extra.DIV_TWO_UNIQUE"
- "DIV_TWO_MONO_EVEN" > "HOL4Prob.prob_extra.DIV_TWO_MONO_EVEN"
- "DIV_TWO_MONO" > "HOL4Prob.prob_extra.DIV_TWO_MONO"
- "DIV_TWO_EXP" > "HOL4Prob.prob_extra.DIV_TWO_EXP"
- "DIV_TWO_CANCEL" > "HOL4Prob.prob_extra.DIV_TWO_CANCEL"
- "DIV_TWO_BASIC" > "HOL4Prob.prob_extra.DIV_TWO_BASIC"
- "DIV_TWO" > "HOL4Prob.prob_extra.DIV_TWO"
- "DIV_THEN_MULT" > "HOL4Prob.prob_extra.DIV_THEN_MULT"
- "DIVISION_TWO" > "HOL4Prob.prob_extra.DIVISION_TWO"
- "COMPL_def" > "HOL4Base.pred_set.COMPL_DEF"
- "COMPL_SPLITS" > "HOL4Base.pred_set.COMPL_SPLITS"
- "COMPL_COMPL" > "HOL4Base.pred_set.COMPL_COMPL"
- "COMPL_CLAUSES" > "HOL4Base.pred_set.COMPL_CLAUSES"
- "BOOL_BOOL_CASES_THM" > "HOL4Prob.prob_extra.BOOL_BOOL_CASES_THM"
- "BOOL_BOOL_CASES" > "HOL4Base.bool.BOOL_FUN_INDUCT"
- "APPEND_MEM" > "HOL4Base.list.MEM_APPEND"
- "ABS_UNIT_INTERVAL" > "HOL4Prob.prob_extra.ABS_UNIT_INTERVAL"
- "ABS_BETWEEN_LE" > "HOL4Prob.prob_extra.ABS_BETWEEN_LE"
-
-end
--- a/src/HOL/Import/HOL4/Generated/prob_indep.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,56 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "indep_set" > "indep_set_primdef"
- "indep" > "indep_primdef"
- "alg_cover_set" > "alg_cover_set_primdef"
- "alg_cover" > "alg_cover_primdef"
-
-const_maps
- "indep_set" > "HOL4Prob.prob_indep.indep_set"
- "indep" > "HOL4Prob.prob_indep.indep"
- "alg_cover_set" > "HOL4Prob.prob_indep.alg_cover_set"
- "alg_cover" > "HOL4Prob.prob_indep.alg_cover"
-
-thm_maps
- "indep_set_primdef" > "HOL4Prob.prob_indep.indep_set_primdef"
- "indep_set_def" > "HOL4Prob.prob_indep.indep_set_def"
- "indep_primdef" > "HOL4Prob.prob_indep.indep_primdef"
- "indep_def" > "HOL4Prob.prob_indep.indep_def"
- "alg_cover_set_primdef" > "HOL4Prob.prob_indep.alg_cover_set_primdef"
- "alg_cover_set_def" > "HOL4Prob.prob_indep.alg_cover_set_def"
- "alg_cover_primdef" > "HOL4Prob.prob_indep.alg_cover_primdef"
- "alg_cover_def" > "HOL4Prob.prob_indep.alg_cover_def"
- "PROB_INDEP_BOUND" > "HOL4Prob.prob_indep.PROB_INDEP_BOUND"
- "MAP_CONS_TL_FILTER" > "HOL4Prob.prob_indep.MAP_CONS_TL_FILTER"
- "INDEP_UNIT" > "HOL4Prob.prob_indep.INDEP_UNIT"
- "INDEP_SET_SYM" > "HOL4Prob.prob_indep.INDEP_SET_SYM"
- "INDEP_SET_LIST" > "HOL4Prob.prob_indep.INDEP_SET_LIST"
- "INDEP_SET_DISJOINT_DECOMP" > "HOL4Prob.prob_indep.INDEP_SET_DISJOINT_DECOMP"
- "INDEP_SET_BASIC" > "HOL4Prob.prob_indep.INDEP_SET_BASIC"
- "INDEP_SDEST" > "HOL4Prob.prob_indep.INDEP_SDEST"
- "INDEP_PROB" > "HOL4Prob.prob_indep.INDEP_PROB"
- "INDEP_MEASURABLE2" > "HOL4Prob.prob_indep.INDEP_MEASURABLE2"
- "INDEP_MEASURABLE1" > "HOL4Prob.prob_indep.INDEP_MEASURABLE1"
- "INDEP_INDEP_SET_LEMMA" > "HOL4Prob.prob_indep.INDEP_INDEP_SET_LEMMA"
- "INDEP_INDEP_SET" > "HOL4Prob.prob_indep.INDEP_INDEP_SET"
- "INDEP_BIND_SDEST" > "HOL4Prob.prob_indep.INDEP_BIND_SDEST"
- "INDEP_BIND" > "HOL4Prob.prob_indep.INDEP_BIND"
- "BIND_STEP" > "HOL4Prob.prob_indep.BIND_STEP"
- "ALG_COVER_WELL_DEFINED" > "HOL4Prob.prob_indep.ALG_COVER_WELL_DEFINED"
- "ALG_COVER_UNIV" > "HOL4Prob.prob_indep.ALG_COVER_UNIV"
- "ALG_COVER_UNIQUE" > "HOL4Prob.prob_indep.ALG_COVER_UNIQUE"
- "ALG_COVER_TAIL_STEP" > "HOL4Prob.prob_indep.ALG_COVER_TAIL_STEP"
- "ALG_COVER_TAIL_PROB" > "HOL4Prob.prob_indep.ALG_COVER_TAIL_PROB"
- "ALG_COVER_TAIL_MEASURABLE" > "HOL4Prob.prob_indep.ALG_COVER_TAIL_MEASURABLE"
- "ALG_COVER_STEP" > "HOL4Prob.prob_indep.ALG_COVER_STEP"
- "ALG_COVER_SET_INDUCTION" > "HOL4Prob.prob_indep.ALG_COVER_SET_INDUCTION"
- "ALG_COVER_SET_CASES_THM" > "HOL4Prob.prob_indep.ALG_COVER_SET_CASES_THM"
- "ALG_COVER_SET_CASES" > "HOL4Prob.prob_indep.ALG_COVER_SET_CASES"
- "ALG_COVER_SET_BASIC" > "HOL4Prob.prob_indep.ALG_COVER_SET_BASIC"
- "ALG_COVER_HEAD" > "HOL4Prob.prob_indep.ALG_COVER_HEAD"
- "ALG_COVER_EXISTS_UNIQUE" > "HOL4Prob.prob_indep.ALG_COVER_EXISTS_UNIQUE"
-
-end
--- a/src/HOL/Import/HOL4/Generated/prob_pseudo.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,26 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "pseudo_linear_tl" > "pseudo_linear_tl_primdef"
- "pseudo_linear_hd" > "pseudo_linear_hd_primdef"
- "pseudo_linear1" > "pseudo_linear1_primdef"
- "pseudo" > "pseudo_primdef"
-
-const_maps
- "pseudo_linear_tl" > "HOL4Prob.prob_pseudo.pseudo_linear_tl"
- "pseudo_linear_hd" > "HOL4Prob.prob_pseudo.pseudo_linear_hd"
- "pseudo" > "HOL4Prob.prob_pseudo.pseudo"
-
-thm_maps
- "pseudo_primdef" > "HOL4Prob.prob_pseudo.pseudo_primdef"
- "pseudo_linear_tl_primdef" > "HOL4Prob.prob_pseudo.pseudo_linear_tl_primdef"
- "pseudo_linear_tl_def" > "HOL4Prob.prob_pseudo.pseudo_linear_tl_def"
- "pseudo_linear_hd_primdef" > "HOL4Prob.prob_pseudo.pseudo_linear_hd_primdef"
- "pseudo_linear_hd_def" > "HOL4Prob.prob_pseudo.pseudo_linear_hd_def"
- "pseudo_linear1_def" > "HOL4Prob.prob_pseudo.pseudo_linear1_def"
- "pseudo_def" > "HOL4Prob.prob_pseudo.pseudo_def"
- "PSEUDO_LINEAR1_EXECUTE" > "HOL4Prob.prob_pseudo.PSEUDO_LINEAR1_EXECUTE"
-
-end
--- a/src/HOL/Import/HOL4/Generated/prob_uniform.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,57 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "uniform_tupled" > "uniform_tupled_def"
- "uniform" > "uniform_primdef"
- "unif_tupled" > "unif_tupled_def"
- "unif_bound" > "unif_bound_primdef"
- "unif" > "unif_primdef"
-
-const_maps
- "uniform_tupled" > "HOL4Prob.prob_uniform.uniform_tupled"
- "uniform" > "HOL4Prob.prob_uniform.uniform"
- "unif_tupled" > "HOL4Prob.prob_uniform.unif_tupled"
- "unif_bound" > "HOL4Prob.prob_uniform.unif_bound"
- "unif" > "HOL4Prob.prob_uniform.unif"
-
-thm_maps
- "uniform_tupled_primitive_def" > "HOL4Prob.prob_uniform.uniform_tupled_primitive_def"
- "uniform_tupled_def" > "HOL4Prob.prob_uniform.uniform_tupled_def"
- "uniform_primdef" > "HOL4Prob.prob_uniform.uniform_primdef"
- "uniform_ind" > "HOL4Prob.prob_uniform.uniform_ind"
- "uniform_def" > "HOL4Prob.prob_uniform.uniform_def"
- "uniform_curried_def" > "HOL4Prob.prob_uniform.uniform_curried_def"
- "unif_tupled_primitive_def" > "HOL4Prob.prob_uniform.unif_tupled_primitive_def"
- "unif_tupled_def" > "HOL4Prob.prob_uniform.unif_tupled_def"
- "unif_primdef" > "HOL4Prob.prob_uniform.unif_primdef"
- "unif_ind" > "HOL4Prob.prob_uniform.unif_ind"
- "unif_def" > "HOL4Prob.prob_uniform.unif_def"
- "unif_curried_def" > "HOL4Prob.prob_uniform.unif_curried_def"
- "unif_bound_primitive_def" > "HOL4Prob.prob_uniform.unif_bound_primitive_def"
- "unif_bound_primdef" > "HOL4Prob.prob_uniform.unif_bound_primdef"
- "unif_bound_ind" > "HOL4Prob.prob_uniform.unif_bound_ind"
- "unif_bound_def" > "HOL4Prob.prob_uniform.unif_bound_def"
- "UNIF_RANGE" > "HOL4Prob.prob_uniform.UNIF_RANGE"
- "UNIF_DEF_MONAD" > "HOL4Prob.prob_uniform.UNIF_DEF_MONAD"
- "UNIF_BOUND_UPPER_SUC" > "HOL4Prob.prob_uniform.UNIF_BOUND_UPPER_SUC"
- "UNIF_BOUND_UPPER" > "HOL4Prob.prob_uniform.UNIF_BOUND_UPPER"
- "UNIF_BOUND_LOWER_SUC" > "HOL4Prob.prob_uniform.UNIF_BOUND_LOWER_SUC"
- "UNIF_BOUND_LOWER" > "HOL4Prob.prob_uniform.UNIF_BOUND_LOWER"
- "UNIFORM_RANGE" > "HOL4Prob.prob_uniform.UNIFORM_RANGE"
- "UNIFORM_DEF_MONAD" > "HOL4Prob.prob_uniform.UNIFORM_DEF_MONAD"
- "SUC_DIV_TWO_ZERO" > "HOL4Prob.prob_uniform.SUC_DIV_TWO_ZERO"
- "PROB_UNIF_PAIR" > "HOL4Prob.prob_uniform.PROB_UNIF_PAIR"
- "PROB_UNIF_GOOD" > "HOL4Prob.prob_uniform.PROB_UNIF_GOOD"
- "PROB_UNIF_BOUND" > "HOL4Prob.prob_uniform.PROB_UNIF_BOUND"
- "PROB_UNIFORM_UPPER_BOUND" > "HOL4Prob.prob_uniform.PROB_UNIFORM_UPPER_BOUND"
- "PROB_UNIFORM_SUC" > "HOL4Prob.prob_uniform.PROB_UNIFORM_SUC"
- "PROB_UNIFORM_PAIR_SUC" > "HOL4Prob.prob_uniform.PROB_UNIFORM_PAIR_SUC"
- "PROB_UNIFORM_LOWER_BOUND" > "HOL4Prob.prob_uniform.PROB_UNIFORM_LOWER_BOUND"
- "PROB_UNIFORM" > "HOL4Prob.prob_uniform.PROB_UNIFORM"
- "PROB_UNIF" > "HOL4Prob.prob_uniform.PROB_UNIF"
- "INDEP_UNIFORM" > "HOL4Prob.prob_uniform.INDEP_UNIFORM"
- "INDEP_UNIF" > "HOL4Prob.prob_uniform.INDEP_UNIF"
-
-end
--- a/src/HOL/Import/HOL4/Generated/real.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,359 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "sup" > "sup_def"
- "sumc" > "sumc_def"
- "sum" > "sum_def"
-
-const_maps
- "sup" > "HOL4Real.real.sup"
- "sum" > "HOL4Real.real.sum"
- "real_sub" > "Groups.minus_class.minus" :: "real => real => real"
- "real_of_num" > "RealDef.real" :: "nat => real"
- "real_lte" > "Orderings.ord_class.less_eq" :: "real => real => bool"
- "real_gt" > "Compatibility.real_gt"
- "real_ge" > "Compatibility.real_ge"
- "pow" > "Power.power_class.power" :: "real => nat => real"
- "abs" > "Groups.abs_class.abs" :: "real => real"
- "/" > "Fields.inverse_class.divide" :: "real => real => real"
-
-thm_maps
- "sup_def" > "HOL4Real.real.sup_def"
- "sup" > "HOL4Real.real.sup"
- "sumc" > "HOL4Real.real.sumc"
- "sum_def" > "HOL4Real.real.sum_def"
- "sum" > "HOL4Real.real.sum"
- "real_sub" > "Fields.linordered_field_class.sign_simps_16"
- "real_of_num" > "Compatibility.real_of_num"
- "real_lte" > "Compatibility.real_lte"
- "real_lt" > "Orderings.linorder_class.not_le"
- "real_gt" > "Compatibility.GREATER_DEF"
- "real_ge" > "Compatibility.real_ge"
- "real_div" > "Fields.division_ring_class.divide_inverse"
- "pow" > "Compatibility.pow"
- "abs" > "Compatibility.abs"
- "SUP_LEMMA3" > "HOL4Real.real.SUP_LEMMA3"
- "SUP_LEMMA2" > "HOL4Real.real.SUP_LEMMA2"
- "SUP_LEMMA1" > "HOL4Real.real.SUP_LEMMA1"
- "SUM_ZERO" > "HOL4Real.real.SUM_ZERO"
- "SUM_TWO" > "HOL4Real.real.SUM_TWO"
- "SUM_SUBST" > "HOL4Real.real.SUM_SUBST"
- "SUM_SUB" > "HOL4Real.real.SUM_SUB"
- "SUM_REINDEX" > "HOL4Real.real.SUM_REINDEX"
- "SUM_POS_GEN" > "HOL4Real.real.SUM_POS_GEN"
- "SUM_POS" > "HOL4Real.real.SUM_POS"
- "SUM_PERMUTE_0" > "HOL4Real.real.SUM_PERMUTE_0"
- "SUM_OFFSET" > "HOL4Real.real.SUM_OFFSET"
- "SUM_NSUB" > "HOL4Real.real.SUM_NSUB"
- "SUM_NEG" > "HOL4Real.real.SUM_NEG"
- "SUM_LE" > "HOL4Real.real.SUM_LE"
- "SUM_GROUP" > "HOL4Real.real.SUM_GROUP"
- "SUM_EQ" > "HOL4Real.real.SUM_EQ"
- "SUM_DIFF" > "HOL4Real.real.SUM_DIFF"
- "SUM_DEF" > "HOL4Real.real.SUM_DEF"
- "SUM_CMUL" > "HOL4Real.real.SUM_CMUL"
- "SUM_CANCEL" > "HOL4Real.real.SUM_CANCEL"
- "SUM_BOUND" > "HOL4Real.real.SUM_BOUND"
- "SUM_ADD" > "HOL4Real.real.SUM_ADD"
- "SUM_ABS_LE" > "HOL4Real.real.SUM_ABS_LE"
- "SUM_ABS" > "HOL4Real.real.SUM_ABS"
- "SUM_2" > "HOL4Real.real.SUM_2"
- "SUM_1" > "HOL4Real.real.SUM_1"
- "SUM_0" > "HOL4Real.real.SUM_0"
- "SETOK_LE_LT" > "HOL4Real.real.SETOK_LE_LT"
- "REAL_SUP_UBOUND_LE" > "HOL4Real.real.REAL_SUP_UBOUND_LE"
- "REAL_SUP_UBOUND" > "HOL4Real.real.REAL_SUP_UBOUND"
- "REAL_SUP_SOMEPOS" > "HOL4Real.real.REAL_SUP_SOMEPOS"
- "REAL_SUP_LE" > "HOL4Real.real.REAL_SUP_LE"
- "REAL_SUP_EXISTS" > "HOL4Real.real.REAL_SUP_EXISTS"
- "REAL_SUP_ALLPOS" > "Compatibility.REAL_SUP_ALLPOS"
- "REAL_SUP" > "HOL4Real.real.REAL_SUP"
- "REAL_SUMSQ" > "Nat_Numeral.linordered_ring_strict_class.sum_squares_eq_zero_iff"
- "REAL_SUB_TRIANGLE" > "HOL4Real.real.REAL_SUB_TRIANGLE"
- "REAL_SUB_SUB2" > "HOL4Real.real.REAL_SUB_SUB2"
- "REAL_SUB_SUB" > "HOL4Real.real.REAL_SUB_SUB"
- "REAL_SUB_RZERO" > "Groups.group_add_class.diff_0_right"
- "REAL_SUB_RNEG" > "Groups.group_add_class.diff_minus_eq_add"
- "REAL_SUB_REFL" > "Groups.group_add_class.diff_self"
- "REAL_SUB_RDISTRIB" > "Fields.linordered_field_class.sign_simps_5"
- "REAL_SUB_NEG2" > "HOL4Real.real.REAL_SUB_NEG2"
- "REAL_SUB_LZERO" > "Groups.group_add_class.diff_0"
- "REAL_SUB_LT" > "HOL4Real.real.REAL_SUB_LT"
- "REAL_SUB_LNEG" > "HOL4Real.real.REAL_SUB_LNEG"
- "REAL_SUB_LE" > "HOL4Real.real.REAL_SUB_LE"
- "REAL_SUB_LDISTRIB" > "Fields.linordered_field_class.sign_simps_6"
- "REAL_SUB_INV2" > "HOL4Real.real.REAL_SUB_INV2"
- "REAL_SUB_ADD2" > "HOL4Real.real.REAL_SUB_ADD2"
- "REAL_SUB_ADD" > "Groups.group_add_class.diff_add_cancel"
- "REAL_SUB_ABS" > "Groups.ordered_ab_group_add_abs_class.abs_triangle_ineq2"
- "REAL_SUB_0" > "Groups.ab_group_add_class.diff_eq_0_iff_eq"
- "REAL_RNEG_UNIQ" > "Groups.group_add_class.add_eq_0_iff"
- "REAL_RINV_UNIQ" > "Fields.division_ring_class.inverse_unique"
- "REAL_RDISTRIB" > "Fields.linordered_field_class.sign_simps_8"
- "REAL_POW_POW" > "Power.monoid_mult_class.power_mult"
- "REAL_POW_MONO_LT" > "HOL4Real.real.REAL_POW_MONO_LT"
- "REAL_POW_LT2" > "HOL4Real.real.REAL_POW_LT2"
- "REAL_POW_LT" > "Power.linordered_semidom_class.zero_less_power"
- "REAL_POW_INV" > "Power.power_inverse"
- "REAL_POW_DIV" > "Power.power_divide"
- "REAL_POW_ADD" > "Power.monoid_mult_class.power_add"
- "REAL_POW2_ABS" > "Nat_Numeral.linordered_idom_class.power2_abs"
- "REAL_POS_NZ" > "HOL4Real.real.REAL_POS_NZ"
- "REAL_POS" > "RealDef.real_of_nat_ge_zero"
- "REAL_POASQ" > "HOL4Real.real.REAL_POASQ"
- "REAL_OVER1" > "Fields.division_ring_class.divide_1"
- "REAL_OF_NUM_SUC" > "RealDef.real_of_nat_Suc"
- "REAL_OF_NUM_POW" > "RealDef.power_real_of_nat"
- "REAL_OF_NUM_MUL" > "RealDef.real_of_nat_mult"
- "REAL_OF_NUM_LE" > "RealDef.real_of_nat_le_iff"
- "REAL_OF_NUM_EQ" > "RealDef.real_of_nat_inject"
- "REAL_OF_NUM_ADD" > "RealDef.real_of_nat_add"
- "REAL_NZ_IMP_LT" > "HOL4Real.real.REAL_NZ_IMP_LT"
- "REAL_NOT_LT" > "Compatibility.real_lte"
- "REAL_NOT_LE" > "Orderings.linorder_class.not_le"
- "REAL_NEG_SUB" > "Groups.group_add_class.minus_diff_eq"
- "REAL_NEG_RMUL" > "Int.int_arith_rules_14"
- "REAL_NEG_NEG" > "Groups.group_add_class.minus_minus"
- "REAL_NEG_MUL2" > "Rings.ring_class.minus_mult_minus"
- "REAL_NEG_MINUS1" > "Semiring_Normalization.comm_ring_1_class.normalizing_ring_rules_1"
- "REAL_NEG_LT0" > "Groups.ordered_ab_group_add_class.neg_less_0_iff_less"
- "REAL_NEG_LMUL" > "Int.int_arith_rules_13"
- "REAL_NEG_LE0" > "Groups.ordered_ab_group_add_class.neg_le_0_iff_le"
- "REAL_NEG_INV" > "Fields.division_ring_class.nonzero_inverse_minus_eq"
- "REAL_NEG_GT0" > "Groups.ordered_ab_group_add_class.neg_0_less_iff_less"
- "REAL_NEG_GE0" > "Groups.ordered_ab_group_add_class.neg_0_le_iff_le"
- "REAL_NEG_EQ0" > "Groups.group_add_class.neg_equal_0_iff_equal"
- "REAL_NEG_EQ" > "HOL4Real.real.REAL_NEG_EQ"
- "REAL_NEG_ADD" > "Groups.ab_group_add_class.minus_add_distrib"
- "REAL_NEG_0" > "Groups.group_add_class.minus_zero"
- "REAL_NEGNEG" > "Groups.group_add_class.minus_minus"
- "REAL_MUL_SYM" > "Fields.linordered_field_class.sign_simps_21"
- "REAL_MUL_RZERO" > "Divides.arithmetic_simps_41"
- "REAL_MUL_RNEG" > "Int.int_arith_rules_14"
- "REAL_MUL_RINV" > "Fields.division_ring_class.right_inverse"
- "REAL_MUL_RID" > "Divides.arithmetic_simps_43"
- "REAL_MUL_LZERO" > "Divides.arithmetic_simps_40"
- "REAL_MUL_LNEG" > "Int.int_arith_rules_13"
- "REAL_MUL_LINV" > "Fields.division_ring_class.left_inverse"
- "REAL_MUL_LID" > "Divides.arithmetic_simps_42"
- "REAL_MUL_ASSOC" > "Fields.linordered_field_class.sign_simps_22"
- "REAL_MUL" > "RealDef.real_of_nat_mult"
- "REAL_MIDDLE2" > "HOL4Real.real.REAL_MIDDLE2"
- "REAL_MIDDLE1" > "HOL4Real.real.REAL_MIDDLE1"
- "REAL_MEAN" > "Orderings.dense_linorder_class.dense"
- "REAL_LT_TRANS" > "Orderings.order_less_trans"
- "REAL_LT_TOTAL" > "Compatibility.REAL_LT_TOTAL"
- "REAL_LT_SUB_RADD" > "Fields.linordered_field_class.sign_simps_4"
- "REAL_LT_SUB_LADD" > "Fields.linordered_field_class.sign_simps_3"
- "REAL_LT_RMUL_IMP" > "Rings.linordered_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"
- "REAL_LT_RDIV_EQ" > "Fields.linordered_field_class.pos_less_divide_eq"
- "REAL_LT_RDIV_0" > "HOL4Real.real.REAL_LT_RDIV_0"
- "REAL_LT_RDIV" > "HOL4Real.real.REAL_LT_RDIV"
- "REAL_LT_RADD" > "Groups.ordered_ab_semigroup_add_imp_le_class.add_less_cancel_right"
- "REAL_LT_NZ" > "HOL4Real.real.REAL_LT_NZ"
- "REAL_LT_NEGTOTAL" > "HOL4Real.real.REAL_LT_NEGTOTAL"
- "REAL_LT_NEG" > "Groups.ordered_ab_group_add_class.neg_less_iff_less"
- "REAL_LT_MULTIPLE" > "HOL4Real.real.REAL_LT_MULTIPLE"
- "REAL_LT_MUL2" > "Rings.linordered_semiring_strict_class.mult_strict_mono'"
- "REAL_LT_MUL" > "RealDef.real_mult_order"
- "REAL_LT_LMUL_IMP" > "RealDef.real_mult_less_mono2"
- "REAL_LT_LMUL_0" > "HOL4Real.real.REAL_LT_LMUL_0"
- "REAL_LT_LMUL" > "Rings.linordered_ring_strict_class.mult_less_cancel_left_pos"
- "REAL_LT_LE" > "Orderings.order_class.less_le"
- "REAL_LT_LDIV_EQ" > "Fields.linordered_field_class.pos_divide_less_eq"
- "REAL_LT_LADD" > "Groups.ordered_ab_semigroup_add_imp_le_class.add_less_cancel_left"
- "REAL_LT_INV_EQ" > "Fields.linordered_field_inverse_zero_class.inverse_positive_iff_positive"
- "REAL_LT_INV" > "Fields.linordered_field_class.less_imp_inverse_less"
- "REAL_LT_IMP_NE" > "Orderings.order_class.less_imp_neq"
- "REAL_LT_IMP_LE" > "Orderings.order_less_imp_le"
- "REAL_LT_IADD" > "Groups.ordered_cancel_ab_semigroup_add_class.add_strict_left_mono"
- "REAL_LT_HALF2" > "HOL4Real.real.REAL_LT_HALF2"
- "REAL_LT_HALF1" > "Int.half_gt_zero_iff"
- "REAL_LT_GT" > "Orderings.order_less_not_sym"
- "REAL_LT_FRACTION_0" > "HOL4Real.real.REAL_LT_FRACTION_0"
- "REAL_LT_FRACTION" > "HOL4Real.real.REAL_LT_FRACTION"
- "REAL_LT_DIV" > "Fields.linordered_field_class.divide_pos_pos"
- "REAL_LT_ANTISYM" > "HOL4Real.real.REAL_LT_ANTISYM"
- "REAL_LT_ADD_SUB" > "Fields.linordered_field_class.sign_simps_3"
- "REAL_LT_ADDR" > "HOL4Real.real.REAL_LT_ADDR"
- "REAL_LT_ADDNEG2" > "HOL4Real.real.REAL_LT_ADDNEG2"
- "REAL_LT_ADDNEG" > "HOL4Real.real.REAL_LT_ADDNEG"
- "REAL_LT_ADDL" > "HOL4Real.real.REAL_LT_ADDL"
- "REAL_LT_ADD2" > "Groups.add_mono_thms_linordered_field_5"
- "REAL_LT_ADD1" > "HOL4Real.real.REAL_LT_ADD1"
- "REAL_LT_ADD" > "Groups.ordered_comm_monoid_add_class.add_pos_pos"
- "REAL_LT_1" > "HOL4Real.real.REAL_LT_1"
- "REAL_LT_01" > "Rings.linordered_semidom_class.zero_less_one"
- "REAL_LTE_TRANS" > "Orderings.order_less_le_trans"
- "REAL_LTE_TOTAL" > "HOL4Real.real.REAL_LTE_TOTAL"
- "REAL_LTE_ANTSYM" > "HOL4Real.real.REAL_LTE_ANTSYM"
- "REAL_LTE_ADD2" > "Groups.add_mono_thms_linordered_field_3"
- "REAL_LTE_ADD" > "Groups.ordered_comm_monoid_add_class.add_pos_nonneg"
- "REAL_LT1_POW2" > "HOL4Real.real.REAL_LT1_POW2"
- "REAL_LT" > "RealDef.real_of_nat_less_iff"
- "REAL_LNEG_UNIQ" > "Groups.group_add_class.eq_neg_iff_add_eq_0"
- "REAL_LINV_UNIQ" > "HOL4Real.real.REAL_LINV_UNIQ"
- "REAL_LE_TRANS" > "Orderings.order_trans_rules_23"
- "REAL_LE_TOTAL" > "Orderings.linorder_class.linear"
- "REAL_LE_SUB_RADD" > "Fields.linordered_field_class.sign_simps_2"
- "REAL_LE_SUB_LADD" > "Fields.linordered_field_class.sign_simps_1"
- "REAL_LE_SQUARE" > "Rings.linordered_ring_class.zero_le_square"
- "REAL_LE_RNEG" > "HOL4Real.real.REAL_LE_RNEG"
- "REAL_LE_RMUL_IMP" > "Rings.ordered_semiring_class.mult_right_mono"
- "REAL_LE_RMUL" > "RealDef.real_mult_le_cancel_iff1"
- "REAL_LE_REFL" > "Orderings.preorder_class.order_refl"
- "REAL_LE_RDIV_EQ" > "Fields.linordered_field_class.pos_le_divide_eq"
- "REAL_LE_RDIV" > "Fields.linordered_field_class.mult_imp_le_div_pos"
- "REAL_LE_RADD" > "Groups.ordered_ab_semigroup_add_imp_le_class.add_le_cancel_right"
- "REAL_LE_POW2" > "Nat_Numeral.linordered_idom_class.zero_le_power2"
- "REAL_LE_NEGTOTAL" > "HOL4Real.real.REAL_LE_NEGTOTAL"
- "REAL_LE_NEGR" > "Groups.linordered_ab_group_add_class.le_minus_self_iff"
- "REAL_LE_NEGL" > "Groups.linordered_ab_group_add_class.minus_le_self_iff"
- "REAL_LE_NEG2" > "Groups.ordered_ab_group_add_class.neg_le_iff_le"
- "REAL_LE_NEG" > "Groups.ordered_ab_group_add_class.neg_le_iff_le"
- "REAL_LE_MUL2" > "Rings.ordered_semiring_class.mult_mono'"
- "REAL_LE_MUL" > "Rings.mult_sign_intros_1"
- "REAL_LE_LT" > "Orderings.order_class.le_less"
- "REAL_LE_LNEG" > "RealDef.real_0_le_add_iff"
- "REAL_LE_LMUL_IMP" > "Rings.ordered_comm_semiring_class.comm_mult_left_mono"
- "REAL_LE_LMUL" > "RealDef.real_mult_le_cancel_iff2"
- "REAL_LE_LDIV_EQ" > "Fields.linordered_field_class.pos_divide_le_eq"
- "REAL_LE_LDIV" > "Fields.linordered_field_class.mult_imp_div_pos_le"
- "REAL_LE_LADD_IMP" > "Groups.ordered_ab_semigroup_add_class.add_left_mono"
- "REAL_LE_LADD" > "Groups.ordered_ab_semigroup_add_imp_le_class.add_le_cancel_left"
- "REAL_LE_INV_EQ" > "Fields.linordered_field_inverse_zero_class.inverse_nonnegative_iff_nonnegative"
- "REAL_LE_INV" > "HOL4Real.real.REAL_LE_INV"
- "REAL_LE_DOUBLE" > "Groups.linordered_ab_group_add_class.zero_le_double_add_iff_zero_le_single_add"
- "REAL_LE_DIV" > "HOL4Real.real.REAL_LE_DIV"
- "REAL_LE_ANTISYM" > "Orderings.order_class.eq_iff"
- "REAL_LE_ADDR" > "HOL4Real.real.REAL_LE_ADDR"
- "REAL_LE_ADDL" > "HOL4Real.real.REAL_LE_ADDL"
- "REAL_LE_ADD2" > "Groups.add_mono_thms_linordered_semiring_1"
- "REAL_LE_ADD" > "Groups.ordered_comm_monoid_add_class.add_nonneg_nonneg"
- "REAL_LE_01" > "Rings.linordered_semidom_class.zero_le_one"
- "REAL_LET_TRANS" > "Orderings.order_le_less_trans"
- "REAL_LET_TOTAL" > "Orderings.linorder_class.le_less_linear"
- "REAL_LET_ANTISYM" > "HOL4Real.real.REAL_LET_ANTISYM"
- "REAL_LET_ADD2" > "Groups.add_mono_thms_linordered_field_4"
- "REAL_LET_ADD" > "Groups.ordered_comm_monoid_add_class.add_nonneg_pos"
- "REAL_LE1_POW2" > "HOL4Real.real.REAL_LE1_POW2"
- "REAL_LE" > "RealDef.real_of_nat_le_iff"
- "REAL_LDISTRIB" > "Fields.linordered_field_class.sign_simps_7"
- "REAL_INV_POS" > "Fields.linordered_field_class.positive_imp_inverse_positive"
- "REAL_INV_NZ" > "Fields.division_ring_class.nonzero_imp_inverse_nonzero"
- "REAL_INV_MUL" > "HOL4Real.real.REAL_INV_MUL"
- "REAL_INV_LT1" > "Fields.linordered_field_class.one_less_inverse"
- "REAL_INV_INV" > "Fields.division_ring_inverse_zero_class.inverse_inverse_eq"
- "REAL_INV_EQ_0" > "Fields.division_ring_inverse_zero_class.inverse_nonzero_iff_nonzero"
- "REAL_INV_1OVER" > "Fields.division_ring_class.inverse_eq_divide"
- "REAL_INV_0" > "Fields.division_ring_inverse_zero_class.inverse_zero"
- "REAL_INVINV" > "Fields.division_ring_class.nonzero_inverse_inverse_eq"
- "REAL_INV1" > "Fields.division_ring_class.inverse_1"
- "REAL_INJ" > "RealDef.real_of_nat_inject"
- "REAL_HALF_DOUBLE" > "RComplete.real_sum_of_halves"
- "REAL_FACT_NZ" > "HOL4Real.real.REAL_FACT_NZ"
- "REAL_EQ_SUB_RADD" > "Fields.linordered_field_class.sign_simps_12"
- "REAL_EQ_SUB_LADD" > "Fields.linordered_field_class.sign_simps_11"
- "REAL_EQ_RMUL_IMP" > "HOL4Real.real.REAL_EQ_RMUL_IMP"
- "REAL_EQ_RMUL" > "Rings.mult_compare_simps_13"
- "REAL_EQ_RDIV_EQ" > "HOL4Real.real.REAL_EQ_RDIV_EQ"
- "REAL_EQ_RADD" > "Groups.cancel_semigroup_add_class.add_right_cancel"
- "REAL_EQ_NEG" > "Groups.group_add_class.neg_equal_iff_equal"
- "REAL_EQ_MUL_LCANCEL" > "Rings.mult_compare_simps_14"
- "REAL_EQ_LMUL_IMP" > "HOL4Real.real.REAL_EQ_LMUL_IMP"
- "REAL_EQ_LMUL2" > "RealDef.real_mult_left_cancel"
- "REAL_EQ_LMUL" > "Rings.mult_compare_simps_14"
- "REAL_EQ_LDIV_EQ" > "HOL4Real.real.REAL_EQ_LDIV_EQ"
- "REAL_EQ_LADD" > "Groups.cancel_semigroup_add_class.add_left_cancel"
- "REAL_EQ_IMP_LE" > "Orderings.order_eq_refl"
- "REAL_ENTIRE" > "Rings.ring_no_zero_divisors_class.mult_eq_0_iff"
- "REAL_DOWN2" > "RealDef.real_lbound_gt_zero"
- "REAL_DOWN" > "HOL4Real.real.REAL_DOWN"
- "REAL_DOUBLE" > "Int.mult_2"
- "REAL_DIV_RMUL" > "HOL4Real.real.REAL_DIV_RMUL"
- "REAL_DIV_REFL" > "Fields.division_ring_class.divide_self"
- "REAL_DIV_MUL2" > "HOL4Real.real.REAL_DIV_MUL2"
- "REAL_DIV_LZERO" > "Fields.division_ring_class.divide_zero_left"
- "REAL_DIV_LMUL" > "HOL4Real.real.REAL_DIV_LMUL"
- "REAL_DIFFSQ" > "Rings.comm_ring_class.square_diff_square_factored"
- "REAL_ARCH_LEAST" > "Transcendental.reals_Archimedean4"
- "REAL_ARCH" > "RComplete.reals_Archimedean3"
- "REAL_ADD_SYM" > "Fields.linordered_field_class.sign_simps_18"
- "REAL_ADD_SUB2" > "HOL4Real.real.REAL_ADD_SUB2"
- "REAL_ADD_SUB" > "HOL4Real.real.REAL_ADD_SUB"
- "REAL_ADD_RINV" > "Groups.group_add_class.right_minus"
- "REAL_ADD_RID_UNIQ" > "HOL4Real.real.REAL_ADD_RID_UNIQ"
- "REAL_ADD_RID" > "Divides.arithmetic_simps_39"
- "REAL_ADD_RDISTRIB" > "Fields.linordered_field_class.sign_simps_8"
- "REAL_ADD_LINV" > "Groups.ab_group_add_class.ab_left_minus"
- "REAL_ADD_LID_UNIQ" > "HOL4Real.real.REAL_ADD_LID_UNIQ"
- "REAL_ADD_LID" > "Divides.arithmetic_simps_38"
- "REAL_ADD_LDISTRIB" > "Fields.linordered_field_class.sign_simps_7"
- "REAL_ADD_ASSOC" > "Fields.linordered_field_class.sign_simps_19"
- "REAL_ADD2_SUB2" > "RealDef.add_diff_add"
- "REAL_ADD" > "RealDef.real_of_nat_add"
- "REAL_ABS_TRIANGLE" > "Groups.ordered_ab_group_add_abs_class.abs_triangle_ineq"
- "REAL_ABS_POS" > "Groups.ordered_ab_group_add_abs_class.abs_ge_zero"
- "REAL_ABS_MUL" > "Rings.linordered_idom_class.abs_mult"
- "REAL_ABS_0" > "Divides.arithmetic_simps_27"
- "REAL_10" > "Compatibility.REAL_10"
- "REAL_1" > "HOL4Real.real.REAL_1"
- "REAL_0" > "HOL4Real.real.REAL_0"
- "REAL" > "RealDef.real_of_nat_Suc"
- "POW_ZERO_EQ" > "HOL4Real.real.POW_ZERO_EQ"
- "POW_ZERO" > "HOL4Real.real.POW_ZERO"
- "POW_POS_LT" > "HOL4Real.real.POW_POS_LT"
- "POW_POS" > "Power.linordered_semidom_class.zero_le_power"
- "POW_PLUS1" > "HOL4Real.real.POW_PLUS1"
- "POW_ONE" > "Power.monoid_mult_class.power_one"
- "POW_NZ" > "Power.ring_1_no_zero_divisors_class.field_power_not_zero"
- "POW_MUL" > "Power.comm_monoid_mult_class.power_mult_distrib"
- "POW_MINUS1" > "Nat_Numeral.ring_1_class.power_minus1_even"
- "POW_M1" > "HOL4Real.real.POW_M1"
- "POW_LT" > "HOL4Real.real.POW_LT"
- "POW_LE" > "Power.linordered_semidom_class.power_mono"
- "POW_INV" > "Power.division_ring_class.nonzero_power_inverse"
- "POW_EQ" > "Power.linordered_semidom_class.power_inject_base"
- "POW_ADD" > "Power.monoid_mult_class.power_add"
- "POW_ABS" > "Power.linordered_idom_class.power_abs"
- "POW_2_LT" > "RealDef.two_realpow_gt"
- "POW_2_LE1" > "RealDef.two_realpow_ge_one"
- "POW_2" > "Nat_Numeral.monoid_mult_class.power2_eq_square"
- "POW_1" > "Power.monoid_mult_class.power_one_right"
- "POW_0" > "Power.power_0_Suc"
- "ABS_ZERO" > "Groups.ordered_ab_group_add_abs_class.abs_eq_0"
- "ABS_TRIANGLE" > "Groups.ordered_ab_group_add_abs_class.abs_triangle_ineq"
- "ABS_SUM" > "HOL4Real.real.ABS_SUM"
- "ABS_SUB_ABS" > "Groups.ordered_ab_group_add_abs_class.abs_triangle_ineq3"
- "ABS_SUB" > "Groups.ordered_ab_group_add_abs_class.abs_minus_commute"
- "ABS_STILLNZ" > "HOL4Real.real.ABS_STILLNZ"
- "ABS_SIGN2" > "HOL4Real.real.ABS_SIGN2"
- "ABS_SIGN" > "HOL4Real.real.ABS_SIGN"
- "ABS_REFL" > "HOL4Real.real.ABS_REFL"
- "ABS_POW2" > "Nat_Numeral.linordered_idom_class.abs_power2"
- "ABS_POS" > "Groups.ordered_ab_group_add_abs_class.abs_ge_zero"
- "ABS_NZ" > "Groups.ordered_ab_group_add_abs_class.zero_less_abs_iff"
- "ABS_NEG" > "Groups.ordered_ab_group_add_abs_class.abs_minus_cancel"
- "ABS_N" > "RealDef.abs_real_of_nat_cancel"
- "ABS_MUL" > "Rings.linordered_idom_class.abs_mult"
- "ABS_LT_MUL2" > "HOL4Real.real.ABS_LT_MUL2"
- "ABS_LE" > "Groups.ordered_ab_group_add_abs_class.abs_ge_self"
- "ABS_INV" > "Fields.linordered_field_class.nonzero_abs_inverse"
- "ABS_DIV" > "Fields.linordered_field_class.nonzero_abs_divide"
- "ABS_CIRCLE" > "HOL4Real.real.ABS_CIRCLE"
- "ABS_CASES" > "HOL4Real.real.ABS_CASES"
- "ABS_BOUNDS" > "RealDef.abs_le_interval_iff"
- "ABS_BOUND" > "HOL4Real.real.ABS_BOUND"
- "ABS_BETWEEN2" > "HOL4Real.real.ABS_BETWEEN2"
- "ABS_BETWEEN1" > "HOL4Real.real.ABS_BETWEEN1"
- "ABS_BETWEEN" > "HOL4Real.real.ABS_BETWEEN"
- "ABS_ABS" > "Groups.ordered_ab_group_add_abs_class.abs_idempotent"
- "ABS_1" > "Divides.arithmetic_simps_28"
- "ABS_0" > "Divides.arithmetic_simps_27"
-
-end
--- a/src/HOL/Import/HOL4/Generated/realax.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,145 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "treal_of_hreal" > "treal_of_hreal_def"
- "treal_neg" > "treal_neg_def"
- "treal_mul" > "treal_mul_def"
- "treal_lt" > "treal_lt_def"
- "treal_inv" > "treal_inv_def"
- "treal_eq" > "treal_eq_def"
- "treal_add" > "treal_add_def"
- "treal_1" > "treal_1_def"
- "treal_0" > "treal_0_def"
- "hreal_of_treal" > "hreal_of_treal_def"
-
-type_maps
- "real" > "RealDef.real"
-
-const_maps
- "treal_of_hreal" > "HOL4Real.realax.treal_of_hreal"
- "treal_neg" > "HOL4Real.realax.treal_neg"
- "treal_mul" > "HOL4Real.realax.treal_mul"
- "treal_lt" > "HOL4Real.realax.treal_lt"
- "treal_inv" > "HOL4Real.realax.treal_inv"
- "treal_eq" > "HOL4Real.realax.treal_eq"
- "treal_add" > "HOL4Real.realax.treal_add"
- "treal_1" > "HOL4Real.realax.treal_1"
- "treal_0" > "HOL4Real.realax.treal_0"
- "real_sub" > "Groups.minus_class.minus" :: "real => real => real"
- "real_neg" > "Groups.uminus_class.uminus" :: "real => real"
- "real_mul" > "Groups.times_class.times" :: "real => real => real"
- "real_lt" > "Orderings.ord_class.less" :: "real => real => bool"
- "real_div" > "Fields.inverse_class.divide" :: "real => real => real"
- "real_add" > "Groups.plus_class.plus" :: "real => real => real"
- "real_1" > "Groups.one_class.one" :: "real"
- "real_0" > "Groups.zero_class.zero" :: "real"
- "mk_real" > "HOL.undefined"
- "inv" > "Fields.inverse_class.inverse" :: "real => real"
- "hreal_of_treal" > "HOL4Real.realax.hreal_of_treal"
- "dest_real" > "HOL.undefined"
-
-thm_maps
- "treal_of_hreal_def" > "HOL4Real.realax.treal_of_hreal_def"
- "treal_of_hreal" > "HOL4Real.realax.treal_of_hreal"
- "treal_neg_def" > "HOL4Real.realax.treal_neg_def"
- "treal_neg" > "HOL4Real.realax.treal_neg"
- "treal_mul_def" > "HOL4Real.realax.treal_mul_def"
- "treal_mul" > "HOL4Real.realax.treal_mul"
- "treal_lt_def" > "HOL4Real.realax.treal_lt_def"
- "treal_lt" > "HOL4Real.realax.treal_lt"
- "treal_inv_def" > "HOL4Real.realax.treal_inv_def"
- "treal_inv" > "HOL4Real.realax.treal_inv"
- "treal_eq_def" > "HOL4Real.realax.treal_eq_def"
- "treal_eq" > "HOL4Real.realax.treal_eq"
- "treal_add_def" > "HOL4Real.realax.treal_add_def"
- "treal_add" > "HOL4Real.realax.treal_add"
- "treal_1_def" > "HOL4Real.realax.treal_1_def"
- "treal_1" > "HOL4Real.realax.treal_1"
- "treal_0_def" > "HOL4Real.realax.treal_0_def"
- "treal_0" > "HOL4Real.realax.treal_0"
- "hreal_of_treal_def" > "HOL4Real.realax.hreal_of_treal_def"
- "hreal_of_treal" > "HOL4Real.realax.hreal_of_treal"
- "TREAL_NEG_WELLDEF" > "HOL4Real.realax.TREAL_NEG_WELLDEF"
- "TREAL_MUL_WELLDEFR" > "HOL4Real.realax.TREAL_MUL_WELLDEFR"
- "TREAL_MUL_WELLDEF" > "HOL4Real.realax.TREAL_MUL_WELLDEF"
- "TREAL_MUL_SYM" > "HOL4Real.realax.TREAL_MUL_SYM"
- "TREAL_MUL_LINV" > "HOL4Real.realax.TREAL_MUL_LINV"
- "TREAL_MUL_LID" > "HOL4Real.realax.TREAL_MUL_LID"
- "TREAL_MUL_ASSOC" > "HOL4Real.realax.TREAL_MUL_ASSOC"
- "TREAL_LT_WELLDEFR" > "HOL4Real.realax.TREAL_LT_WELLDEFR"
- "TREAL_LT_WELLDEFL" > "HOL4Real.realax.TREAL_LT_WELLDEFL"
- "TREAL_LT_WELLDEF" > "HOL4Real.realax.TREAL_LT_WELLDEF"
- "TREAL_LT_TRANS" > "HOL4Real.realax.TREAL_LT_TRANS"
- "TREAL_LT_TOTAL" > "HOL4Real.realax.TREAL_LT_TOTAL"
- "TREAL_LT_REFL" > "HOL4Real.realax.TREAL_LT_REFL"
- "TREAL_LT_MUL" > "HOL4Real.realax.TREAL_LT_MUL"
- "TREAL_LT_ADD" > "HOL4Real.realax.TREAL_LT_ADD"
- "TREAL_LDISTRIB" > "HOL4Real.realax.TREAL_LDISTRIB"
- "TREAL_ISO" > "HOL4Real.realax.TREAL_ISO"
- "TREAL_INV_WELLDEF" > "HOL4Real.realax.TREAL_INV_WELLDEF"
- "TREAL_INV_0" > "HOL4Real.realax.TREAL_INV_0"
- "TREAL_EQ_TRANS" > "HOL4Real.realax.TREAL_EQ_TRANS"
- "TREAL_EQ_SYM" > "HOL4Real.realax.TREAL_EQ_SYM"
- "TREAL_EQ_REFL" > "HOL4Real.realax.TREAL_EQ_REFL"
- "TREAL_EQ_EQUIV" > "HOL4Real.realax.TREAL_EQ_EQUIV"
- "TREAL_EQ_AP" > "HOL4Real.realax.TREAL_EQ_AP"
- "TREAL_BIJ_WELLDEF" > "HOL4Real.realax.TREAL_BIJ_WELLDEF"
- "TREAL_BIJ" > "HOL4Real.realax.TREAL_BIJ"
- "TREAL_ADD_WELLDEFR" > "HOL4Real.realax.TREAL_ADD_WELLDEFR"
- "TREAL_ADD_WELLDEF" > "HOL4Real.realax.TREAL_ADD_WELLDEF"
- "TREAL_ADD_SYM" > "HOL4Real.realax.TREAL_ADD_SYM"
- "TREAL_ADD_LINV" > "HOL4Real.realax.TREAL_ADD_LINV"
- "TREAL_ADD_LID" > "HOL4Real.realax.TREAL_ADD_LID"
- "TREAL_ADD_ASSOC" > "HOL4Real.realax.TREAL_ADD_ASSOC"
- "TREAL_10" > "HOL4Real.realax.TREAL_10"
- "REAL_SUP_ALLPOS" > "Compatibility.REAL_SUP_ALLPOS"
- "REAL_MUL_SYM" > "Fields.linordered_field_class.sign_simps_21"
- "REAL_MUL_LINV" > "Fields.division_ring_class.left_inverse"
- "REAL_MUL_LID" > "Divides.arithmetic_simps_42"
- "REAL_MUL_ASSOC" > "Fields.linordered_field_class.sign_simps_22"
- "REAL_LT_TRANS" > "Orderings.order_less_trans"
- "REAL_LT_TOTAL" > "Compatibility.REAL_LT_TOTAL"
- "REAL_LT_REFL" > "Orderings.order_less_irrefl"
- "REAL_LT_MUL" > "RealDef.real_mult_order"
- "REAL_LT_IADD" > "Groups.ordered_cancel_ab_semigroup_add_class.add_strict_left_mono"
- "REAL_LDISTRIB" > "Fields.linordered_field_class.sign_simps_7"
- "REAL_INV_0" > "Fields.division_ring_inverse_zero_class.inverse_zero"
- "REAL_ADD_SYM" > "Fields.linordered_field_class.sign_simps_18"
- "REAL_ADD_LINV" > "Groups.ab_group_add_class.ab_left_minus"
- "REAL_ADD_LID" > "Divides.arithmetic_simps_38"
- "REAL_ADD_ASSOC" > "Fields.linordered_field_class.sign_simps_19"
- "REAL_10" > "Compatibility.REAL_10"
- "HREAL_RDISTRIB" > "HOL4Real.realax.HREAL_RDISTRIB"
- "HREAL_LT_REFL" > "HOL4Real.realax.HREAL_LT_REFL"
- "HREAL_LT_NE" > "HOL4Real.realax.HREAL_LT_NE"
- "HREAL_LT_LADD" > "HOL4Real.realax.HREAL_LT_LADD"
- "HREAL_LT_GT" > "HOL4Real.realax.HREAL_LT_GT"
- "HREAL_LT_ADDR" > "HOL4Real.realax.HREAL_LT_ADDR"
- "HREAL_LT_ADDL" > "HOL4Real.realax.HREAL_LT_ADDL"
- "HREAL_LT_ADD2" > "HOL4Real.realax.HREAL_LT_ADD2"
- "HREAL_EQ_LADD" > "HOL4Real.realax.HREAL_EQ_LADD"
- "HREAL_EQ_ADDR" > "HOL4Base.hreal.HREAL_NOZERO"
- "HREAL_EQ_ADDL" > "HOL4Real.realax.HREAL_EQ_ADDL"
-
-ignore_thms
- "real_tybij"
- "real_of_hreal"
- "real_neg"
- "real_mul"
- "real_lt"
- "real_inv"
- "real_add"
- "real_TY_DEF"
- "real_1"
- "real_0"
- "hreal_of_real"
- "SUP_ALLPOS_LEMMA4"
- "SUP_ALLPOS_LEMMA3"
- "SUP_ALLPOS_LEMMA2"
- "SUP_ALLPOS_LEMMA1"
- "REAL_POS"
- "REAL_ISO_EQ"
-
-end
--- a/src/HOL/Import/HOL4/Generated/relation.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,102 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "transitive" > "transitive_primdef"
- "the_fun" > "the_fun_primdef"
- "pred_reflexive" > "pred_reflexive_def"
- "inv_image" > "inv_image_primdef"
- "approx" > "approx_primdef"
- "WFREC" > "WFREC_def"
- "WF" > "WF_def"
- "TC" > "TC_def"
- "RTC" > "RTC_def"
- "RESTRICT" > "RESTRICT_def"
- "RC" > "RC_primdef"
- "EMPTY_REL" > "EMPTY_REL_def"
-
-const_maps
- "transitive" > "HOL4Base.relation.transitive"
- "the_fun" > "HOL4Base.relation.the_fun"
- "pred_reflexive" > "HOL4Base.relation.pred_reflexive"
- "inv_image" > "HOL4Base.relation.inv_image"
- "approx" > "HOL4Base.relation.approx"
- "WFREC" > "HOL4Base.relation.WFREC"
- "WF" > "HOL4Base.relation.WF"
- "TC" > "HOL4Base.relation.TC"
- "RTC" > "HOL4Base.relation.RTC"
- "RESTRICT" > "HOL4Base.relation.RESTRICT"
- "RC" > "HOL4Base.relation.RC"
- "EMPTY_REL" > "HOL4Base.relation.EMPTY_REL"
-
-const_renames
- "reflexive" > "pred_reflexive"
-
-thm_maps
- "transitive_primdef" > "HOL4Base.relation.transitive_primdef"
- "transitive_def" > "HOL4Base.relation.transitive_def"
- "the_fun_primdef" > "HOL4Base.relation.the_fun_primdef"
- "the_fun_def" > "HOL4Base.relation.the_fun_def"
- "reflexive_def" > "HOL4Base.relation.reflexive_def"
- "pred_reflexive_def" > "HOL4Base.relation.pred_reflexive_def"
- "inv_image_primdef" > "HOL4Base.relation.inv_image_primdef"
- "inv_image_def" > "HOL4Base.relation.inv_image_def"
- "approx_primdef" > "HOL4Base.relation.approx_primdef"
- "approx_def" > "HOL4Base.relation.approx_def"
- "WF_inv_image" > "HOL4Base.relation.WF_inv_image"
- "WF_def" > "HOL4Base.relation.WF_def"
- "WF_TC" > "HOL4Base.relation.WF_TC"
- "WF_SUBSET" > "HOL4Base.relation.WF_SUBSET"
- "WF_RECURSION_THM" > "HOL4Base.relation.WF_RECURSION_THM"
- "WF_NOT_REFL" > "HOL4Base.relation.WF_NOT_REFL"
- "WF_INDUCTION_THM" > "HOL4Base.relation.WF_INDUCTION_THM"
- "WF_EMPTY_REL" > "HOL4Base.relation.WF_EMPTY_REL"
- "WF_DEF" > "HOL4Base.relation.WF_DEF"
- "WFREC_def" > "HOL4Base.relation.WFREC_def"
- "WFREC_THM" > "HOL4Base.relation.WFREC_THM"
- "WFREC_DEF" > "HOL4Base.relation.WFREC_DEF"
- "WFREC_COROLLARY" > "HOL4Base.relation.WFREC_COROLLARY"
- "TC_def" > "HOL4Base.relation.TC_def"
- "TC_TRANSITIVE" > "HOL4Base.relation.TC_TRANSITIVE"
- "TC_SUBSET" > "HOL4Base.relation.TC_SUBSET"
- "TC_STRONG_INDUCT_LEFT1" > "HOL4Base.relation.TC_STRONG_INDUCT_LEFT1"
- "TC_STRONG_INDUCT" > "HOL4Base.relation.TC_STRONG_INDUCT"
- "TC_RULES" > "HOL4Base.relation.TC_RULES"
- "TC_RTC" > "HOL4Base.relation.TC_RTC"
- "TC_RC_EQNS" > "HOL4Base.relation.TC_RC_EQNS"
- "TC_MONOTONE" > "HOL4Base.relation.TC_MONOTONE"
- "TC_INDUCT_LEFT1" > "HOL4Base.relation.TC_INDUCT_LEFT1"
- "TC_INDUCT" > "HOL4Base.relation.TC_INDUCT"
- "TC_IDEM" > "HOL4Base.relation.TC_IDEM"
- "TC_DEF" > "HOL4Base.relation.TC_DEF"
- "TC_CASES2" > "HOL4Base.relation.TC_CASES2"
- "TC_CASES1" > "HOL4Base.relation.TC_CASES1"
- "RTC_def" > "HOL4Base.relation.RTC_def"
- "RTC_TRANSITIVE" > "HOL4Base.relation.RTC_TRANSITIVE"
- "RTC_TC_RC" > "HOL4Base.relation.RTC_TC_RC"
- "RTC_SUBSET" > "HOL4Base.relation.RTC_SUBSET"
- "RTC_STRONG_INDUCT" > "HOL4Base.relation.RTC_STRONG_INDUCT"
- "RTC_RULES" > "HOL4Base.relation.RTC_RULES"
- "RTC_RTC" > "HOL4Base.relation.RTC_RTC"
- "RTC_REFLEXIVE" > "HOL4Base.relation.RTC_REFLEXIVE"
- "RTC_MONOTONE" > "HOL4Base.relation.RTC_MONOTONE"
- "RTC_INDUCT" > "HOL4Base.relation.RTC_INDUCT"
- "RTC_IDEM" > "HOL4Base.relation.RTC_IDEM"
- "RTC_DEF" > "HOL4Base.relation.RTC_DEF"
- "RTC_CASES_RTC_TWICE" > "HOL4Base.relation.RTC_CASES_RTC_TWICE"
- "RTC_CASES2" > "HOL4Base.relation.RTC_CASES2"
- "RTC_CASES1" > "HOL4Base.relation.RTC_CASES1"
- "RESTRICT_def" > "HOL4Base.relation.RESTRICT_def"
- "RESTRICT_LEMMA" > "HOL4Base.relation.RESTRICT_LEMMA"
- "RESTRICT_DEF" > "HOL4Base.relation.RESTRICT_DEF"
- "RC_primdef" > "HOL4Base.relation.RC_primdef"
- "RC_def" > "HOL4Base.relation.RC_def"
- "RC_SUBSET" > "HOL4Base.relation.RC_SUBSET"
- "RC_RTC" > "HOL4Base.relation.RC_RTC"
- "RC_REFLEXIVE" > "HOL4Base.relation.RC_REFLEXIVE"
- "RC_IDEM" > "HOL4Base.relation.RC_IDEM"
- "EMPTY_REL_def" > "HOL4Base.relation.EMPTY_REL_def"
- "EMPTY_REL_DEF" > "HOL4Base.relation.EMPTY_REL_DEF"
-
-end
--- a/src/HOL/Import/HOL4/Generated/res_quan.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,37 +0,0 @@
-import
-
-import_segment "hol4"
-
-thm_maps
- "RES_SELECT_UNIV" > "HOL4Vec.res_quan.RES_SELECT_UNIV"
- "RES_SELECT_EMPTY" > "HOL4Vec.res_quan.RES_SELECT_EMPTY"
- "RES_SELECT" > "HOL4Base.bool.RES_SELECT_DEF"
- "RES_FORALL_UNIV" > "HOL4Vec.res_quan.RES_FORALL_UNIV"
- "RES_FORALL_UNIQUE" > "HOL4Vec.res_quan.RES_FORALL_UNIQUE"
- "RES_FORALL_REORDER" > "HOL4Vec.res_quan.RES_FORALL_REORDER"
- "RES_FORALL_NULL" > "HOL4Vec.res_quan.RES_FORALL_NULL"
- "RES_FORALL_FORALL" > "HOL4Vec.res_quan.RES_FORALL_FORALL"
- "RES_FORALL_EMPTY" > "HOL4Vec.res_quan.RES_FORALL_EMPTY"
- "RES_FORALL_DISJ_DIST" > "HOL4Vec.res_quan.RES_FORALL_DISJ_DIST"
- "RES_FORALL_CONJ_DIST" > "HOL4Vec.res_quan.RES_FORALL_CONJ_DIST"
- "RES_FORALL" > "HOL4Base.bool.RES_FORALL_DEF"
- "RES_EXISTS_UNIV" > "HOL4Vec.res_quan.RES_EXISTS_UNIV"
- "RES_EXISTS_UNIQUE_UNIV" > "HOL4Vec.res_quan.RES_EXISTS_UNIQUE_UNIV"
- "RES_EXISTS_UNIQUE_NULL" > "HOL4Vec.res_quan.RES_EXISTS_UNIQUE_NULL"
- "RES_EXISTS_UNIQUE_EMPTY" > "HOL4Vec.res_quan.RES_EXISTS_UNIQUE_EMPTY"
- "RES_EXISTS_UNIQUE_ALT" > "HOL4Vec.res_quan.RES_EXISTS_UNIQUE_ALT"
- "RES_EXISTS_UNIQUE" > "HOL4Base.bool.RES_EXISTS_UNIQUE_DEF"
- "RES_EXISTS_REORDER" > "HOL4Vec.res_quan.RES_EXISTS_REORDER"
- "RES_EXISTS_NULL" > "HOL4Vec.res_quan.RES_EXISTS_NULL"
- "RES_EXISTS_EQUAL" > "HOL4Vec.res_quan.RES_EXISTS_EQUAL"
- "RES_EXISTS_EMPTY" > "HOL4Vec.res_quan.RES_EXISTS_EMPTY"
- "RES_EXISTS_DISJ_DIST" > "HOL4Vec.res_quan.RES_EXISTS_DISJ_DIST"
- "RES_EXISTS_ALT" > "HOL4Vec.res_quan.RES_EXISTS_ALT"
- "RES_EXISTS" > "HOL4Base.bool.RES_EXISTS_DEF"
- "RES_DISJ_EXISTS_DIST" > "HOL4Vec.res_quan.RES_DISJ_EXISTS_DIST"
- "RES_ABSTRACT_IDEMPOT" > "HOL4Vec.res_quan.RES_ABSTRACT_IDEMPOT"
- "RES_ABSTRACT_EQUAL_EQ" > "HOL4Vec.res_quan.RES_ABSTRACT_EQUAL_EQ"
- "RES_ABSTRACT_EQUAL" > "HOL4Vec.res_quan.RES_ABSTRACT_EQUAL"
- "RES_ABSTRACT" > "HOL4Vec.res_quan.RES_ABSTRACT"
-
-end
--- a/src/HOL/Import/HOL4/Generated/rich_list.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,373 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "UNZIP_SND" > "UNZIP_SND_def"
- "UNZIP_FST" > "UNZIP_FST_def"
- "SUFFIX" > "SUFFIX_def"
- "SPLITP" > "SPLITP_def"
- "SNOC" > "SNOC_def"
- "SEG" > "SEG_def"
- "SCANR" > "SCANR_def"
- "SCANL" > "SCANL_def"
- "REPLICATE" > "REPLICATE_def"
- "PREFIX" > "PREFIX_def"
- "OR_EL" > "OR_EL_def"
- "LASTN" > "LASTN_def"
- "IS_SUFFIX" > "IS_SUFFIX_def"
- "IS_SUBLIST" > "IS_SUBLIST_def"
- "IS_PREFIX" > "IS_PREFIX_def"
- "GENLIST" > "GENLIST_def"
- "FIRSTN" > "FIRSTN_def"
- "ELL" > "ELL_def"
- "BUTLASTN" > "BUTLASTN_def"
- "BUTFIRSTN" > "BUTFIRSTN_def"
- "AND_EL" > "AND_EL_def"
-
-const_maps
- "UNZIP_SND" > "HOL4Base.rich_list.UNZIP_SND"
- "UNZIP_FST" > "HOL4Base.rich_list.UNZIP_FST"
- "SUFFIX" > "HOL4Base.rich_list.SUFFIX"
- "PREFIX" > "HOL4Base.rich_list.PREFIX"
- "OR_EL" > "HOL4Base.rich_list.OR_EL"
- "AND_EL" > "HOL4Base.rich_list.AND_EL"
-
-thm_maps
- "list_INDUCT" > "Compatibility.list_INDUCT"
- "list_CASES" > "Compatibility.list_CASES"
- "ZIP_UNZIP" > "HOL4Base.list.ZIP_UNZIP"
- "ZIP_SNOC" > "HOL4Base.rich_list.ZIP_SNOC"
- "ZIP" > "Compatibility.ZIP"
- "UNZIP_ZIP" > "HOL4Base.list.UNZIP_ZIP"
- "UNZIP_SNOC" > "HOL4Base.rich_list.UNZIP_SNOC"
- "UNZIP_SND_def" > "HOL4Base.rich_list.UNZIP_SND_def"
- "UNZIP_SND_DEF" > "HOL4Base.rich_list.UNZIP_SND_DEF"
- "UNZIP_FST_def" > "HOL4Base.rich_list.UNZIP_FST_def"
- "UNZIP_FST_DEF" > "HOL4Base.rich_list.UNZIP_FST_DEF"
- "UNZIP" > "Compatibility.UNZIP"
- "TL_SNOC" > "HOL4Base.rich_list.TL_SNOC"
- "TL" > "List.tl.simps_2"
- "SUM_SNOC" > "HOL4Base.rich_list.SUM_SNOC"
- "SUM_REVERSE" > "HOL4Base.rich_list.SUM_REVERSE"
- "SUM_FOLDR" > "Compatibility.sum_def"
- "SUM_FOLDL" > "HOL4Base.rich_list.SUM_FOLDL"
- "SUM_FLAT" > "HOL4Base.rich_list.SUM_FLAT"
- "SUM_APPEND" > "HOL4Base.rich_list.SUM_APPEND"
- "SUM" > "Compatibility.SUM"
- "SUFFIX_def" > "HOL4Base.rich_list.SUFFIX_def"
- "SUFFIX_DEF" > "HOL4Base.rich_list.SUFFIX_DEF"
- "SPLITP" > "HOL4Base.rich_list.SPLITP"
- "SOME_EL_SNOC" > "HOL4Base.rich_list.SOME_EL_SNOC"
- "SOME_EL_SEG" > "HOL4Base.rich_list.SOME_EL_SEG"
- "SOME_EL_REVERSE" > "List.list_ex_rev"
- "SOME_EL_MAP" > "HOL4Base.rich_list.SOME_EL_MAP"
- "SOME_EL_LASTN" > "HOL4Base.rich_list.SOME_EL_LASTN"
- "SOME_EL_FOLDR_MAP" > "HOL4Base.rich_list.SOME_EL_FOLDR_MAP"
- "SOME_EL_FOLDR" > "HOL4Base.rich_list.SOME_EL_FOLDR"
- "SOME_EL_FOLDL_MAP" > "HOL4Base.rich_list.SOME_EL_FOLDL_MAP"
- "SOME_EL_FOLDL" > "HOL4Base.rich_list.SOME_EL_FOLDL"
- "SOME_EL_FIRSTN" > "HOL4Base.rich_list.SOME_EL_FIRSTN"
- "SOME_EL_DISJ" > "HOL4Base.rich_list.SOME_EL_DISJ"
- "SOME_EL_BUTLASTN" > "HOL4Base.rich_list.SOME_EL_BUTLASTN"
- "SOME_EL_BUTFIRSTN" > "HOL4Base.rich_list.SOME_EL_BUTFIRSTN"
- "SOME_EL_APPEND" > "List.list_ex_append"
- "SOME_EL" > "Compatibility.list_exists_DEF"
- "SNOC_REVERSE_CONS" > "HOL4Base.rich_list.SNOC_REVERSE_CONS"
- "SNOC_INDUCT" > "HOL4Base.rich_list.SNOC_INDUCT"
- "SNOC_FOLDR" > "HOL4Base.rich_list.SNOC_FOLDR"
- "SNOC_EQ_LENGTH_EQ" > "HOL4Base.rich_list.SNOC_EQ_LENGTH_EQ"
- "SNOC_CASES" > "HOL4Base.rich_list.SNOC_CASES"
- "SNOC_Axiom" > "HOL4Base.rich_list.SNOC_Axiom"
- "SNOC_APPEND" > "HOL4Base.rich_list.SNOC_APPEND"
- "SNOC_11" > "HOL4Base.rich_list.SNOC_11"
- "SNOC" > "HOL4Base.rich_list.SNOC"
- "SEG_SUC_CONS" > "HOL4Base.rich_list.SEG_SUC_CONS"
- "SEG_SNOC" > "HOL4Base.rich_list.SEG_SNOC"
- "SEG_SEG" > "HOL4Base.rich_list.SEG_SEG"
- "SEG_REVERSE" > "HOL4Base.rich_list.SEG_REVERSE"
- "SEG_LENGTH_SNOC" > "HOL4Base.rich_list.SEG_LENGTH_SNOC"
- "SEG_LENGTH_ID" > "HOL4Base.rich_list.SEG_LENGTH_ID"
- "SEG_LASTN_BUTLASTN" > "HOL4Base.rich_list.SEG_LASTN_BUTLASTN"
- "SEG_FIRSTN_BUTFISTN" > "HOL4Base.rich_list.SEG_FIRSTN_BUTFISTN"
- "SEG_APPEND2" > "HOL4Base.rich_list.SEG_APPEND2"
- "SEG_APPEND1" > "HOL4Base.rich_list.SEG_APPEND1"
- "SEG_APPEND" > "HOL4Base.rich_list.SEG_APPEND"
- "SEG_0_SNOC" > "HOL4Base.rich_list.SEG_0_SNOC"
- "SEG" > "HOL4Base.rich_list.SEG"
- "SCANR" > "HOL4Base.rich_list.SCANR"
- "SCANL" > "HOL4Base.rich_list.SCANL"
- "REVERSE_SNOC" > "HOL4Base.rich_list.REVERSE_SNOC"
- "REVERSE_REVERSE" > "List.rev_rev_ident"
- "REVERSE_FOLDR" > "HOL4Base.rich_list.REVERSE_FOLDR"
- "REVERSE_FLAT" > "HOL4Base.rich_list.REVERSE_FLAT"
- "REVERSE_EQ_NIL" > "List.rev_is_Nil_conv"
- "REVERSE_APPEND" > "List.rev_append"
- "REVERSE" > "HOL4Base.rich_list.REVERSE"
- "REPLICATE" > "HOL4Base.rich_list.REPLICATE"
- "PREFIX_def" > "HOL4Base.rich_list.PREFIX_def"
- "PREFIX_FOLDR" > "HOL4Base.rich_list.PREFIX_FOLDR"
- "PREFIX_DEF" > "HOL4Base.rich_list.PREFIX_DEF"
- "PREFIX" > "HOL4Base.rich_list.PREFIX"
- "OR_EL_def" > "HOL4Base.rich_list.OR_EL_def"
- "OR_EL_FOLDR" > "HOL4Base.rich_list.OR_EL_FOLDR"
- "OR_EL_FOLDL" > "HOL4Base.rich_list.OR_EL_FOLDL"
- "OR_EL_DEF" > "HOL4Base.rich_list.OR_EL_DEF"
- "NULL_FOLDR" > "HOL4Base.rich_list.NULL_FOLDR"
- "NULL_FOLDL" > "HOL4Base.rich_list.NULL_FOLDL"
- "NULL_EQ_NIL" > "List.eq_Nil_null"
- "NULL_DEF" > "Compatibility.NULL_DEF"
- "NULL" > "HOL4Base.list.NULL"
- "NOT_SOME_EL_ALL_EL" > "HOL4Base.list.NOT_EXISTS"
- "NOT_SNOC_NIL" > "HOL4Base.rich_list.NOT_SNOC_NIL"
- "NOT_NIL_SNOC" > "HOL4Base.rich_list.NOT_NIL_SNOC"
- "NOT_NIL_CONS" > "List.list.distinct_1"
- "NOT_EQ_LIST" > "HOL4Base.list.NOT_EQ_LIST"
- "NOT_CONS_NIL" > "List.list.distinct_2"
- "NOT_ALL_EL_SOME_EL" > "HOL4Base.list.NOT_EVERY"
- "MONOID_APPEND_NIL" > "HOL4Base.rich_list.MONOID_APPEND_NIL"
- "MAP_o" > "List.map.comp"
- "MAP_SNOC" > "HOL4Base.rich_list.MAP_SNOC"
- "MAP_REVERSE" > "List.rev_map"
- "MAP_MAP_o" > "List.map.compositionality"
- "MAP_FOLDR" > "HOL4Base.rich_list.MAP_FOLDR"
- "MAP_FOLDL" > "HOL4Base.rich_list.MAP_FOLDL"
- "MAP_FLAT" > "List.map_concat"
- "MAP_FILTER" > "HOL4Base.rich_list.MAP_FILTER"
- "MAP_APPEND" > "List.map_append"
- "MAP2_ZIP" > "HOL4Base.list.MAP2_ZIP"
- "MAP2" > "Compatibility.MAP2"
- "MAP" > "Compatibility.MAP"
- "LIST_NOT_EQ" > "HOL4Base.list.LIST_NOT_EQ"
- "LENGTH_ZIP" > "HOL4Base.list.LENGTH_ZIP"
- "LENGTH_UNZIP_SND" > "HOL4Base.rich_list.LENGTH_UNZIP_SND"
- "LENGTH_UNZIP_FST" > "HOL4Base.rich_list.LENGTH_UNZIP_FST"
- "LENGTH_SNOC" > "HOL4Base.rich_list.LENGTH_SNOC"
- "LENGTH_SEG" > "HOL4Base.rich_list.LENGTH_SEG"
- "LENGTH_SCANR" > "HOL4Base.rich_list.LENGTH_SCANR"
- "LENGTH_SCANL" > "HOL4Base.rich_list.LENGTH_SCANL"
- "LENGTH_REVERSE" > "List.length_rev"
- "LENGTH_REPLICATE" > "HOL4Base.rich_list.LENGTH_REPLICATE"
- "LENGTH_NOT_NULL" > "HOL4Base.rich_list.LENGTH_NOT_NULL"
- "LENGTH_NIL" > "List.length_0_conv"
- "LENGTH_MAP2" > "HOL4Base.rich_list.LENGTH_MAP2"
- "LENGTH_MAP" > "List.length_map"
- "LENGTH_LASTN" > "HOL4Base.rich_list.LENGTH_LASTN"
- "LENGTH_GENLIST" > "HOL4Base.rich_list.LENGTH_GENLIST"
- "LENGTH_FOLDR" > "HOL4Base.rich_list.LENGTH_FOLDR"
- "LENGTH_FOLDL" > "HOL4Base.rich_list.LENGTH_FOLDL"
- "LENGTH_FLAT" > "HOL4Base.rich_list.LENGTH_FLAT"
- "LENGTH_FIRSTN" > "HOL4Base.rich_list.LENGTH_FIRSTN"
- "LENGTH_EQ_NIL" > "HOL4Base.list.LENGTH_EQ_NIL"
- "LENGTH_EQ" > "HOL4Base.rich_list.LENGTH_EQ"
- "LENGTH_CONS" > "HOL4Base.list.LENGTH_CONS"
- "LENGTH_BUTLASTN" > "HOL4Base.rich_list.LENGTH_BUTLASTN"
- "LENGTH_BUTLAST" > "HOL4Base.rich_list.LENGTH_BUTLAST"
- "LENGTH_BUTFIRSTN" > "HOL4Base.rich_list.LENGTH_BUTFIRSTN"
- "LENGTH_APPEND" > "List.length_append"
- "LENGTH" > "Compatibility.LENGTH"
- "LAST_LASTN_LAST" > "HOL4Base.rich_list.LAST_LASTN_LAST"
- "LAST_CONS" > "HOL4Base.list.LAST_CONS"
- "LASTN_SEG" > "HOL4Base.rich_list.LASTN_SEG"
- "LASTN_REVERSE" > "HOL4Base.rich_list.LASTN_REVERSE"
- "LASTN_MAP" > "HOL4Base.rich_list.LASTN_MAP"
- "LASTN_LENGTH_ID" > "HOL4Base.rich_list.LASTN_LENGTH_ID"
- "LASTN_LENGTH_APPEND" > "HOL4Base.rich_list.LASTN_LENGTH_APPEND"
- "LASTN_LASTN" > "HOL4Base.rich_list.LASTN_LASTN"
- "LASTN_CONS" > "HOL4Base.rich_list.LASTN_CONS"
- "LASTN_BUTLASTN" > "HOL4Base.rich_list.LASTN_BUTLASTN"
- "LASTN_BUTFIRSTN" > "HOL4Base.rich_list.LASTN_BUTFIRSTN"
- "LASTN_APPEND2" > "HOL4Base.rich_list.LASTN_APPEND2"
- "LASTN_APPEND1" > "HOL4Base.rich_list.LASTN_APPEND1"
- "LASTN_1" > "HOL4Base.rich_list.LASTN_1"
- "LASTN" > "HOL4Base.rich_list.LASTN"
- "LAST" > "HOL4Base.rich_list.LAST"
- "IS_SUFFIX_REVERSE" > "HOL4Base.rich_list.IS_SUFFIX_REVERSE"
- "IS_SUFFIX_IS_SUBLIST" > "HOL4Base.rich_list.IS_SUFFIX_IS_SUBLIST"
- "IS_SUFFIX_APPEND" > "HOL4Base.rich_list.IS_SUFFIX_APPEND"
- "IS_SUFFIX" > "HOL4Base.rich_list.IS_SUFFIX"
- "IS_SUBLIST_REVERSE" > "HOL4Base.rich_list.IS_SUBLIST_REVERSE"
- "IS_SUBLIST_APPEND" > "HOL4Base.rich_list.IS_SUBLIST_APPEND"
- "IS_SUBLIST" > "HOL4Base.rich_list.IS_SUBLIST"
- "IS_PREFIX_REVERSE" > "HOL4Base.rich_list.IS_PREFIX_REVERSE"
- "IS_PREFIX_PREFIX" > "HOL4Base.rich_list.IS_PREFIX_PREFIX"
- "IS_PREFIX_IS_SUBLIST" > "HOL4Base.rich_list.IS_PREFIX_IS_SUBLIST"
- "IS_PREFIX_APPEND" > "HOL4Base.rich_list.IS_PREFIX_APPEND"
- "IS_PREFIX" > "HOL4Base.rich_list.IS_PREFIX"
- "IS_EL_SOME_EL" > "HOL4Base.rich_list.IS_EL_SOME_EL"
- "IS_EL_SNOC" > "HOL4Base.rich_list.IS_EL_SNOC"
- "IS_EL_SEG" > "HOL4Base.rich_list.IS_EL_SEG"
- "IS_EL_REVERSE" > "HOL4Base.rich_list.IS_EL_REVERSE"
- "IS_EL_REPLICATE" > "HOL4Base.rich_list.IS_EL_REPLICATE"
- "IS_EL_LASTN" > "HOL4Base.rich_list.IS_EL_LASTN"
- "IS_EL_FOLDR_MAP" > "HOL4Base.rich_list.IS_EL_FOLDR_MAP"
- "IS_EL_FOLDR" > "HOL4Base.rich_list.IS_EL_FOLDR"
- "IS_EL_FOLDL_MAP" > "HOL4Base.rich_list.IS_EL_FOLDL_MAP"
- "IS_EL_FOLDL" > "HOL4Base.rich_list.IS_EL_FOLDL"
- "IS_EL_FIRSTN" > "HOL4Base.rich_list.IS_EL_FIRSTN"
- "IS_EL_FILTER" > "HOL4Base.rich_list.IS_EL_FILTER"
- "IS_EL_DEF" > "HOL4Base.rich_list.IS_EL_DEF"
- "IS_EL_BUTLASTN" > "HOL4Base.rich_list.IS_EL_BUTLASTN"
- "IS_EL_BUTFIRSTN" > "HOL4Base.rich_list.IS_EL_BUTFIRSTN"
- "IS_EL_APPEND" > "HOL4Base.list.MEM_APPEND"
- "IS_EL" > "Compatibility.MEM"
- "HD" > "List.hd.simps"
- "GENLIST" > "HOL4Base.rich_list.GENLIST"
- "FOLDR_SNOC" > "HOL4Base.rich_list.FOLDR_SNOC"
- "FOLDR_SINGLE" > "HOL4Base.rich_list.FOLDR_SINGLE"
- "FOLDR_REVERSE" > "HOL4Base.rich_list.FOLDR_REVERSE"
- "FOLDR_MAP_REVERSE" > "HOL4Base.rich_list.FOLDR_MAP_REVERSE"
- "FOLDR_MAP" > "HOL4Base.rich_list.FOLDR_MAP"
- "FOLDR_FOLDL_REVERSE" > "List.foldr_foldl"
- "FOLDR_FOLDL" > "HOL4Base.rich_list.FOLDR_FOLDL"
- "FOLDR_FILTER_REVERSE" > "HOL4Base.rich_list.FOLDR_FILTER_REVERSE"
- "FOLDR_FILTER" > "HOL4Base.rich_list.FOLDR_FILTER"
- "FOLDR_CONS_NIL" > "HOL4Base.rich_list.FOLDR_CONS_NIL"
- "FOLDR_APPEND" > "List.foldr_append"
- "FOLDR" > "Compatibility.FOLDR"
- "FOLDL_SNOC_NIL" > "HOL4Base.rich_list.FOLDL_SNOC_NIL"
- "FOLDL_SNOC" > "HOL4Base.rich_list.FOLDL_SNOC"
- "FOLDL_SINGLE" > "HOL4Base.rich_list.FOLDL_SINGLE"
- "FOLDL_REVERSE" > "HOL4Base.rich_list.FOLDL_REVERSE"
- "FOLDL_MAP" > "List.foldl_map"
- "FOLDL_FOLDR_REVERSE" > "List.foldl_foldr"
- "FOLDL_FILTER" > "HOL4Base.rich_list.FOLDL_FILTER"
- "FOLDL_APPEND" > "List.foldl_append"
- "FOLDL" > "Compatibility.FOLDL"
- "FLAT_SNOC" > "HOL4Base.rich_list.FLAT_SNOC"
- "FLAT_REVERSE" > "HOL4Base.rich_list.FLAT_REVERSE"
- "FLAT_FOLDR" > "HOL4Base.rich_list.FLAT_FOLDR"
- "FLAT_FLAT" > "HOL4Base.rich_list.FLAT_FLAT"
- "FLAT_APPEND" > "List.concat_append"
- "FLAT" > "Compatibility.FLAT"
- "FIRSTN_SNOC" > "HOL4Base.rich_list.FIRSTN_SNOC"
- "FIRSTN_SEG" > "HOL4Base.rich_list.FIRSTN_SEG"
- "FIRSTN_REVERSE" > "HOL4Base.rich_list.FIRSTN_REVERSE"
- "FIRSTN_LENGTH_ID" > "HOL4Base.rich_list.FIRSTN_LENGTH_ID"
- "FIRSTN_LENGTH_APPEND" > "HOL4Base.rich_list.FIRSTN_LENGTH_APPEND"
- "FIRSTN_FIRSTN" > "HOL4Base.rich_list.FIRSTN_FIRSTN"
- "FIRSTN_BUTLASTN" > "HOL4Base.rich_list.FIRSTN_BUTLASTN"
- "FIRSTN_APPEND2" > "HOL4Base.rich_list.FIRSTN_APPEND2"
- "FIRSTN_APPEND1" > "HOL4Base.rich_list.FIRSTN_APPEND1"
- "FIRSTN" > "HOL4Base.rich_list.FIRSTN"
- "FILTER_SNOC" > "HOL4Base.rich_list.FILTER_SNOC"
- "FILTER_REVERSE" > "List.rev_filter"
- "FILTER_MAP" > "List.filter_map"
- "FILTER_IDEM" > "HOL4Base.rich_list.FILTER_IDEM"
- "FILTER_FOLDR" > "HOL4Base.rich_list.FILTER_FOLDR"
- "FILTER_FOLDL" > "HOL4Base.rich_list.FILTER_FOLDL"
- "FILTER_FLAT" > "List.filter_concat"
- "FILTER_FILTER" > "HOL4Base.rich_list.FILTER_FILTER"
- "FILTER_COMM" > "HOL4Base.rich_list.FILTER_COMM"
- "FILTER_APPEND" > "List.filter_append"
- "FILTER" > "Compatibility.FILTER"
- "FCOMM_FOLDR_FLAT" > "HOL4Base.rich_list.FCOMM_FOLDR_FLAT"
- "FCOMM_FOLDR_APPEND" > "HOL4Base.rich_list.FCOMM_FOLDR_APPEND"
- "FCOMM_FOLDL_FLAT" > "HOL4Base.rich_list.FCOMM_FOLDL_FLAT"
- "FCOMM_FOLDL_APPEND" > "HOL4Base.rich_list.FCOMM_FOLDL_APPEND"
- "EQ_LIST" > "HOL4Base.list.EQ_LIST"
- "EL_SNOC" > "HOL4Base.rich_list.EL_SNOC"
- "EL_SEG" > "HOL4Base.rich_list.EL_SEG"
- "EL_REVERSE_ELL" > "HOL4Base.rich_list.EL_REVERSE_ELL"
- "EL_REVERSE" > "HOL4Base.rich_list.EL_REVERSE"
- "EL_PRE_LENGTH" > "HOL4Base.rich_list.EL_PRE_LENGTH"
- "EL_MAP" > "HOL4Base.rich_list.EL_MAP"
- "EL_LENGTH_SNOC" > "HOL4Base.rich_list.EL_LENGTH_SNOC"
- "EL_LENGTH_APPEND" > "HOL4Base.rich_list.EL_LENGTH_APPEND"
- "EL_IS_EL" > "HOL4Base.rich_list.EL_IS_EL"
- "EL_ELL" > "HOL4Base.rich_list.EL_ELL"
- "EL_CONS" > "HOL4Base.rich_list.EL_CONS"
- "EL_APPEND2" > "HOL4Base.rich_list.EL_APPEND2"
- "EL_APPEND1" > "HOL4Base.rich_list.EL_APPEND1"
- "ELL_SUC_SNOC" > "HOL4Base.rich_list.ELL_SUC_SNOC"
- "ELL_SNOC" > "HOL4Base.rich_list.ELL_SNOC"
- "ELL_SEG" > "HOL4Base.rich_list.ELL_SEG"
- "ELL_REVERSE_EL" > "HOL4Base.rich_list.ELL_REVERSE_EL"
- "ELL_REVERSE" > "HOL4Base.rich_list.ELL_REVERSE"
- "ELL_PRE_LENGTH" > "HOL4Base.rich_list.ELL_PRE_LENGTH"
- "ELL_MAP" > "HOL4Base.rich_list.ELL_MAP"
- "ELL_LENGTH_SNOC" > "HOL4Base.rich_list.ELL_LENGTH_SNOC"
- "ELL_LENGTH_CONS" > "HOL4Base.rich_list.ELL_LENGTH_CONS"
- "ELL_LENGTH_APPEND" > "HOL4Base.rich_list.ELL_LENGTH_APPEND"
- "ELL_LAST" > "HOL4Base.rich_list.ELL_LAST"
- "ELL_IS_EL" > "HOL4Base.rich_list.ELL_IS_EL"
- "ELL_EL" > "HOL4Base.rich_list.ELL_EL"
- "ELL_CONS" > "HOL4Base.rich_list.ELL_CONS"
- "ELL_APPEND2" > "HOL4Base.rich_list.ELL_APPEND2"
- "ELL_APPEND1" > "HOL4Base.rich_list.ELL_APPEND1"
- "ELL_0_SNOC" > "HOL4Base.rich_list.ELL_0_SNOC"
- "ELL" > "HOL4Base.rich_list.ELL"
- "EL" > "HOL4Base.rich_list.EL"
- "CONS_APPEND" > "HOL4Base.rich_list.CONS_APPEND"
- "CONS_11" > "List.list.inject"
- "CONS" > "HOL4Base.list.CONS"
- "COMM_MONOID_FOLDR" > "HOL4Base.rich_list.COMM_MONOID_FOLDR"
- "COMM_MONOID_FOLDL" > "HOL4Base.rich_list.COMM_MONOID_FOLDL"
- "COMM_ASSOC_FOLDR_REVERSE" > "HOL4Base.rich_list.COMM_ASSOC_FOLDR_REVERSE"
- "COMM_ASSOC_FOLDL_REVERSE" > "HOL4Base.rich_list.COMM_ASSOC_FOLDL_REVERSE"
- "BUTLAST_CONS" > "HOL4Base.list.FRONT_CONS"
- "BUTLASTN_SUC_BUTLAST" > "HOL4Base.rich_list.BUTLASTN_SUC_BUTLAST"
- "BUTLASTN_SEG" > "HOL4Base.rich_list.BUTLASTN_SEG"
- "BUTLASTN_REVERSE" > "HOL4Base.rich_list.BUTLASTN_REVERSE"
- "BUTLASTN_MAP" > "HOL4Base.rich_list.BUTLASTN_MAP"
- "BUTLASTN_LENGTH_NIL" > "HOL4Base.rich_list.BUTLASTN_LENGTH_NIL"
- "BUTLASTN_LENGTH_CONS" > "HOL4Base.rich_list.BUTLASTN_LENGTH_CONS"
- "BUTLASTN_LENGTH_APPEND" > "HOL4Base.rich_list.BUTLASTN_LENGTH_APPEND"
- "BUTLASTN_LASTN_NIL" > "HOL4Base.rich_list.BUTLASTN_LASTN_NIL"
- "BUTLASTN_LASTN" > "HOL4Base.rich_list.BUTLASTN_LASTN"
- "BUTLASTN_FIRSTN" > "HOL4Base.rich_list.BUTLASTN_FIRSTN"
- "BUTLASTN_CONS" > "HOL4Base.rich_list.BUTLASTN_CONS"
- "BUTLASTN_BUTLASTN" > "HOL4Base.rich_list.BUTLASTN_BUTLASTN"
- "BUTLASTN_BUTLAST" > "HOL4Base.rich_list.BUTLASTN_BUTLAST"
- "BUTLASTN_APPEND2" > "HOL4Base.rich_list.BUTLASTN_APPEND2"
- "BUTLASTN_APPEND1" > "HOL4Base.rich_list.BUTLASTN_APPEND1"
- "BUTLASTN_1" > "HOL4Base.rich_list.BUTLASTN_1"
- "BUTLASTN" > "HOL4Base.rich_list.BUTLASTN"
- "BUTLAST" > "HOL4Base.rich_list.BUTLAST"
- "BUTFIRSTN_SNOC" > "HOL4Base.rich_list.BUTFIRSTN_SNOC"
- "BUTFIRSTN_SEG" > "HOL4Base.rich_list.BUTFIRSTN_SEG"
- "BUTFIRSTN_REVERSE" > "HOL4Base.rich_list.BUTFIRSTN_REVERSE"
- "BUTFIRSTN_LENGTH_NIL" > "HOL4Base.rich_list.BUTFIRSTN_LENGTH_NIL"
- "BUTFIRSTN_LENGTH_APPEND" > "HOL4Base.rich_list.BUTFIRSTN_LENGTH_APPEND"
- "BUTFIRSTN_LASTN" > "HOL4Base.rich_list.BUTFIRSTN_LASTN"
- "BUTFIRSTN_BUTFIRSTN" > "HOL4Base.rich_list.BUTFIRSTN_BUTFIRSTN"
- "BUTFIRSTN_APPEND2" > "HOL4Base.rich_list.BUTFIRSTN_APPEND2"
- "BUTFIRSTN_APPEND1" > "HOL4Base.rich_list.BUTFIRSTN_APPEND1"
- "BUTFIRSTN" > "HOL4Base.rich_list.BUTFIRSTN"
- "ASSOC_FOLDR_FLAT" > "HOL4Base.rich_list.ASSOC_FOLDR_FLAT"
- "ASSOC_FOLDL_FLAT" > "HOL4Base.rich_list.ASSOC_FOLDL_FLAT"
- "ASSOC_APPEND" > "HOL4Base.rich_list.ASSOC_APPEND"
- "APPEND_SNOC" > "HOL4Base.rich_list.APPEND_SNOC"
- "APPEND_NIL" > "HOL4Base.rich_list.APPEND_NIL"
- "APPEND_LENGTH_EQ" > "HOL4Base.rich_list.APPEND_LENGTH_EQ"
- "APPEND_FOLDR" > "HOL4Base.rich_list.APPEND_FOLDR"
- "APPEND_FOLDL" > "HOL4Base.rich_list.APPEND_FOLDL"
- "APPEND_FIRSTN_LASTN" > "HOL4Base.rich_list.APPEND_FIRSTN_LASTN"
- "APPEND_FIRSTN_BUTFIRSTN" > "HOL4Base.rich_list.APPEND_FIRSTN_BUTFIRSTN"
- "APPEND_BUTLAST_LAST" > "List.append_butlast_last_id"
- "APPEND_BUTLASTN_LASTN" > "HOL4Base.rich_list.APPEND_BUTLASTN_LASTN"
- "APPEND_BUTLASTN_BUTFIRSTN" > "HOL4Base.rich_list.APPEND_BUTLASTN_BUTFIRSTN"
- "APPEND_ASSOC" > "List.append_assoc"
- "APPEND" > "Compatibility.APPEND"
- "AND_EL_def" > "HOL4Base.rich_list.AND_EL_def"
- "AND_EL_FOLDR" > "HOL4Base.rich_list.AND_EL_FOLDR"
- "AND_EL_FOLDL" > "HOL4Base.rich_list.AND_EL_FOLDL"
- "AND_EL_DEF" > "HOL4Base.rich_list.AND_EL_DEF"
- "ALL_EL_SNOC" > "HOL4Base.rich_list.ALL_EL_SNOC"
- "ALL_EL_SEG" > "HOL4Base.rich_list.ALL_EL_SEG"
- "ALL_EL_REVERSE" > "List.list_all_rev"
- "ALL_EL_REPLICATE" > "HOL4Base.rich_list.ALL_EL_REPLICATE"
- "ALL_EL_MAP" > "HOL4Base.rich_list.ALL_EL_MAP"
- "ALL_EL_LASTN" > "HOL4Base.rich_list.ALL_EL_LASTN"
- "ALL_EL_FOLDR_MAP" > "HOL4Base.rich_list.ALL_EL_FOLDR_MAP"
- "ALL_EL_FOLDR" > "HOL4Base.rich_list.ALL_EL_FOLDR"
- "ALL_EL_FOLDL_MAP" > "HOL4Base.rich_list.ALL_EL_FOLDL_MAP"
- "ALL_EL_FOLDL" > "HOL4Base.rich_list.ALL_EL_FOLDL"
- "ALL_EL_FIRSTN" > "HOL4Base.rich_list.ALL_EL_FIRSTN"
- "ALL_EL_CONJ" > "HOL4Base.list.EVERY_CONJ"
- "ALL_EL_BUTLASTN" > "HOL4Base.rich_list.ALL_EL_BUTLASTN"
- "ALL_EL_BUTFIRSTN" > "HOL4Base.rich_list.ALL_EL_BUTFIRSTN"
- "ALL_EL_APPEND" > "List.list_all_append"
- "ALL_EL" > "Compatibility.EVERY_DEF"
-
-end
--- a/src/HOL/Import/HOL4/Generated/seq.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,112 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "sums" > "sums_def"
- "summable" > "summable_def"
- "suminf" > "suminf_def"
- "subseq" > "subseq_def"
- "mono" > "mono_def"
- "lim" > "lim_def"
- "hol4-->" > "hol4-->_def"
- "convergent" > "convergent_def"
- "cauchy" > "cauchy_def"
-
-const_maps
- "sums" > "HOL4Real.seq.sums"
- "summable" > "HOL4Real.seq.summable"
- "suminf" > "HOL4Real.seq.suminf"
- "subseq" > "HOL4Real.seq.subseq"
- "mono" > "HOL4Real.seq.mono"
- "lim" > "HOL4Real.seq.lim"
- "hol4-->" > "HOL4Real.seq.hol4-->"
- "convergent" > "HOL4Real.seq.convergent"
- "cauchy" > "HOL4Real.seq.cauchy"
-
-const_renames
- "-->" > "hol4-->"
-
-thm_maps
- "tends_num_real" > "HOL4Real.seq.tends_num_real"
- "sums_def" > "HOL4Real.seq.sums_def"
- "sums" > "HOL4Real.seq.sums"
- "summable_def" > "HOL4Real.seq.summable_def"
- "summable" > "HOL4Real.seq.summable"
- "suminf_def" > "HOL4Real.seq.suminf_def"
- "suminf" > "HOL4Real.seq.suminf"
- "subseq_def" > "HOL4Real.seq.subseq_def"
- "subseq" > "HOL4Real.seq.subseq"
- "mono_def" > "HOL4Real.seq.mono_def"
- "mono" > "HOL4Real.seq.mono"
- "lim_def" > "HOL4Real.seq.lim_def"
- "lim" > "HOL4Real.seq.lim"
- "hol4-->_def" > "HOL4Real.seq.hol4-->_def"
- "convergent_def" > "HOL4Real.seq.convergent_def"
- "convergent" > "HOL4Real.seq.convergent"
- "cauchy_def" > "HOL4Real.seq.cauchy_def"
- "cauchy" > "HOL4Real.seq.cauchy"
- "SUM_UNIQ" > "HOL4Real.seq.SUM_UNIQ"
- "SUM_SUMMABLE" > "HOL4Real.seq.SUM_SUMMABLE"
- "SUMMABLE_SUM" > "HOL4Real.seq.SUMMABLE_SUM"
- "SUBSEQ_SUC" > "HOL4Real.seq.SUBSEQ_SUC"
- "SER_ZERO" > "HOL4Real.seq.SER_ZERO"
- "SER_SUB" > "HOL4Real.seq.SER_SUB"
- "SER_RATIO" > "HOL4Real.seq.SER_RATIO"
- "SER_POS_LT_PAIR" > "HOL4Real.seq.SER_POS_LT_PAIR"
- "SER_POS_LT" > "HOL4Real.seq.SER_POS_LT"
- "SER_POS_LE" > "HOL4Real.seq.SER_POS_LE"
- "SER_PAIR" > "HOL4Real.seq.SER_PAIR"
- "SER_OFFSET" > "HOL4Real.seq.SER_OFFSET"
- "SER_NEG" > "HOL4Real.seq.SER_NEG"
- "SER_LE2" > "HOL4Real.seq.SER_LE2"
- "SER_LE" > "HOL4Real.seq.SER_LE"
- "SER_GROUP" > "HOL4Real.seq.SER_GROUP"
- "SER_COMPARA" > "HOL4Real.seq.SER_COMPARA"
- "SER_COMPAR" > "HOL4Real.seq.SER_COMPAR"
- "SER_CMUL" > "HOL4Real.seq.SER_CMUL"
- "SER_CDIV" > "HOL4Real.seq.SER_CDIV"
- "SER_CAUCHY" > "HOL4Real.seq.SER_CAUCHY"
- "SER_ADD" > "HOL4Real.seq.SER_ADD"
- "SER_ACONV" > "HOL4Real.seq.SER_ACONV"
- "SER_ABS" > "HOL4Real.seq.SER_ABS"
- "SER_0" > "HOL4Real.seq.SER_0"
- "SEQ_UNIQ" > "HOL4Real.seq.SEQ_UNIQ"
- "SEQ_SUC" > "HOL4Real.seq.SEQ_SUC"
- "SEQ_SUBLE" > "HOL4Real.seq.SEQ_SUBLE"
- "SEQ_SUB" > "HOL4Real.seq.SEQ_SUB"
- "SEQ_SBOUNDED" > "HOL4Real.seq.SEQ_SBOUNDED"
- "SEQ_POWER_ABS" > "HOL4Real.seq.SEQ_POWER_ABS"
- "SEQ_POWER" > "HOL4Real.seq.SEQ_POWER"
- "SEQ_NEG_CONV" > "HOL4Real.seq.SEQ_NEG_CONV"
- "SEQ_NEG_BOUNDED" > "HOL4Real.seq.SEQ_NEG_BOUNDED"
- "SEQ_NEG" > "HOL4Real.seq.SEQ_NEG"
- "SEQ_MUL" > "HOL4Real.seq.SEQ_MUL"
- "SEQ_MONOSUB" > "HOL4Real.seq.SEQ_MONOSUB"
- "SEQ_LIM" > "HOL4Real.seq.SEQ_LIM"
- "SEQ_LE" > "HOL4Real.seq.SEQ_LE"
- "SEQ_INV0" > "HOL4Real.seq.SEQ_INV0"
- "SEQ_INV" > "HOL4Real.seq.SEQ_INV"
- "SEQ_ICONV" > "HOL4Real.seq.SEQ_ICONV"
- "SEQ_DIV" > "HOL4Real.seq.SEQ_DIV"
- "SEQ_DIRECT" > "HOL4Real.seq.SEQ_DIRECT"
- "SEQ_CONST" > "HOL4Real.seq.SEQ_CONST"
- "SEQ_CBOUNDED" > "HOL4Real.seq.SEQ_CBOUNDED"
- "SEQ_CAUCHY" > "HOL4Real.seq.SEQ_CAUCHY"
- "SEQ_BOUNDED_2" > "HOL4Real.seq.SEQ_BOUNDED_2"
- "SEQ_BOUNDED" > "HOL4Real.seq.SEQ_BOUNDED"
- "SEQ_BCONV" > "HOL4Real.seq.SEQ_BCONV"
- "SEQ_ADD" > "HOL4Real.seq.SEQ_ADD"
- "SEQ_ABS_IMP" > "HOL4Real.seq.SEQ_ABS_IMP"
- "SEQ_ABS" > "HOL4Real.seq.SEQ_ABS"
- "SEQ" > "HOL4Real.seq.SEQ"
- "NEST_LEMMA_UNIQ" > "HOL4Real.seq.NEST_LEMMA_UNIQ"
- "NEST_LEMMA" > "HOL4Real.seq.NEST_LEMMA"
- "MONO_SUC" > "HOL4Real.seq.MONO_SUC"
- "MAX_LEMMA" > "HOL4Real.seq.MAX_LEMMA"
- "GP_FINITE" > "HOL4Real.seq.GP_FINITE"
- "GP" > "HOL4Real.seq.GP"
- "BOLZANO_LEMMA" > "Deriv.lemma_BOLZANO"
- "ABS_NEG_LEMMA" > "Series.rabs_ratiotest_lemma"
-
-end
--- a/src/HOL/Import/HOL4/Generated/state_transformer.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,42 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "UNIT" > "UNIT_def"
- "MMAP" > "MMAP_def"
- "JOIN" > "JOIN_def"
- "BIND" > "BIND_def"
-
-const_maps
- "UNIT" > "HOL4Base.state_transformer.UNIT"
- "MMAP" > "HOL4Base.state_transformer.MMAP"
- "JOIN" > "HOL4Base.state_transformer.JOIN"
- "BIND" > "HOL4Base.state_transformer.BIND"
-
-thm_maps
- "UNIT_def" > "HOL4Base.state_transformer.UNIT_def"
- "UNIT_UNCURRY" > "HOL4Base.state_transformer.UNIT_UNCURRY"
- "UNIT_DEF" > "HOL4Base.state_transformer.UNIT_DEF"
- "SND_o_UNIT" > "HOL4Base.state_transformer.SND_o_UNIT"
- "MMAP_def" > "HOL4Base.state_transformer.MMAP_def"
- "MMAP_UNIT" > "HOL4Base.state_transformer.MMAP_UNIT"
- "MMAP_JOIN" > "HOL4Base.state_transformer.MMAP_JOIN"
- "MMAP_ID" > "HOL4Base.state_transformer.MMAP_ID"
- "MMAP_DEF" > "HOL4Base.state_transformer.MMAP_DEF"
- "MMAP_COMP" > "HOL4Base.state_transformer.MMAP_COMP"
- "JOIN_def" > "HOL4Base.state_transformer.JOIN_def"
- "JOIN_UNIT" > "HOL4Base.state_transformer.JOIN_UNIT"
- "JOIN_MMAP_UNIT" > "HOL4Base.state_transformer.JOIN_MMAP_UNIT"
- "JOIN_MAP_JOIN" > "HOL4Base.state_transformer.JOIN_MAP_JOIN"
- "JOIN_MAP" > "HOL4Base.state_transformer.JOIN_MAP"
- "JOIN_DEF" > "HOL4Base.state_transformer.JOIN_DEF"
- "FST_o_UNIT" > "HOL4Base.state_transformer.FST_o_UNIT"
- "FST_o_MMAP" > "HOL4Base.state_transformer.FST_o_MMAP"
- "BIND_def" > "HOL4Base.state_transformer.BIND_def"
- "BIND_RIGHT_UNIT" > "HOL4Base.state_transformer.BIND_RIGHT_UNIT"
- "BIND_LEFT_UNIT" > "HOL4Base.state_transformer.BIND_LEFT_UNIT"
- "BIND_DEF" > "HOL4Base.state_transformer.BIND_DEF"
- "BIND_ASSOC" > "HOL4Base.state_transformer.BIND_ASSOC"
-
-end
--- a/src/HOL/Import/HOL4/Generated/sum.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,43 +0,0 @@
-import
-
-import_segment "hol4"
-
-type_maps
- "sum" > "Sum_Type.sum"
-
-const_maps
- "sum_case" > "Sum_Type.sum.sum_case"
- "OUTR" > "Compatibility.OUTR"
- "OUTL" > "Compatibility.OUTL"
- "ISR" > "Compatibility.ISR"
- "ISL" > "Compatibility.ISL"
- "INR" > "Sum_Type.Inr"
- "INL" > "Sum_Type.Inl"
-
-thm_maps
- "sum_distinct1" > "Sum_Type.Inr_not_Inl"
- "sum_distinct" > "Sum_Type.Inl_not_Inr"
- "sum_case_def" > "Compatibility.sum_case_def"
- "sum_case_cong" > "HOL4Base.sum.sum_case_cong"
- "sum_axiom" > "Compatibility.sum_axiom"
- "sum_INDUCT" > "Sum_Type.sum.induct"
- "sum_CASES" > "Sum_Type.sum.nchotomy"
- "OUTR" > "Compatibility.OUTR"
- "OUTL" > "Compatibility.OUTL"
- "ISR" > "Compatibility.ISR"
- "ISL_OR_ISR" > "HOL4Base.sum.ISL_OR_ISR"
- "ISL" > "Compatibility.ISL"
- "INR_neq_INL" > "Sum_Type.Inr_not_Inl"
- "INR_INL_11" > "Compatibility.INR_INL_11"
- "INR" > "HOL4Base.sum.INR"
- "INL" > "HOL4Base.sum.INL"
-
-ignore_thms
- "sum_TY_DEF"
- "sum_ISO_DEF"
- "sum_Axiom"
- "IS_SUM_REP"
- "INR_DEF"
- "INL_DEF"
-
-end
--- a/src/HOL/Import/HOL4/Generated/topology.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,116 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "topology" > "topology_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"
- "open" > "open_def"
- "neigh" > "neigh_def"
- "mtop" > "mtop_def"
- "mr1" > "mr1_def"
- "metric" > "metric_def"
- "limpt" > "limpt_def"
- "istopology" > "istopology_def"
- "ismet" > "ismet_def"
- "dist" > "dist_def"
- "closed" > "closed_def"
- "B" > "B_def"
-
-type_maps
- "topology" > "HOL4Real.topology.topology"
- "metric" > "HOL4Real.topology.metric"
-
-const_maps
- "re_universe" > "HOL4Real.topology.re_universe"
- "re_union" > "HOL4Real.topology.re_union"
- "re_subset" > "HOL4Real.topology.re_subset"
- "re_null" > "HOL4Real.topology.re_null"
- "re_intersect" > "HOL4Real.topology.re_intersect"
- "re_compl" > "HOL4Real.topology.re_compl"
- "re_Union" > "HOL4Real.topology.re_Union"
- "neigh" > "HOL4Real.topology.neigh"
- "mtop" > "HOL4Real.topology.mtop"
- "mr1" > "HOL4Real.topology.mr1"
- "limpt" > "HOL4Real.topology.limpt"
- "istopology" > "HOL4Real.topology.istopology"
- "ismet" > "HOL4Real.topology.ismet"
- "closed" > "HOL4Real.topology.closed"
- "B" > "HOL4Real.topology.B"
-
-thm_maps
- "topology_tybij" > "HOL4Real.topology.topology_tybij"
- "topology_TY_DEF" > "HOL4Real.topology.topology_TY_DEF"
- "re_universe_def" > "HOL4Real.topology.re_universe_def"
- "re_universe" > "HOL4Real.topology.re_universe"
- "re_union_def" > "HOL4Real.topology.re_union_def"
- "re_union" > "HOL4Real.topology.re_union"
- "re_subset_def" > "HOL4Real.topology.re_subset_def"
- "re_subset" > "HOL4Real.topology.re_subset"
- "re_null_def" > "HOL4Real.topology.re_null_def"
- "re_null" > "HOL4Real.topology.re_null"
- "re_intersect_def" > "HOL4Real.topology.re_intersect_def"
- "re_intersect" > "HOL4Real.topology.re_intersect"
- "re_compl_def" > "HOL4Real.topology.re_compl_def"
- "re_compl" > "HOL4Real.topology.re_compl"
- "re_Union_def" > "HOL4Real.topology.re_Union_def"
- "re_Union" > "HOL4Real.topology.re_Union"
- "neigh_def" > "HOL4Real.topology.neigh_def"
- "neigh" > "HOL4Real.topology.neigh"
- "mtop_istopology" > "HOL4Real.topology.mtop_istopology"
- "mtop_def" > "HOL4Real.topology.mtop_def"
- "mtop" > "HOL4Real.topology.mtop"
- "mr1_def" > "HOL4Real.topology.mr1_def"
- "mr1" > "HOL4Real.topology.mr1"
- "metric_tybij" > "HOL4Real.topology.metric_tybij"
- "metric_TY_DEF" > "HOL4Real.topology.metric_TY_DEF"
- "limpt_def" > "HOL4Real.topology.limpt_def"
- "limpt" > "HOL4Real.topology.limpt"
- "istopology_def" > "HOL4Real.topology.istopology_def"
- "istopology" > "HOL4Real.topology.istopology"
- "ismet_def" > "HOL4Real.topology.ismet_def"
- "ismet" > "HOL4Real.topology.ismet"
- "closed_def" > "HOL4Real.topology.closed_def"
- "closed" > "HOL4Real.topology.closed"
- "ball" > "HOL4Real.topology.ball"
- "TOPOLOGY_UNION" > "HOL4Real.topology.TOPOLOGY_UNION"
- "TOPOLOGY" > "HOL4Real.topology.TOPOLOGY"
- "SUBSET_TRANS" > "HOL4Real.topology.SUBSET_TRANS"
- "SUBSET_REFL" > "HOL4Real.topology.SUBSET_REFL"
- "SUBSET_ANTISYM" > "HOL4Real.topology.SUBSET_ANTISYM"
- "OPEN_UNOPEN" > "HOL4Real.topology.OPEN_UNOPEN"
- "OPEN_SUBOPEN" > "HOL4Real.topology.OPEN_SUBOPEN"
- "OPEN_OWN_NEIGH" > "HOL4Real.topology.OPEN_OWN_NEIGH"
- "OPEN_NEIGH" > "HOL4Real.topology.OPEN_NEIGH"
- "MTOP_OPEN" > "HOL4Real.topology.MTOP_OPEN"
- "MTOP_LIMPT" > "HOL4Real.topology.MTOP_LIMPT"
- "MR1_SUB_LT" > "HOL4Real.topology.MR1_SUB_LT"
- "MR1_SUB_LE" > "HOL4Real.topology.MR1_SUB_LE"
- "MR1_SUB" > "HOL4Real.topology.MR1_SUB"
- "MR1_LIMPT" > "HOL4Real.topology.MR1_LIMPT"
- "MR1_DEF" > "HOL4Real.topology.MR1_DEF"
- "MR1_BETWEEN1" > "HOL4Real.topology.MR1_BETWEEN1"
- "MR1_ADD_POS" > "HOL4Real.topology.MR1_ADD_POS"
- "MR1_ADD_LT" > "HOL4Real.topology.MR1_ADD_LT"
- "MR1_ADD" > "HOL4Real.topology.MR1_ADD"
- "METRIC_ZERO" > "HOL4Real.topology.METRIC_ZERO"
- "METRIC_TRIANGLE" > "HOL4Real.topology.METRIC_TRIANGLE"
- "METRIC_SYM" > "HOL4Real.topology.METRIC_SYM"
- "METRIC_SAME" > "HOL4Real.topology.METRIC_SAME"
- "METRIC_POS" > "HOL4Real.topology.METRIC_POS"
- "METRIC_NZ" > "HOL4Real.topology.METRIC_NZ"
- "METRIC_ISMET" > "HOL4Real.topology.METRIC_ISMET"
- "ISMET_R1" > "HOL4Real.topology.ISMET_R1"
- "COMPL_MEM" > "HOL4Real.topology.COMPL_MEM"
- "CLOSED_LIMPT" > "HOL4Real.topology.CLOSED_LIMPT"
- "B_def" > "HOL4Real.topology.B_def"
- "BALL_OPEN" > "HOL4Real.topology.BALL_OPEN"
- "BALL_NEIGH" > "HOL4Real.topology.BALL_NEIGH"
-
-end
--- a/src/HOL/Import/HOL4/Generated/transc.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,273 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "tdiv" > "tdiv_def"
- "tan" > "tan_def"
- "sqrt" > "sqrt_def"
- "sin" > "sin_def"
- "rsum" > "rsum_def"
- "root" > "root_def"
- "pi" > "pi_def"
- "ln" > "ln_def"
- "gauge" > "gauge_def"
- "fine" > "fine_def"
- "exp" > "exp_def"
- "dsize" > "dsize_def"
- "division" > "division_def"
- "cos" > "cos_def"
- "atn" > "atn_def"
- "asn" > "asn_def"
- "acs" > "acs_def"
- "Dint" > "Dint_def"
-
-const_maps
- "tdiv" > "HOL4Real.transc.tdiv"
- "tan" > "HOL4Real.transc.tan"
- "sqrt" > "HOL4Real.transc.sqrt"
- "sin" > "HOL4Real.transc.sin"
- "rsum" > "HOL4Real.transc.rsum"
- "root" > "HOL4Real.transc.root"
- "pi" > "HOL4Real.transc.pi"
- "ln" > "HOL4Real.transc.ln"
- "gauge" > "HOL4Real.transc.gauge"
- "fine" > "HOL4Real.transc.fine"
- "exp" > "HOL4Real.transc.exp"
- "dsize" > "HOL4Real.transc.dsize"
- "division" > "HOL4Real.transc.division"
- "cos" > "HOL4Real.transc.cos"
- "atn" > "HOL4Real.transc.atn"
- "asn" > "HOL4Real.transc.asn"
- "acs" > "HOL4Real.transc.acs"
- "Dint" > "HOL4Real.transc.Dint"
-
-thm_maps
- "tdiv_def" > "HOL4Real.transc.tdiv_def"
- "tdiv" > "HOL4Real.transc.tdiv"
- "tan_def" > "HOL4Real.transc.tan_def"
- "tan" > "HOL4Real.transc.tan"
- "sqrt_def" > "HOL4Real.transc.sqrt_def"
- "sqrt" > "HOL4Real.transc.sqrt"
- "sin_def" > "HOL4Real.transc.sin_def"
- "sin" > "HOL4Real.transc.sin"
- "rsum_def" > "HOL4Real.transc.rsum_def"
- "rsum" > "HOL4Real.transc.rsum"
- "root_def" > "HOL4Real.transc.root_def"
- "root" > "HOL4Real.transc.root"
- "pi_def" > "HOL4Real.transc.pi_def"
- "pi" > "HOL4Real.transc.pi"
- "ln_def" > "HOL4Real.transc.ln_def"
- "ln" > "HOL4Real.transc.ln"
- "gauge_def" > "HOL4Real.transc.gauge_def"
- "gauge" > "HOL4Real.transc.gauge"
- "fine_def" > "HOL4Real.transc.fine_def"
- "fine" > "HOL4Real.transc.fine"
- "exp_def" > "HOL4Real.transc.exp_def"
- "exp" > "HOL4Real.transc.exp"
- "dsize_def" > "HOL4Real.transc.dsize_def"
- "dsize" > "HOL4Real.transc.dsize"
- "division_def" > "HOL4Real.transc.division_def"
- "division" > "HOL4Real.transc.division"
- "cos_def" > "HOL4Real.transc.cos_def"
- "cos" > "HOL4Real.transc.cos"
- "atn_def" > "HOL4Real.transc.atn_def"
- "atn" > "HOL4Real.transc.atn"
- "asn_def" > "HOL4Real.transc.asn_def"
- "asn" > "HOL4Real.transc.asn"
- "acs_def" > "HOL4Real.transc.acs_def"
- "acs" > "HOL4Real.transc.acs"
- "TAN_TOTAL_POS" > "HOL4Real.transc.TAN_TOTAL_POS"
- "TAN_TOTAL_LEMMA" > "HOL4Real.transc.TAN_TOTAL_LEMMA"
- "TAN_TOTAL" > "HOL4Real.transc.TAN_TOTAL"
- "TAN_SEC" > "HOL4Real.transc.TAN_SEC"
- "TAN_POS_PI2" > "HOL4Real.transc.TAN_POS_PI2"
- "TAN_PI" > "HOL4Real.transc.TAN_PI"
- "TAN_PERIODIC" > "HOL4Real.transc.TAN_PERIODIC"
- "TAN_NPI" > "HOL4Real.transc.TAN_NPI"
- "TAN_NEG" > "HOL4Real.transc.TAN_NEG"
- "TAN_DOUBLE" > "HOL4Real.transc.TAN_DOUBLE"
- "TAN_ATN" > "HOL4Real.transc.TAN_ATN"
- "TAN_ADD" > "HOL4Real.transc.TAN_ADD"
- "TAN_0" > "HOL4Real.transc.TAN_0"
- "SQRT_POW_2" > "HOL4Real.transc.SQRT_POW_2"
- "SQRT_POW2" > "HOL4Real.transc.SQRT_POW2"
- "SQRT_POS_UNIQ" > "HOL4Real.transc.SQRT_POS_UNIQ"
- "SQRT_POS_LT" > "HOL4Real.transc.SQRT_POS_LT"
- "SQRT_POS_LE" > "HOL4Real.transc.SQRT_POS_LE"
- "SQRT_MUL" > "HOL4Real.transc.SQRT_MUL"
- "SQRT_MONO_LE" > "HOL4Real.transc.SQRT_MONO_LE"
- "SQRT_INV" > "HOL4Real.transc.SQRT_INV"
- "SQRT_EVEN_POW2" > "HOL4Real.transc.SQRT_EVEN_POW2"
- "SQRT_EQ" > "HOL4Real.transc.SQRT_EQ"
- "SQRT_DIV" > "HOL4Real.transc.SQRT_DIV"
- "SQRT_1" > "HOL4Real.transc.SQRT_1"
- "SQRT_0" > "HOL4Real.transc.SQRT_0"
- "SIN_ZERO_LEMMA" > "HOL4Real.transc.SIN_ZERO_LEMMA"
- "SIN_ZERO" > "HOL4Real.transc.SIN_ZERO"
- "SIN_TOTAL" > "HOL4Real.transc.SIN_TOTAL"
- "SIN_POS_PI_LE" > "HOL4Real.transc.SIN_POS_PI_LE"
- "SIN_POS_PI2_LE" > "HOL4Real.transc.SIN_POS_PI2_LE"
- "SIN_POS_PI2" > "HOL4Real.transc.SIN_POS_PI2"
- "SIN_POS_PI" > "HOL4Real.transc.SIN_POS_PI"
- "SIN_POS" > "HOL4Real.transc.SIN_POS"
- "SIN_PI2" > "HOL4Real.transc.SIN_PI2"
- "SIN_PI" > "HOL4Real.transc.SIN_PI"
- "SIN_PERIODIC_PI" > "HOL4Real.transc.SIN_PERIODIC_PI"
- "SIN_PERIODIC" > "HOL4Real.transc.SIN_PERIODIC"
- "SIN_PAIRED" > "HOL4Real.transc.SIN_PAIRED"
- "SIN_NPI" > "HOL4Real.transc.SIN_NPI"
- "SIN_NEGLEMMA" > "HOL4Real.transc.SIN_NEGLEMMA"
- "SIN_NEG" > "HOL4Real.transc.SIN_NEG"
- "SIN_FDIFF" > "HOL4Real.transc.SIN_FDIFF"
- "SIN_DOUBLE" > "HOL4Real.transc.SIN_DOUBLE"
- "SIN_COS_SQRT" > "HOL4Real.transc.SIN_COS_SQRT"
- "SIN_COS_SQ" > "HOL4Real.transc.SIN_COS_SQ"
- "SIN_COS_NEG" > "HOL4Real.transc.SIN_COS_NEG"
- "SIN_COS_ADD" > "HOL4Real.transc.SIN_COS_ADD"
- "SIN_COS" > "HOL4Real.transc.SIN_COS"
- "SIN_CONVERGES" > "HOL4Real.transc.SIN_CONVERGES"
- "SIN_CIRCLE" > "HOL4Real.transc.SIN_CIRCLE"
- "SIN_BOUNDS" > "HOL4Real.transc.SIN_BOUNDS"
- "SIN_BOUND" > "HOL4Real.transc.SIN_BOUND"
- "SIN_ASN" > "HOL4Real.transc.SIN_ASN"
- "SIN_ADD" > "HOL4Real.transc.SIN_ADD"
- "SIN_ACS_NZ" > "HOL4Real.transc.SIN_ACS_NZ"
- "SIN_0" > "HOL4Real.transc.SIN_0"
- "ROOT_POW_POS" > "HOL4Real.transc.ROOT_POW_POS"
- "ROOT_POS_UNIQ" > "HOL4Real.transc.ROOT_POS_UNIQ"
- "ROOT_POS_LT" > "HOL4Real.transc.ROOT_POS_LT"
- "ROOT_POS" > "HOL4Real.transc.ROOT_POS"
- "ROOT_MUL" > "HOL4Real.transc.ROOT_MUL"
- "ROOT_MONO_LE" > "HOL4Real.transc.ROOT_MONO_LE"
- "ROOT_LT_LEMMA" > "HOL4Real.transc.ROOT_LT_LEMMA"
- "ROOT_LN" > "HOL4Real.transc.ROOT_LN"
- "ROOT_INV" > "HOL4Real.transc.ROOT_INV"
- "ROOT_DIV" > "HOL4Real.transc.ROOT_DIV"
- "ROOT_1" > "HOL4Real.transc.ROOT_1"
- "ROOT_0" > "HOL4Real.transc.ROOT_0"
- "REAL_DIV_SQRT" > "HOL4Real.transc.REAL_DIV_SQRT"
- "POW_ROOT_POS" > "HOL4Real.transc.POW_ROOT_POS"
- "POW_2_SQRT" > "HOL4Real.transc.POW_2_SQRT"
- "PI_POS" > "HOL4Real.transc.PI_POS"
- "PI2_BOUNDS" > "HOL4Real.transc.PI2_BOUNDS"
- "PI2" > "HOL4Real.transc.PI2"
- "MCLAURIN_ZERO" > "HOL4Real.transc.MCLAURIN_ZERO"
- "MCLAURIN_NEG" > "HOL4Real.transc.MCLAURIN_NEG"
- "MCLAURIN_EXP_LT" > "HOL4Real.transc.MCLAURIN_EXP_LT"
- "MCLAURIN_EXP_LE" > "HOL4Real.transc.MCLAURIN_EXP_LE"
- "MCLAURIN_ALL_LT" > "HOL4Real.transc.MCLAURIN_ALL_LT"
- "MCLAURIN_ALL_LE" > "HOL4Real.transc.MCLAURIN_ALL_LE"
- "MCLAURIN" > "HOL4Real.transc.MCLAURIN"
- "LN_POW" > "HOL4Real.transc.LN_POW"
- "LN_POS" > "HOL4Real.transc.LN_POS"
- "LN_MUL" > "HOL4Real.transc.LN_MUL"
- "LN_MONO_LT" > "HOL4Real.transc.LN_MONO_LT"
- "LN_MONO_LE" > "HOL4Real.transc.LN_MONO_LE"
- "LN_LT_X" > "HOL4Real.transc.LN_LT_X"
- "LN_LE" > "HOL4Real.transc.LN_LE"
- "LN_INV" > "HOL4Real.transc.LN_INV"
- "LN_INJ" > "HOL4Real.transc.LN_INJ"
- "LN_EXP" > "HOL4Real.transc.LN_EXP"
- "LN_DIV" > "HOL4Real.transc.LN_DIV"
- "LN_1" > "HOL4Real.transc.LN_1"
- "INTEGRAL_NULL" > "HOL4Real.transc.INTEGRAL_NULL"
- "GAUGE_MIN" > "HOL4Real.transc.GAUGE_MIN"
- "FTC1" > "HOL4Real.transc.FTC1"
- "FINE_MIN" > "HOL4Real.transc.FINE_MIN"
- "EXP_TOTAL_LEMMA" > "HOL4Real.transc.EXP_TOTAL_LEMMA"
- "EXP_TOTAL" > "HOL4Real.transc.EXP_TOTAL"
- "EXP_SUB" > "HOL4Real.transc.EXP_SUB"
- "EXP_POS_LT" > "HOL4Real.transc.EXP_POS_LT"
- "EXP_POS_LE" > "HOL4Real.transc.EXP_POS_LE"
- "EXP_NZ" > "HOL4Real.transc.EXP_NZ"
- "EXP_NEG_MUL2" > "HOL4Real.transc.EXP_NEG_MUL2"
- "EXP_NEG_MUL" > "HOL4Real.transc.EXP_NEG_MUL"
- "EXP_NEG" > "HOL4Real.transc.EXP_NEG"
- "EXP_N" > "HOL4Real.transc.EXP_N"
- "EXP_MONO_LT" > "HOL4Real.transc.EXP_MONO_LT"
- "EXP_MONO_LE" > "HOL4Real.transc.EXP_MONO_LE"
- "EXP_MONO_IMP" > "HOL4Real.transc.EXP_MONO_IMP"
- "EXP_LT_1" > "HOL4Real.transc.EXP_LT_1"
- "EXP_LN" > "HOL4Real.transc.EXP_LN"
- "EXP_LE_X" > "HOL4Real.transc.EXP_LE_X"
- "EXP_INJ" > "HOL4Real.transc.EXP_INJ"
- "EXP_FDIFF" > "HOL4Real.transc.EXP_FDIFF"
- "EXP_CONVERGES" > "HOL4Real.transc.EXP_CONVERGES"
- "EXP_ADD_MUL" > "HOL4Real.transc.EXP_ADD_MUL"
- "EXP_ADD" > "HOL4Real.transc.EXP_ADD"
- "EXP_0" > "HOL4Real.transc.EXP_0"
- "Dint_def" > "HOL4Real.transc.Dint_def"
- "Dint" > "HOL4Real.transc.Dint"
- "DIVISION_UBOUND_LT" > "HOL4Real.transc.DIVISION_UBOUND_LT"
- "DIVISION_UBOUND" > "HOL4Real.transc.DIVISION_UBOUND"
- "DIVISION_THM" > "HOL4Real.transc.DIVISION_THM"
- "DIVISION_SINGLE" > "HOL4Real.transc.DIVISION_SINGLE"
- "DIVISION_RHS" > "HOL4Real.transc.DIVISION_RHS"
- "DIVISION_LT_GEN" > "HOL4Real.transc.DIVISION_LT_GEN"
- "DIVISION_LT" > "HOL4Real.transc.DIVISION_LT"
- "DIVISION_LHS" > "HOL4Real.transc.DIVISION_LHS"
- "DIVISION_LE" > "HOL4Real.transc.DIVISION_LE"
- "DIVISION_LBOUND_LT" > "HOL4Real.transc.DIVISION_LBOUND_LT"
- "DIVISION_LBOUND" > "HOL4Real.transc.DIVISION_LBOUND"
- "DIVISION_GT" > "HOL4Real.transc.DIVISION_GT"
- "DIVISION_EXISTS" > "HOL4Real.transc.DIVISION_EXISTS"
- "DIVISION_EQ" > "HOL4Real.transc.DIVISION_EQ"
- "DIVISION_APPEND" > "HOL4Real.transc.DIVISION_APPEND"
- "DIVISION_1" > "HOL4Real.transc.DIVISION_1"
- "DIVISION_0" > "HOL4Real.transc.DIVISION_0"
- "DINT_UNIQ" > "HOL4Real.transc.DINT_UNIQ"
- "DIFF_TAN" > "HOL4Real.transc.DIFF_TAN"
- "DIFF_SIN" > "HOL4Real.transc.DIFF_SIN"
- "DIFF_LN_COMPOSITE" > "HOL4Real.transc.DIFF_LN_COMPOSITE"
- "DIFF_LN" > "HOL4Real.transc.DIFF_LN"
- "DIFF_EXP" > "HOL4Real.transc.DIFF_EXP"
- "DIFF_COS" > "HOL4Real.transc.DIFF_COS"
- "DIFF_COMPOSITE" > "HOL4Real.transc.DIFF_COMPOSITE"
- "DIFF_ATN" > "HOL4Real.transc.DIFF_ATN"
- "DIFF_ASN_LEMMA" > "HOL4Real.transc.DIFF_ASN_LEMMA"
- "DIFF_ASN" > "HOL4Real.transc.DIFF_ASN"
- "DIFF_ACS_LEMMA" > "HOL4Real.transc.DIFF_ACS_LEMMA"
- "DIFF_ACS" > "HOL4Real.transc.DIFF_ACS"
- "COS_ZERO_LEMMA" > "HOL4Real.transc.COS_ZERO_LEMMA"
- "COS_ZERO" > "HOL4Real.transc.COS_ZERO"
- "COS_TOTAL" > "HOL4Real.transc.COS_TOTAL"
- "COS_SIN_SQRT" > "HOL4Real.transc.COS_SIN_SQRT"
- "COS_SIN_SQ" > "HOL4Real.transc.COS_SIN_SQ"
- "COS_SIN" > "HOL4Real.transc.COS_SIN"
- "COS_POS_PI_LE" > "HOL4Real.transc.COS_POS_PI_LE"
- "COS_POS_PI2_LE" > "HOL4Real.transc.COS_POS_PI2_LE"
- "COS_POS_PI2" > "HOL4Real.transc.COS_POS_PI2"
- "COS_POS_PI" > "HOL4Real.transc.COS_POS_PI"
- "COS_PI2" > "HOL4Real.transc.COS_PI2"
- "COS_PI" > "HOL4Real.transc.COS_PI"
- "COS_PERIODIC_PI" > "HOL4Real.transc.COS_PERIODIC_PI"
- "COS_PERIODIC" > "HOL4Real.transc.COS_PERIODIC"
- "COS_PAIRED" > "HOL4Real.transc.COS_PAIRED"
- "COS_NPI" > "HOL4Real.transc.COS_NPI"
- "COS_NEG" > "HOL4Real.transc.COS_NEG"
- "COS_ISZERO" > "HOL4Real.transc.COS_ISZERO"
- "COS_FDIFF" > "HOL4Real.transc.COS_FDIFF"
- "COS_DOUBLE" > "HOL4Real.transc.COS_DOUBLE"
- "COS_CONVERGES" > "HOL4Real.transc.COS_CONVERGES"
- "COS_BOUNDS" > "HOL4Real.transc.COS_BOUNDS"
- "COS_BOUND" > "HOL4Real.transc.COS_BOUND"
- "COS_ATN_NZ" > "HOL4Real.transc.COS_ATN_NZ"
- "COS_ASN_NZ" > "HOL4Real.transc.COS_ASN_NZ"
- "COS_ADD" > "HOL4Real.transc.COS_ADD"
- "COS_ACS" > "HOL4Real.transc.COS_ACS"
- "COS_2" > "HOL4Real.transc.COS_2"
- "COS_0" > "HOL4Real.transc.COS_0"
- "ATN_TAN" > "HOL4Real.transc.ATN_TAN"
- "ATN_BOUNDS" > "HOL4Real.transc.ATN_BOUNDS"
- "ATN" > "HOL4Real.transc.ATN"
- "ASN_SIN" > "HOL4Real.transc.ASN_SIN"
- "ASN_BOUNDS_LT" > "HOL4Real.transc.ASN_BOUNDS_LT"
- "ASN_BOUNDS" > "HOL4Real.transc.ASN_BOUNDS"
- "ASN" > "HOL4Real.transc.ASN"
- "ACS_COS" > "HOL4Real.transc.ACS_COS"
- "ACS_BOUNDS_LT" > "HOL4Real.transc.ACS_BOUNDS_LT"
- "ACS_BOUNDS" > "HOL4Real.transc.ACS_BOUNDS"
- "ACS" > "HOL4Real.transc.ACS"
-
-end
--- a/src/HOL/Import/HOL4/Generated/word32.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,377 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "word_suc" > "word_suc_def"
- "word_sub" > "word_sub_def"
- "word_ror1" > "word_ror1_def"
- "word_ror" > "word_ror_def"
- "word_mul" > "word_mul_def"
- "word_lsr1" > "word_lsr1_def"
- "word_lsr" > "word_lsr_def"
- "word_lsl" > "word_lsl_def"
- "word_asr1" > "word_asr1_def"
- "word_asr" > "word_asr_def"
- "word_add" > "word_add_def"
- "word_2comp" > "word_2comp_def"
- "word_1comp" > "word_1comp_def"
- "w_T" > "w_T_primdef"
- "w_1" > "w_1_primdef"
- "w_0" > "w_0_primdef"
- "w2n" > "w2n_primdef"
- "n2w" > "n2w_primdef"
- "mk_word32" > "mk_word32_def"
- "dest_word32" > "dest_word32_def"
- "bitwise_or" > "bitwise_or_def"
- "bitwise_eor" > "bitwise_eor_def"
- "bitwise_and" > "bitwise_and_def"
- "WL" > "WL_primdef"
- "TWO_COMP" > "TWO_COMP_primdef"
- "TOw" > "TOw_primdef"
- "SLICEw" > "SLICEw_primdef"
- "RRXn" > "RRXn_primdef"
- "RRX" > "RRX_primdef"
- "ROR_ONE" > "ROR_ONE_primdef"
- "OR" > "OR_primdef"
- "ONE_COMP" > "ONE_COMP_primdef"
- "MSBn" > "MSBn_primdef"
- "MSB" > "MSB_primdef"
- "MODw" > "MODw_primdef"
- "LSR_ONE" > "LSR_ONE_primdef"
- "LSB" > "LSB_primdef"
- "INw" > "INw_primdef"
- "HB" > "HB_primdef"
- "EQUIV" > "EQUIV_primdef"
- "EOR" > "EOR_primdef"
- "COMP0" > "COMP0_primdef"
- "BITw" > "BITw_primdef"
- "BITSw" > "BITSw_primdef"
- "ASR_ONE" > "ASR_ONE_primdef"
- "AONE" > "AONE_primdef"
- "AND" > "AND_primdef"
-
-type_maps
- "word32" > "HOL4Word32.word32.word32"
-
-const_maps
- "word_suc" > "HOL4Word32.word32.word_suc"
- "word_sub" > "HOL4Word32.word32.word_sub"
- "word_ror1" > "HOL4Word32.word32.word_ror1"
- "word_ror" > "HOL4Word32.word32.word_ror"
- "word_mul" > "HOL4Word32.word32.word_mul"
- "word_lsr1" > "HOL4Word32.word32.word_lsr1"
- "word_lsr" > "HOL4Word32.word32.word_lsr"
- "word_lsl" > "HOL4Word32.word32.word_lsl"
- "word_asr1" > "HOL4Word32.word32.word_asr1"
- "word_asr" > "HOL4Word32.word32.word_asr"
- "word_add" > "HOL4Word32.word32.word_add"
- "word_2comp" > "HOL4Word32.word32.word_2comp"
- "word_1comp" > "HOL4Word32.word32.word_1comp"
- "w_T" > "HOL4Word32.word32.w_T"
- "w_1" > "HOL4Word32.word32.w_1"
- "w_0" > "HOL4Word32.word32.w_0"
- "w2n" > "HOL4Word32.word32.w2n"
- "n2w" > "HOL4Word32.word32.n2w"
- "bitwise_or" > "HOL4Word32.word32.bitwise_or"
- "bitwise_eor" > "HOL4Word32.word32.bitwise_eor"
- "bitwise_and" > "HOL4Word32.word32.bitwise_and"
- "WL" > "HOL4Word32.word32.WL"
- "TWO_COMP" > "HOL4Word32.word32.TWO_COMP"
- "TOw" > "HOL4Word32.word32.TOw"
- "SLICEw" > "HOL4Word32.word32.SLICEw"
- "RRXn" > "HOL4Word32.word32.RRXn"
- "RRX" > "HOL4Word32.word32.RRX"
- "ROR_ONE" > "HOL4Word32.word32.ROR_ONE"
- "OR" > "HOL4Word32.word32.OR"
- "ONE_COMP" > "HOL4Word32.word32.ONE_COMP"
- "MSBn" > "HOL4Word32.word32.MSBn"
- "MSB" > "HOL4Word32.word32.MSB"
- "MODw" > "HOL4Word32.word32.MODw"
- "LSR_ONE" > "HOL4Word32.word32.LSR_ONE"
- "LSB" > "HOL4Word32.word32.LSB"
- "INw" > "HOL4Word32.word32.INw"
- "HB" > "HOL4Word32.word32.HB"
- "EQUIV" > "HOL4Word32.word32.EQUIV"
- "EOR" > "HOL4Word32.word32.EOR"
- "COMP0" > "HOL4Word32.word32.COMP0"
- "BITw" > "HOL4Word32.word32.BITw"
- "BITSw" > "HOL4Word32.word32.BITSw"
- "ASR_ONE" > "HOL4Word32.word32.ASR_ONE"
- "AONE" > "HOL4Word32.word32.AONE"
- "AND" > "HOL4Word32.word32.AND"
-
-const_renames
- "==" > "EQUIV"
-
-thm_maps
- "word_suc_def" > "HOL4Word32.word32.word_suc_def"
- "word_suc" > "HOL4Word32.word32.word_suc"
- "word_sub_def" > "HOL4Word32.word32.word_sub_def"
- "word_sub" > "HOL4Word32.word32.word_sub"
- "word_ror_def" > "HOL4Word32.word32.word_ror_def"
- "word_ror1_def" > "HOL4Word32.word32.word_ror1_def"
- "word_ror1" > "HOL4Word32.word32.word_ror1"
- "word_ror" > "HOL4Word32.word32.word_ror"
- "word_nchotomy" > "HOL4Word32.word32.word_nchotomy"
- "word_mul_def" > "HOL4Word32.word32.word_mul_def"
- "word_mul" > "HOL4Word32.word32.word_mul"
- "word_lsr_def" > "HOL4Word32.word32.word_lsr_def"
- "word_lsr1_def" > "HOL4Word32.word32.word_lsr1_def"
- "word_lsr1" > "HOL4Word32.word32.word_lsr1"
- "word_lsr" > "HOL4Word32.word32.word_lsr"
- "word_lsl_def" > "HOL4Word32.word32.word_lsl_def"
- "word_lsl" > "HOL4Word32.word32.word_lsl"
- "word_asr_def" > "HOL4Word32.word32.word_asr_def"
- "word_asr1_def" > "HOL4Word32.word32.word_asr1_def"
- "word_asr1" > "HOL4Word32.word32.word_asr1"
- "word_asr" > "HOL4Word32.word32.word_asr"
- "word_add_def" > "HOL4Word32.word32.word_add_def"
- "word_add" > "HOL4Word32.word32.word_add"
- "word_2comp_def" > "HOL4Word32.word32.word_2comp_def"
- "word_2comp" > "HOL4Word32.word32.word_2comp"
- "word_1comp_def" > "HOL4Word32.word32.word_1comp_def"
- "word_1comp" > "HOL4Word32.word32.word_1comp"
- "word32_tybij" > "HOL4Word32.word32.word32_tybij"
- "word32_TY_DEF" > "HOL4Word32.word32.word32_TY_DEF"
- "w_T_primdef" > "HOL4Word32.word32.w_T_primdef"
- "w_T_def" > "HOL4Word32.word32.w_T_def"
- "w_T" > "HOL4Word32.word32.w_T"
- "w_1_primdef" > "HOL4Word32.word32.w_1_primdef"
- "w_1_def" > "HOL4Word32.word32.w_1_def"
- "w_1" > "HOL4Word32.word32.w_1"
- "w_0_primdef" > "HOL4Word32.word32.w_0_primdef"
- "w_0_def" > "HOL4Word32.word32.w_0_def"
- "w_0" > "HOL4Word32.word32.w_0"
- "w2n_primdef" > "HOL4Word32.word32.w2n_primdef"
- "w2n_def" > "HOL4Word32.word32.w2n_def"
- "w2n_EVAL" > "HOL4Word32.word32.w2n_EVAL"
- "w2n_ELIM" > "HOL4Word32.word32.w2n_ELIM"
- "n2w_primdef" > "HOL4Word32.word32.n2w_primdef"
- "n2w_def" > "HOL4Word32.word32.n2w_def"
- "n2w_11" > "HOL4Word32.word32.n2w_11"
- "dest_word_mk_word_eq3" > "HOL4Word32.word32.dest_word_mk_word_eq3"
- "bitwise_or_def" > "HOL4Word32.word32.bitwise_or_def"
- "bitwise_or" > "HOL4Word32.word32.bitwise_or"
- "bitwise_eor_def" > "HOL4Word32.word32.bitwise_eor_def"
- "bitwise_eor" > "HOL4Word32.word32.bitwise_eor"
- "bitwise_and_def" > "HOL4Word32.word32.bitwise_and_def"
- "bitwise_and" > "HOL4Word32.word32.bitwise_and"
- "ZERO_SHIFT2" > "HOL4Word32.word32.ZERO_SHIFT2"
- "ZERO_SHIFT" > "HOL4Word32.word32.ZERO_SHIFT"
- "WL_primdef" > "HOL4Word32.word32.WL_primdef"
- "WL_def" > "HOL4Word32.word32.WL_def"
- "TWO_COMP_primdef" > "HOL4Word32.word32.TWO_COMP_primdef"
- "TWO_COMP_def" > "HOL4Word32.word32.TWO_COMP_def"
- "TWO_COMP_WELLDEF" > "HOL4Word32.word32.TWO_COMP_WELLDEF"
- "TWO_COMP_ONE_COMP_QT" > "HOL4Word32.word32.TWO_COMP_ONE_COMP_QT"
- "TWO_COMP_ONE_COMP" > "HOL4Word32.word32.TWO_COMP_ONE_COMP"
- "TWO_COMP_EVAL2" > "HOL4Word32.word32.TWO_COMP_EVAL2"
- "TWO_COMP_EVAL" > "HOL4Word32.word32.TWO_COMP_EVAL"
- "TWO_COMP_ELIM" > "HOL4Word32.word32.TWO_COMP_ELIM"
- "TWO_COMP_ADD" > "HOL4Word32.word32.TWO_COMP_ADD"
- "TOw_primdef" > "HOL4Word32.word32.TOw_primdef"
- "TOw_def" > "HOL4Word32.word32.TOw_def"
- "TOw_WELLDEF" > "HOL4Word32.word32.TOw_WELLDEF"
- "TOw_QT" > "HOL4Word32.word32.TOw_QT"
- "TOw_IDEM" > "HOL4Word32.word32.TOw_IDEM"
- "SUC_WELLDEF" > "HOL4Word32.word32.SUC_WELLDEF"
- "SUC_EQUIV_COMP" > "HOL4Word32.word32.SUC_EQUIV_COMP"
- "SUBw" > "HOL4Word32.word32.SUBw"
- "SUB_SUBw" > "HOL4Word32.word32.SUB_SUBw"
- "SUB_PLUSw" > "HOL4Word32.word32.SUB_PLUSw"
- "SUB_EQUALw" > "HOL4Word32.word32.SUB_EQUALw"
- "SLICEw_primdef" > "HOL4Word32.word32.SLICEw_primdef"
- "SLICEw_def" > "HOL4Word32.word32.SLICEw_def"
- "SLICEw_ZERO_THM" > "HOL4Word32.word32.SLICEw_ZERO_THM"
- "SLICEw_ZERO" > "HOL4Word32.word32.SLICEw_ZERO"
- "SLICEw_THM" > "HOL4Word32.word32.SLICEw_THM"
- "SLICEw_COMP_THM" > "HOL4Word32.word32.SLICEw_COMP_THM"
- "SLICE_EVAL" > "HOL4Word32.word32.SLICE_EVAL"
- "RRXn_primdef" > "HOL4Word32.word32.RRXn_primdef"
- "RRXn_def" > "HOL4Word32.word32.RRXn_def"
- "RRX_primdef" > "HOL4Word32.word32.RRX_primdef"
- "RRX_def" > "HOL4Word32.word32.RRX_def"
- "RRX_WELLDEF" > "HOL4Word32.word32.RRX_WELLDEF"
- "RRX_EVAL2" > "HOL4Word32.word32.RRX_EVAL2"
- "RRX_EVAL" > "HOL4Word32.word32.RRX_EVAL"
- "ROR_w_T" > "HOL4Word32.word32.ROR_w_T"
- "ROR_THM" > "HOL4Word32.word32.ROR_THM"
- "ROR_ONE_primdef" > "HOL4Word32.word32.ROR_ONE_primdef"
- "ROR_ONE_def" > "HOL4Word32.word32.ROR_ONE_def"
- "ROR_ONE_WELLDEF" > "HOL4Word32.word32.ROR_ONE_WELLDEF"
- "ROR_ONE_EVAL2" > "HOL4Word32.word32.ROR_ONE_EVAL2"
- "ROR_ONE_EVAL" > "HOL4Word32.word32.ROR_ONE_EVAL"
- "ROR_CYCLE" > "HOL4Word32.word32.ROR_CYCLE"
- "ROR_ADD" > "HOL4Word32.word32.ROR_ADD"
- "RIGHT_OR_OVER_ANDw" > "HOL4Word32.word32.RIGHT_OR_OVER_ANDw"
- "RIGHT_OR_OVER_AND_QT" > "HOL4Word32.word32.RIGHT_OR_OVER_AND_QT"
- "RIGHT_AND_OVER_ORw" > "HOL4Word32.word32.RIGHT_AND_OVER_ORw"
- "RIGHT_AND_OVER_OR_QT" > "HOL4Word32.word32.RIGHT_AND_OVER_OR_QT"
- "OR_primdef" > "HOL4Word32.word32.OR_primdef"
- "OR_def" > "HOL4Word32.word32.OR_def"
- "OR_IDEMw" > "HOL4Word32.word32.OR_IDEMw"
- "OR_IDEM_QT" > "HOL4Word32.word32.OR_IDEM_QT"
- "OR_EVAL2" > "HOL4Word32.word32.OR_EVAL2"
- "OR_EVAL" > "HOL4Word32.word32.OR_EVAL"
- "OR_COMP_QT" > "HOL4Word32.word32.OR_COMP_QT"
- "OR_COMMw" > "HOL4Word32.word32.OR_COMMw"
- "OR_COMM_QT" > "HOL4Word32.word32.OR_COMM_QT"
- "OR_ASSOCw" > "HOL4Word32.word32.OR_ASSOCw"
- "OR_ASSOC_QT" > "HOL4Word32.word32.OR_ASSOC_QT"
- "OR_ABSORBw" > "HOL4Word32.word32.OR_ABSORBw"
- "OR_ABSORB_QT" > "HOL4Word32.word32.OR_ABSORB_QT"
- "ONE_COMPw" > "HOL4Word32.word32.ONE_COMPw"
- "ONE_COMP_primdef" > "HOL4Word32.word32.ONE_COMP_primdef"
- "ONE_COMP_def" > "HOL4Word32.word32.ONE_COMP_def"
- "ONE_COMP_WELLDEF" > "HOL4Word32.word32.ONE_COMP_WELLDEF"
- "ONE_COMP_TWO_COMP" > "HOL4Word32.word32.ONE_COMP_TWO_COMP"
- "ONE_COMP_THM" > "HOL4Word32.word32.ONE_COMP_THM"
- "ONE_COMP_QT" > "HOL4Word32.word32.ONE_COMP_QT"
- "ONE_COMP_EVAL2" > "HOL4Word32.word32.ONE_COMP_EVAL2"
- "ONE_COMP_EVAL" > "HOL4Word32.word32.ONE_COMP_EVAL"
- "MUL_WELLDEF" > "HOL4Word32.word32.MUL_WELLDEF"
- "MUL_EVAL2" > "HOL4Word32.word32.MUL_EVAL2"
- "MUL_EVAL" > "HOL4Word32.word32.MUL_EVAL"
- "MULT_QT" > "HOL4Word32.word32.MULT_QT"
- "MULT_COMMw" > "HOL4Word32.word32.MULT_COMMw"
- "MULT_COMM_QT" > "HOL4Word32.word32.MULT_COMM_QT"
- "MULT_CLAUSESw" > "HOL4Word32.word32.MULT_CLAUSESw"
- "MULT_CLAUSES_QT" > "HOL4Word32.word32.MULT_CLAUSES_QT"
- "MULT_ASSOCw" > "HOL4Word32.word32.MULT_ASSOCw"
- "MULT_ASSOC_QT" > "HOL4Word32.word32.MULT_ASSOC_QT"
- "MSBn_primdef" > "HOL4Word32.word32.MSBn_primdef"
- "MSBn_def" > "HOL4Word32.word32.MSBn_def"
- "MSB_primdef" > "HOL4Word32.word32.MSB_primdef"
- "MSB_def" > "HOL4Word32.word32.MSB_def"
- "MSB_WELLDEF" > "HOL4Word32.word32.MSB_WELLDEF"
- "MSB_EVAL2" > "HOL4Word32.word32.MSB_EVAL2"
- "MSB_EVAL" > "HOL4Word32.word32.MSB_EVAL"
- "MODw_primdef" > "HOL4Word32.word32.MODw_primdef"
- "MODw_def" > "HOL4Word32.word32.MODw_def"
- "MODw_THM" > "HOL4Word32.word32.MODw_THM"
- "MODw_MULT" > "HOL4Word32.word32.MODw_MULT"
- "MODw_IDEM2" > "HOL4Word32.word32.MODw_IDEM2"
- "MODw_EVAL" > "HOL4Word32.word32.MODw_EVAL"
- "MODw_ELIM" > "HOL4Word32.word32.MODw_ELIM"
- "MOD_MOD_DIV_2EXP" > "HOL4Word32.word32.MOD_MOD_DIV_2EXP"
- "MOD_MOD_DIV" > "HOL4Word32.word32.MOD_MOD_DIV"
- "MOD_ADD" > "HOL4Word32.word32.MOD_ADD"
- "LSR_THM" > "HOL4Word32.word32.LSR_THM"
- "LSR_ONE_primdef" > "HOL4Word32.word32.LSR_ONE_primdef"
- "LSR_ONE_def" > "HOL4Word32.word32.LSR_ONE_def"
- "LSR_ONE_WELLDEF" > "HOL4Word32.word32.LSR_ONE_WELLDEF"
- "LSR_ONE_EVAL2" > "HOL4Word32.word32.LSR_ONE_EVAL2"
- "LSR_ONE_EVAL" > "HOL4Word32.word32.LSR_ONE_EVAL"
- "LSR_ONE" > "HOL4Word32.word32.LSR_ONE"
- "LSR_LIMIT" > "HOL4Word32.word32.LSR_LIMIT"
- "LSR_EVAL" > "HOL4Word32.word32.LSR_EVAL"
- "LSR_ADD" > "HOL4Word32.word32.LSR_ADD"
- "LSL_LIMIT" > "HOL4Word32.word32.LSL_LIMIT"
- "LSL_ADD" > "HOL4Word32.word32.LSL_ADD"
- "LSB_primdef" > "HOL4Word32.word32.LSB_primdef"
- "LSB_def" > "HOL4Word32.word32.LSB_def"
- "LSB_WELLDEF" > "HOL4Word32.word32.LSB_WELLDEF"
- "LSB_EVAL2" > "HOL4Word32.word32.LSB_EVAL2"
- "LSB_EVAL" > "HOL4Word32.word32.LSB_EVAL"
- "LEFT_SHIFT_LESS" > "HOL4Word32.word32.LEFT_SHIFT_LESS"
- "LEFT_ADD_DISTRIBw" > "HOL4Word32.word32.LEFT_ADD_DISTRIBw"
- "LEFT_ADD_DISTRIB_QT" > "HOL4Word32.word32.LEFT_ADD_DISTRIB_QT"
- "INw_primdef" > "HOL4Word32.word32.INw_primdef"
- "INw_def" > "HOL4Word32.word32.INw_def"
- "INw_MODw" > "HOL4Word32.word32.INw_MODw"
- "INV_SUC_EQ_QT" > "HOL4Word32.word32.INV_SUC_EQ_QT"
- "HB_primdef" > "HOL4Word32.word32.HB_primdef"
- "HB_def" > "HOL4Word32.word32.HB_def"
- "FUNPOW_THM2" > "HOL4Word32.word32.FUNPOW_THM2"
- "FUNPOW_THM" > "Nat.funpow_swap1"
- "FUNPOW_COMP" > "HOL4Word32.word32.FUNPOW_COMP"
- "EQ_ADD_RCANCELw" > "HOL4Word32.word32.EQ_ADD_RCANCELw"
- "EQ_ADD_RCANCEL_QT" > "HOL4Word32.word32.EQ_ADD_RCANCEL_QT"
- "EQ_ADD_LCANCELw" > "HOL4Word32.word32.EQ_ADD_LCANCELw"
- "EQ_ADD_LCANCEL_QT" > "HOL4Word32.word32.EQ_ADD_LCANCEL_QT"
- "EQUIV_primdef" > "HOL4Word32.word32.EQUIV_primdef"
- "EQUIV_def" > "HOL4Word32.word32.EQUIV_def"
- "EQUIV_QT" > "HOL4Word32.word32.EQUIV_QT"
- "EOR_primdef" > "HOL4Word32.word32.EOR_primdef"
- "EOR_def" > "HOL4Word32.word32.EOR_def"
- "EOR_EVAL2" > "HOL4Word32.word32.EOR_EVAL2"
- "EOR_EVAL" > "HOL4Word32.word32.EOR_EVAL"
- "DE_MORGAN_THMw" > "HOL4Word32.word32.DE_MORGAN_THMw"
- "DE_MORGAN_THM_QT" > "HOL4Word32.word32.DE_MORGAN_THM_QT"
- "COMP0_primdef" > "HOL4Word32.word32.COMP0_primdef"
- "COMP0_def" > "HOL4Word32.word32.COMP0_def"
- "CANCEL_SUBw" > "HOL4Word32.word32.CANCEL_SUBw"
- "BITw_primdef" > "HOL4Word32.word32.BITw_primdef"
- "BITw_def" > "HOL4Word32.word32.BITw_def"
- "BITw_THM" > "HOL4Word32.word32.BITw_THM"
- "BIT_EVAL" > "HOL4Word32.word32.BIT_EVAL"
- "BIT_EQUIV_THM" > "HOL4Word32.word32.BIT_EQUIV_THM"
- "BIT_EQUIV" > "HOL4Word32.word32.BIT_EQUIV"
- "BITWISEw_WELLDEF" > "HOL4Word32.word32.BITWISEw_WELLDEF"
- "BITWISE_WELLDEF" > "HOL4Word32.word32.BITWISE_WELLDEF"
- "BITWISE_THM2" > "HOL4Word32.word32.BITWISE_THM2"
- "BITWISE_ONE_COMP_THM" > "HOL4Word32.word32.BITWISE_ONE_COMP_THM"
- "BITWISE_ISTEP" > "HOL4Word32.word32.BITWISE_ISTEP"
- "BITWISE_EVAL2" > "HOL4Word32.word32.BITWISE_EVAL2"
- "BITWISE_EVAL" > "HOL4Word32.word32.BITWISE_EVAL"
- "BITSw_primdef" > "HOL4Word32.word32.BITSw_primdef"
- "BITSw_def" > "HOL4Word32.word32.BITSw_def"
- "BITSw_ZERO" > "HOL4Word32.word32.BITSw_ZERO"
- "BITSw_DIV_THM" > "HOL4Word32.word32.BITSw_DIV_THM"
- "BITSw_COMP_THM" > "HOL4Word32.word32.BITSw_COMP_THM"
- "BITSwLT_THM" > "HOL4Word32.word32.BITSwLT_THM"
- "BITS_SUC2" > "HOL4Word32.word32.BITS_SUC2"
- "BITS_SLICEw_THM" > "HOL4Word32.word32.BITS_SLICEw_THM"
- "BITS_EVAL" > "HOL4Word32.word32.BITS_EVAL"
- "ASR_w_T" > "HOL4Word32.word32.ASR_w_T"
- "ASR_THM" > "HOL4Word32.word32.ASR_THM"
- "ASR_ONE_primdef" > "HOL4Word32.word32.ASR_ONE_primdef"
- "ASR_ONE_def" > "HOL4Word32.word32.ASR_ONE_def"
- "ASR_ONE_WELLDEF" > "HOL4Word32.word32.ASR_ONE_WELLDEF"
- "ASR_ONE_EVAL2" > "HOL4Word32.word32.ASR_ONE_EVAL2"
- "ASR_ONE_EVAL" > "HOL4Word32.word32.ASR_ONE_EVAL"
- "ASR_LIMIT" > "HOL4Word32.word32.ASR_LIMIT"
- "ASR_ADD" > "HOL4Word32.word32.ASR_ADD"
- "AONE_primdef" > "HOL4Word32.word32.AONE_primdef"
- "AONE_def" > "HOL4Word32.word32.AONE_def"
- "AND_primdef" > "HOL4Word32.word32.AND_primdef"
- "AND_def" > "HOL4Word32.word32.AND_def"
- "AND_IDEMw" > "HOL4Word32.word32.AND_IDEMw"
- "AND_IDEM_QT" > "HOL4Word32.word32.AND_IDEM_QT"
- "AND_EVAL2" > "HOL4Word32.word32.AND_EVAL2"
- "AND_EVAL" > "HOL4Word32.word32.AND_EVAL"
- "AND_COMP_QT" > "HOL4Word32.word32.AND_COMP_QT"
- "AND_COMMw" > "HOL4Word32.word32.AND_COMMw"
- "AND_COMM_QT" > "HOL4Word32.word32.AND_COMM_QT"
- "AND_ASSOCw" > "HOL4Word32.word32.AND_ASSOCw"
- "AND_ASSOC_QT" > "HOL4Word32.word32.AND_ASSOC_QT"
- "AND_ABSORBw" > "HOL4Word32.word32.AND_ABSORBw"
- "AND_ABSORB_QT" > "HOL4Word32.word32.AND_ABSORB_QT"
- "ADDw" > "HOL4Word32.word32.ADDw"
- "ADD_WELLDEF" > "HOL4Word32.word32.ADD_WELLDEF"
- "ADD_TWO_COMP_QT" > "HOL4Word32.word32.ADD_TWO_COMP_QT"
- "ADD_TWO_COMP2" > "HOL4Word32.word32.ADD_TWO_COMP2"
- "ADD_TWO_COMP" > "HOL4Word32.word32.ADD_TWO_COMP"
- "ADD_SUBw" > "HOL4Word32.word32.ADD_SUBw"
- "ADD_SUB_SYM" > "HOL4Word32.word32.ADD_SUB_SYM"
- "ADD_SUB_ASSOC" > "HOL4Word32.word32.ADD_SUB_ASSOC"
- "ADD_QT" > "HOL4Word32.word32.ADD_QT"
- "ADD_INV_0_QT" > "HOL4Word32.word32.ADD_INV_0_QT"
- "ADD_INV_0_EQw" > "HOL4Word32.word32.ADD_INV_0_EQw"
- "ADD_INV_0_EQ_QT" > "HOL4Word32.word32.ADD_INV_0_EQ_QT"
- "ADD_EVAL2" > "HOL4Word32.word32.ADD_EVAL2"
- "ADD_EVAL" > "HOL4Word32.word32.ADD_EVAL"
- "ADD_EQ_SUBw" > "HOL4Word32.word32.ADD_EQ_SUBw"
- "ADD_COMMw" > "HOL4Word32.word32.ADD_COMMw"
- "ADD_COMM_QT" > "HOL4Word32.word32.ADD_COMM_QT"
- "ADD_CLAUSESw" > "HOL4Word32.word32.ADD_CLAUSESw"
- "ADD_CLAUSES_QT" > "HOL4Word32.word32.ADD_CLAUSES_QT"
- "ADD_ASSOCw" > "HOL4Word32.word32.ADD_ASSOCw"
- "ADD_ASSOC_QT" > "HOL4Word32.word32.ADD_ASSOC_QT"
- "ADD_0w" > "HOL4Word32.word32.ADD_0w"
- "ADD_0_QT" > "HOL4Word32.word32.ADD_0_QT"
- "ADD1w" > "HOL4Word32.word32.ADD1w"
- "ADD1_QT" > "HOL4Word32.word32.ADD1_QT"
-
-end
--- a/src/HOL/Import/HOL4/Generated/word_base.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,102 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "word_size" > "word_size_primdef"
- "word_case" > "word_case_primdef"
- "word_base0" > "word_base0_primdef"
- "mk_word" > "mk_word_def"
- "dest_word" > "dest_word_def"
- "bit" > "bit_def"
- "WSPLIT" > "WSPLIT_def"
- "WSEG" > "WSEG_def"
- "WORDLEN" > "WORDLEN_def"
- "WORD" > "WORD_def"
- "WCAT" > "WCAT_def"
- "PWORDLEN" > "PWORDLEN_primdef"
- "MSB" > "MSB_def"
- "LSB" > "LSB_def"
-
-type_maps
- "word" > "HOL4Vec.word_base.word"
-
-const_maps
- "word_base0" > "HOL4Vec.word_base.word_base0"
- "WORD" > "HOL4Vec.word_base.WORD"
- "PWORDLEN" > "HOL4Vec.word_base.PWORDLEN"
-
-const_renames
- "BIT" > "bit"
-
-thm_maps
- "word_size_def" > "HOL4Vec.word_base.word_size_def"
- "word_repfns" > "HOL4Vec.word_base.word_repfns"
- "word_nchotomy" > "HOL4Vec.word_base.word_nchotomy"
- "word_induction" > "HOL4Vec.word_base.word_induction"
- "word_induct" > "HOL4Vec.word_base.word_induct"
- "word_cases" > "HOL4Vec.word_base.word_cases"
- "word_case_def" > "HOL4Vec.word_base.word_case_def"
- "word_case_cong" > "HOL4Vec.word_base.word_case_cong"
- "word_base0_primdef" > "HOL4Vec.word_base.word_base0_primdef"
- "word_base0_def" > "HOL4Vec.word_base.word_base0_def"
- "word_TY_DEF" > "HOL4Vec.word_base.word_TY_DEF"
- "word_Axiom" > "HOL4Vec.word_base.word_Axiom"
- "word_Ax" > "HOL4Vec.word_base.word_Ax"
- "word_11" > "HOL4Vec.word_base.word_11"
- "WSPLIT_WSEG2" > "HOL4Vec.word_base.WSPLIT_WSEG2"
- "WSPLIT_WSEG1" > "HOL4Vec.word_base.WSPLIT_WSEG1"
- "WSPLIT_WSEG" > "HOL4Vec.word_base.WSPLIT_WSEG"
- "WSPLIT_PWORDLEN" > "HOL4Vec.word_base.WSPLIT_PWORDLEN"
- "WSPLIT_DEF" > "HOL4Vec.word_base.WSPLIT_DEF"
- "WSEG_WSEG" > "HOL4Vec.word_base.WSEG_WSEG"
- "WSEG_WORD_LENGTH" > "HOL4Vec.word_base.WSEG_WORD_LENGTH"
- "WSEG_WORDLEN" > "HOL4Vec.word_base.WSEG_WORDLEN"
- "WSEG_WCAT_WSEG2" > "HOL4Vec.word_base.WSEG_WCAT_WSEG2"
- "WSEG_WCAT_WSEG1" > "HOL4Vec.word_base.WSEG_WCAT_WSEG1"
- "WSEG_WCAT_WSEG" > "HOL4Vec.word_base.WSEG_WCAT_WSEG"
- "WSEG_WCAT2" > "HOL4Vec.word_base.WSEG_WCAT2"
- "WSEG_WCAT1" > "HOL4Vec.word_base.WSEG_WCAT1"
- "WSEG_SUC" > "HOL4Vec.word_base.WSEG_SUC"
- "WSEG_PWORDLEN" > "HOL4Vec.word_base.WSEG_PWORDLEN"
- "WSEG_DEF" > "HOL4Vec.word_base.WSEG_DEF"
- "WSEG_BIT" > "HOL4Vec.word_base.WSEG_BIT"
- "WSEG0" > "HOL4Vec.word_base.WSEG0"
- "WORD_def" > "HOL4Vec.word_base.WORD_def"
- "WORD_SPLIT" > "HOL4Vec.word_base.WORD_SPLIT"
- "WORD_SNOC_WCAT" > "HOL4Vec.word_base.WORD_SNOC_WCAT"
- "WORD_PARTITION" > "HOL4Vec.word_base.WORD_PARTITION"
- "WORD_CONS_WCAT" > "HOL4Vec.word_base.WORD_CONS_WCAT"
- "WORD_11" > "HOL4Vec.word_base.WORD_11"
- "WORDLEN_SUC_WCAT_WSEG_WSEG_RIGHT" > "HOL4Vec.word_base.WORDLEN_SUC_WCAT_WSEG_WSEG_RIGHT"
- "WORDLEN_SUC_WCAT_WSEG_WSEG" > "HOL4Vec.word_base.WORDLEN_SUC_WCAT_WSEG_WSEG"
- "WORDLEN_SUC_WCAT_BIT_WSEG_RIGHT" > "HOL4Vec.word_base.WORDLEN_SUC_WCAT_BIT_WSEG_RIGHT"
- "WORDLEN_SUC_WCAT_BIT_WSEG" > "HOL4Vec.word_base.WORDLEN_SUC_WCAT_BIT_WSEG"
- "WORDLEN_SUC_WCAT" > "HOL4Vec.word_base.WORDLEN_SUC_WCAT"
- "WORDLEN_DEF" > "HOL4Vec.word_base.WORDLEN_DEF"
- "WORD" > "HOL4Vec.word_base.WORD"
- "WCAT_WSEG_WSEG" > "HOL4Vec.word_base.WCAT_WSEG_WSEG"
- "WCAT_PWORDLEN" > "HOL4Vec.word_base.WCAT_PWORDLEN"
- "WCAT_DEF" > "HOL4Vec.word_base.WCAT_DEF"
- "WCAT_ASSOC" > "HOL4Vec.word_base.WCAT_ASSOC"
- "WCAT_11" > "HOL4Vec.word_base.WCAT_11"
- "WCAT0" > "HOL4Vec.word_base.WCAT0"
- "PWORDLEN_primdef" > "HOL4Vec.word_base.PWORDLEN_primdef"
- "PWORDLEN_def" > "HOL4Vec.word_base.PWORDLEN_def"
- "PWORDLEN1" > "HOL4Vec.word_base.PWORDLEN1"
- "PWORDLEN0" > "HOL4Vec.word_base.PWORDLEN0"
- "PWORDLEN" > "HOL4Vec.word_base.PWORDLEN"
- "MSB_DEF" > "HOL4Vec.word_base.MSB_DEF"
- "MSB" > "HOL4Vec.word_base.MSB"
- "LSB_DEF" > "HOL4Vec.word_base.LSB_DEF"
- "LSB" > "HOL4Vec.word_base.LSB"
- "IN_PWORDLEN" > "HOL4Vec.word_base.IN_PWORDLEN"
- "BIT_WSEG" > "HOL4Vec.word_base.BIT_WSEG"
- "BIT_WCAT_SND" > "HOL4Vec.word_base.BIT_WCAT_SND"
- "BIT_WCAT_FST" > "HOL4Vec.word_base.BIT_WCAT_FST"
- "BIT_WCAT1" > "HOL4Vec.word_base.BIT_WCAT1"
- "BIT_EQ_IMP_WORD_EQ" > "HOL4Vec.word_base.BIT_EQ_IMP_WORD_EQ"
- "BIT_DEF" > "HOL4Vec.word_base.BIT_DEF"
- "BIT0" > "HOL4Vec.word_base.BIT0"
-
-end
--- a/src/HOL/Import/HOL4/Generated/word_bitop.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,64 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "WMAP" > "WMAP_def"
- "SHR" > "SHR_def"
- "SHL" > "SHL_def"
- "PBITOP" > "PBITOP_primdef"
- "PBITBOP" > "PBITBOP_primdef"
- "FORALLBITS" > "FORALLBITS_def"
- "EXISTSABIT" > "EXISTSABIT_def"
-
-const_maps
- "SHR" > "HOL4Vec.word_bitop.SHR"
- "SHL" > "HOL4Vec.word_bitop.SHL"
- "PBITOP" > "HOL4Vec.word_bitop.PBITOP"
- "PBITBOP" > "HOL4Vec.word_bitop.PBITBOP"
-
-thm_maps
- "WSEG_SHL_0" > "HOL4Vec.word_bitop.WSEG_SHL_0"
- "WSEG_SHL" > "HOL4Vec.word_bitop.WSEG_SHL"
- "WMAP_o" > "HOL4Vec.word_bitop.WMAP_o"
- "WMAP_WSEG" > "HOL4Vec.word_bitop.WMAP_WSEG"
- "WMAP_WCAT" > "HOL4Vec.word_bitop.WMAP_WCAT"
- "WMAP_PWORDLEN" > "HOL4Vec.word_bitop.WMAP_PWORDLEN"
- "WMAP_PBITOP" > "HOL4Vec.word_bitop.WMAP_PBITOP"
- "WMAP_DEF" > "HOL4Vec.word_bitop.WMAP_DEF"
- "WMAP_BIT" > "HOL4Vec.word_bitop.WMAP_BIT"
- "WMAP_0" > "HOL4Vec.word_bitop.WMAP_0"
- "SHR_def" > "HOL4Vec.word_bitop.SHR_def"
- "SHR_WSEG_NF" > "HOL4Vec.word_bitop.SHR_WSEG_NF"
- "SHR_WSEG_1F" > "HOL4Vec.word_bitop.SHR_WSEG_1F"
- "SHR_WSEG" > "HOL4Vec.word_bitop.SHR_WSEG"
- "SHR_DEF" > "HOL4Vec.word_bitop.SHR_DEF"
- "SHL_def" > "HOL4Vec.word_bitop.SHL_def"
- "SHL_WSEG_NF" > "HOL4Vec.word_bitop.SHL_WSEG_NF"
- "SHL_WSEG_1F" > "HOL4Vec.word_bitop.SHL_WSEG_1F"
- "SHL_WSEG" > "HOL4Vec.word_bitop.SHL_WSEG"
- "SHL_DEF" > "HOL4Vec.word_bitop.SHL_DEF"
- "PBITOP_primdef" > "HOL4Vec.word_bitop.PBITOP_primdef"
- "PBITOP_def" > "HOL4Vec.word_bitop.PBITOP_def"
- "PBITOP_WSEG" > "HOL4Vec.word_bitop.PBITOP_WSEG"
- "PBITOP_PWORDLEN" > "HOL4Vec.word_bitop.PBITOP_PWORDLEN"
- "PBITOP_BIT" > "HOL4Vec.word_bitop.PBITOP_BIT"
- "PBITBOP_primdef" > "HOL4Vec.word_bitop.PBITBOP_primdef"
- "PBITBOP_def" > "HOL4Vec.word_bitop.PBITBOP_def"
- "PBITBOP_WSEG" > "HOL4Vec.word_bitop.PBITBOP_WSEG"
- "PBITBOP_PWORDLEN" > "HOL4Vec.word_bitop.PBITBOP_PWORDLEN"
- "PBITBOP_EXISTS" > "HOL4Vec.word_bitop.PBITBOP_EXISTS"
- "NOT_FORALLBITS" > "HOL4Vec.word_bitop.NOT_FORALLBITS"
- "NOT_EXISTSABIT" > "HOL4Vec.word_bitop.NOT_EXISTSABIT"
- "IN_PBITOP" > "HOL4Vec.word_bitop.IN_PBITOP"
- "IN_PBITBOP" > "HOL4Vec.word_bitop.IN_PBITBOP"
- "FORALLBITS_WSEG" > "HOL4Vec.word_bitop.FORALLBITS_WSEG"
- "FORALLBITS_WCAT" > "HOL4Vec.word_bitop.FORALLBITS_WCAT"
- "FORALLBITS_DEF" > "HOL4Vec.word_bitop.FORALLBITS_DEF"
- "FORALLBITS" > "HOL4Vec.word_bitop.FORALLBITS"
- "EXISTSABIT_WSEG" > "HOL4Vec.word_bitop.EXISTSABIT_WSEG"
- "EXISTSABIT_WCAT" > "HOL4Vec.word_bitop.EXISTSABIT_WCAT"
- "EXISTSABIT_DEF" > "HOL4Vec.word_bitop.EXISTSABIT_DEF"
- "EXISTSABIT" > "HOL4Vec.word_bitop.EXISTSABIT"
-
-end
--- a/src/HOL/Import/HOL4/Generated/word_num.imp Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,35 +0,0 @@
-import
-
-import_segment "hol4"
-
-def_maps
- "NWORD" > "NWORD_def"
- "NVAL" > "NVAL_def"
- "NLIST" > "NLIST_def"
- "LVAL" > "LVAL_def"
-
-const_maps
- "NWORD" > "HOL4Vec.word_num.NWORD"
- "LVAL" > "HOL4Vec.word_num.LVAL"
-
-thm_maps
- "NWORD_def" > "HOL4Vec.word_num.NWORD_def"
- "NWORD_PWORDLEN" > "HOL4Vec.word_num.NWORD_PWORDLEN"
- "NWORD_LENGTH" > "HOL4Vec.word_num.NWORD_LENGTH"
- "NWORD_DEF" > "HOL4Vec.word_num.NWORD_DEF"
- "NVAL_WORDLEN_0" > "HOL4Vec.word_num.NVAL_WORDLEN_0"
- "NVAL_WCAT2" > "HOL4Vec.word_num.NVAL_WCAT2"
- "NVAL_WCAT1" > "HOL4Vec.word_num.NVAL_WCAT1"
- "NVAL_WCAT" > "HOL4Vec.word_num.NVAL_WCAT"
- "NVAL_MAX" > "HOL4Vec.word_num.NVAL_MAX"
- "NVAL_DEF" > "HOL4Vec.word_num.NVAL_DEF"
- "NVAL1" > "HOL4Vec.word_num.NVAL1"
- "NVAL0" > "HOL4Vec.word_num.NVAL0"
- "NLIST_DEF" > "HOL4Vec.word_num.NLIST_DEF"
- "LVAL_def" > "HOL4Vec.word_num.LVAL_def"
- "LVAL_SNOC" > "HOL4Vec.word_num.LVAL_SNOC"
- "LVAL_MAX" > "HOL4Vec.word_num.LVAL_MAX"
- "LVAL_DEF" > "HOL4Vec.word_num.LVAL_DEF"
- "LVAL" > "HOL4Vec.word_num.LVAL"
-
-end
--- a/src/HOL/Import/HOL4/Imported.thy Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,6 +0,0 @@
-theory Imported
-imports "Generated/HOL4Vec" "Generated/HOL4Word32" "Generated/HOL4Real" "Generated/HOL4Prob"
-begin
-
-end
-
--- a/src/HOL/Import/HOL4/Importer.thy Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,236 +0,0 @@
-(* Title: HOL/Import/Importer.thy
- Author: Sebastian Skalberg, TU Muenchen
-*)
-
-theory Importer
-imports Main
-keywords
- "import_segment" "import_theory" "end_import" "setup_theory" "end_setup"
- "setup_dump" "append_dump" "flush_dump" "ignore_thms" "type_maps"
- "def_maps" "thm_maps" "const_renames" "const_moves" "const_maps" :: thy_decl and ">"
-uses "shuffler.ML" "import_rews.ML" ("proof_kernel.ML") ("replay.ML") ("import.ML")
-begin
-
-setup {* Shuffler.setup #> importer_setup *}
-
-parse_ast_translation smarter_trueprop_parsing
-
-lemma conj_norm [shuffle_rule]: "(A & B ==> PROP C) == ([| A ; B |] ==> PROP C)"
-proof
- assume "A & B ==> PROP C" A B
- thus "PROP C"
- by auto
-next
- assume "[| A; B |] ==> PROP C" "A & B"
- thus "PROP C"
- by auto
-qed
-
-lemma imp_norm [shuffle_rule]: "(Trueprop (A --> B)) == (A ==> B)"
-proof
- assume "A --> B" A
- thus B ..
-next
- assume "A ==> B"
- thus "A --> B"
- by auto
-qed
-
-lemma all_norm [shuffle_rule]: "(Trueprop (ALL x. P x)) == (!!x. P x)"
-proof
- fix x
- assume "ALL x. P x"
- thus "P x" ..
-next
- assume "!!x. P x"
- thus "ALL x. P x"
- ..
-qed
-
-lemma ex_norm [shuffle_rule]: "(EX x. P x ==> PROP Q) == (!!x. P x ==> PROP Q)"
-proof
- fix x
- assume ex: "EX x. P x ==> PROP Q"
- assume "P x"
- hence "EX x. P x" ..
- with ex show "PROP Q" .
-next
- assume allx: "!!x. P x ==> PROP Q"
- assume "EX x. P x"
- hence p: "P (SOME x. P x)"
- ..
- from allx
- have "P (SOME x. P x) ==> PROP Q"
- .
- with p
- show "PROP Q"
- by auto
-qed
-
-lemma eq_norm [shuffle_rule]: "Trueprop (t = u) == (t == u)"
-proof
- assume "t = u"
- thus "t == u" by simp
-next
- assume "t == u"
- thus "t = u"
- by simp
-qed
-
-section {* General Setup *}
-
-lemma eq_imp: "P = Q \<Longrightarrow> P \<longrightarrow> Q"
- by auto
-
-lemma HOLallI: "(!! bogus. P bogus) \<Longrightarrow> (ALL bogus. P bogus)"
-proof -
- assume "!! bogus. P bogus"
- thus "ALL x. P x"
- ..
-qed
-
-consts
- ONE_ONE :: "('a => 'b) => bool"
-
-defs
- ONE_ONE_DEF: "ONE_ONE f == ALL x y. f x = f y --> x = y"
-
-lemma ONE_ONE_rew: "ONE_ONE f = inj_on f UNIV"
- by (simp add: ONE_ONE_DEF inj_on_def)
-
-lemma INFINITY_AX: "EX (f::ind \<Rightarrow> ind). (inj f & ~(surj f))"
-proof (rule exI,safe)
- show "inj Suc_Rep"
- by (rule injI) (rule Suc_Rep_inject)
-next
- assume "surj Suc_Rep"
- hence "ALL y. EX x. y = Suc_Rep x"
- by (simp add: surj_def)
- hence "EX x. Zero_Rep = Suc_Rep x"
- by (rule spec)
- thus False
- proof (rule exE)
- fix x
- assume "Zero_Rep = Suc_Rep x"
- hence "Suc_Rep x = Zero_Rep"
- ..
- with Suc_Rep_not_Zero_Rep
- show False
- ..
- qed
-qed
-
-lemma EXISTS_DEF: "Ex P = P (Eps P)"
-proof (rule iffI)
- assume "Ex P"
- thus "P (Eps P)"
- ..
-next
- assume "P (Eps P)"
- thus "Ex P"
- ..
-qed
-
-consts
- TYPE_DEFINITION :: "('a => bool) => ('b => 'a) => bool"
-
-defs
- TYPE_DEFINITION: "TYPE_DEFINITION p rep == ((ALL x y. (rep x = rep y) --> (x = y)) & (ALL x. (p x = (EX y. x = rep y))))"
-
-lemma ex_imp_nonempty: "Ex P ==> EX x. x : (Collect P)"
- by simp
-
-lemma light_ex_imp_nonempty: "P t ==> EX x. x : (Collect P)"
-proof -
- assume "P t"
- hence "EX x. P x"
- ..
- thus ?thesis
- by (rule ex_imp_nonempty)
-qed
-
-lemma light_imp_as: "[| Q --> P; P --> Q |] ==> P = Q"
- by blast
-
-lemma typedef_hol2hol4:
- assumes a: "type_definition (Rep::'a=>'b) Abs (Collect P)"
- shows "EX rep. TYPE_DEFINITION P (rep::'a=>'b)"
-proof -
- from a
- have td: "(ALL x. P (Rep x)) & (ALL x. Abs (Rep x) = x) & (ALL y. P y \<longrightarrow> Rep (Abs y) = y)"
- by (simp add: type_definition_def)
- have ed: "TYPE_DEFINITION P Rep"
- proof (auto simp add: TYPE_DEFINITION)
- fix x y
- assume b: "Rep x = Rep y"
- from td have "x = Abs (Rep x)"
- by auto
- also have "Abs (Rep x) = Abs (Rep y)"
- by (simp add: b)
- also from td have "Abs (Rep y) = y"
- by auto
- finally show "x = y" .
- next
- fix x
- assume "P x"
- with td
- have "Rep (Abs x) = x"
- by auto
- hence "x = Rep (Abs x)"
- ..
- thus "EX y. x = Rep y"
- ..
- next
- fix y
- from td
- show "P (Rep y)"
- by auto
- qed
- show ?thesis
- apply (rule exI [of _ Rep])
- apply (rule ed)
- .
-qed
-
-lemma typedef_hol2hollight:
- assumes a: "type_definition (Rep::'a=>'b) Abs (Collect P)"
- shows "(Abs (Rep a) = a) & (P r = (Rep (Abs r) = r))"
-proof
- from a
- show "Abs (Rep a) = a"
- by (rule type_definition.Rep_inverse)
-next
- show "P r = (Rep (Abs r) = r)"
- proof
- assume "P r"
- hence "r \<in> (Collect P)"
- by simp
- with a
- show "Rep (Abs r) = r"
- by (rule type_definition.Abs_inverse)
- next
- assume ra: "Rep (Abs r) = r"
- from a
- have "Rep (Abs r) \<in> (Collect P)"
- by (rule type_definition.Rep)
- thus "P r"
- by (simp add: ra)
- qed
-qed
-
-lemma termspec_help: "[| Ex P ; c == Eps P |] ==> P c"
- apply simp
- apply (rule someI_ex)
- .
-
-lemma typedef_helper: "EX x. P x \<Longrightarrow> EX x. x \<in> (Collect P)"
- by simp
-
-use "proof_kernel.ML"
-use "replay.ML"
-use "import.ML"
-
-setup Import.setup
-
-end
-
--- a/src/HOL/Import/HOL4/README Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,19 +0,0 @@
-
-ATTENTION! This is largely outdated. The hint to PROOF_DIRS might be
-everything which is still relevant.
-
-All the files in this directory (except this README, Importer.thy, and
-ROOT.ML) are automatically generated. Edit the files in
-../Generate-HOL and run "isabelle make HOL-Complex-Generate-HOL" in
-~~/src/HOL, if something needs to be changed.
-
-To build the logic in this directory, simply do a "isabelle make
-HOL-Import-HOL" in ~~/src/HOL.
-
-Note that the quick_and_dirty flag is on as default for this
-directory, which means that the original external proofs are not consulted
-at all. If a real replay of the external proofs is desired, get and
-unpack the external proof objects to somewhere on your harddisk, and set
-the variable PROOF_DIRS to the directory where the directory "hol4"
-is. Now edit the ROOT.ML file to unset the quick_and_dirty flag and
-do "isabelle make HOL-Import-HOL" in ~~/src/HOL.
--- a/src/HOL/Import/HOL4/ROOT.ML Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,2 +0,0 @@
-
-use_thy "Compatibility";
--- a/src/HOL/Import/HOL4/Template/GenHOL4Base.thy Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,284 +0,0 @@
-(* Title: HOL/Import/HOL4/Template/GenHOL4Base.thy
- Author: Sebastian Skalberg, TU Muenchen
-*)
-
-theory GenHOL4Base
-imports "../../Importer" "../Compatibility"
-begin
-
-import_segment "hol4"
-
-setup_dump "../Generated" "HOL4Base"
-
-append_dump {*theory HOL4Base
-imports "../../Importer" "../Compatibility"
-begin
-*}
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" bool;
-
-type_maps
- bool > HOL.bool;
-
-const_maps
- T > HOL.True
- F > HOL.False
- "!" > HOL.All
- "/\\" > HOL.conj
- "\\/" > HOL.disj
- "?" > HOL.Ex
- "?!" > HOL.Ex1
- "~" > HOL.Not
- COND > HOL.If
- bool_case > Product_Type.bool.bool_case
- ONE_ONE > Importer.ONE_ONE
- ONTO > Fun.surj
- TYPE_DEFINITION > Importer.TYPE_DEFINITION
- LET > Compatibility.LET;
-
-ignore_thms
- BOUNDED_DEF
- BOUNDED_THM
- UNBOUNDED_DEF
- UNBOUNDED_THM;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" combin;
-
-const_maps
- o > Fun.comp;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" sum;
-
-type_maps
- sum > Sum_Type.sum;
-
-const_maps
- INL > Sum_Type.Inl
- INR > Sum_Type.Inr
- ISL > Compatibility.ISL
- ISR > Compatibility.ISR
- OUTL > Compatibility.OUTL
- OUTR > Compatibility.OUTR
- sum_case > Sum_Type.sum.sum_case;
-
-ignore_thms
- sum_TY_DEF
- sum_ISO_DEF
- IS_SUM_REP
- INL_DEF
- INR_DEF
- sum_Axiom;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" one;
-
-type_maps
- one > Product_Type.unit;
-
-const_maps
- one > Product_Type.Unity;
-
-ignore_thms
- one_TY_DEF
- one_axiom
- one_Axiom
- one_DEF;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" option;
-
-type_maps
- option > Option.option;
-
-const_maps
- NONE > Option.option.None
- SOME > Option.option.Some
- option_case > Option.option.option_case
- OPTION_MAP > Option.map
- THE > Option.the
- IS_SOME > Compatibility.IS_SOME
- IS_NONE > Compatibility.IS_NONE
- OPTION_JOIN > Compatibility.OPTION_JOIN;
-
-ignore_thms
- option_axiom
- option_Axiom
- option_TY_DEF
- option_REP_ABS_DEF
- SOME_DEF
- NONE_DEF;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" marker;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" relation;
-
-const_renames
- reflexive > pred_reflexive;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" pair;
-
-type_maps
- prod > Product_Type.prod;
-
-const_maps
- "," > Product_Type.Pair
- FST > Product_Type.fst
- SND > Product_Type.snd
- CURRY > Product_Type.curry
- UNCURRY > Product_Type.prod.prod_case
- "##" > Product_Type.map_pair
- pair_case > Product_Type.prod.prod_case;
-
-ignore_thms
- prod_TY_DEF
- MK_PAIR_DEF
- IS_PAIR_DEF
- ABS_REP_prod
- COMMA_DEF;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" num;
-
-type_maps
- num > Nat.nat;
-
-const_maps
- SUC > Nat.Suc
- 0 > Groups.zero_class.zero :: nat;
-
-ignore_thms
- num_TY_DEF
- num_ISO_DEF
- IS_NUM_REP
- ZERO_REP_DEF
- SUC_REP_DEF
- ZERO_DEF
- SUC_DEF;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" prim_rec;
-
-const_maps
- "<" > Orderings.ord_class.less :: "nat \<Rightarrow> nat \<Rightarrow> bool";
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" arithmetic;
-
-const_maps
- ALT_ZERO > Compatibility.ALT_ZERO
- NUMERAL_BIT1 > Compatibility.NUMERAL_BIT1
- NUMERAL_BIT2 > Compatibility.NUMERAL_BIT2
- NUMERAL > Compatibility.NUMERAL
- num_case > Nat.nat.nat_case
- ">" > Compatibility.nat_gt
- ">=" > Compatibility.nat_ge
- FUNPOW > Compatibility.FUNPOW
- "<=" > Orderings.ord_class.less_eq :: "nat \<Rightarrow> nat \<Rightarrow> bool"
- "+" > Groups.plus_class.plus :: "nat \<Rightarrow> nat \<Rightarrow> nat"
- "*" > Groups.times_class.times :: "nat \<Rightarrow> nat \<Rightarrow> nat"
- "-" > Groups.minus_class.minus :: "nat \<Rightarrow> nat \<Rightarrow> nat"
- MIN > Orderings.ord_class.min :: "nat \<Rightarrow> nat \<Rightarrow> nat"
- MAX > Orderings.ord_class.max :: "nat \<Rightarrow> nat \<Rightarrow> nat"
- DIV > Divides.div_class.div :: "nat \<Rightarrow> nat \<Rightarrow> nat"
- MOD > Divides.div_class.mod :: "nat \<Rightarrow> nat \<Rightarrow> nat"
- EXP > Power.power_class.power :: "nat \<Rightarrow> nat \<Rightarrow> nat";
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" hrat;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" hreal;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" numeral;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" ind_type;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" divides;
-
-const_maps
- divides > Rings.dvd_class.dvd :: "nat \<Rightarrow> nat \<Rightarrow> bool";
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" prime;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" list;
-
-type_maps
- list > List.list;
-
-const_maps
- CONS > List.list.Cons
- NIL > List.list.Nil
- list_case > List.list.list_case
- NULL > List.null
- HD > List.hd
- TL > List.tl
- MAP > List.map
- MEM > Compatibility.list_mem
- FILTER > List.filter
- FOLDL > List.foldl
- EVERY > List.list_all
- REVERSE > List.rev
- LAST > List.last
- FRONT > List.butlast
- APPEND > List.append
- FLAT > List.concat
- LENGTH > Nat.size_class.size
- REPLICATE > List.replicate
- list_size > Compatibility.list_size
- SUM > Compatibility.sum
- FOLDR > Compatibility.FOLDR
- EXISTS > List.list_ex
- MAP2 > Compatibility.map2
- ZIP > Compatibility.ZIP
- UNZIP > Compatibility.unzip;
-
-ignore_thms
- list_TY_DEF
- list_repfns
- list0_def
- list1_def
- NIL
- CONS_def;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" pred_set;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" operator;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" rich_list;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" state_transformer;
-end_import;
-
-append_dump "end";
-
-flush_dump;
-
-import_segment "";
-
-end
--- a/src/HOL/Import/HOL4/Template/GenHOL4Prob.thy Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,52 +0,0 @@
-(* Title: HOL/Import/HOL4/Template/GenHOL4Prob.thy
- Author: Sebastian Skalberg, TU Muenchen
-*)
-
-theory GenHOL4Prob
-imports GenHOL4Real
-begin
-
-import_segment "hol4"
-
-setup_dump "../Generated" "HOL4Prob"
-
-append_dump {*theory HOL4Prob
-imports HOL4Real
-begin
-*}
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" prob_extra;
-
-const_moves
- COMPL > GenHOL4Base.pred_set.COMPL;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" prob_canon;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" boolean_sequence;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" prob_algebra;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" prob;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" prob_pseudo;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" prob_indep;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" prob_uniform;
-end_import;
-
-append_dump "end";
-
-flush_dump;
-
-import_segment "";
-
-end
--- a/src/HOL/Import/HOL4/Template/GenHOL4Real.thy Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,101 +0,0 @@
-(* Title: HOL/Import/HOL4/Template/GenHOL4Real.thy
- Author: Sebastian Skalberg (TU Muenchen)
-*)
-
-theory GenHOL4Real
-imports GenHOL4Base
-begin
-
-import_segment "hol4"
-
-setup_dump "../Generated" "HOL4Real"
-
-append_dump {*theory HOL4Real
-imports HOL4Base
-begin
-*}
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" realax;
-
-type_maps
- real > RealDef.real;
-
-const_maps
- real_0 > Groups.zero_class.zero :: real
- real_1 > Groups.one_class.one :: real
- real_neg > Groups.uminus_class.uminus :: "real \<Rightarrow> real"
- inv > Fields.inverse_class.inverse :: "real \<Rightarrow> real"
- real_add > Groups.plus_class.plus :: "real \<Rightarrow> real \<Rightarrow> real"
- real_sub > Groups.minus_class.minus :: "real \<Rightarrow> real \<Rightarrow> real"
- real_mul > Groups.times_class.times :: "real \<Rightarrow> real \<Rightarrow> real"
- real_div > Fields.inverse_class.divide :: "real \<Rightarrow> real \<Rightarrow> real"
- real_lt > Orderings.ord_class.less :: "real \<Rightarrow> real \<Rightarrow> bool"
- mk_real > HOL.undefined (* Otherwise proof_import_concl fails *)
- dest_real > HOL.undefined
-
-ignore_thms
- real_TY_DEF
- real_tybij
- real_0
- real_1
- real_neg
- real_inv
- real_add
- real_mul
- real_lt
- real_of_hreal
- hreal_of_real
- REAL_ISO_EQ
- REAL_POS
- SUP_ALLPOS_LEMMA1
- SUP_ALLPOS_LEMMA2
- SUP_ALLPOS_LEMMA3
- SUP_ALLPOS_LEMMA4;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" real;
-
-const_maps
- real_gt > Compatibility.real_gt
- real_ge > Compatibility.real_ge
- real_lte > Orderings.ord_class.less_eq :: "real \<Rightarrow> real \<Rightarrow> bool"
- real_sub > Groups.minus_class.minus :: "real \<Rightarrow> real \<Rightarrow> real"
- "/" > Fields.inverse_class.divide :: "real \<Rightarrow> real \<Rightarrow> real"
- pow > Power.power_class.power :: "real \<Rightarrow> nat \<Rightarrow> real"
- abs > Groups.abs_class.abs :: "real => real"
- real_of_num > RealDef.real :: "nat => real";
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" topology;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" nets;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" seq;
-const_renames
-"-->" > "hol4-->";
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" lim;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" powser;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" transc;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" poly;
-end_import;
-
-append_dump "end";
-
-flush_dump;
-
-import_segment "";
-
-end
--- a/src/HOL/Import/HOL4/Template/GenHOL4Vec.thy Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,49 +0,0 @@
-(* Title: HOL/Import/HOL4/Template/GenHOL4Vec.thy
- Author: Sebastian Skalberg, TU Muenchen
-*)
-
-theory GenHOL4Vec
-imports GenHOL4Base
-begin
-
-import_segment "hol4"
-
-setup_dump "../Generated" "HOL4Vev"
-
-append_dump {*theory HOL4Vec
-imports HOL4Base
-begin
-*}
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" res_quan;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" word_base;
-
-const_renames
- BIT > bit;
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" word_num;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" word_bitop;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" bword_num;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" bword_arith;
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" bword_bitop;
-end_import;
-
-append_dump "end";
-
-flush_dump;
-
-import_segment "";
-
-end
--- a/src/HOL/Import/HOL4/Template/GenHOL4Word32.thy Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,38 +0,0 @@
-(* Title: HOL/Import/HOL4/Template/GenHOL4Word32.thy
- Author: Sebastian Skalberg, TU Muenchen
-*)
-
-theory GenHOL4Word32
-imports GenHOL4Base
-begin
-
-import_segment "hol4"
-
-setup_dump "../Generated" "HOL4Word32"
-
-append_dump {*theory HOL4Word32
-imports HOL4Base
-begin
-*}
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" bits;
-
-const_renames
- BIT > bit
-
-end_import;
-
-import_theory "~~/src/HOL/Import/HOL4/Generated" word32;
-
-const_renames
- "==" > EQUIV;
-
-end_import;
-
-append_dump "end";
-
-flush_dump;
-
-import_segment "";
-
-end
--- a/src/HOL/Import/HOL4/generate.ML Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,2 +0,0 @@
-
-use_thy "Generate";
--- a/src/HOL/Import/HOL4/import.ML Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,280 +0,0 @@
-(* Title: HOL/Import/import.ML
- Author: Sebastian Skalberg (TU Muenchen)
-*)
-
-signature IMPORT =
-sig
- val debug : bool Unsynchronized.ref
- val import_tac : Proof.context -> string * string -> tactic
- val setup : theory -> theory
-end
-
-structure ImportData = Theory_Data
-(
- type T = ProofKernel.thm option array option (* FIXME mutable array !??!!! *)
- val empty = NONE
- val extend = I
- fun merge _ = NONE
-)
-
-structure Import : IMPORT =
-struct
-
-val debug = Unsynchronized.ref false
-fun message s = if !debug then writeln s else ()
-
-fun import_tac ctxt (thyname, thmname) =
- if ! quick_and_dirty
- then Skip_Proof.cheat_tac (Proof_Context.theory_of ctxt)
- else
- fn th =>
- let
- val thy = Proof_Context.theory_of ctxt
- val prem = hd (prems_of th)
- val _ = message ("Import_tac: thyname=" ^ thyname ^ ", thmname=" ^ thmname)
- val _ = message ("Import trying to prove " ^ Syntax.string_of_term ctxt prem)
- val int_thms = case ImportData.get thy of
- NONE => fst (Replay.setup_int_thms thyname thy)
- | SOME a => a
- val proof = snd (ProofKernel.import_proof thyname thmname thy) thy
- val importerthm = snd (Replay.replay_proof int_thms thyname thmname proof thy)
- val thm = snd (ProofKernel.to_isa_thm importerthm)
- val rew = ProofKernel.rewrite_importer_term (concl_of thm) thy
- val thm = Thm.equal_elim rew thm
- val prew = ProofKernel.rewrite_importer_term prem thy
- val prem' = #2 (Logic.dest_equals (prop_of prew))
- val _ = message ("Import proved " ^ Display.string_of_thm ctxt thm)
- val thm = ProofKernel.disambiguate_frees thm
- val _ = message ("Disambiguate: " ^ Display.string_of_thm ctxt thm)
- in
- case Shuffler.set_prop thy prem' [("",thm)] of
- SOME (_,thm) =>
- let
- val _ = if prem' aconv (prop_of thm)
- then message "import: Terms match up"
- else message "import: Terms DO NOT match up"
- val thm' = Thm.equal_elim (Thm.symmetric prew) thm
- val res = Thm.bicompose true (false,thm',0) 1 th
- in
- res
- end
- | NONE => (message "import: set_prop didn't succeed"; no_tac th)
- end
-
-val setup = Method.setup @{binding import}
- (Scan.lift (Args.name -- Args.name) >>
- (fn arg => fn ctxt => SIMPLE_METHOD (import_tac ctxt arg)))
- "import external theorem"
-
-(* Parsers *)
-
-val import_segment = Parse.name >> set_import_segment
-
-
-val import_theory = (Parse.name -- Parse.name) >> (fn (location, thyname) =>
- fn thy =>
- thy |> set_generating_thy thyname
- |> Sign.add_path thyname
- |> add_dump ("setup_theory " ^ quote location ^ " " ^ thyname))
-
-fun end_import toks =
- Scan.succeed
- (fn thy =>
- let
- val thyname = get_generating_thy thy
- val segname = get_import_segment thy
- val (int_thms,facts) = Replay.setup_int_thms thyname thy
- val thmnames = filter_out (should_ignore thyname thy) facts
- fun replay thy = Replay.import_thms thyname int_thms thmnames thy
- in
- thy |> clear_import_thy
- |> set_segment thyname segname
- |> set_used_names facts
- |> replay
- |> clear_used_names
- |> export_importer_pending
- |> Sign.parent_path
- |> dump_import_thy thyname
- |> add_dump ";end_setup"
- end) toks
-
-val ignore_thms = Scan.repeat1 Parse.name
- >> (fn ignored =>
- fn thy =>
- let
- val thyname = get_import_thy thy
- in
- Library.foldl (fn (thy,thmname) => ignore_importer thyname thmname thy) (thy,ignored)
- end)
-
-val thm_maps = Scan.repeat1 (Parse.name --| Parse.$$$ ">" -- Parse.xname)
- >> (fn thmmaps =>
- fn thy =>
- let
- val thyname = get_import_thy thy
- in
- Library.foldl (fn (thy,(hol,isa)) => add_importer_mapping thyname hol isa thy) (thy,thmmaps)
- end)
-
-val type_maps = Scan.repeat1 (Parse.name --| Parse.$$$ ">" -- Parse.xname)
- >> (fn typmaps =>
- fn thy =>
- let
- val thyname = get_import_thy thy
- in
- Library.foldl (fn (thy,(hol,isa)) => add_importer_type_mapping thyname hol false isa thy) (thy,typmaps)
- end)
-
-val def_maps = Scan.repeat1 (Parse.name --| Parse.$$$ ">" -- Parse.xname)
- >> (fn defmaps =>
- fn thy =>
- let
- val thyname = get_import_thy thy
- in
- Library.foldl (fn (thy,(hol,isa)) => add_defmap thyname hol isa thy) (thy,defmaps)
- end)
-
-val const_renames = Scan.repeat1 (Parse.name --| Parse.$$$ ">" -- Parse.name)
- >> (fn renames =>
- fn thy =>
- let
- val thyname = get_import_thy thy
- in
- Library.foldl (fn (thy,(hol,isa)) => add_importer_const_renaming thyname hol isa thy) (thy,renames)
- end)
-
-val const_maps = Scan.repeat1 (Parse.name --| Parse.$$$ ">" -- Parse.xname -- Scan.option (Parse.$$$ "::" |-- Parse.typ))
- >> (fn constmaps =>
- fn thy =>
- let
- val thyname = get_import_thy thy
- in
- Library.foldl (fn (thy,((hol,isa),NONE)) => add_importer_const_mapping thyname hol false isa thy
- | (thy,((hol,isa),SOME ty)) => add_importer_const_wt_mapping thyname hol false isa (Syntax.read_typ_global thy ty) thy) (thy,constmaps)
- end)
-
-val const_moves = Scan.repeat1 (Parse.name --| Parse.$$$ ">" -- Parse.xname -- Scan.option (Parse.$$$ "::" |-- Parse.typ))
- >> (fn constmaps =>
- fn thy =>
- let
- val thyname = get_import_thy thy
- in
- Library.foldl (fn (thy,((hol,isa),NONE)) => add_importer_const_mapping thyname hol true isa thy
- | (thy,((hol,isa),SOME ty)) => add_importer_const_wt_mapping thyname hol true isa (Syntax.read_typ_global thy ty) thy) (thy,constmaps)
- end)
-
-fun import_thy location s =
- let
- val src_location = Path.append (Path.explode location) (Path.basic (s ^ ".imp"))
- val is = TextIO.openIn (File.platform_path src_location)
- val inp = TextIO.inputAll is
- val _ = TextIO.closeIn is
- val orig_source = Source.of_string inp
- val symb_source = Symbol.source orig_source
- val lexes =
- (Scan.make_lexicon
- (map Symbol.explode ["import_segment","ignore_thms","import","end",">","::","const_maps","const_moves","thm_maps","const_renames","type_maps","def_maps"]),
- Scan.empty_lexicon)
- val token_source = Token.source {do_recover = NONE} (K lexes) Position.start symb_source
- val token_list = filter_out (Token.is_kind Token.Space) (Source.exhaust token_source)
- val import_segmentP = Parse.$$$ "import_segment" |-- import_segment
- val type_mapsP = Parse.$$$ "type_maps" |-- type_maps
- val def_mapsP = Parse.$$$ "def_maps" |-- def_maps
- val const_mapsP = Parse.$$$ "const_maps" |-- const_maps
- val const_movesP = Parse.$$$ "const_moves" |-- const_moves
- val const_renamesP = Parse.$$$ "const_renames" |-- const_renames
- val ignore_thmsP = Parse.$$$ "ignore_thms" |-- ignore_thms
- val thm_mapsP = Parse.$$$ "thm_maps" |-- thm_maps
- val parser = type_mapsP || def_mapsP || const_mapsP || const_movesP || const_renamesP || thm_mapsP || ignore_thmsP || import_segmentP
- val importP = Parse.$$$ "import" |-- Scan.repeat parser --| Parse.$$$ "end"
- fun apply [] thy = thy
- | apply (f::fs) thy = apply fs (f thy)
- in
- apply (set_replaying_thy s :: Sign.add_path s :: fst (importP token_list))
- end
-
-fun create_int_thms thyname thy =
- if ! quick_and_dirty
- then thy
- else
- case ImportData.get thy of
- NONE => ImportData.put (SOME (fst (Replay.setup_int_thms thyname thy))) thy
- | SOME _ => error "Import data not closed - forgotten an end_setup, mayhap?"
-
-fun clear_int_thms thy =
- if ! quick_and_dirty
- then thy
- else
- case ImportData.get thy of
- NONE => error "Import data already cleared - forgotten a setup_theory?"
- | SOME _ => ImportData.put NONE thy
-
-val setup_theory = (Parse.name -- Parse.name)
- >>
- (fn (location, thyname) =>
- fn thy =>
- (case Importer_DefThy.get thy of
- NoImport => thy
- | Generating _ => error "Currently generating a theory!"
- | Replaying _ => thy |> clear_import_thy)
- |> import_thy location thyname
- |> create_int_thms thyname)
-
-fun end_setup toks =
- Scan.succeed
- (fn thy =>
- let
- val thyname = get_import_thy thy
- val segname = get_import_segment thy
- in
- thy |> set_segment thyname segname
- |> clear_import_thy
- |> clear_int_thms
- |> Sign.parent_path
- end) toks
-
-val set_dump = Parse.string -- Parse.string >> setup_dump
-fun fl_dump toks = Scan.succeed flush_dump toks
-val append_dump = (Parse.verbatim || Parse.string) >> add_dump
-
-val _ =
- (Outer_Syntax.command @{command_spec "import_segment"} "set import segment name"
- (import_segment >> Toplevel.theory);
- Outer_Syntax.command @{command_spec "import_theory"} "set default external theory name"
- (import_theory >> Toplevel.theory);
- Outer_Syntax.command @{command_spec "end_import"} "end external import"
- (end_import >> Toplevel.theory);
- Outer_Syntax.command @{command_spec "setup_theory"} "setup external theory replaying"
- (setup_theory >> Toplevel.theory);
- Outer_Syntax.command @{command_spec "end_setup"} "end external setup"
- (end_setup >> Toplevel.theory);
- Outer_Syntax.command @{command_spec "setup_dump"} "setup the dump file name"
- (set_dump >> Toplevel.theory);
- Outer_Syntax.command @{command_spec "append_dump"} "add text to dump file"
- (append_dump >> Toplevel.theory);
- Outer_Syntax.command @{command_spec "flush_dump"} "write the dump to file"
- (fl_dump >> Toplevel.theory);
- Outer_Syntax.command @{command_spec "ignore_thms"}
- "theorems to ignore in next external theory import"
- (ignore_thms >> Toplevel.theory);
- Outer_Syntax.command @{command_spec "type_maps"}
- "map external type names to existing Isabelle/HOL type names"
- (type_maps >> Toplevel.theory);
- Outer_Syntax.command @{command_spec "def_maps"}
- "map external constant names to their primitive definitions"
- (def_maps >> Toplevel.theory);
- Outer_Syntax.command @{command_spec "thm_maps"}
- "map external theorem names to existing Isabelle/HOL theorem names"
- (thm_maps >> Toplevel.theory);
- Outer_Syntax.command @{command_spec "const_renames"}
- "rename external const names"
- (const_renames >> Toplevel.theory);
- Outer_Syntax.command @{command_spec "const_moves"}
- "rename external const names to other external constants"
- (const_moves >> Toplevel.theory);
- Outer_Syntax.command @{command_spec "const_maps"}
- "map external const names to existing Isabelle/HOL const names"
- (const_maps >> Toplevel.theory));
-
-end
-
--- a/src/HOL/Import/HOL4/import_rews.ML Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,633 +0,0 @@
-(* Title: HOL/Import/import_rews.ML
- Author: Sebastian Skalberg (TU Muenchen)
-*)
-
-structure StringPair = Table(type key = string * string val ord = prod_ord string_ord string_ord);
-
-type holthm = (term * term) list * thm
-
-datatype ImportStatus =
- NoImport
- | Generating of string
- | Replaying of string
-
-structure Importer_DefThy = Theory_Data
-(
- type T = ImportStatus
- val empty = NoImport
- val extend = I
- fun merge (NoImport, NoImport) = NoImport
- | merge _ = (warning "Import status set during merge"; NoImport)
-)
-
-structure ImportSegment = Theory_Data
-(
- type T = string
- val empty = ""
- val extend = I
- fun merge ("",arg) = arg
- | merge (arg,"") = arg
- | merge (s1,s2) =
- if s1 = s2
- then s1
- else error "Trying to merge two different import segments"
-)
-
-val get_import_segment = ImportSegment.get
-val set_import_segment = ImportSegment.put
-
-structure Importer_UNames = Theory_Data
-(
- type T = string list
- val empty = []
- val extend = I
- fun merge ([], []) = []
- | merge _ = error "Used names not empty during merge"
-)
-
-structure Importer_Dump = Theory_Data
-(
- type T = string * string * string list
- val empty = ("","",[])
- val extend = I
- fun merge (("","",[]),("","",[])) = ("","",[])
- | merge _ = error "Dump data not empty during merge"
-)
-
-structure Importer_Moves = Theory_Data
-(
- type T = string Symtab.table
- val empty = Symtab.empty
- val extend = I
- fun merge data = Symtab.merge (K true) data
-)
-
-structure Importer_Imports = Theory_Data
-(
- type T = string Symtab.table
- val empty = Symtab.empty
- val extend = I
- fun merge data = Symtab.merge (K true) data
-)
-
-fun get_segment2 thyname thy =
- Symtab.lookup (Importer_Imports.get thy) thyname
-
-fun set_segment thyname segname thy =
- let
- val imps = Importer_Imports.get thy
- val imps' = Symtab.update_new (thyname,segname) imps
- in
- Importer_Imports.put imps' thy
- end
-
-structure Importer_CMoves = Theory_Data
-(
- type T = string Symtab.table
- val empty = Symtab.empty
- val extend = I
- fun merge data = Symtab.merge (K true) data
-)
-
-structure Importer_Maps = Theory_Data
-(
- type T = string option StringPair.table
- val empty = StringPair.empty
- val extend = I
- fun merge data = StringPair.merge (K true) data
-)
-
-structure Importer_Thms = Theory_Data
-(
- type T = holthm StringPair.table
- val empty = StringPair.empty
- val extend = I
- fun merge data = StringPair.merge (K true) data
-)
-
-structure Importer_ConstMaps = Theory_Data
-(
- type T = (bool * string * typ option) StringPair.table
- val empty = StringPair.empty
- val extend = I
- fun merge data = StringPair.merge (K true) data
-)
-
-structure Importer_Rename = Theory_Data
-(
- type T = string StringPair.table
- val empty = StringPair.empty
- val extend = I
- fun merge data = StringPair.merge (K true) data
-)
-
-structure Importer_DefMaps = Theory_Data
-(
- type T = string StringPair.table
- val empty = StringPair.empty
- val extend = I
- fun merge data = StringPair.merge (K true) data
-)
-
-structure Importer_TypeMaps = Theory_Data
-(
- type T = (bool * string) StringPair.table
- val empty = StringPair.empty
- val extend = I
- fun merge data = StringPair.merge (K true) data
-)
-
-structure Importer_Pending = Theory_Data
-(
- type T = ((term * term) list * thm) StringPair.table
- val empty = StringPair.empty
- val extend = I
- fun merge data = StringPair.merge (K true) data
-)
-
-structure Importer_Rewrites = Theory_Data
-(
- type T = thm list
- val empty = []
- val extend = I
- val merge = Thm.merge_thms
-)
-
-val importer_debug = Unsynchronized.ref false
-fun message s = if !importer_debug then writeln s else ()
-
-fun add_importer_rewrite (Context.Theory thy, th) =
- let
- val _ = message "Adding external rewrite"
- val th1 = th RS @{thm eq_reflection}
- handle THM _ => th
- val current_rews = Importer_Rewrites.get thy
- val new_rews = insert Thm.eq_thm th1 current_rews
- val updated_thy = Importer_Rewrites.put new_rews thy
- in
- (Context.Theory updated_thy,th1)
- end
- | add_importer_rewrite (context, th) = (context,
- (th RS @{thm eq_reflection} handle THM _ => th)
- );
-
-fun ignore_importer bthy bthm thy =
- let
- val _ = message ("Ignoring " ^ bthy ^ "." ^ bthm)
- val curmaps = Importer_Maps.get thy
- val newmaps = StringPair.update_new ((bthy,bthm),NONE) curmaps
- val upd_thy = Importer_Maps.put newmaps thy
- in
- upd_thy
- end
-
-val opt_get_output_thy = #2 o Importer_Dump.get
-
-fun get_output_thy thy =
- case #2 (Importer_Dump.get thy) of
- "" => error "No theory file being output"
- | thyname => thyname
-
-val get_output_dir = #1 o Importer_Dump.get
-
-fun add_importer_move bef aft thy =
- let
- val curmoves = Importer_Moves.get thy
- val newmoves = Symtab.update_new (bef, aft) curmoves
- in
- Importer_Moves.put newmoves thy
- end
-
-fun get_importer_move bef thy =
- Symtab.lookup (Importer_Moves.get thy) bef
-
-fun follow_name thmname thy =
- let
- val moves = Importer_Moves.get thy
- fun F thmname =
- case Symtab.lookup moves thmname of
- SOME name => F name
- | NONE => thmname
- in
- F thmname
- end
-
-fun add_importer_cmove bef aft thy =
- let
- val curmoves = Importer_CMoves.get thy
- val newmoves = Symtab.update_new (bef, aft) curmoves
- in
- Importer_CMoves.put newmoves thy
- end
-
-fun get_importer_cmove bef thy =
- Symtab.lookup (Importer_CMoves.get thy) bef
-
-fun follow_cname thmname thy =
- let
- val moves = Importer_CMoves.get thy
- fun F thmname =
- case Symtab.lookup moves thmname of
- SOME name => F name
- | NONE => thmname
- in
- F thmname
- end
-
-fun add_importer_mapping bthy bthm isathm thy =
- let
- (* val _ = writeln ("Before follow_name: "^isathm) *)
- val isathm = follow_name isathm thy
- (* val _ = writeln ("Adding theorem map: " ^ bthy ^ "." ^ bthm ^ " --> " ^ isathm)*)
- val curmaps = Importer_Maps.get thy
- val newmaps = StringPair.update_new ((bthy,bthm),SOME isathm) curmaps
- val upd_thy = Importer_Maps.put newmaps thy
- in
- upd_thy
- end;
-
-fun get_importer_type_mapping bthy tycon thy =
- let
- val maps = Importer_TypeMaps.get thy
- in
- StringPair.lookup maps (bthy,tycon)
- end
-
-fun get_importer_mapping bthy bthm thy =
- let
- val curmaps = Importer_Maps.get thy
- in
- StringPair.lookup curmaps (bthy,bthm)
- end;
-
-fun add_importer_const_mapping bthy bconst internal isaconst thy =
- let
- val thy = case opt_get_output_thy thy of
- "" => thy
- | output_thy => if internal
- then add_importer_cmove (Sign.full_bname thy bconst) (output_thy ^ "." ^ bthy ^ "." ^ bconst) thy
- else thy
- val _ = message ("Adding cmap " ^ bthy ^ "." ^ bconst ^ " -> " ^ isaconst ^ (if internal then " (*)" else ""))
- val curmaps = Importer_ConstMaps.get thy
- val newmaps = StringPair.update_new ((bthy,bconst),(internal,isaconst,NONE)) curmaps
- val upd_thy = Importer_ConstMaps.put newmaps thy
- in
- upd_thy
- end;
-
-fun add_importer_const_renaming bthy bconst newname thy =
- let
- val currens = Importer_Rename.get thy
- val _ = message ("Adding renaming " ^ bthy ^ "." ^ bconst ^ " -> " ^ newname)
- val newrens = StringPair.update_new ((bthy,bconst),newname) currens
- val upd_thy = Importer_Rename.put newrens thy
- in
- upd_thy
- end;
-
-fun get_importer_const_renaming bthy bconst thy =
- let
- val currens = Importer_Rename.get thy
- in
- StringPair.lookup currens (bthy,bconst)
- end;
-
-fun get_importer_const_mapping bthy bconst thy =
- let
- val bconst = case get_importer_const_renaming bthy bconst thy of
- SOME name => name
- | NONE => bconst
- val maps = Importer_ConstMaps.get thy
- in
- StringPair.lookup maps (bthy,bconst)
- end
-
-fun add_importer_const_wt_mapping bthy bconst internal isaconst typ thy =
- let
- val thy = case opt_get_output_thy thy of
- "" => thy
- | output_thy => if internal
- then add_importer_cmove (Sign.full_bname thy bconst) (output_thy ^ "." ^ bthy ^ "." ^ bconst) thy
- else thy
- val _ = message ("Adding cmap " ^ bthy ^ "." ^ bconst ^ " -> " ^ isaconst ^ (if internal then " (*)" else ""))
- val curmaps = Importer_ConstMaps.get thy
- val newmaps = StringPair.update_new ((bthy,bconst),(internal,isaconst,SOME typ)) curmaps
- val upd_thy = Importer_ConstMaps.put newmaps thy
- in
- upd_thy
- end;
-
-fun add_importer_type_mapping bthy bconst internal isaconst thy =
- let
- val curmaps = Importer_TypeMaps.get thy
- val _ = writeln ("Adding tmap " ^ bthy ^ "." ^ bconst ^ " -> " ^ isaconst ^ (if internal then " (*)" else ""))
- val newmaps = StringPair.update_new ((bthy,bconst),(internal,isaconst)) curmaps
- (* FIXME avoid handle x *)
- handle x => let val (_, isaconst') = the (StringPair.lookup curmaps (bthy, bconst)) in
- warning ("couldn't map type "^bthy^"."^bconst^" to "^isaconst^": already mapped to "^isaconst'); raise x end
- val upd_thy = Importer_TypeMaps.put newmaps thy
- in
- upd_thy
- end;
-
-fun add_importer_pending bthy bthm hth thy =
- let
- val thmname = Sign.full_bname thy bthm
- val _ = message ("Add pending " ^ bthy ^ "." ^ bthm)
- val curpend = Importer_Pending.get thy
- val newpend = StringPair.update_new ((bthy,bthm),hth) curpend
- val upd_thy = Importer_Pending.put newpend thy
- val thy' = case opt_get_output_thy upd_thy of
- "" => add_importer_mapping bthy bthm thmname upd_thy
- | output_thy =>
- let
- val new_thmname = output_thy ^ "." ^ bthy ^ "." ^ bthm
- in
- upd_thy |> add_importer_move thmname new_thmname
- |> add_importer_mapping bthy bthm new_thmname
- end
- in
- thy'
- end;
-
-fun get_importer_theorem thyname thmname thy =
- let
- val isathms = Importer_Thms.get thy
- in
- StringPair.lookup isathms (thyname,thmname)
- end;
-
-fun add_importer_theorem thyname thmname hth =
- let
- val _ = message ("Adding external theorem " ^ thyname ^ "." ^ thmname)
- in
- Importer_Thms.map (StringPair.update_new ((thyname, thmname), hth))
- end;
-
-fun export_importer_pending thy =
- let
- val rews = Importer_Rewrites.get thy;
- val pending = Importer_Pending.get thy;
- fun process ((bthy,bthm), hth as (_,thm)) thy =
- let
- val thm1 = rewrite_rule (map (Thm.transfer thy) rews) (Thm.transfer thy thm);
- val thm2 = Drule.export_without_context thm1;
- in
- thy
- |> Global_Theory.store_thm (Binding.name bthm, thm2)
- |> snd
- |> add_importer_theorem bthy bthm hth
- end;
- in
- thy
- |> StringPair.fold process pending
- |> Importer_Pending.put StringPair.empty
- end;
-
-fun setup_dump (dir,thyname) thy =
- Importer_Dump.put (dir,thyname,["(* AUTOMATICALLY GENERATED, DO NOT EDIT! *)"]) thy
-
-fun add_dump str thy =
- let
- val (dir,thyname,curdump) = Importer_Dump.get thy
- in
- Importer_Dump.put (dir,thyname,str::curdump) thy
- end
-
-fun flush_dump thy =
- let
- val (dir,thyname,dumpdata) = Importer_Dump.get thy
- val os = TextIO.openOut (OS.Path.joinDirFile {dir=dir,
- file=thyname ^ ".thy"})
- val _ = app (fn s => TextIO.output(os,s ^ "\n\n")) (rev dumpdata)
- val _ = TextIO.closeOut os
- in
- Importer_Dump.put ("","",[]) thy
- end
-
-fun set_generating_thy thyname thy =
- case Importer_DefThy.get thy of
- NoImport => Importer_DefThy.put (Generating thyname) thy
- | _ => error "Import already in progess"
-
-fun set_replaying_thy thyname thy =
- case Importer_DefThy.get thy of
- NoImport => Importer_DefThy.put (Replaying thyname) thy
- | _ => error "Import already in progess"
-
-fun clear_import_thy thy =
- case Importer_DefThy.get thy of
- NoImport => error "No import in progress"
- | _ => Importer_DefThy.put NoImport thy
-
-fun get_generating_thy thy =
- case Importer_DefThy.get thy of
- Generating thyname => thyname
- | _ => error "No theory being generated"
-
-fun get_replaying_thy thy =
- case Importer_DefThy.get thy of
- Replaying thyname => thyname
- | _ => error "No theory being replayed"
-
-fun get_import_thy thy =
- case Importer_DefThy.get thy of
- Replaying thyname => thyname
- | Generating thyname => thyname
- | _ => error "No theory being imported"
-
-fun should_ignore thyname thy thmname =
- case get_importer_mapping thyname thmname thy of
- SOME NONE => true
- | _ => false
-
-val trans_string =
- let
- fun quote s = "\"" ^ s ^ "\""
- fun F [] = []
- | F (#"\\" :: cs) = patch #"\\" cs
- | F (#"\"" :: cs) = patch #"\"" cs
- | F (c :: cs) = c :: F cs
- and patch c rest = #"\\" :: c :: F rest
- in
- quote o String.implode o F o String.explode
- end
-
-fun dump_import_thy thyname thy =
- let
- val output_dir = get_output_dir thy
- val output_thy = get_output_thy thy
- val input_thy = Context.theory_name thy
- val import_segment = get_import_segment thy
- val os = TextIO.openOut (OS.Path.joinDirFile {dir=output_dir,
- file=thyname ^ ".imp"})
- fun out s = TextIO.output(os,s)
- val (ignored, mapped) = StringPair.fold
- (fn ((bthy, bthm), v) => fn (ign, map) =>
- if bthy = thyname
- then case v
- of NONE => (bthm :: ign, map)
- | SOME w => (ign, (bthm, w) :: map)
- else (ign, map)) (Importer_Maps.get thy) ([],[]);
- fun mk init = StringPair.fold
- (fn ((bthy, bthm), v) => if bthy = thyname then cons (bthm, v) else I) init [];
- val constmaps = mk (Importer_ConstMaps.get thy);
- val constrenames = mk (Importer_Rename.get thy);
- val typemaps = mk (Importer_TypeMaps.get thy);
- val defmaps = mk (Importer_DefMaps.get thy);
- fun new_name internal isa =
- if internal
- then
- let
- val paths = Long_Name.explode isa
- val i = drop (length paths - 2) paths
- in
- case i of
- [seg,con] => output_thy ^ "." ^ seg ^ "." ^ con
- | _ => error "import_rews.dump internal error"
- end
- else
- isa
-
- val _ = out "import\n\n"
-
- val _ = out ("import_segment " ^ trans_string import_segment ^ "\n\n")
- val _ = if null defmaps
- then ()
- else out "def_maps"
- val _ = app (fn (hol,isa) =>
- out ("\n " ^ (trans_string hol) ^ " > " ^ (trans_string isa))) defmaps
- val _ = if null defmaps
- then ()
- else out "\n\n"
-
- val _ = if null typemaps
- then ()
- else out "type_maps"
- val _ = app (fn (hol,(internal,isa)) =>
- out ("\n " ^ (trans_string hol) ^ " > " ^ (trans_string (new_name internal isa)))) typemaps
- val _ = if null typemaps
- then ()
- else out "\n\n"
-
- val _ = if null constmaps
- then ()
- else out "const_maps"
- val _ = app (fn (hol,(_,isa,opt_ty)) =>
- (out ("\n " ^ (trans_string hol) ^ " > " ^ (trans_string (follow_cname isa thy)));
- case opt_ty of
- SOME ty => out (" :: \"" ^ Syntax.string_of_typ_global thy ty ^ "\"")
- | NONE => ())) constmaps
- val _ = if null constmaps
- then ()
- else out "\n\n"
-
- val _ = if null constrenames
- then ()
- else out "const_renames"
- val _ = app (fn (old,new) =>
- out ("\n " ^ (trans_string old) ^ " > " ^ (trans_string new))) constrenames
- val _ = if null constrenames
- then ()
- else out "\n\n"
-
- fun gen2replay in_thy out_thy s =
- let
- val ss = Long_Name.explode s
- in
- if (hd ss = in_thy) then
- Long_Name.implode (out_thy::(tl ss))
- else
- s
- end
-
- val _ = if null mapped
- then ()
- else out "thm_maps"
- val _ = app (fn (hol,isa) => out ("\n " ^ (trans_string hol) ^ " > " ^ (trans_string (gen2replay input_thy output_thy isa)))) mapped
- val _ = if null mapped
- then ()
- else out "\n\n"
-
- val _ = if null ignored
- then ()
- else out "ignore_thms"
- val _ = app (fn ign => out ("\n " ^ (trans_string ign))) ignored
- val _ = if null ignored
- then ()
- else out "\n\n"
-
- val _ = out "end\n"
- val _ = TextIO.closeOut os
- in
- thy
- end
-
-fun set_used_names names thy =
- let
- val unames = Importer_UNames.get thy
- in
- case unames of
- [] => Importer_UNames.put names thy
- | _ => error "import_rews.set_used_names called on initialized data!"
- end
-
-val clear_used_names = Importer_UNames.put [];
-
-fun get_defmap thyname const thy =
- let
- val maps = Importer_DefMaps.get thy
- in
- StringPair.lookup maps (thyname,const)
- end
-
-fun add_defmap thyname const defname thy =
- let
- val _ = message ("Adding defmap " ^ thyname ^ "." ^ const ^ " --> " ^ defname)
- val maps = Importer_DefMaps.get thy
- val maps' = StringPair.update_new ((thyname,const),defname) maps
- val thy' = Importer_DefMaps.put maps' thy
- in
- thy'
- end
-
-fun get_defname thyname name thy =
- let
- val maps = Importer_DefMaps.get thy
- fun F dname = (dname,add_defmap thyname name dname thy)
- in
- case StringPair.lookup maps (thyname,name) of
- SOME thmname => (thmname,thy)
- | NONE =>
- let
- val used = Importer_UNames.get thy
- val defname = Thm.def_name name
- val pdefname = name ^ "_primdef"
- in
- if not (member (op =) used defname)
- then F defname (* name_def *)
- else if not (member (op =) used pdefname)
- then F pdefname (* name_primdef *)
- else F (singleton (Name.variant_list used) pdefname) (* last resort *)
- end
- end
-
-local
- fun handle_meta [x as Ast.Appl [Ast.Appl [Ast.Constant "_constrain", Ast.Constant @{const_syntax "=="}, _],_,_]] = x
- | handle_meta [x as Ast.Appl [Ast.Appl [Ast.Constant "_constrain", Ast.Constant @{const_syntax all}, _],_]] = x
- | handle_meta [x as Ast.Appl [Ast.Appl [Ast.Constant "_constrain", Ast.Constant @{const_syntax "==>"}, _],_,_]] = x
- | handle_meta [x] = Ast.Appl [Ast.Constant @{const_syntax Trueprop}, x]
- | handle_meta _ = error "import_rews error: Trueprop not applied to single argument"
-in
-val smarter_trueprop_parsing = [(@{const_syntax Trueprop},handle_meta)]
-end
-
-val importer_setup =
- add_importer_type_mapping "min" "bool" false @{type_name bool}
- #> add_importer_type_mapping "min" "fun" false "fun"
- #> add_importer_type_mapping "min" "ind" false @{type_name ind}
- #> add_importer_const_mapping "min" "=" false @{const_name HOL.eq}
- #> add_importer_const_mapping "min" "==>" false @{const_name HOL.implies}
- #> add_importer_const_mapping "min" "@" false @{const_name "Eps"}
- #> Attrib.setup @{binding import_rew}
- (Scan.succeed (Thm.mixed_attribute add_importer_rewrite)) "external rewrite rule";
--- a/src/HOL/Import/HOL4/imported.ML Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,2 +0,0 @@
-
-Unsynchronized.setmp quick_and_dirty true use_thy "Imported";
--- a/src/HOL/Import/HOL4/proof_kernel.ML Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,2084 +0,0 @@
-(* Title: HOL/Import/proof_kernel.ML
- Author: Sebastian Skalberg and Steven Obua, TU Muenchen
-*)
-
-signature ProofKernel =
-sig
- type hol_type
- type tag
- type term
- type thm
- type ('a,'b) subst
-
- type proof_info
- datatype proof = Proof of proof_info * proof_content
- and proof_content
- = PRefl of term
- | PInstT of proof * (hol_type,hol_type) subst
- | PSubst of proof list * term * proof
- | PAbs of proof * term
- | PDisch of proof * term
- | PMp of proof * proof
- | PHyp of term
- | PAxm of string * term
- | PDef of string * string * term
- | PTmSpec of string * string list * proof
- | PTyDef of string * string * proof
- | PTyIntro of string * string * string * string * term * term * proof
- | POracle of tag * term list * term
- | PDisk
- | PSpec of proof * term
- | PInst of proof * (term,term) subst
- | PGen of proof * term
- | PGenAbs of proof * term option * term list
- | PImpAS of proof * proof
- | PSym of proof
- | PTrans of proof * proof
- | PComb of proof * proof
- | PEqMp of proof * proof
- | PEqImp of proof
- | PExists of proof * term * term
- | PChoose of term * proof * proof
- | PConj of proof * proof
- | PConjunct1 of proof
- | PConjunct2 of proof
- | PDisj1 of proof * term
- | PDisj2 of proof * term
- | PDisjCases of proof * proof * proof
- | PNotI of proof
- | PNotE of proof
- | PContr of proof * term
-
- exception PK of string * string
-
- val get_proof_dir: string -> theory -> string option
- val disambiguate_frees : Thm.thm -> Thm.thm
- val debug : bool Unsynchronized.ref
- val disk_info_of : proof -> (string * string) option
- val set_disk_info_of : proof -> string -> string -> unit
- val mk_proof : proof_content -> proof
- val content_of : proof -> proof_content
- val import_proof : string -> string -> theory -> (theory -> term) option * (theory -> proof)
-
- val rewrite_importer_term: Term.term -> theory -> Thm.thm
-
- val type_of : term -> hol_type
-
- val get_thm : string -> string -> theory -> (theory * thm option)
- val get_def : string -> string -> term -> theory -> (theory * thm option)
- val get_axiom: string -> string -> theory -> (theory * thm option)
-
- val store_thm : string -> string -> thm -> theory -> theory * thm
-
- val to_isa_thm : thm -> (term * term) list * Thm.thm
- val to_isa_term: term -> Term.term
- val to_hol_thm : Thm.thm -> thm
-
- val REFL : term -> theory -> theory * thm
- val ASSUME : term -> theory -> theory * thm
- val INST_TYPE : (hol_type,hol_type) subst -> thm -> theory -> theory * thm
- val INST : (term,term)subst -> thm -> theory -> theory * thm
- val EQ_MP : thm -> thm -> theory -> theory * thm
- val EQ_IMP_RULE : thm -> theory -> theory * thm
- val SUBST : thm list -> term -> thm -> theory -> theory * thm
- val DISJ_CASES : thm -> thm -> thm -> theory -> theory * thm
- val DISJ1: thm -> term -> theory -> theory * thm
- val DISJ2: term -> thm -> theory -> theory * thm
- val IMP_ANTISYM: thm -> thm -> theory -> theory * thm
- val SYM : thm -> theory -> theory * thm
- val MP : thm -> thm -> theory -> theory * thm
- val GEN : term -> thm -> theory -> theory * thm
- val CHOOSE : term -> thm -> thm -> theory -> theory * thm
- val EXISTS : term -> term -> thm -> theory -> theory * thm
- val ABS : term -> thm -> theory -> theory * thm
- val GEN_ABS : term option -> term list -> thm -> theory -> theory * thm
- val TRANS : thm -> thm -> theory -> theory * thm
- val CCONTR : term -> thm -> theory -> theory * thm
- val CONJ : thm -> thm -> theory -> theory * thm
- val CONJUNCT1: thm -> theory -> theory * thm
- val CONJUNCT2: thm -> theory -> theory * thm
- val NOT_INTRO: thm -> theory -> theory * thm
- val NOT_ELIM : thm -> theory -> theory * thm
- val SPEC : term -> thm -> theory -> theory * thm
- val COMB : thm -> thm -> theory -> theory * thm
- val DISCH: term -> thm -> theory -> theory * thm
-
- val type_introduction: string -> string -> string -> string -> string -> term * term -> thm -> theory -> theory * thm
-
- val new_definition : string -> string -> term -> theory -> theory * thm
- val new_specification : string -> string -> string list -> thm -> theory -> theory * thm
- val new_type_definition : string -> string -> string -> thm -> theory -> theory * thm
- val new_axiom : string -> term -> theory -> theory * thm
-
- val prin : term -> unit
- val protect_factname : string -> string
- val replay_protect_varname : string -> string -> unit
- val replay_add_dump : string -> theory -> theory
-end
-
-structure ProofKernel : ProofKernel =
-struct
-type hol_type = Term.typ
-type term = Term.term
-datatype tag = Tag of string list
-type ('a,'b) subst = ('a * 'b) list
-datatype thm = HOLThm of (Term.term * Term.term) list * Thm.thm
-
-fun hthm2thm (HOLThm (_, th)) = th
-
-fun to_hol_thm th = HOLThm ([], th)
-
-val replay_add_dump = add_dump
-fun add_dump s thy = replay_add_dump s thy
-
-datatype proof_info
- = Info of {disk_info: (string * string) option Unsynchronized.ref}
-
-datatype proof = Proof of proof_info * proof_content
- and proof_content
- = PRefl of term
- | PInstT of proof * (hol_type,hol_type) subst
- | PSubst of proof list * term * proof
- | PAbs of proof * term
- | PDisch of proof * term
- | PMp of proof * proof
- | PHyp of term
- | PAxm of string * term
- | PDef of string * string * term
- | PTmSpec of string * string list * proof
- | PTyDef of string * string * proof
- | PTyIntro of string * string * string * string * term * term * proof
- | POracle of tag * term list * term
- | PDisk
- | PSpec of proof * term
- | PInst of proof * (term,term) subst
- | PGen of proof * term
- | PGenAbs of proof * term option * term list
- | PImpAS of proof * proof
- | PSym of proof
- | PTrans of proof * proof
- | PComb of proof * proof
- | PEqMp of proof * proof
- | PEqImp of proof
- | PExists of proof * term * term
- | PChoose of term * proof * proof
- | PConj of proof * proof
- | PConjunct1 of proof
- | PConjunct2 of proof
- | PDisj1 of proof * term
- | PDisj2 of proof * term
- | PDisjCases of proof * proof * proof
- | PNotI of proof
- | PNotE of proof
- | PContr of proof * term
-
-exception PK of string * string
-fun ERR f mesg = PK (f,mesg)
-
-
-(* Compatibility. *)
-
-val string_of_mixfix = Pretty.string_of o Mixfix.pretty_mixfix;
-
-fun mk_syn thy c =
- if Lexicon.is_identifier c andalso not (Syntax.is_keyword (Sign.syn_of thy) c) then NoSyn
- else Delimfix (Syntax_Ext.escape c)
-
-fun quotename c =
- if Lexicon.is_identifier c andalso not (Keyword.is_keyword c) then c else quote c
-
-exception SMART_STRING
-
-fun no_vars context tm =
- let
- val ctxt = Variable.set_body false context;
- val ([tm'], _) = Variable.import_terms true [tm] ctxt;
- in tm' end
-
-fun smart_string_of_cterm ctxt0 ct =
- let
- val ctxt = ctxt0
- |> Config.put show_brackets false
- |> Config.put show_all_types false
- |> Config.put show_types false
- |> Config.put show_sorts false;
- val {t,T,...} = rep_cterm ct
- (* Hack to avoid parse errors with Trueprop *)
- val t' = HOLogic.dest_Trueprop t
- handle TERM _ => t
- val tn = no_vars ctxt t'
- fun match u =
- let val _ = Thm.match (ct, cterm_of (Proof_Context.theory_of ctxt) u) in true end
- handle Pattern.MATCH => false
- fun G 0 f ctxt x = f ctxt x
- | G 1 f ctxt x = f (Config.put show_types true ctxt) x
- | G 2 f ctxt x = G 1 f (Config.put show_sorts true ctxt) x
- | G 3 f ctxt x = G 2 f (Config.put show_all_types true ctxt) x
- | G 4 f ctxt x = G 3 f (Config.put show_brackets true ctxt) x
- | G _ _ _ _ = raise SMART_STRING
- fun F n =
- let
- val str = G n Syntax.string_of_term ctxt tn
- val _ = warning (@{make_string} (n, str))
- val u = Syntax.parse_term ctxt str
- val u = if t = t' then u else HOLogic.mk_Trueprop u
- val u = Syntax.check_term ctxt (Type.constraint T u)
- in
- if match u
- then quote str
- else F (n+1)
- end
- handle ERROR _ => F (n + 1)
- | SMART_STRING =>
- let val _ =
- warning ("smart_string failed for: "^ G 0 Syntax.string_of_term ctxt (term_of ct))
- in quote (G 2 Syntax.string_of_term ctxt tn) end
- in
- Print_Mode.setmp [] F 0
- end
-
-fun smart_string_of_thm ctxt = smart_string_of_cterm ctxt o cprop_of
-
-fun prth th = writeln (Print_Mode.setmp [] Display.string_of_thm_without_context th);
-val topctxt = ML_Context.the_local_context ();
-fun prin t = writeln (Print_Mode.setmp []
- (fn () => Syntax.string_of_term topctxt t) ());
-fun pth (HOLThm(_,thm)) =
- let
- (*val _ = writeln "Renaming:"
- val _ = app (fn(v,w) => (prin v; writeln " -->"; prin w)) ren*)
- val _ = prth thm
- in
- ()
- end
-
-fun disk_info_of (Proof(Info{disk_info,...},_)) = !disk_info
-fun mk_proof p = Proof(Info{disk_info = Unsynchronized.ref NONE},p)
-fun content_of (Proof(_,p)) = p
-
-fun set_disk_info_of (Proof(Info{disk_info,...},_)) thyname thmname =
- disk_info := SOME(thyname,thmname)
-
-structure Lib =
-struct
-
-fun assoc x =
- let
- fun F [] = raise PK("Lib.assoc","Not found")
- | F ((x',y)::rest) = if x = x'
- then y
- else F rest
- in
- F
- end
-infix mem;
-fun i mem L =
- let fun itr [] = false
- | itr (a::rst) = i=a orelse itr rst
- in itr L end;
-
-infix union;
-fun [] union S = S
- | S union [] = S
- | (a::rst) union S2 = rst union (insert (op =) a S2);
-
-fun implode_subst [] = []
- | implode_subst (x::r::rest) = ((x,r)::(implode_subst rest))
- | implode_subst _ = raise ERR "implode_subst" "malformed substitution list"
-
-end
-open Lib
-
-structure Tag =
-struct
-val empty_tag = Tag []
-fun read name = Tag [name]
-fun merge (Tag tag1) (Tag tag2) = Tag (Lib.union(tag1,tag2))
-end
-
-(* Actual code. *)
-
-fun get_segment thyname l = (Lib.assoc "s" l
- handle PK _ => thyname)
-val get_name : (string * string) list -> string = Lib.assoc "n"
-
-exception XML of string
-
-datatype xml = Elem of string * (string * string) list * xml list
-datatype XMLtype = XMLty of xml | FullType of hol_type
-datatype XMLterm = XMLtm of xml | FullTerm of term
-
-fun xml_to_import_xml (XML.Elem ((n, l), ts)) = Elem (n, l, map xml_to_import_xml ts)
- | xml_to_import_xml (XML.Text _) = raise XML "Incorrect proof file: text";
-
-val type_of = Term.type_of
-
-val propT = Type("prop",[])
-
-fun mk_defeq name rhs thy =
- let
- val ty = type_of rhs
- in
- Logic.mk_equals (Const(Sign.intern_const thy name,ty),rhs)
- end
-
-fun mk_teq name rhs thy =
- let
- val ty = type_of rhs
- in
- HOLogic.mk_eq (Const(Sign.intern_const thy name,ty),rhs)
- end
-
-fun intern_const_name thyname const thy =
- case get_importer_const_mapping thyname const thy of
- SOME (_,cname,_) => cname
- | NONE => (case get_importer_const_renaming thyname const thy of
- SOME cname => Sign.intern_const thy (thyname ^ "." ^ cname)
- | NONE => Sign.intern_const thy (thyname ^ "." ^ const))
-
-fun intern_type_name thyname const thy =
- case get_importer_type_mapping thyname const thy of
- SOME (_,cname) => cname
- | NONE => Sign.intern_const thy (thyname ^ "." ^ const)
-
-fun mk_vartype name = TFree(name,["HOL.type"])
-fun mk_thy_type thy Thy Tyop Args = Type(intern_type_name Thy Tyop thy,Args)
-
-val mk_var = Free
-
-fun mk_thy_const thy Thy Nam Ty = Const(intern_const_name Thy Nam thy,Ty)
-
-local
- fun get_const sg _ name =
- (case Sign.const_type sg name of
- SOME ty => Const (name, ty)
- | NONE => raise ERR "get_type" (name ^ ": No such constant"))
-in
-fun prim_mk_const thy Thy Nam =
- let
- val name = intern_const_name Thy Nam thy
- val cmaps = Importer_ConstMaps.get thy
- in
- case StringPair.lookup cmaps (Thy,Nam) of
- SOME(_,_,SOME ty) => Const(name,ty)
- | _ => get_const thy Thy name
- end
-end
-
-fun mk_comb(f,a) = f $ a
-
-(* Needed for HOL Light *)
-fun protect_tyvarname s =
- let
- fun no_quest s =
- if Char.contains s #"?"
- then String.translate (fn #"?" => "q_" | c => Char.toString c) s
- else s
- fun beg_prime s =
- if String.isPrefix "'" s
- then s
- else "'" ^ s
- in
- s |> no_quest |> beg_prime
- end
-
-val protected_varnames = Unsynchronized.ref (Symtab.empty:string Symtab.table)
-val invented_isavar = Unsynchronized.ref 0
-
-fun innocent_varname s = Lexicon.is_identifier s andalso not (String.isPrefix "u_" s)
-
-fun valid_boundvarname s =
- can (fn () => Syntax.read_term_global @{theory Main} ("SOME "^s^". True")) ();
-
-fun valid_varname s =
- can (fn () => Syntax.read_term_global @{theory Main} s) ();
-
-fun protect_varname s =
- if innocent_varname s andalso valid_varname s then s else
- case Symtab.lookup (!protected_varnames) s of
- SOME t => t
- | NONE =>
- let
- val _ = Unsynchronized.inc invented_isavar
- val t = "u_" ^ string_of_int (!invented_isavar)
- val _ = protected_varnames := Symtab.update (s, t) (!protected_varnames)
- in
- t
- end
-
-exception REPLAY_PROTECT_VARNAME of string*string*string
-
-fun replay_protect_varname s t =
- case Symtab.lookup (!protected_varnames) s of
- SOME t' => raise REPLAY_PROTECT_VARNAME (s, t, t')
- | NONE =>
- let
- val _ = Unsynchronized.inc invented_isavar
- val t = "u_" ^ string_of_int (!invented_isavar)
- val _ = protected_varnames := Symtab.update (s, t) (!protected_varnames)
- in
- ()
- end
-
-fun protect_boundvarname s = if innocent_varname s andalso valid_boundvarname s then s else "u"
-
-fun mk_lambda (v as Free (x, T)) t = Abs (protect_boundvarname x, T, abstract_over (v, t))
- | mk_lambda (v as Var ((x, _), T)) t = Abs (protect_boundvarname x, T, abstract_over (v, t))
- | mk_lambda v t = raise TERM ("lambda", [v, t]);
-
-fun replacestr x y s =
-let
- val xl = raw_explode x
- val yl = raw_explode y
- fun isprefix [] _ = true
- | isprefix (x::xs) (y::ys) = if x = y then isprefix xs ys else false
- | isprefix _ _ = false
- fun isp s = isprefix xl s
- fun chg s = yl@(List.drop (s, List.length xl))
- fun r [] = []
- | r (S as (s::ss)) = if isp S then r (chg S) else s::(r ss)
-in
- implode(r (raw_explode s))
-end
-
-fun protect_factname s = replacestr "." "_dot_" s
-fun unprotect_factname s = replacestr "_dot_" "." s
-
-val ty_num_prefix = "N_"
-
-fun startsWithDigit s = Char.isDigit (hd (String.explode s))
-
-fun protect_tyname tyn =
- let
- val tyn' =
- if String.isPrefix ty_num_prefix tyn then raise (ERR "protect_ty_name" ("type name '"^tyn^"' is reserved")) else
- (if startsWithDigit tyn then ty_num_prefix^tyn else tyn)
- in
- tyn'
- end
-
-fun protect_constname tcn = tcn
- (* if tcn = ".." then "dotdot"
- else if tcn = "==" then "eqeq"
- else tcn*)
-
-structure TypeNet =
-struct
-
-fun get_type_from_index thy thyname types is =
- case Int.fromString is of
- SOME i => (case Array.sub(types,i) of
- FullType ty => ty
- | XMLty xty =>
- let
- val ty = get_type_from_xml thy thyname types xty
- val _ = Array.update(types,i,FullType ty)
- in
- ty
- end)
- | NONE => raise ERR "get_type_from_index" "Bad index"
-and get_type_from_xml thy thyname types =
- let
- fun gtfx (Elem("tyi",[("i",iS)],[])) =
- get_type_from_index thy thyname types iS
- | gtfx (Elem("tyc",atts,[])) =
- mk_thy_type thy
- (get_segment thyname atts)
- (protect_tyname (get_name atts))
- []
- | gtfx (Elem("tyv",[("n",s)],[])) = mk_vartype (protect_tyvarname s)
- | gtfx (Elem("tya",[],(Elem("tyc",atts,[]))::tys)) =
- mk_thy_type thy
- (get_segment thyname atts)
- (protect_tyname (get_name atts))
- (map gtfx tys)
- | gtfx _ = raise ERR "get_type" "Bad type"
- in
- gtfx
- end
-
-fun input_types _ (Elem("tylist",[("i",i)],xtys)) =
- let
- val types = Array.array(the (Int.fromString i),XMLty (Elem("",[],[])))
- fun IT _ [] = ()
- | IT n (xty::xtys) =
- (Array.update(types,n,XMLty xty);
- IT (n+1) xtys)
- val _ = IT 0 xtys
- in
- types
- end
- | input_types _ _ = raise ERR "input_types" "Bad type list"
-end
-
-structure TermNet =
-struct
-
-fun get_term_from_index thy thyname types terms is =
- case Int.fromString is of
- SOME i => (case Array.sub(terms,i) of
- FullTerm tm => tm
- | XMLtm xtm =>
- let
- val tm = get_term_from_xml thy thyname types terms xtm
- val _ = Array.update(terms,i,FullTerm tm)
- in
- tm
- end)
- | NONE => raise ERR "get_term_from_index" "Bad index"
-and get_term_from_xml thy thyname types terms =
- let
- fun gtfx (Elem("tmv",[("n",name),("t",tyi)],[])) =
- mk_var(protect_varname name,TypeNet.get_type_from_index thy thyname types tyi)
- | gtfx (Elem("tmc",atts,[])) =
- let
- val segment = get_segment thyname atts
- val name = protect_constname(get_name atts)
- in
- mk_thy_const thy segment name (TypeNet.get_type_from_index thy thyname types (Lib.assoc "t" atts))
- handle PK _ => prim_mk_const thy segment name
- end
- | gtfx (Elem("tma",[("f",tmf),("a",tma)],[])) =
- let
- val f = get_term_from_index thy thyname types terms tmf
- val a = get_term_from_index thy thyname types terms tma
- in
- mk_comb(f,a)
- end
- | gtfx (Elem("tml",[("x",tmx),("a",tma)],[])) =
- let
- val x = get_term_from_index thy thyname types terms tmx
- val a = get_term_from_index thy thyname types terms tma
- in
- mk_lambda x a
- end
- | gtfx (Elem("tmi",[("i",iS)],[])) =
- get_term_from_index thy thyname types terms iS
- | gtfx (Elem(tag,_,_)) =
- raise ERR "get_term" ("Not a term: "^tag)
- in
- gtfx
- end
-
-fun input_terms _ _ (Elem("tmlist",[("i",i)],xtms)) =
- let
- val terms = Array.array(the (Int.fromString i), XMLtm (Elem("",[],[])))
-
- fun IT _ [] = ()
- | IT n (xtm::xtms) =
- (Array.update(terms,n,XMLtm xtm);
- IT (n+1) xtms)
- val _ = IT 0 xtms
- in
- terms
- end
- | input_terms _ _ _ = raise ERR "input_terms" "Bad term list"
-end
-
-fun get_proof_dir (thyname:string) thy =
- let
- val import_segment =
- case get_segment2 thyname thy of
- SOME seg => seg
- | NONE => get_import_segment thy
- val path = space_explode ":" (getenv "IMPORTER_PROOFS")
- fun find [] = NONE
- | find (p::ps) =
- (let
- val dir = OS.Path.joinDirFile {dir = p,file=import_segment}
- in
- if OS.FileSys.isDir dir
- then SOME dir
- else find ps
- end) handle OS.SysErr _ => find ps
- in
- Option.map (fn p => OS.Path.joinDirFile {dir = p, file = thyname}) (find path)
- end
-
-fun proof_file_name thyname thmname thy =
- let
- val path = case get_proof_dir thyname thy of
- SOME p => p
- | NONE => error "Cannot find proof files"
- val _ = OS.FileSys.mkDir path handle OS.SysErr _ => ()
- in
- OS.Path.joinDirFile {dir = path, file = OS.Path.joinBaseExt {base = (unprotect_factname thmname), ext = SOME "prf"}}
- end
-
-fun xml_to_proof thyname types terms prf thy =
- let
- val xml_to_hol_type = TypeNet.get_type_from_xml thy thyname types
- val xml_to_term = TermNet.get_term_from_xml thy thyname types terms
-
- fun index_to_term is =
- TermNet.get_term_from_index thy thyname types terms is
-
- fun x2p (Elem("prefl",[("i",is)],[])) = mk_proof (PRefl (index_to_term is))
- | x2p (Elem("pinstt",[],p::lambda)) =
- let
- val p = x2p p
- val lambda = implode_subst (map xml_to_hol_type lambda)
- in
- mk_proof (PInstT(p,lambda))
- end
- | x2p (Elem("psubst",[("i",is)],prf::prfs)) =
- let
- val tm = index_to_term is
- val prf = x2p prf
- val prfs = map x2p prfs
- in
- mk_proof (PSubst(prfs,tm,prf))
- end
- | x2p (Elem("pabs",[("i",is)],[prf])) =
- let
- val p = x2p prf
- val t = index_to_term is
- in
- mk_proof (PAbs (p,t))
- end
- | x2p (Elem("pdisch",[("i",is)],[prf])) =
- let
- val p = x2p prf
- val t = index_to_term is
- in
- mk_proof (PDisch (p,t))
- end
- | x2p (Elem("pmp",[],[prf1,prf2])) =
- let
- val p1 = x2p prf1
- val p2 = x2p prf2
- in
- mk_proof (PMp(p1,p2))
- end
- | x2p (Elem("phyp",[("i",is)],[])) = mk_proof (PHyp (index_to_term is))
- | x2p (Elem("paxiom",[("n",n),("i",is)],[])) =
- mk_proof (PAxm(n,index_to_term is))
- | x2p (Elem("pfact",atts,[])) =
- let
- val thyname = get_segment thyname atts
- val thmname = protect_factname (get_name atts)
- val p = mk_proof PDisk
- val _ = set_disk_info_of p thyname thmname
- in
- p
- end
- | x2p (Elem("pdef",[("s",seg),("n",name),("i",is)],[])) =
- mk_proof (PDef(seg,protect_constname name,index_to_term is))
- | x2p (Elem("ptmspec",[("s",seg)],p::names)) =
- let
- val names = map (fn Elem("name",[("n",name)],[]) => name
- | _ => raise ERR "x2p" "Bad proof (ptmspec)") names
- in
- mk_proof (PTmSpec(seg,names,x2p p))
- end
- | x2p (Elem("ptyintro",[("s",seg),("n",name),("a",abs_name),("r",rep_name)],[xP,xt,p])) =
- let
- val P = xml_to_term xP
- val t = xml_to_term xt
- in
- mk_proof (PTyIntro(seg,protect_tyname name,protect_constname abs_name,protect_constname rep_name,P,t,x2p p))
- end
- | x2p (Elem("ptydef",[("s",seg),("n",name)],[p])) =
- mk_proof (PTyDef(seg,protect_tyname name,x2p p))
- | x2p (Elem("poracle",[],chldr)) =
- let
- val (oracles,terms) = List.partition (fn (Elem("oracle",_,_)) => true | _ => false) chldr
- val ors = map (fn (Elem("oracle",[("n",name)],[])) => name | _ => raise ERR "x2p" "bad oracle") oracles
- val (c,asl) = case terms of
- [] => raise ERR "x2p" "Bad oracle description"
- | (hd::tl) => (hd,tl)
- val tg = fold_rev (Tag.merge o Tag.read) ors Tag.empty_tag
- in
- mk_proof (POracle(tg,map xml_to_term asl,xml_to_term c))
- end
- | x2p (Elem("pspec",[("i",is)],[prf])) =
- let
- val p = x2p prf
- val tm = index_to_term is
- in
- mk_proof (PSpec(p,tm))
- end
- | x2p (Elem("pinst",[],p::theta)) =
- let
- val p = x2p p
- val theta = implode_subst (map xml_to_term theta)
- in
- mk_proof (PInst(p,theta))
- end
- | x2p (Elem("pgen",[("i",is)],[prf])) =
- let
- val p = x2p prf
- val tm = index_to_term is
- in
- mk_proof (PGen(p,tm))
- end
- | x2p (Elem("pgenabs",[],prf::tms)) =
- let
- val p = x2p prf
- val tml = map xml_to_term tms
- in
- mk_proof (PGenAbs(p,NONE,tml))
- end
- | x2p (Elem("pgenabs",[("i",is)],prf::tms)) =
- let
- val p = x2p prf
- val tml = map xml_to_term tms
- in
- mk_proof (PGenAbs(p,SOME (index_to_term is),tml))
- end
- | x2p (Elem("pimpas",[],[prf1,prf2])) =
- let
- val p1 = x2p prf1
- val p2 = x2p prf2
- in
- mk_proof (PImpAS(p1,p2))
- end
- | x2p (Elem("psym",[],[prf])) =
- let
- val p = x2p prf
- in
- mk_proof (PSym p)
- end
- | x2p (Elem("ptrans",[],[prf1,prf2])) =
- let
- val p1 = x2p prf1
- val p2 = x2p prf2
- in
- mk_proof (PTrans(p1,p2))
- end
- | x2p (Elem("pcomb",[],[prf1,prf2])) =
- let
- val p1 = x2p prf1
- val p2 = x2p prf2
- in
- mk_proof (PComb(p1,p2))
- end
- | x2p (Elem("peqmp",[],[prf1,prf2])) =
- let
- val p1 = x2p prf1
- val p2 = x2p prf2
- in
- mk_proof (PEqMp(p1,p2))
- end
- | x2p (Elem("peqimp",[],[prf])) =
- let
- val p = x2p prf
- in
- mk_proof (PEqImp p)
- end
- | x2p (Elem("pexists",[("e",ise),("w",isw)],[prf])) =
- let
- val p = x2p prf
- val ex = index_to_term ise
- val w = index_to_term isw
- in
- mk_proof (PExists(p,ex,w))
- end
- | x2p (Elem("pchoose",[("i",is)],[prf1,prf2])) =
- let
- val v = index_to_term is
- val p1 = x2p prf1
- val p2 = x2p prf2
- in
- mk_proof (PChoose(v,p1,p2))
- end
- | x2p (Elem("pconj",[],[prf1,prf2])) =
- let
- val p1 = x2p prf1
- val p2 = x2p prf2
- in
- mk_proof (PConj(p1,p2))
- end
- | x2p (Elem("pconjunct1",[],[prf])) =
- let
- val p = x2p prf
- in
- mk_proof (PConjunct1 p)
- end
- | x2p (Elem("pconjunct2",[],[prf])) =
- let
- val p = x2p prf
- in
- mk_proof (PConjunct2 p)
- end
- | x2p (Elem("pdisj1",[("i",is)],[prf])) =
- let
- val p = x2p prf
- val t = index_to_term is
- in
- mk_proof (PDisj1 (p,t))
- end
- | x2p (Elem("pdisj2",[("i",is)],[prf])) =
- let
- val p = x2p prf
- val t = index_to_term is
- in
- mk_proof (PDisj2 (p,t))
- end
- | x2p (Elem("pdisjcases",[],[prf1,prf2,prf3])) =
- let
- val p1 = x2p prf1
- val p2 = x2p prf2
- val p3 = x2p prf3
- in
- mk_proof (PDisjCases(p1,p2,p3))
- end
- | x2p (Elem("pnoti",[],[prf])) =
- let
- val p = x2p prf
- in
- mk_proof (PNotI p)
- end
- | x2p (Elem("pnote",[],[prf])) =
- let
- val p = x2p prf
- in
- mk_proof (PNotE p)
- end
- | x2p (Elem("pcontr",[("i",is)],[prf])) =
- let
- val p = x2p prf
- val t = index_to_term is
- in
- mk_proof (PContr (p,t))
- end
- | x2p _ = raise ERR "x2p" "Bad proof"
- in
- x2p prf
- end
-
-fun import_proof_concl thyname thmname thy =
- let
- val is = TextIO.openIn(proof_file_name thyname thmname thy)
- val proof_xml = xml_to_import_xml (XML.parse (TextIO.inputAll is))
- val _ = TextIO.closeIn is
- in
- case proof_xml of
- Elem("proof",[],xtypes::xterms::_::rest) =>
- let
- val types = TypeNet.input_types thyname xtypes
- val terms = TermNet.input_terms thyname types xterms
- fun f xtm thy = TermNet.get_term_from_xml thy thyname types terms xtm
- in
- case rest of
- [] => NONE
- | [xtm] => SOME (f xtm)
- | _ => raise ERR "import_proof" "Bad argument list"
- end
- | _ => raise ERR "import_proof" "Bad proof"
- end
-
-fun import_proof thyname thmname thy =
- let
- val is = TextIO.openIn(proof_file_name thyname thmname thy)
- val proof_xml = xml_to_import_xml (XML.parse (TextIO.inputAll is))
- val _ = TextIO.closeIn is
- in
- case proof_xml of
- Elem("proof",[],xtypes::xterms::prf::rest) =>
- let
- val types = TypeNet.input_types thyname xtypes
- val terms = TermNet.input_terms thyname types xterms
- in
- (case rest of
- [] => NONE
- | [xtm] => SOME (fn thy => TermNet.get_term_from_xml thy thyname types terms xtm)
- | _ => raise ERR "import_proof" "Bad argument list",
- xml_to_proof thyname types terms prf)
- end
- | _ => raise ERR "import_proof" "Bad proof"
- end
-
-fun uniq_compose m th i st =
- let
- val res = Thm.bicompose false (false,th,m) i st
- in
- case Seq.pull res of
- SOME (th,rest) => (case Seq.pull rest of
- SOME _ => raise ERR "uniq_compose" "Not unique!"
- | NONE => th)
- | NONE => raise ERR "uniq_compose" "No result"
- end
-
-val reflexivity_thm = @{thm refl}
-val mp_thm = @{thm mp}
-val imp_antisym_thm = @{thm light_imp_as}
-val disch_thm = @{thm impI}
-val ccontr_thm = @{thm ccontr}
-
-val meta_eq_to_obj_eq_thm = @{thm meta_eq_to_obj_eq}
-
-val gen_thm = @{thm HOLallI}
-val choose_thm = @{thm exE}
-val exists_thm = @{thm exI}
-val conj_thm = @{thm conjI}
-val conjunct1_thm = @{thm conjunct1}
-val conjunct2_thm = @{thm conjunct2}
-val spec_thm = @{thm spec}
-val disj_cases_thm = @{thm disjE}
-val disj1_thm = @{thm disjI1}
-val disj2_thm = @{thm disjI2}
-
-local
- val th = @{thm not_def}
- val thy = theory_of_thm th
- val pp = Thm.reflexive (cterm_of thy (Const(@{const_name Trueprop},HOLogic.boolT-->propT)))
-in
-val not_elim_thm = Thm.combination pp th
-end
-
-val not_intro_thm = Thm.symmetric not_elim_thm
-val abs_thm = @{thm ext}
-val trans_thm = @{thm trans}
-val symmetry_thm = @{thm sym}
-val eqmp_thm = @{thm iffD1}
-val eqimp_thm = @{thm Importer.eq_imp}
-val comb_thm = @{thm cong}
-
-(* Beta-eta normalizes a theorem (only the conclusion, not the *
-hypotheses!) *)
-
-fun beta_eta_thm th =
- let
- val th1 = Thm.equal_elim (Thm.beta_conversion true (cprop_of th)) th
- val th2 = Thm.equal_elim (Thm.eta_conversion (cprop_of th1)) th1
- in
- th2
- end
-
-fun implies_elim_all th =
- Library.foldl (fn (th,p) => Thm.implies_elim th (Thm.assume p)) (th,cprems_of th)
-
-fun norm_hyps th =
- th |> beta_eta_thm
- |> implies_elim_all
- |> implies_intr_hyps
-
-fun mk_GEN v th sg =
- let
- val c = HOLogic.dest_Trueprop (concl_of th)
- val cv = cterm_of sg v
- val lc = Term.lambda v c
- val clc = Thm.cterm_of sg lc
- val cvty = ctyp_of_term cv
- val th1 = implies_elim_all th
- val th2 = beta_eta_thm (Thm.forall_intr cv th1)
- val th3 = th2 COMP (beta_eta_thm (Drule.instantiate' [SOME cvty] [SOME clc] gen_thm))
- val c = prop_of th3
- val vname = fst(dest_Free v)
- val (cold,cnew) = case c of
- tpc $ (Const(@{const_name All},_) $ Abs(oldname,_,_)) =>
- (Abs(oldname,dummyT,Bound 0),Abs(vname,dummyT,Bound 0))
- | tpc $ (Const(@{const_name All},_) $ _) => (tpc,tpc)
- | _ => raise ERR "mk_GEN" "Unknown conclusion"
- val th4 = Thm.rename_boundvars cold cnew th3
- val res = implies_intr_hyps th4
- in
- res
- end
-
-fun rearrange sg tm th =
- let
- val tm' = Envir.beta_eta_contract tm
- fun find [] n = Thm.permute_prems 0 1 (Thm.implies_intr (Thm.cterm_of sg tm) th)
- | find (p::ps) n = if tm' aconv (Envir.beta_eta_contract p)
- then Thm.permute_prems n 1 th
- else find ps (n+1)
- in
- find (prems_of th) 0
- end
-
-fun zip (x::xs) (y::ys) = (x,y)::(zip xs ys)
- | zip [] [] = []
- | zip _ _ = raise ERR "zip" "arguments not of same length"
-
-fun mk_INST dom rng th =
- th |> forall_intr_list dom
- |> forall_elim_list rng
-
-(* Code for disambiguating variablenames (wrt. types) *)
-
-val disamb_info_empty = {vars=[],rens=[]}
-
-fun rens_of { vars = _, rens = rens } = rens
-
-fun disamb_term_from info tm = (info, tm)
-
-fun has_ren (HOLThm _) = false
-
-fun disamb_thm_from info (HOLThm (_,thm)) = (info, thm)
-
-fun disamb_terms_from info tms = (info, tms)
-
-fun disamb_thms_from info hthms = (info, map hthm2thm hthms)
-
-fun disamb_term tm = disamb_term_from disamb_info_empty tm
-fun disamb_thm thm = disamb_thm_from disamb_info_empty thm
-fun disamb_thms thms = disamb_thms_from disamb_info_empty thms
-
-fun norm_hthm _ (hth as HOLThm _) = hth
-
-(* End of disambiguating code *)
-
-fun disambiguate_frees thm =
- let
- fun ERR s = error ("Drule.disambiguate_frees: "^s)
- val ct = cprop_of thm
- val t = term_of ct
- val thy = theory_of_cterm ct
- val frees = Misc_Legacy.term_frees t
- val freenames = Term.add_free_names t []
- val is_old_name = member (op =) freenames
- fun name_of (Free (n, _)) = n
- | name_of _ = ERR "name_of"
- fun new_name' bump map n =
- let val n' = n^bump in
- if is_old_name n' orelse Symtab.lookup map n' <> NONE then
- new_name' (Symbol.bump_string bump) map n
- else
- n'
- end
- val new_name = new_name' "a"
- fun replace_name n' (Free (_, t)) = Free (n', t)
- | replace_name _ _ = ERR "replace_name"
- (* map: old or fresh name -> old free,
- invmap: old free which has fresh name assigned to it -> fresh name *)
- fun dis v (mapping as (map,invmap)) =
- let val n = name_of v in
- case Symtab.lookup map n of
- NONE => (Symtab.update (n, v) map, invmap)
- | SOME v' =>
- if v=v' then
- mapping
- else
- let val n' = new_name map n in
- (Symtab.update (n', v) map,
- Termtab.update (v, n') invmap)
- end
- end
- in
- if (length freenames = length frees) then
- thm
- else
- let
- val (_, invmap) =
- fold dis frees (Symtab.empty, Termtab.empty)
- fun make_subst (oldfree, newname) (intros, elims) =
- (cterm_of thy oldfree :: intros,
- cterm_of thy (replace_name newname oldfree) :: elims)
- val (intros, elims) = fold make_subst (Termtab.dest invmap) ([], [])
- in
- forall_elim_list elims (forall_intr_list intros thm)
- end
- end
-
-val debug = Unsynchronized.ref false
-
-fun if_debug f x = if !debug then f x else ()
-val message = if_debug writeln
-
-fun get_importer_thm thyname thmname thy =
- case get_importer_theorem thyname thmname thy of
- SOME hth => SOME (HOLThm hth)
- | NONE =>
- let
- val pending = Importer_Pending.get thy
- in
- case StringPair.lookup pending (thyname,thmname) of
- SOME hth => SOME (HOLThm hth)
- | NONE => NONE
- end
-
-fun non_trivial_term_consts t = fold_aterms
- (fn Const (c, _) =>
- if c = @{const_name Trueprop} orelse c = @{const_name All}
- orelse c = @{const_name HOL.implies} orelse c = @{const_name HOL.conj} orelse c = @{const_name HOL.eq}
- then I else insert (op =) c
- | _ => I) t [];
-
-fun split_name str =
- let
- val sub = Substring.full str
- val (f,idx) = apsnd Substring.string (Substring.splitr Char.isDigit sub)
- val (newstr,u) = pairself Substring.string (Substring.splitr (fn c => c = #"_") f)
- in
- if not (idx = "") andalso u = "_"
- then SOME (newstr, the (Int.fromString idx))
- else NONE
- end
- handle _ => NONE (* FIXME avoid handle _ *)
-
-fun rewrite_importer_term t thy =
- let
- val import_rews1 = map (Thm.transfer thy) (Importer_Rewrites.get thy)
- val importerss = Simplifier.global_context thy empty_ss addsimps import_rews1
- in
- Thm.transfer thy (Simplifier.full_rewrite importerss (cterm_of thy t))
- end
-
-fun get_isabelle_thm thyname thmname importerconc thy =
- let
- val (info,importerconc') = disamb_term importerconc
- val i2h_conc = Thm.symmetric (rewrite_importer_term (HOLogic.mk_Trueprop importerconc') thy)
- val isaconc =
- case concl_of i2h_conc of
- Const("==",_) $ lhs $ _ => lhs
- | _ => error "get_isabelle_thm" "Bad rewrite rule"
- val _ = (message "Original conclusion:";
- if_debug prin importerconc';
- message "Modified conclusion:";
- if_debug prin isaconc)
-
- fun mk_res th = HOLThm (rens_of info, Thm.equal_elim i2h_conc th)
- in
- case get_importer_mapping thyname thmname thy of
- SOME (SOME thmname) =>
- let
- val th1 = (SOME (Global_Theory.get_thm thy thmname)
- handle ERROR _ =>
- (case split_name thmname of
- SOME (listname,idx) => (SOME (nth (Global_Theory.get_thms thy listname) (idx - 1))
- handle _ => NONE) (* FIXME avoid handle _ *)
- | NONE => NONE))
- in
- case th1 of
- SOME th2 =>
- (case Shuffler.set_prop thy isaconc [(thmname,th2)] of
- SOME (_,th) => (message "YES";(thy, SOME (mk_res th)))
- | NONE => (message "NO2";error "get_isabelle_thm" "Bad mapping"))
- | NONE => (message "NO1";error "get_isabelle_thm" "Bad mapping")
- end
- | SOME NONE => error ("Trying to access ignored theorem " ^ thmname)
- | NONE =>
- let
- val _ = (message "Looking for conclusion:";
- if_debug prin isaconc)
- val cs = non_trivial_term_consts isaconc;
- val _ = (message "Looking for consts:";
- message (commas cs))
- val pot_thms = Shuffler.find_potential thy isaconc
- val _ = message (string_of_int (length pot_thms) ^ " potential theorems")
- in
- case Shuffler.set_prop thy isaconc pot_thms of
- SOME (isaname,th) =>
- let
- val hth as HOLThm args = mk_res th
- val thy' = thy |> add_importer_theorem thyname thmname args
- |> add_importer_mapping thyname thmname isaname
- in
- (thy',SOME hth)
- end
- | NONE => (thy,NONE)
- end
- end
- handle e =>
- if Exn.is_interrupt e then reraise e
- else
- (if_debug (fn () =>
- writeln ("Exception in get_isabelle_thm:\n" ^ ML_Compiler.exn_message e)) ();
- (thy,NONE))
-
-fun get_isabelle_thm_and_warn thyname thmname importerconc thy =
- let
- val (a, b) = get_isabelle_thm thyname thmname importerconc thy
- fun warn () =
- let
- val (_,importerconc') = disamb_term importerconc
- val i2h_conc = Thm.symmetric (rewrite_importer_term (HOLogic.mk_Trueprop importerconc') thy)
- in
- case concl_of i2h_conc of
- Const("==",_) $ lhs $ _ =>
- (warning ("Failed lookup of theorem '"^thmname^"':");
- writeln "Original conclusion:";
- prin importerconc';
- writeln "Modified conclusion:";
- prin lhs)
- | _ => ()
- end
- in
- case b of
- NONE => (warn () handle _ => (); (a,b)) (* FIXME avoid handle _ *)
- | _ => (a, b)
- end
-
-fun get_thm thyname thmname thy =
- case get_importer_thm thyname thmname thy of
- SOME hth => (thy,SOME hth)
- | NONE => ((case import_proof_concl thyname thmname thy of
- SOME f => get_isabelle_thm_and_warn thyname thmname (f thy) thy
- | NONE => (message "No conclusion"; (thy,NONE)))
- handle IO.Io _ => (message "IO exception"; (thy,NONE))
- | PK _ => (message "PK exception"; (thy,NONE)))
-
-fun rename_const thyname thy name =
- case get_importer_const_renaming thyname name thy of
- SOME cname => cname
- | NONE => name
-
-fun get_def thyname constname rhs thy =
- let
- val constname = rename_const thyname thy constname
- val (thmname,thy') = get_defname thyname constname thy
- val _ = message ("Looking for definition " ^ thyname ^ "." ^ thmname)
- in
- get_isabelle_thm_and_warn thyname thmname (mk_teq (thyname ^ "." ^ constname) rhs thy') thy'
- end
-
-fun get_axiom thyname axname thy =
- case get_thm thyname axname thy of
- arg as (_,SOME _) => arg
- | _ => raise ERR "get_axiom" ("Trying to retrieve axiom (" ^ axname ^ ")")
-
-fun intern_store_thm gen_output thyname thmname hth thy =
- let
- val (hth' as HOLThm (args as (_,th))) = norm_hthm thy hth
- val rew = rewrite_importer_term (concl_of th) thy
- val th = Thm.equal_elim rew th
- val thy' = add_importer_pending thyname thmname args thy
- val th = disambiguate_frees th
- val th = Object_Logic.rulify th
- val thy2 =
- if gen_output
- then
- add_dump ("lemma " ^ (quotename thmname) ^ ": " ^
- (smart_string_of_thm (Syntax.init_pretty_global thy') th) ^ "\n by (import " ^
- thyname ^ " " ^ (quotename thmname) ^ ")") thy'
- else thy'
- in
- (thy2,hth')
- end
-
-val store_thm = intern_store_thm true
-
-fun mk_REFL ctm =
- let
- val cty = Thm.ctyp_of_term ctm
- in
- Drule.instantiate' [SOME cty] [SOME ctm] reflexivity_thm
- end
-
-fun REFL tm thy =
- let
- val _ = message "REFL:"
- val (info,tm') = disamb_term tm
- val ctm = Thm.cterm_of thy tm'
- val res = HOLThm(rens_of info,mk_REFL ctm)
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun ASSUME tm thy =
- let
- val _ = message "ASSUME:"
- val (info,tm') = disamb_term tm
- val ctm = Thm.cterm_of thy (HOLogic.mk_Trueprop tm')
- val th = Thm.trivial ctm
- val res = HOLThm(rens_of info,th)
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun INST_TYPE lambda (hth as HOLThm(_,th)) thy =
- let
- val _ = message "INST_TYPE:"
- val _ = if_debug pth hth
- val tys_before = Misc_Legacy.add_term_tfrees (prop_of th,[])
- val th1 = Thm.varifyT_global th
- val tys_after = Misc_Legacy.add_term_tvars (prop_of th1,[])
- val tyinst = map (fn (bef, iS) =>
- (case try (Lib.assoc (TFree bef)) lambda of
- SOME ty => (ctyp_of thy (TVar iS), ctyp_of thy ty)
- | NONE => (ctyp_of thy (TVar iS), ctyp_of thy (TFree bef))
- ))
- (zip tys_before tys_after)
- val res = Drule.instantiate_normalize (tyinst,[]) th1
- val hth = HOLThm([],res)
- val res = norm_hthm thy hth
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun INST sigma hth thy =
- let
- val _ = message "INST:"
- val _ = if_debug (app (fn (x,y) => (prin x; prin y))) sigma
- val _ = if_debug pth hth
- val (sdom,srng) = ListPair.unzip (rev sigma)
- val th = hthm2thm hth
- val th1 = mk_INST (map (cterm_of thy) sdom) (map (cterm_of thy) srng) th
- val res = HOLThm([],th1)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun EQ_IMP_RULE (hth as HOLThm(rens,th)) thy =
- let
- val _ = message "EQ_IMP_RULE:"
- val _ = if_debug pth hth
- val res = HOLThm(rens,th RS eqimp_thm)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun mk_EQ_MP th1 th2 = [beta_eta_thm th1, beta_eta_thm th2] MRS eqmp_thm
-
-fun EQ_MP hth1 hth2 thy =
- let
- val _ = message "EQ_MP:"
- val _ = if_debug pth hth1
- val _ = if_debug pth hth2
- val (info,[th1,th2]) = disamb_thms [hth1,hth2]
- val res = HOLThm(rens_of info,mk_EQ_MP th1 th2)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun mk_COMB th1 th2 thy =
- let
- val (f,g) = case concl_of th1 of
- _ $ (Const(@{const_name HOL.eq},_) $ f $ g) => (f,g)
- | _ => raise ERR "mk_COMB" "First theorem not an equality"
- val (x,y) = case concl_of th2 of
- _ $ (Const(@{const_name HOL.eq},_) $ x $ y) => (x,y)
- | _ => raise ERR "mk_COMB" "Second theorem not an equality"
- val fty = type_of f
- val (fd,fr) = Term.dest_funT fty
- val comb_thm' = Drule.instantiate'
- [SOME (ctyp_of thy fd),SOME (ctyp_of thy fr)]
- [SOME (cterm_of thy f),SOME (cterm_of thy g),
- SOME (cterm_of thy x),SOME (cterm_of thy y)] comb_thm
- in
- [th1,th2] MRS comb_thm'
- end
-
-fun SUBST rews ctxt hth thy =
- let
- val _ = message "SUBST:"
- val _ = if_debug (app pth) rews
- val _ = if_debug prin ctxt
- val _ = if_debug pth hth
- val (info,th) = disamb_thm hth
- val (info1,ctxt') = disamb_term_from info ctxt
- val (info2,rews') = disamb_thms_from info1 rews
-
- val cctxt = cterm_of thy ctxt'
- fun subst th [] = th
- | subst th (rew::rews) = subst (mk_COMB th rew thy) rews
- val res = HOLThm(rens_of info2,mk_EQ_MP (subst (mk_REFL cctxt) rews') th)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun DISJ_CASES hth hth1 hth2 thy =
- let
- val _ = message "DISJ_CASES:"
- val _ = if_debug (app pth) [hth,hth1,hth2]
- val (info,th) = disamb_thm hth
- val (info1,th1) = disamb_thm_from info hth1
- val (info2,th2) = disamb_thm_from info1 hth2
- val th1 = norm_hyps th1
- val th2 = norm_hyps th2
- val (l,r) = case concl_of th of
- _ $ (Const(@{const_name HOL.disj},_) $ l $ r) => (l,r)
- | _ => raise ERR "DISJ_CASES" "Conclusion not a disjunction"
- val th1' = rearrange thy (HOLogic.mk_Trueprop l) th1
- val th2' = rearrange thy (HOLogic.mk_Trueprop r) th2
- val res1 = th RS disj_cases_thm
- val res2 = uniq_compose ((nprems_of th1')-1) th1' ((nprems_of th)+1) res1
- val res3 = uniq_compose ((nprems_of th2')-1) th2' (nprems_of res2) res2
- val res = HOLThm(rens_of info2,res3)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun DISJ1 hth tm thy =
- let
- val _ = message "DISJ1:"
- val _ = if_debug pth hth
- val _ = if_debug prin tm
- val (info,th) = disamb_thm hth
- val (info',tm') = disamb_term_from info tm
- val ct = Thm.cterm_of thy tm'
- val disj1_thm' = Drule.instantiate' [] [NONE,SOME ct] disj1_thm
- val res = HOLThm(rens_of info',th RS disj1_thm')
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun DISJ2 tm hth thy =
- let
- val _ = message "DISJ1:"
- val _ = if_debug prin tm
- val _ = if_debug pth hth
- val (info,th) = disamb_thm hth
- val (info',tm') = disamb_term_from info tm
- val ct = Thm.cterm_of thy tm'
- val disj2_thm' = Drule.instantiate' [] [NONE,SOME ct] disj2_thm
- val res = HOLThm(rens_of info',th RS disj2_thm')
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun IMP_ANTISYM hth1 hth2 thy =
- let
- val _ = message "IMP_ANTISYM:"
- val _ = if_debug pth hth1
- val _ = if_debug pth hth2
- val (info,[th1,th2]) = disamb_thms [hth1,hth2]
- val th = [beta_eta_thm th1,beta_eta_thm th2] MRS imp_antisym_thm
- val res = HOLThm(rens_of info,th)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun SYM (hth as HOLThm(rens,th)) thy =
- let
- val _ = message "SYM:"
- val _ = if_debug pth hth
- val th = th RS symmetry_thm
- val res = HOLThm(rens,th)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun MP hth1 hth2 thy =
- let
- val _ = message "MP:"
- val _ = if_debug pth hth1
- val _ = if_debug pth hth2
- val (info,[th1,th2]) = disamb_thms [hth1,hth2]
- val th = [beta_eta_thm th1,beta_eta_thm th2] MRS mp_thm
- val res = HOLThm(rens_of info,th)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun CONJ hth1 hth2 thy =
- let
- val _ = message "CONJ:"
- val _ = if_debug pth hth1
- val _ = if_debug pth hth2
- val (info,[th1,th2]) = disamb_thms [hth1,hth2]
- val th = [th1,th2] MRS conj_thm
- val res = HOLThm(rens_of info,th)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun CONJUNCT1 (hth as HOLThm(rens,th)) thy =
- let
- val _ = message "CONJUNCT1:"
- val _ = if_debug pth hth
- val res = HOLThm(rens,th RS conjunct1_thm)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun CONJUNCT2 (hth as HOLThm(rens,th)) thy =
- let
- val _ = message "CONJUNCT1:"
- val _ = if_debug pth hth
- val res = HOLThm(rens,th RS conjunct2_thm)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun EXISTS ex wit hth thy =
- let
- val _ = message "EXISTS:"
- val _ = if_debug prin ex
- val _ = if_debug prin wit
- val _ = if_debug pth hth
- val (info,th) = disamb_thm hth
- val (info',[ex',wit']) = disamb_terms_from info [ex,wit]
- val cwit = cterm_of thy wit'
- val cty = ctyp_of_term cwit
- val a = case ex' of
- (Const(@{const_name Ex},_) $ a) => a
- | _ => raise ERR "EXISTS" "Argument not existential"
- val ca = cterm_of thy a
- val exists_thm' = beta_eta_thm (Drule.instantiate' [SOME cty] [SOME ca,SOME cwit] exists_thm)
- val th1 = beta_eta_thm th
- val th2 = implies_elim_all th1
- val th3 = th2 COMP exists_thm'
- val th = implies_intr_hyps th3
- val res = HOLThm(rens_of info',th)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun CHOOSE v hth1 hth2 thy =
- let
- val _ = message "CHOOSE:"
- val _ = if_debug prin v
- val _ = if_debug pth hth1
- val _ = if_debug pth hth2
- val (info,[th1,th2]) = disamb_thms [hth1,hth2]
- val (info',v') = disamb_term_from info v
- fun strip 0 _ th = th
- | strip n (p::ps) th =
- strip (n-1) ps (Thm.implies_elim th (Thm.assume p))
- | strip _ _ _ = raise ERR "CHOOSE" "strip error"
- val cv = cterm_of thy v'
- val th2 = norm_hyps th2
- val cvty = ctyp_of_term cv
- val c = HOLogic.dest_Trueprop (concl_of th2)
- val cc = cterm_of thy c
- val a = case concl_of th1 of
- _ $ (Const(@{const_name Ex},_) $ a) => a
- | _ => raise ERR "CHOOSE" "Conclusion not existential"
- val ca = cterm_of (theory_of_thm th1) a
- val choose_thm' = beta_eta_thm (Drule.instantiate' [SOME cvty] [SOME ca,SOME cc] choose_thm)
- val th21 = rearrange thy (HOLogic.mk_Trueprop (a $ v')) th2
- val th22 = strip ((nprems_of th21)-1) (cprems_of th21) th21
- val th23 = beta_eta_thm (Thm.forall_intr cv th22)
- val th11 = implies_elim_all (beta_eta_thm th1)
- val th' = th23 COMP (th11 COMP choose_thm')
- val th = implies_intr_hyps th'
- val res = HOLThm(rens_of info',th)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun GEN v hth thy =
- let
- val _ = message "GEN:"
- val _ = if_debug prin v
- val _ = if_debug pth hth
- val (info,th) = disamb_thm hth
- val (info',v') = disamb_term_from info v
- val res = HOLThm(rens_of info',mk_GEN v' th thy)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun SPEC tm hth thy =
- let
- val _ = message "SPEC:"
- val _ = if_debug prin tm
- val _ = if_debug pth hth
- val (info,th) = disamb_thm hth
- val (info',tm') = disamb_term_from info tm
- val ctm = Thm.cterm_of thy tm'
- val cty = Thm.ctyp_of_term ctm
- val spec' = Drule.instantiate' [SOME cty] [NONE,SOME ctm] spec_thm
- val th = th RS spec'
- val res = HOLThm(rens_of info',th)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun COMB hth1 hth2 thy =
- let
- val _ = message "COMB:"
- val _ = if_debug pth hth1
- val _ = if_debug pth hth2
- val (info,[th1,th2]) = disamb_thms [hth1,hth2]
- val res = HOLThm(rens_of info,mk_COMB th1 th2 thy)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun TRANS hth1 hth2 thy =
- let
- val _ = message "TRANS:"
- val _ = if_debug pth hth1
- val _ = if_debug pth hth2
- val (info,[th1,th2]) = disamb_thms [hth1,hth2]
- val th = [th1,th2] MRS trans_thm
- val res = HOLThm(rens_of info,th)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-
-fun CCONTR tm hth thy =
- let
- val _ = message "SPEC:"
- val _ = if_debug prin tm
- val _ = if_debug pth hth
- val (info,th) = disamb_thm hth
- val (info',tm') = disamb_term_from info tm
- val th = norm_hyps th
- val ct = cterm_of thy tm'
- val th1 = rearrange thy (HOLogic.mk_Trueprop (Const(@{const_name Not},HOLogic.boolT-->HOLogic.boolT) $ tm')) th
- val ccontr_thm' = Drule.instantiate' [] [SOME ct] ccontr_thm
- val res1 = uniq_compose ((nprems_of th1) - 1) th1 1 ccontr_thm'
- val res = HOLThm(rens_of info',res1)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun mk_ABS v th thy =
- let
- val cv = cterm_of thy v
- val th1 = implies_elim_all (beta_eta_thm th)
- val (f,g) = case concl_of th1 of
- _ $ (Const(@{const_name HOL.eq},_) $ f $ g) => (Term.lambda v f,Term.lambda v g)
- | _ => raise ERR "mk_ABS" "Bad conclusion"
- val (fd,fr) = Term.dest_funT (type_of f)
- val abs_thm' = Drule.instantiate' [SOME (ctyp_of thy fd), SOME (ctyp_of thy fr)] [SOME (cterm_of thy f), SOME (cterm_of thy g)] abs_thm
- val th2 = Thm.forall_intr cv th1
- val th3 = th2 COMP abs_thm'
- val res = implies_intr_hyps th3
- in
- res
- end
-
-fun ABS v hth thy =
- let
- val _ = message "ABS:"
- val _ = if_debug prin v
- val _ = if_debug pth hth
- val (info,th) = disamb_thm hth
- val (info',v') = disamb_term_from info v
- val res = HOLThm(rens_of info',mk_ABS v' th thy)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun GEN_ABS copt vlist hth thy =
- let
- val _ = message "GEN_ABS:"
- val _ = case copt of
- SOME c => if_debug prin c
- | NONE => ()
- val _ = if_debug (app prin) vlist
- val _ = if_debug pth hth
- val (info,th) = disamb_thm hth
- val (info',vlist') = disamb_terms_from info vlist
- val th1 =
- case copt of
- SOME (Const(cname,cty)) =>
- let
- fun inst_type ty1 ty2 (TVar _) = raise ERR "GEN_ABS" "Type variable found!"
- | inst_type ty1 ty2 (ty as TFree _) = if ty1 = ty
- then ty2
- else ty
- | inst_type ty1 ty2 (Type(name,tys)) =
- Type(name,map (inst_type ty1 ty2) tys)
- in
- fold_rev (fn v => fn th =>
- let
- val cdom = fst (Term.dest_funT (fst (Term.dest_funT cty)))
- val vty = type_of v
- val newcty = inst_type cdom vty cty
- val cc = cterm_of thy (Const(cname,newcty))
- in
- mk_COMB (mk_REFL cc) (mk_ABS v th thy) thy
- end) vlist' th
- end
- | SOME _ => raise ERR "GEN_ABS" "Bad constant"
- | NONE =>
- fold_rev (fn v => fn th => mk_ABS v th thy) vlist' th
- val res = HOLThm(rens_of info',th1)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun NOT_INTRO (hth as HOLThm(rens,th)) thy =
- let
- val _ = message "NOT_INTRO:"
- val _ = if_debug pth hth
- val th1 = implies_elim_all (beta_eta_thm th)
- val a = case concl_of th1 of
- _ $ (Const(@{const_name HOL.implies},_) $ a $ Const(@{const_name False},_)) => a
- | _ => raise ERR "NOT_INTRO" "Conclusion of bad form"
- val ca = cterm_of thy a
- val th2 = Thm.equal_elim (Drule.instantiate' [] [SOME ca] not_intro_thm) th1
- val res = HOLThm(rens,implies_intr_hyps th2)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun NOT_ELIM (hth as HOLThm(rens,th)) thy =
- let
- val _ = message "NOT_INTRO:"
- val _ = if_debug pth hth
- val th1 = implies_elim_all (beta_eta_thm th)
- val a = case concl_of th1 of
- _ $ (Const(@{const_name Not},_) $ a) => a
- | _ => raise ERR "NOT_ELIM" "Conclusion of bad form"
- val ca = cterm_of thy a
- val th2 = Thm.equal_elim (Drule.instantiate' [] [SOME ca] not_elim_thm) th1
- val res = HOLThm(rens,implies_intr_hyps th2)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-fun DISCH tm hth thy =
- let
- val _ = message "DISCH:"
- val _ = if_debug prin tm
- val _ = if_debug pth hth
- val (info,th) = disamb_thm hth
- val (info',tm') = disamb_term_from info tm
- val th1 = beta_eta_thm th
- val th2 = implies_elim_all th1
- val th3 = Thm.implies_intr (cterm_of thy (HOLogic.mk_Trueprop tm')) th2
- val th4 = th3 COMP disch_thm
- val res = HOLThm (rens_of info', implies_intr_hyps th4)
- val _ = message "RESULT:"
- val _ = if_debug pth res
- in
- (thy,res)
- end
-
-val spaces = space_implode " "
-
-fun new_definition thyname constname rhs thy =
- let
- val constname = rename_const thyname thy constname
- val redeclared = is_some (Sign.const_type thy (Sign.intern_const thy constname));
- val _ = warning ("Introducing constant " ^ constname)
- val (thmname,thy) = get_defname thyname constname thy
- val (_,rhs') = disamb_term rhs
- val ctype = type_of rhs'
- val csyn = mk_syn thy constname
- val thy1 = case Importer_DefThy.get thy of
- Replaying _ => thy
- | _ => Sign.add_consts_i [(Binding.name constname,ctype,csyn)] thy
- val eq = mk_defeq constname rhs' thy1
- val (thms, thy2) = Global_Theory.add_defs false [((Binding.name thmname,eq),[])] thy1
- val def_thm = hd thms
- val thm' = def_thm RS meta_eq_to_obj_eq_thm
- val (thy',th) = (thy2, thm')
- val fullcname = Sign.intern_const thy' constname
- val thy'' = add_importer_const_mapping thyname constname true fullcname thy'
- val (linfo,tm24) = disamb_term (mk_teq constname rhs' thy'')
- val rew = rewrite_importer_term eq thy''
- val crhs = cterm_of thy'' (#2 (Logic.dest_equals (prop_of rew)))
- val thy22 =
- if Thm.def_name constname = thmname andalso not redeclared andalso csyn = NoSyn
- then
- let
- val ctxt = Syntax.init_pretty_global thy''
- val p1 = quotename constname
- val p2 = Syntax.string_of_typ ctxt ctype
- val p3 = string_of_mixfix csyn
- val p4 = smart_string_of_cterm ctxt crhs
- in
- add_dump ("definition\n " ^ p1 ^ " :: \"" ^ p2 ^ "\" "^ p3 ^ " where\n " ^ p4) thy''
- end
- else
- let val ctxt = Syntax.init_pretty_global thy'' in
- add_dump ("consts\n " ^ quotename constname ^ " :: \"" ^
- Syntax.string_of_typ ctxt ctype ^
- "\" " ^ string_of_mixfix csyn ^ "\n\ndefs\n " ^
- quotename thmname ^ ": " ^ smart_string_of_cterm ctxt crhs) thy''
- end
- val hth = case Shuffler.set_prop thy22 (HOLogic.mk_Trueprop tm24) [("",th)] of
- SOME (_,res) => HOLThm(rens_of linfo,res)
- | NONE => raise ERR "new_definition" "Bad conclusion"
- val fullname = Sign.full_bname thy22 thmname
- val thy22' = case opt_get_output_thy thy22 of
- "" => add_importer_mapping thyname thmname fullname thy22
- | output_thy =>
- let
- val moved_thmname = output_thy ^ "." ^ thyname ^ "." ^ thmname
- in
- thy22 |> add_importer_move fullname moved_thmname
- |> add_importer_mapping thyname thmname moved_thmname
- end
- val _ = message "new_definition:"
- val _ = if_debug pth hth
- in
- (thy22',hth)
- end
-
-fun new_specification thyname thmname names hth thy =
- case Importer_DefThy.get thy of
- Replaying _ => (thy,hth)
- | _ =>
- let
- val _ = message "NEW_SPEC:"
- val _ = if_debug pth hth
- val names = map (rename_const thyname thy) names
- val _ = warning ("Introducing constants " ^ commas names)
- val (HOLThm(rens,th)) = norm_hthm thy hth
- val thy1 = case Importer_DefThy.get thy of
- Replaying _ => thy
- | _ =>
- let
- fun dest_eta_abs (Abs(x,xT,body)) = (x,xT,body)
- | dest_eta_abs body =
- let
- val (dT,_) = Term.dest_funT (type_of body)
- in
- ("x",dT,body $ Bound 0)
- end
- handle TYPE _ => raise ERR "new_specification" "not an abstraction type"
- fun dest_exists (Const(@{const_name Ex},_) $ abody) =
- dest_eta_abs abody
- | dest_exists _ =
- raise ERR "new_specification" "Bad existential formula"
-
- val (consts,_) = Library.foldl (fn ((cs,ex),cname) =>
- let
- val (_,cT,p) = dest_exists ex
- in
- ((cname,cT,mk_syn thy cname)::cs,p)
- end) (([],HOLogic.dest_Trueprop (concl_of th)),names)
- val str = Library.foldl (fn (acc, (c, T, csyn)) =>
- acc ^ "\n " ^ quotename c ^ " :: \"" ^
- Syntax.string_of_typ_global thy T ^ "\" " ^ string_of_mixfix csyn) ("consts", consts)
- val thy' = add_dump str thy
- in
- Sign.add_consts_i (map (fn (c, T, mx) => (Binding.name c, T, mx)) consts) thy'
- end
-
- val thy1 = fold_rev (fn name => fn thy =>
- snd (get_defname thyname name thy)) names thy1
- fun new_name name = fst (get_defname thyname name thy1)
- val names' = map (fn name => (new_name name,name,false)) names
- val (thy',res) = Choice_Specification.add_specification NONE
- names'
- (thy1,th)
- val res' = Thm.unvarify_global res
- val hth = HOLThm(rens,res')
- val rew = rewrite_importer_term (concl_of res') thy'
- val th = Thm.equal_elim rew res'
- fun handle_const (name,thy) =
- let
- val defname = Thm.def_name name
- val (newname,thy') = get_defname thyname name thy
- in
- (if defname = newname
- then quotename name
- else (quotename newname) ^ ": " ^ (quotename name),thy')
- end
- val (new_names,thy') = fold_rev (fn name => fn (names, thy) =>
- let
- val (name',thy') = handle_const (name,thy)
- in
- (name'::names,thy')
- end) names ([], thy')
- val thy'' =
- add_dump ("specification (" ^ (spaces new_names) ^ ") " ^ thmname ^ ": " ^
- (smart_string_of_thm (Syntax.init_pretty_global thy') th) ^
- "\n by (import " ^ thyname ^ " " ^ thmname ^ ")")
- thy'
- val _ = message "RESULT:"
- val _ = if_debug pth hth
- in
- intern_store_thm false thyname thmname hth thy''
- end
-
-fun new_axiom name _ _ = raise ERR "new_axiom" ("Oh, no you don't! (" ^ name ^ ")")
-
-fun to_isa_thm (hth as HOLThm(_,th)) =
- let
- val (HOLThm args) = norm_hthm (theory_of_thm th) hth
- in
- apsnd Thm.strip_shyps args
- end
-
-fun to_isa_term tm = tm
-
-local
- val light_nonempty = @{thm light_ex_imp_nonempty}
- val ex_imp_nonempty = @{thm ex_imp_nonempty}
- val typedef_hol2hol4 = @{thm typedef_hol2hol4}
- val typedef_hol2hollight = @{thm typedef_hol2hollight}
-in
-fun new_type_definition thyname thmname tycname hth thy =
- case Importer_DefThy.get thy of
- Replaying _ => (thy,hth)
- | _ =>
- let
- val _ = message "TYPE_DEF:"
- val _ = if_debug pth hth
- val _ = warning ("Introducing type " ^ tycname)
- val (HOLThm(rens,td_th)) = norm_hthm thy hth
- val th2 = beta_eta_thm (td_th RS ex_imp_nonempty)
- val c = case concl_of th2 of
- _ $ (Const(@{const_name Ex},_) $ Abs(_,_,Const(@{const_name Set.member},_) $ _ $ c)) => c
- | _ => raise ERR "new_type_definition" "Bad type definition theorem"
- val tfrees = Misc_Legacy.term_tfrees c
- val tnames = map fst tfrees
- val tsyn = mk_syn thy tycname
- val ((_, typedef_info), thy') =
- Typedef.add_typedef_global false (SOME (Binding.name thmname))
- (Binding.name tycname, map (rpair dummyS) tnames, tsyn) c NONE (rtac th2 1) thy
-
- val th3 = (#type_definition (#2 typedef_info)) RS typedef_hol2hol4
-
- val fulltyname = Sign.intern_type thy' tycname
- val thy'' = add_importer_type_mapping thyname tycname true fulltyname thy'
-
- val (hth' as HOLThm args) = norm_hthm thy'' (HOLThm(rens,th3))
- val _ = if has_ren hth' then warning ("Theorem " ^ thmname ^ " needs variable-disambiguating")
- else ()
- val thy4 = add_importer_pending thyname thmname args thy''
-
- val rew = rewrite_importer_term (concl_of td_th) thy4
- val th = Thm.equal_elim rew (Thm.transfer thy4 td_th)
- val c = case HOLogic.dest_Trueprop (prop_of th) of
- Const(@{const_name Ex},exT) $ P =>
- let
- val PT = domain_type exT
- in
- Const (@{const_name Collect},PT-->HOLogic.mk_setT (domain_type PT)) $ P
- end
- | _ => error "Internal error in ProofKernel.new_typedefinition"
- val tnames_string = if null tnames
- then ""
- else "(" ^ commas tnames ^ ") "
- val proc_prop =
- smart_string_of_cterm
- (Syntax.init_pretty_global thy4
- |> not (null tnames) ? Config.put show_all_types true)
- val thy5 = add_dump ("typedef (open) " ^ tnames_string ^ (quotename tycname) ^ " = " ^ (proc_prop (cterm_of thy4 c)) ^ " "
- ^ (string_of_mixfix tsyn) ^ "\n by (rule typedef_helper,import " ^ thyname ^ " " ^ thmname ^ ")") thy4
-
- val thy6 = add_dump ("lemmas " ^ thmname ^ " = typedef_hol2importer [OF type_definition_" ^ tycname ^ "]") thy5
-
- val _ = message "RESULT:"
- val _ = if_debug pth hth'
- in
- (thy6,hth')
- end
-
-fun add_dump_syntax thy name =
- let
- val n = quotename name
- val syn = string_of_mixfix (mk_syn thy name)
- in
- add_dump ("syntax\n "^n^" :: _ "^syn) thy
- end
-
-fun type_introduction thyname thmname tycname abs_name rep_name (P,t) hth thy =
- case Importer_DefThy.get thy of
- Replaying _ => (thy,
- HOLThm([], Global_Theory.get_thm thy (thmname^"_@intern")) handle ERROR _ => hth)
- | _ =>
- let
- val _ = message "TYPE_INTRO:"
- val _ = if_debug pth hth
- val _ = warning ("Introducing type " ^ tycname ^ " (with morphisms " ^ abs_name ^ " and " ^ rep_name ^ ")")
- val (HOLThm(rens,td_th)) = norm_hthm thy hth
- val tT = type_of t
- val light_nonempty' =
- Drule.instantiate' [SOME (ctyp_of thy tT)]
- [SOME (cterm_of thy P),
- SOME (cterm_of thy t)] light_nonempty
- val th2 = beta_eta_thm (td_th RS (beta_eta_thm light_nonempty'))
- val c = case concl_of th2 of
- _ $ (Const(@{const_name Ex},_) $ Abs(_,_,Const(@{const_name Set.member},_) $ _ $ c)) => c
- | _ => raise ERR "type_introduction" "Bad type definition theorem"
- val tfrees = Misc_Legacy.term_tfrees c
- val tnames = sort_strings (map fst tfrees)
- val tsyn = mk_syn thy tycname
- val ((_, typedef_info), thy') =
- Typedef.add_typedef_global false NONE
- (Binding.name tycname, map (rpair dummyS) tnames, tsyn) c
- (SOME(Binding.name rep_name,Binding.name abs_name)) (rtac th2 1) thy
- val fulltyname = Sign.intern_type thy' tycname
- val aty = Type (fulltyname, map mk_vartype tnames)
- val typedef_hol2hollight' =
- Drule.instantiate'
- [SOME (ctyp_of thy' aty), SOME (ctyp_of thy' tT)]
- [NONE, NONE, NONE, SOME (cterm_of thy' (Free ("a", aty))), SOME (cterm_of thy' (Free ("r", tT)))]
- typedef_hol2hollight
- val th4 = (#type_definition (#2 typedef_info)) RS typedef_hol2hollight'
- val _ = null (Thm.fold_terms Term.add_tvars th4 []) orelse
- raise ERR "type_introduction" "no type variables expected any more"
- val _ = null (Thm.fold_terms Term.add_vars th4 []) orelse
- raise ERR "type_introduction" "no term variables expected any more"
- val _ = message ("step 3: thyname="^thyname^", tycname="^tycname^", fulltyname="^fulltyname)
- val thy'' = add_importer_type_mapping thyname tycname true fulltyname thy'
- val _ = message "step 4"
- val (hth' as HOLThm args) = norm_hthm thy'' (HOLThm(rens,th4))
- val thy4 = add_importer_pending thyname thmname args thy''
-
- val P' = P (* why !? #2 (Logic.dest_equals (concl_of (rewrite_importer_term P thy4))) *)
- val c =
- let
- val PT = type_of P'
- in
- Const (@{const_name Collect},PT-->HOLogic.mk_setT (domain_type PT)) $ P'
- end
-
- val tnames_string = if null tnames
- then ""
- else "(" ^ commas tnames ^ ") "
- val proc_prop =
- smart_string_of_cterm
- (Syntax.init_pretty_global thy4
- |> not (null tnames) ? Config.put show_all_types true)
- val thy = add_dump ("typedef (open) " ^ tnames_string ^ (quotename tycname) ^
- " = " ^ (proc_prop (cterm_of thy4 c)) ^ " " ^
- (string_of_mixfix tsyn) ^ " morphisms "^
- (quote rep_name)^" "^(quote abs_name)^"\n"^
- (" apply (rule light_ex_imp_nonempty[where t="^
- (proc_prop (cterm_of thy4 t))^"])\n"^
- (" by (import " ^ thyname ^ " " ^ (quotename thmname) ^ ")"))) thy4
- val str_aty = Syntax.string_of_typ_global thy aty
- val thy = add_dump_syntax thy rep_name
- val thy = add_dump_syntax thy abs_name
- val thy = add_dump ("lemmas " ^ (quote (thmname^"_@intern")) ^
- " = typedef_hol2hollight \n"^
- " [where a=\"a :: "^str_aty^"\" and r=r" ^
- " ,\n OF "^(quotename ("type_definition_" ^ tycname)) ^ "]") thy
- val _ = message "RESULT:"
- val _ = if_debug pth hth'
- in
- (thy,hth')
- end
-end
-
-val prin = prin
-
-end
--- a/src/HOL/Import/HOL4/replay.ML Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,344 +0,0 @@
-(* Title: HOL/Import/replay.ML
- Author: Sebastian Skalberg (TU Muenchen)
-*)
-
-structure Replay = (* FIXME proper signature *)
-struct
-
-open ProofKernel
-
-exception REPLAY of string * string
-fun ERR f mesg = REPLAY (f,mesg)
-fun NY f = raise ERR f "NOT YET!"
-
-fun replay_proof int_thms thyname thmname prf thy =
- let
- fun rp (PRefl tm) thy = ProofKernel.REFL tm thy
- | rp (PInstT(p,lambda)) thy =
- let
- val (thy',th) = rp' p thy
- in
- ProofKernel.INST_TYPE lambda th thy'
- end
- | rp (PSubst(prfs,ctxt,prf)) thy =
- let
- val (thy',ths) = fold_rev (fn p => fn (thy, ths) =>
- let
- val (thy',th) = rp' p thy
- in
- (thy',th::ths)
- end) prfs (thy,[])
- val (thy'',th) = rp' prf thy'
- in
- ProofKernel.SUBST ths ctxt th thy''
- end
- | rp (PAbs(prf,v)) thy =
- let
- val (thy',th) = rp' prf thy
- in
- ProofKernel.ABS v th thy'
- end
- | rp (PDisch(prf,tm)) thy =
- let
- val (thy',th) = rp' prf thy
- in
- ProofKernel.DISCH tm th thy'
- end
- | rp (PMp(prf1,prf2)) thy =
- let
- val (thy1,th1) = rp' prf1 thy
- val (thy2,th2) = rp' prf2 thy1
- in
- ProofKernel.MP th1 th2 thy2
- end
- | rp (PHyp tm) thy = ProofKernel.ASSUME tm thy
- | rp (PDef(seg,name,rhs)) thy =
- (case ProofKernel.get_def seg name rhs thy of
- (thy',SOME res) => (thy',res)
- | (thy',NONE) =>
- if seg = thyname
- then ProofKernel.new_definition seg name rhs thy'
- else raise ERR "replay_proof" ("Too late for term definition: "^seg^" != "^thyname))
- | rp (POracle _) thy = NY "ORACLE"
- | rp (PSpec(prf,tm)) thy =
- let
- val (thy',th) = rp' prf thy
- in
- ProofKernel.SPEC tm th thy'
- end
- | rp (PInst(prf,theta)) thy =
- let
- val (thy',th) = rp' prf thy
- in
- ProofKernel.INST theta th thy'
- end
- | rp (PGen(prf,v)) thy =
- let
- val (thy',th) = rp' prf thy
- val p = ProofKernel.GEN v th thy'
- in
- p
- end
- | rp (PGenAbs(prf,opt,vl)) thy =
- let
- val (thy',th) = rp' prf thy
- in
- ProofKernel.GEN_ABS opt vl th thy'
- end
- | rp (PImpAS(prf1,prf2)) thy =
- let
- val (thy1,th1) = rp' prf1 thy
- val (thy2,th2) = rp' prf2 thy1
- in
- ProofKernel.IMP_ANTISYM th1 th2 thy2
- end
- | rp (PSym prf) thy =
- let
- val (thy1,th) = rp' prf thy
- in
- ProofKernel.SYM th thy1
- end
- | rp (PTrans(prf1,prf2)) thy =
- let
- val (thy1,th1) = rp' prf1 thy
- val (thy2,th2) = rp' prf2 thy1
- in
- ProofKernel.TRANS th1 th2 thy2
- end
- | rp (PComb(prf1,prf2)) thy =
- let
- val (thy1,th1) = rp' prf1 thy
- val (thy2,th2) = rp' prf2 thy1
- in
- ProofKernel.COMB th1 th2 thy2
- end
- | rp (PEqMp(prf1,prf2)) thy =
- let
- val (thy1,th1) = rp' prf1 thy
- val (thy2,th2) = rp' prf2 thy1
- in
- ProofKernel.EQ_MP th1 th2 thy2
- end
- | rp (PEqImp prf) thy =
- let
- val (thy',th) = rp' prf thy
- in
- ProofKernel.EQ_IMP_RULE th thy'
- end
- | rp (PExists(prf,ex,wit)) thy =
- let
- val (thy',th) = rp' prf thy
- in
- ProofKernel.EXISTS ex wit th thy'
- end
- | rp (PChoose(v,prf1,prf2)) thy =
- let
- val (thy1,th1) = rp' prf1 thy
- val (thy2,th2) = rp' prf2 thy1
- in
- ProofKernel.CHOOSE v th1 th2 thy2
- end
- | rp (PConj(prf1,prf2)) thy =
- let
- val (thy1,th1) = rp' prf1 thy
- val (thy2,th2) = rp' prf2 thy1
- in
- ProofKernel.CONJ th1 th2 thy2
- end
- | rp (PConjunct1 prf) thy =
- let
- val (thy',th) = rp' prf thy
- in
- ProofKernel.CONJUNCT1 th thy'
- end
- | rp (PConjunct2 prf) thy =
- let
- val (thy',th) = rp' prf thy
- in
- ProofKernel.CONJUNCT2 th thy'
- end
- | rp (PDisj1(prf,tm)) thy =
- let
- val (thy',th) = rp' prf thy
- in
- ProofKernel.DISJ1 th tm thy'
- end
- | rp (PDisj2(prf,tm)) thy =
- let
- val (thy',th) = rp' prf thy
- in
- ProofKernel.DISJ2 tm th thy'
- end
- | rp (PDisjCases(prf,prf1,prf2)) thy =
- let
- val (thy',th) = rp' prf thy
- val (thy1,th1) = rp' prf1 thy'
- val (thy2,th2) = rp' prf2 thy1
- in
- ProofKernel.DISJ_CASES th th1 th2 thy2
- end
- | rp (PNotI prf) thy =
- let
- val (thy',th) = rp' prf thy
- in
- ProofKernel.NOT_INTRO th thy'
- end
- | rp (PNotE prf) thy =
- let
- val (thy',th) = rp' prf thy
- in
- ProofKernel.NOT_ELIM th thy'
- end
- | rp (PContr(prf,tm)) thy =
- let
- val (thy',th) = rp' prf thy
- in
- ProofKernel.CCONTR tm th thy'
- end
- | rp (PTmSpec _) _ = raise ERR "rp" "Shouldn't reach here (PTmSpec)"
- | rp (PTyDef _) _ = raise ERR "rp" "Shouldn't reach here (PTyDef)"
- | rp (PTyIntro _) _ = raise ERR "rp" "Shouldn't reach here (PTyIntro)"
- | rp PDisk _ = raise ERR "rp" "Shouldn't reach here (PDisk)"
- | rp _ _ = raise ERR "rp" "What the hell is this? Which case did I forget?"
- and rp' p thy =
- let
- val pc = content_of p
- in
- case pc of
- PDisk => (case disk_info_of p of
- SOME(thyname',thmname) =>
- (case Int.fromString thmname of
- SOME i =>
- if thyname' = thyname
- then
- (case Array.sub(int_thms,i-1) of
- NONE =>
- let
- val (thy',th) = rp' (snd (import_proof thyname' thmname thy) thy) thy
- val _ = Array.update(int_thms,i-1,SOME th)
- in
- (thy',th)
- end
- | SOME th => (thy,th))
- else raise ERR "replay_proof" ("Library " ^ thyname' ^ " should be built before " ^ thyname ^ " (" ^ thmname ^ ")")
- | NONE =>
- (case ProofKernel.get_thm thyname' thmname thy of
- (thy',SOME res) => (thy',res)
- | (thy',NONE) =>
- if thyname' = thyname
- then
- let
- val _ = writeln ("Found no " ^ thmname ^ " theorem, replaying...")
- val (_, prf) = import_proof thyname' thmname thy'
- val prf = prf thy'
- val (thy',th) = replay_proof int_thms thyname' thmname prf thy'
- val _ = writeln ("Successfully finished replaying "^thmname^" !")
- in
- case content_of prf of
- PTmSpec _ => (thy',th)
- | PTyDef _ => (thy',th)
- | PTyIntro _ => (thy',th)
- | _ => ProofKernel.store_thm thyname' thmname th thy'
- end
- else raise ERR "replay_proof" ("Library " ^ thyname' ^ " should be built before " ^ thyname ^ " (" ^ thmname ^ ")")))
- | NONE => raise ERR "rp'.PDisk" "Not enough information")
- | PAxm(name,c) =>
- (case ProofKernel.get_axiom thyname name thy of
- (thy',SOME res) => (thy',res)
- | (thy',NONE) => ProofKernel.new_axiom name c thy')
- | PTmSpec(seg,names,prf') =>
- let
- val (thy',th) = rp' prf' thy
- in
- ProofKernel.new_specification seg thmname names th thy'
- end
- | PTyDef(seg,name,prf') =>
- let
- val (thy',th) = rp' prf' thy
- in
- ProofKernel.new_type_definition seg thmname name th thy'
- end
- | PTyIntro(seg,name,abs_name,rep_name,P,t,prf') =>
- let
- val (thy',th) = rp' prf' thy
- in
- ProofKernel.type_introduction seg thmname name abs_name rep_name (P,t) th thy'
- end
- | _ => rp pc thy
- end
- in
- rp' prf thy
- end
-
-fun setup_int_thms thyname thy =
- let
- val fname =
- case ProofKernel.get_proof_dir thyname thy of
- SOME p => OS.Path.joinDirFile {dir=p,file=OS.Path.joinBaseExt{base = "facts",ext=SOME "lst"}}
- | NONE => error "Cannot find proof files"
- val is = TextIO.openIn fname
- val (num_int_thms,facts) =
- let
- fun get_facts facts =
- case TextIO.inputLine is of
- NONE => (case facts of
- i::facts => (the (Int.fromString i),map ProofKernel.protect_factname (rev facts))
- | _ => raise ERR "replay_thm" "Bad facts.lst file")
- | SOME fact => get_facts ((String.substring(fact,0,String.size fact -1 ))::facts)
- in
- get_facts []
- end
- val _ = TextIO.closeIn is
- val int_thms = Array.array(num_int_thms,NONE:thm option)
- in
- (int_thms,facts)
- end
-
-fun import_single_thm thyname int_thms thmname thy =
- let
- fun replay_fact (thmname,thy) =
- let
- val prf = mk_proof PDisk
- val _ = set_disk_info_of prf thyname thmname
- val _ = writeln ("Replaying "^thmname^" ...")
- val p = fst (replay_proof int_thms thyname thmname prf thy)
- in
- p
- end
- in
- replay_fact (thmname,thy)
- end
-
-fun import_thms thyname int_thms thmnames thy =
- let
- fun replay_fact thmname thy =
- let
- val prf = mk_proof PDisk
- val _ = set_disk_info_of prf thyname thmname
- val _ = writeln ("Replaying "^thmname^" ...")
- val p = fst (replay_proof int_thms thyname thmname prf thy)
- in
- p
- end
- val res_thy = fold replay_fact thmnames thy
- in
- res_thy
- end
-
-fun import_thm thyname thmname thy =
- let
- val int_thms = fst (setup_int_thms thyname thy)
- fun replay_fact (thmname,thy) =
- let
- val prf = mk_proof PDisk
- val _ = set_disk_info_of prf thyname thmname
- val _ = writeln ("Replaying "^thmname^" ...")
- val p = fst (replay_proof int_thms thyname thmname prf thy)
- in
- p
- end
- in
- replay_fact (thmname,thy)
- end
-
-end
--- a/src/HOL/Import/HOL4/shuffler.ML Sun Apr 01 14:50:47 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,585 +0,0 @@
-(* Title: HOL/Import/shuffler.ML
- Author: Sebastian Skalberg, TU Muenchen
-
-Package for proving two terms equal by normalizing (hence the
-"shuffler" name). Uses the simplifier for the normalization.
-*)
-
-signature Shuffler =
-sig
- val debug : bool Unsynchronized.ref
-
- val norm_term : theory -> term -> thm
- val make_equal : theory -> term -> term -> thm option
- val set_prop : theory -> term -> (string * thm) list -> (string * thm) option
-
- val find_potential: theory -> term -> (string * thm) list
-
- val gen_shuffle_tac: Proof.context -> bool -> (string * thm) list -> int -> tactic
- val shuffle_tac: Proof.context -> thm list -> int -> tactic
- val search_tac : Proof.context -> int -> tactic
-
- val print_shuffles: theory -> unit
-
- val add_shuffle_rule: thm -> theory -> theory
- val shuffle_attr: attribute
-
- val setup : theory -> theory
-end
-
-structure Shuffler : Shuffler =
-struct
-
-val debug = Unsynchronized.ref false
-
-fun if_debug f x = if !debug then f x else ()
-val message = if_debug writeln
-
-val string_of_thm = Print_Mode.setmp [] Display.string_of_thm_without_context;
-
-structure ShuffleData = Theory_Data
-(
- type T = thm list
- val empty = []
- val extend = I
- val merge = Thm.merge_thms
-)
-
-fun print_shuffles thy =
- Pretty.writeln (Pretty.big_list "Shuffle theorems:"
- (map (Display.pretty_thm_global thy) (ShuffleData.get thy)))
-
-val weaken =
- let
- val cert = cterm_of Pure.thy
- val P = Free("P",propT)
- val Q = Free("Q",propT)
- val PQ = Logic.mk_implies(P,Q)
- val PPQ = Logic.mk_implies(P,PQ)
- val cP = cert P
- val cPQ = cert PQ
- val cPPQ = cert PPQ
- val th1 = Thm.assume cPQ |> implies_intr_list [cPQ,cP]
- val th3 = Thm.assume cP
- val th4 = implies_elim_list (Thm.assume cPPQ) [th3,th3]
- |> implies_intr_list [cPPQ,cP]
- in
- Thm.equal_intr th4 th1 |> Drule.export_without_context
- end
-
-val imp_comm =
- let
- val cert = cterm_of Pure.thy
- val P = Free("P",propT)
- val Q = Free("Q",propT)
- val R = Free("R",propT)
- val PQR = Logic.mk_implies(P,Logic.mk_implies(Q,R))
- val QPR = Logic.mk_implies(Q,Logic.mk_implies(P,R))
- val cP = cert P
- val cQ = cert Q
- val cPQR = cert PQR
- val cQPR = cert QPR
- val th1 = implies_elim_list (Thm.assume cPQR) [Thm.assume cP,Thm.assume cQ]
- |> implies_intr_list [cPQR,cQ,cP]
- val th2 = implies_elim_list (Thm.assume cQPR) [Thm.assume cQ,Thm.assume cP]
- |> implies_intr_list [cQPR,cP,cQ]
- in
- Thm.equal_intr th1 th2 |> Drule.export_without_context
- end
-
-val all_comm =
- let
- val cert = cterm_of Pure.thy
- val xT = TFree("'a",[])
- val yT = TFree("'b",[])
- val x = Free("x",xT)
- val y = Free("y",yT)
- val P = Free("P",xT-->yT-->propT)
- val lhs = Logic.all x (Logic.all y (P $ x $ y))
- val rhs = Logic.all y (Logic.all x (P $ x $ y))
- val cl = cert lhs
- val cr = cert rhs
- val cx = cert x
- val cy = cert y
- val th1 = Thm.assume cr
- |> forall_elim_list [cy,cx]
- |> forall_intr_list [cx,cy]
- |> Thm.implies_intr cr
- val th2 = Thm.assume cl
- |> forall_elim_list [cx,cy]
- |> forall_intr_list [cy,cx]
- |> Thm.implies_intr cl
- in
- Thm.equal_intr th1 th2 |> Drule.export_without_context
- end
-
-val equiv_comm =
- let
- val cert = cterm_of Pure.thy
- val T = TFree("'a",[])
- val t = Free("t",T)
- val u = Free("u",T)
- val ctu = cert (Logic.mk_equals(t,u))
- val cut = cert (Logic.mk_equals(u,t))
- val th1 = Thm.assume ctu |> Thm.symmetric |> Thm.implies_intr ctu
- val th2 = Thm.assume cut |> Thm.symmetric |> Thm.implies_intr cut
- in
- Thm.equal_intr th1 th2 |> Drule.export_without_context
- end
-
-(* This simplification procedure rewrites !!x y. P x y
-deterministicly, in order for the normalization function, defined
-below, to handle nested quantifiers robustly *)
-
-local
-
-exception RESULT of int
-
-fun find_bound n (Bound i) = if i = n then raise RESULT 0
- else if i = n+1 then raise RESULT 1
- else ()
- | find_bound n (t $ u) = (find_bound n t; find_bound n u)
- | find_bound n (Abs(_,_,t)) = find_bound (n+1) t
- | find_bound _ _ = ()
-
-fun swap_bound n (Bound i) = if i = n then Bound (n+1)
- else if i = n+1 then Bound n
- else Bound i
- | swap_bound n (t $ u) = (swap_bound n t $ swap_bound n u)
- | swap_bound n (Abs(x,xT,t)) = Abs(x,xT,swap_bound (n+1) t)
- | swap_bound n t = t
-
-fun rew_th thy xv yv t =
- let
- val lhs = Logic.list_all ([xv,yv],t)
- val rhs = Logic.list_all ([yv,xv],swap_bound 0 t)
- val rew = Logic.mk_equals (lhs,rhs)
- val init = Thm.trivial (cterm_of thy rew)
- in
- all_comm RS init
- end
-
-fun quant_rewrite thy _ (t as Const("all",T1) $ (Abs(x,xT,Const("all",T2) $ Abs(y,yT,body)))) =
- let
- val res = (find_bound 0 body;2) handle RESULT i => i
- in
- case res of
- 0 => SOME (rew_th thy (x,xT) (y,yT) body)
- | 1 => if string_ord(y,x) = LESS
- then
- let
- val newt = Const("all",T1) $ (Abs(y,xT,Const("all",T2) $ Abs(x,yT,body)))
- val t_th = Thm.reflexive (cterm_of thy t)
- val newt_th = Thm.reflexive (cterm_of thy newt)
- in
- SOME (Thm.transitive t_th newt_th)
- end
- else NONE
- | _ => error "norm_term (quant_rewrite) internal error"
- end
- | quant_rewrite _ _ _ = (warning "quant_rewrite: Unknown lhs"; NONE)
-
-fun freeze_thaw_term t =
- let
- val tvars = Misc_Legacy.term_tvars t
- val tfree_names = Misc_Legacy.add_term_tfree_names(t,[])
- val (type_inst,_) =
- fold (fn (w as (v,_), S) => fn (inst, used) =>
- let
- val v' = singleton (Name.variant_list used) v
- in
- ((w,TFree(v',S))::inst,v'::used)
- end)
- tvars ([], tfree_names)
- val t' = subst_TVars type_inst t
- in
- (t', map (fn (w,TFree(v,S)) => (v,TVar(w,S))
- | _ => error "Internal error in Shuffler.freeze_thaw") type_inst)
- end
-
-fun inst_tfrees thy [] thm = thm
- | inst_tfrees thy ((name,U)::rest) thm =
- let
- val cU = ctyp_of thy U
- val tfrees = Misc_Legacy.add_term_tfrees (prop_of thm,[])
- val (rens, thm') = Thm.varifyT_global'
- (remove (op = o apsnd fst) name tfrees) thm
- val mid =
- case rens of
- [] => thm'
- | [((_, S), idx)] => Drule.instantiate_normalize
- ([(ctyp_of thy (TVar (idx, S)), cU)], []) thm'
- | _ => error "Shuffler.inst_tfrees internal error"
- in
- inst_tfrees thy rest mid
- end
-
-fun is_Abs (Abs _) = true
- | is_Abs _ = false
-
-fun eta_redex (t $ Bound 0) =
- let
- fun free n (Bound i) = i = n
- | free n (t $ u) = free n t orelse free n u
- | free n (Abs(_,_,t)) = free (n+1) t
- | free n _ = false
- in
- not (free 0 t)
- end
- | eta_redex _ = false
-
-fun eta_contract thy _ origt =
- let
- val (typet,Tinst) = freeze_thaw_term origt
- val (init,thaw) = Misc_Legacy.freeze_thaw (Thm.reflexive (cterm_of thy typet))
- val final = inst_tfrees thy Tinst o thaw
- val t = #1 (Logic.dest_equals (prop_of init))
- val _ =
- let
- val lhs = #1 (Logic.dest_equals (prop_of (final init)))
- in
- if not (lhs aconv origt)
- then
- writeln (cat_lines
- (["Something is utterly wrong: (orig, lhs, frozen type, t, tinst)",
- Syntax.string_of_term_global thy origt,
- Syntax.string_of_term_global thy lhs,
- Syntax.string_of_term_global thy typet,
- Syntax.string_of_term_global thy t] @
- map (fn (n, T) => n ^ ": " ^ Syntax.string_of_typ_global thy T) Tinst))
- else ()
- end
- in
- case t of
- Const("all",_) $ (Abs(x,xT,Const("==",_) $ P $ Q)) =>
- (if eta_redex P andalso eta_redex Q
- then
- let
- val cert = cterm_of thy
- val v = Free (singleton (Name.variant_list (Term.add_free_names t [])) "v", xT)
- val cv = cert v
- val ct = cert t
- val th = (Thm.assume ct)
- |> Thm.forall_elim cv
- |> Thm.abstract_rule x cv
- val ext_th = Thm.eta_conversion (cert (Abs(x,xT,P)))
- val th' = Thm.transitive (Thm.symmetric ext_th) th
- val cu = cert (prop_of th')
- val uth = Thm.combination (Thm.assume cu) (Thm.reflexive cv)
- val uth' = (Thm.beta_conversion false (cert (Abs(x,xT,Q) $ v)))
- |> Thm.transitive uth
- |> Thm.forall_intr cv
- |> Thm.implies_intr cu
- val rew_th = Thm.equal_intr (th' |> Thm.implies_intr ct) uth'
- val res = final rew_th
- in
- SOME res
- end
- else NONE)
- | _ => NONE
- end
-
-fun eta_expand thy _ origt =
- let
- val (typet,Tinst) = freeze_thaw_term origt
- val (init,thaw) = Misc_Legacy.freeze_thaw (Thm.reflexive (cterm_of thy typet))
- val final = inst_tfrees thy Tinst o thaw
- val t = #1 (Logic.dest_equals (prop_of init))
- val _ =
- let
- val lhs = #1 (Logic.dest_equals (prop_of (final init)))
- in
- if not (lhs aconv origt)
- then
- writeln (cat_lines
- (["Something is utterly wrong: (orig, lhs, frozen type, t, tinst)",
- Syntax.string_of_term_global thy origt,
- Syntax.string_of_term_global thy lhs,
- Syntax.string_of_term_global thy typet,
- Syntax.string_of_term_global thy t] @
- map (fn (n, T) => n ^ ": " ^ Syntax.string_of_typ_global thy T) Tinst))
- else ()
- end
- in
- case t of
- Const("==",T) $ P $ Q =>
- if is_Abs P orelse is_Abs Q
- then (case domain_type T of
- Type("fun",[aT,_]) =>
- let
- val cert = cterm_of thy
- val vname = singleton (Name.variant_list (Term.add_free_names t [])) "v"
- val v = Free(vname,aT)
- val cv = cert v
- val ct = cert t
- val th1 = (Thm.combination (Thm.assume ct) (Thm.reflexive cv))
- |> Thm.forall_intr cv
- |> Thm.implies_intr ct
- val concl = cert (concl_of th1)
- val th2 = (Thm.assume concl)
- |> Thm.forall_elim cv
- |> Thm.abstract_rule vname cv
- val (lhs,rhs) = Logic.dest_equals (prop_of th2)
- val elhs = Thm.eta_conversion (cert lhs)
- val erhs = Thm.eta_conversion (cert rhs)
- val th2' = Thm.transitive
- (Thm.transitive (Thm.symmetric elhs) th2)
- erhs
- val res = Thm.equal_intr th1 (th2' |> Thm.implies_intr concl)
- val res' = final res
- in
- SOME res'
- end
- | _ => NONE)
- else NONE
- | _ => error ("Bad eta_expand argument" ^ Syntax.string_of_term_global thy t)
- end;
-
-fun mk_tfree s = TFree("'"^s,[])
-fun mk_free s t = Free (s,t)
-val xT = mk_tfree "a"
-val yT = mk_tfree "b"
-val x = Free ("x", xT)
-val y = Free ("y", yT)
-val P = mk_free "P" (xT-->yT-->propT)
-val Q = mk_free "Q" (xT-->yT)
-val R = mk_free "R" (xT-->yT)
-in
-
-fun quant_simproc thy = Simplifier.simproc_global_i
- thy
- "Ordered rewriting of nested quantifiers"
- [Logic.all x (Logic.all y (P $ x $ y))]
- quant_rewrite
-fun eta_expand_simproc thy = Simplifier.simproc_global_i
- thy
- "Smart eta-expansion by equivalences"
- [Logic.mk_equals(Q,R)]
- eta_expand
-fun eta_contract_simproc thy = Simplifier.simproc_global_i
- thy
- "Smart handling of eta-contractions"
- [Logic.all x (Logic.mk_equals (Q $ x, R $ x))]
- eta_contract
-end
-
-(* Disambiguates the names of bound variables in a term, returning t
-== t' where all the names of bound variables in t' are unique *)
-
-fun disamb_bound thy t =
- let
-
- fun F (t $ u,idx) =
- let
- val (t',idx') = F (t,idx)
- val (u',idx'') = F (u,idx')
- in
- (t' $ u',idx'')
- end
- | F (Abs(_,xT,t),idx) =
- let
- val x' = "x" ^ string_of_int idx
- val (t',idx') = F (t,idx+1)
- in
- (Abs(x',xT,t'),idx')
- end
- | F arg = arg
- val (t',_) = F (t,0)
- val ct = cterm_of thy t
- val ct' = cterm_of thy t'
- val res = Thm.transitive (Thm.reflexive ct) (Thm.reflexive ct')
- val _ = message ("disamb_term: " ^ (string_of_thm res))
- in
- res
- end
-
-(* Transforms a term t to some normal form t', returning the theorem t
-== t'. This is originally a help function for make_equal, but might
-be handy in its own right, for example for indexing terms. *)
-
-fun norm_term thy t =
- let
- val norms = ShuffleData.get thy
- val ss = Simplifier.global_context thy empty_ss
- addsimps (map (Thm.transfer thy) norms)
- addsimprocs [quant_simproc thy, eta_expand_simproc thy,eta_contract_simproc thy]
- fun chain f th =
- let
- val rhs = Thm.rhs_of th
- in
- Thm.transitive th (f rhs)
- end
- val th =
- t |> disamb_bound thy
- |> chain (Simplifier.full_rewrite ss)
- |> chain Thm.eta_conversion
- |> Thm.strip_shyps
- val _ = message ("norm_term: " ^ (string_of_thm th))
- in
- th
- end
-
-
-(* Closes a theorem with respect to free and schematic variables (does
-not touch type variables, though). *)
-
-fun close_thm th =
- let
- val thy = Thm.theory_of_thm th
- val c = prop_of th
- val vars = Misc_Legacy.add_term_frees (c, Misc_Legacy.add_term_vars(c,[]))
- in
- Drule.forall_intr_list (map (cterm_of thy) vars) th
- end
-
-
-(* Normalizes a theorem's conclusion using norm_term. *)
-
-fun norm_thm thy th =
- let
- val c = prop_of th
- in
- Thm.equal_elim (norm_term thy c) th
- end
-
-(* make_equal thy t u tries to construct the theorem t == u under the
-signature thy. If it succeeds, SOME (t == u) is returned, otherwise
-NONE is returned. *)
-
-fun make_equal thy t u =
- let
- val t_is_t' = norm_term thy t
- val u_is_u' = norm_term thy u
- val th = Thm.transitive t_is_t' (Thm.symmetric u_is_u')
- val _ = message ("make_equal: SOME " ^ (string_of_thm th))
- in
- SOME th
- end
- handle THM _ => (message "make_equal: NONE";NONE)
-
-fun match_consts ignore t (* th *) =
- let
- fun add_consts (Const (c, _), cs) =
- if member (op =) ignore c
- then cs
- else insert (op =) c cs
- | add_consts (t $ u, cs) = add_consts (t, add_consts (u, cs))
- | add_consts (Abs (_, _, t), cs) = add_consts (t, cs)
- | add_consts (_, cs) = cs
- val t_consts = add_consts(t,[])
- in
- fn (_,th) =>
- let
- val th_consts = add_consts(prop_of th,[])
- in
- eq_set (op =) (t_consts, th_consts)
- end
- end
-
-val collect_ignored = fold_rev (fn thm => fn cs =>
- let
- val (lhs, rhs) = Logic.dest_equals (prop_of thm);
- val consts_lhs = Term.add_const_names lhs [];
- val consts_rhs = Term.add_const_names rhs [];
- val ignore_lhs = subtract (op =) consts_rhs consts_lhs;
- val ignore_rhs = subtract (op =) consts_lhs consts_rhs;
- in
- fold_rev (insert (op =)) cs (ignore_lhs @ ignore_rhs)
- end)
-
-(* set_prop t thms tries to make a theorem with the proposition t from
-one of the theorems thms, by shuffling the propositions around. If it
-succeeds, SOME theorem is returned, otherwise NONE. *)
-
-fun set_prop thy t =
- let
- val vars = Misc_Legacy.add_term_frees (t, Misc_Legacy.add_term_vars (t,[]))
- val closed_t = fold_rev Logic.all vars t
- val rew_th = norm_term thy closed_t
- val rhs = Thm.rhs_of rew_th
-
- fun process [] = NONE
- | process ((name,th)::thms) =
- let
- val norm_th = Thm.varifyT_global (norm_thm thy (close_thm (Thm.transfer thy th)))
- val triv_th = Thm.trivial rhs
- val _ = message ("Shuffler.set_prop: Gluing together " ^ (string_of_thm norm_th) ^ " and " ^ (string_of_thm triv_th))
- val mod_th = case Seq.pull (Thm.bicompose false (*true*) (false,norm_th,0) 1 triv_th) of
- SOME(th,_) => SOME th
- | NONE => NONE
- in
- case mod_th of
- SOME mod_th =>
- let
- val closed_th = Thm.equal_elim (Thm.symmetric rew_th) mod_th
- in
- message ("Shuffler.set_prop succeeded by " ^ name);
- SOME (name,forall_elim_list (map (cterm_of thy) vars) closed_th)
- end
- | NONE => process thms
- end
- handle THM _ => process thms
- in
- fn thms =>
- case process thms of
- res as SOME (_,th) => if (prop_of th) aconv t
- then res
- else error "Internal error in set_prop"
- | NONE => NONE
- end
-
-fun find_potential thy t =
- let
- val shuffles = ShuffleData.get thy
- val ignored = collect_ignored shuffles []
- val all_thms =
- map (`Thm.get_name_hint) (maps #2 (Facts.dest_static [] (Global_Theory.facts_of thy)))
- in
- filter (match_consts ignored t) all_thms
- end
-
-fun gen_shuffle_tac ctxt search thms = SUBGOAL (fn (t, i) =>
- let
- val thy = Proof_Context.theory_of ctxt
- val set = set_prop thy t
- fun process_tac thms st =
- case set thms of
- SOME (_,th) => Seq.of_list (compose (th,i,st))
- | NONE => Seq.empty
- in
- process_tac thms APPEND
- (if search then process_tac (find_potential thy t) else no_tac)
- end)
-
-fun shuffle_tac ctxt thms =
- gen_shuffle_tac ctxt false (map (pair "") thms);
-
-fun search_tac ctxt =
- gen_shuffle_tac ctxt true (map (pair "premise") (Assumption.all_prems_of ctxt));
-
-fun add_shuffle_rule thm thy =
- let
- val shuffles = ShuffleData.get thy
- in
- if exists (curry Thm.eq_thm thm) shuffles
- then (warning ((string_of_thm thm) ^ " already known to the shuffler");
- thy)
- else ShuffleData.put (thm::shuffles) thy
- end
-
-val shuffle_attr = Thm.declaration_attribute (fn th => Context.mapping (add_shuffle_rule th) I);
-
-val setup =
- Method.setup @{binding shuffle_tac}
- (Attrib.thms >> (fn ths => fn ctxt => SIMPLE_METHOD' (shuffle_tac ctxt ths)))
- "solve goal by shuffling terms around" #>
- Method.setup @{binding search_tac}
- (Scan.succeed (SIMPLE_METHOD' o search_tac)) "search for suitable theorems" #>
- add_shuffle_rule weaken #>
- add_shuffle_rule equiv_comm #>
- add_shuffle_rule imp_comm #>
- add_shuffle_rule Drule.norm_hhf_eq #>
- add_shuffle_rule Drule.triv_forall_equality #>
- Attrib.setup @{binding shuffle_rule} (Scan.succeed shuffle_attr) "declare rule for shuffler";
-
-end
--- a/src/HOL/IsaMakefile Sun Apr 01 14:50:47 2012 +0200
+++ b/src/HOL/IsaMakefile Sun Apr 01 22:03:45 2012 +0200
@@ -38,8 +38,6 @@
HOLCF-Library \
HOLCF-Tutorial \
HOLCF-ex \
- HOL-HOL4 \
- HOL-HOL4-Imported \
HOL-HOL_Light \
HOL-IMPP \
HOL-IOA \
@@ -81,9 +79,6 @@
HOL-ZF
# ^ this is the sort position
-generate: \
- HOL-HOL4-Generate
-
benchmark: \
HOL-Datatype_Benchmark \
HOL-Record_Benchmark
@@ -556,25 +551,6 @@
## Import sessions
-IMPORTER_BASIC_DEPENDENCIES = \
- Import/HOL4/Importer.thy \
- Import/HOL4/shuffler.ML \
- Import/HOL4/import_rews.ML \
- Import/HOL4/proof_kernel.ML \
- Import/HOL4/replay.ML \
- Import/HOL4/import.ML
-
-IMPORTER_HOL4_COMPATIBILITY_DEDEPENDENCIES = \
- Import/HOL4/ROOT.ML \
- Import/HOL4/Compatibility.thy
-
-HOL-HOL4: $(LOG)/HOL-HOL4.gz
-
-$(LOG)/HOL-HOL4.gz: $(OUT)/HOL \
- $(IMPORTER_BASIC_DEPENDENCIES) \
- $(IMPORTER_HOL4_COMPATIBILITY_DEDEPENDENCIES)
- @$(ISABELLE_TOOL) usedir $(OUT)/HOL Import/HOL4
-
HOL-HOL_Light: $(LOG)/HOL-HOL_Light.gz
$(LOG)/HOL-HOL_Light.gz: $(OUT)/HOL \
@@ -586,82 +562,6 @@
Import/HOL_Light_Import.thy
@cd Import; $(ISABELLE_TOOL) usedir -b -g true $(OUT)/HOL HOL-HOL_Light
-HOL-HOL4-Imported: $(LOG)/HOL-HOL4-Imported.gz
-
-$(LOG)/HOL-HOL4-Imported.gz: $(OUT)/HOL \
- $(IMPORTER_BASIC_DEPENDENCIES) \
- $(IMPORTER_HOL4_COMPATIBILITY_DEDEPENDENCIES) \
- Import/HOL4/imported.ML \
- Import/HOL4/Imported.thy \
- Import/HOL4/Generated/HOL4Base.thy \
- Import/HOL4/Generated/HOL4Prob.thy \
- Import/HOL4/Generated/HOL4Real.thy \
- Import/HOL4/Generated/HOL4Vec.thy \
- Import/HOL4/Generated/HOL4Word32.thy \
- Import/HOL4/Generated/arithmetic.imp \
- Import/HOL4/Generated/bits.imp \
- Import/HOL4/Generated/boolean_sequence.imp \
- Import/HOL4/Generated/bool.imp \
- Import/HOL4/Generated/bword_arith.imp \
- Import/HOL4/Generated/bword_bitop.imp \
- Import/HOL4/Generated/bword_num.imp \
- Import/HOL4/Generated/combin.imp \
- Import/HOL4/Generated/divides.imp \
- Import/HOL4/Generated/hrat.imp \
- Import/HOL4/Generated/hreal.imp \
- Import/HOL4/Generated/ind_type.imp \
- Import/HOL4/Generated/lim.imp \
- Import/HOL4/Generated/list.imp \
- Import/HOL4/Generated/marker.imp \
- Import/HOL4/Generated/nets.imp \
- Import/HOL4/Generated/numeral.imp \
- Import/HOL4/Generated/num.imp \
- Import/HOL4/Generated/one.imp \
- Import/HOL4/Generated/operator.imp \
- Import/HOL4/Generated/option.imp \
- Import/HOL4/Generated/pair.imp \
- Import/HOL4/Generated/poly.imp \
- Import/HOL4/Generated/powser.imp \
- Import/HOL4/Generated/pred_set.imp \
- Import/HOL4/Generated/prime.imp \
- Import/HOL4/Generated/prim_rec.imp \
- Import/HOL4/Generated/prob_algebra.imp \
- Import/HOL4/Generated/prob_canon.imp \
- Import/HOL4/Generated/prob_extra.imp \
- Import/HOL4/Generated/prob.imp \
- Import/HOL4/Generated/prob_indep.imp \
- Import/HOL4/Generated/prob_pseudo.imp \
- Import/HOL4/Generated/prob_uniform.imp \
- Import/HOL4/Generated/realax.imp \
- Import/HOL4/Generated/real.imp \
- Import/HOL4/Generated/relation.imp \
- Import/HOL4/Generated/res_quan.imp \
- Import/HOL4/Generated/rich_list.imp \
- Import/HOL4/Generated/seq.imp \
- Import/HOL4/Generated/state_transformer.imp \
- Import/HOL4/Generated/sum.imp \
- Import/HOL4/Generated/topology.imp \
- Import/HOL4/Generated/transc.imp \
- Import/HOL4/Generated/word32.imp \
- Import/HOL4/Generated/word_base.imp \
- Import/HOL4/Generated/word_bitop.imp \
- Import/HOL4/Generated/word_num.imp
- @$(ISABELLE_TOOL) usedir -f imported.ML -s HOL4-Imported -p 0 $(OUT)/HOL Import/HOL4
-
-HOL-HOL4-Generate: $(LOG)/Import-HOL4-Generate.gz
-
-$(LOG)/Import-HOL4-Generate.gz: $(OUT)/HOL \
- $(IMPORTER_BASIC_DEPENDENCIES) \
- $(IMPORTER_HOL4_COMPATIBILITY_DEDEPENDENCIES) \
- Import/HOL4/generate.ML \
- Import/HOL4/Generate.thy \
- Import/HOL4/Template/GenHOL4Base.thy \
- Import/HOL4/Template/GenHOL4Prob.thy \
- Import/HOL4/Template/GenHOL4Real.thy \
- Import/HOL4/Template/GenHOL4Vec.thy \
- Import/HOL4/Template/GenHOL4Word32.thy
- @$(ISABELLE_TOOL) usedir -f generate.ML -s HOL4-Generate -p 0 $(OUT)/HOL Import/HOL4
-
## HOL-Number_Theory
HOL-Number_Theory: HOL $(LOG)/HOL-Number_Theory.gz
@@ -1918,14 +1818,14 @@
$(LOG)/HOL-TPTP.gz $(LOG)/HOL-UNITY.gz \
$(LOG)/HOL-Unix.gz $(LOG)/HOL-Word-Examples.gz \
$(LOG)/HOL-Word.gz $(LOG)/HOL-ZF.gz $(LOG)/HOL-ex.gz \
- $(LOG)/HOL.gz $(LOG)/HOL4.gz $(LOG)/TLA-Buffer.gz \
+ $(LOG)/HOL.gz $(LOG)/TLA-Buffer.gz \
$(LOG)/TLA-Inc.gz $(LOG)/TLA-Memory.gz $(LOG)/TLA.gz \
$(OUT)/HOL $(OUT)/HOL-Algebra $(OUT)/HOL-Base \
$(OUT)/HOL-Boogie $(OUT)/HOL-IMP $(OUT)/HOL-Library \
$(OUT)/HOL-Main $(OUT)/HOL-Multivariate_Analysis \
$(OUT)/HOL-NSA $(OUT)/HOL-Nominal $(OUT)/HOL-Plain \
$(OUT)/HOL-Probability $(OUT)/HOL-Proofs \
- $(OUT)/HOL-SPARK $(OUT)/HOL-Word $(OUT)/HOL4 \
+ $(OUT)/HOL-SPARK $(OUT)/HOL-Word \
$(OUT)/TLA $(OUT)/HOLCF $(LOG)/HOLCF.gz \
$(LOG)/HOLCF-IMP.gz $(LOG)/HOLCF-ex.gz \
$(LOG)/HOLCF-FOCUS.gz $(OUT)/IOA $(LOG)/IOA.gz \