# HG changeset patch # User krauss # Date 1333310625 -7200 # Node ID 2d4ea84278da5e28432ce2be8e57df9c7cd8e811 # Parent 880e587eee9fb7742a3d821071e1526f246ed73f removed old HOL4 import -- corresponding exporter is lost, code is broken, no users known, maintenance nightmare diff -r 880e587eee9f -r 2d4ea84278da etc/settings --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Compatibility.thy --- 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 \ 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 \ 'b,'a] \ '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) \ 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) \ P n) & P m & ~P n" - by auto -next - fix P - assume alln: "!n. P (Suc n) \ P n" - assume pm: "P m" - assume npn: "~P n" - have "!k q. q + k = m \ P q" - proof - fix k - show "!q. q + k = m \ P q" - proof (induct k,simp_all) - show "P m" by fact - next - fix k - assume ind: "!q. q + k = m \ P q" - show "!q. Suc (q + k) = m \ 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 \ P q" - .. - hence hehe: "n + (m - n) = m \ P n" - .. - show "m < n" - proof (rule classical) - assume "~(m '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 \ nat" where - "NUMERAL_BIT1 n == n + (n + Suc 0)" - -definition NUMERAL_BIT2 :: "nat \ nat" where - "NUMERAL_BIT2 n == n + (n + Suc (Suc 0))" - -definition NUMERAL :: "nat \ 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 \ nat) \ 'a list \ 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' = [] \ v = v') & - (!a0 a1. (M' = a0#a1) \ (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' = [] \ v = v'" - and 2: "!a0 a1. M' = a0 # a1 \ 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 \ 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]\'b,'b,'a list] \ '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]\'c,'a list,'b list] \ '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: "\ P [] ; !t. P t \ (!h. P (h#t)) \ \ !l. P l" -proof - fix l - assume "P []" - assume allt: "!t. P t \ (!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 \ ('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 \ '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: "\ ALL x. P (x::real) \ 0 < x ; EX x. P x; EX z. ALL x. P x \ x < z \ \ EX s. ALL y. (EX x. P x & y < x) = (y < s)" -proof safe - fix x z - assume allx: "ALL x. P x \ 0 < x" - assume px: "P x" - assume allx': "ALL x. P x \ 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generate.thy --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/HOL4Base.thy --- 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 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 (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 \ 'a\type \ 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 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 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 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 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 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 - diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/HOL4Prob.thy --- 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 - diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/HOL4Real.thy --- 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 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=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 contl f x) & -(ALL x. a < x & x lim.differentiable f x) -==> EX z>a. z contl f x) & -(ALL x. a < x & x lim.differentiable f x) -==> EX l z. a < z & z contl f x) & -(ALL x. a < x & x diffl f 0 x) -==> f b = f a" - by (import lim DIFF_ISCONST_END) - -lemma DIFF_ISCONST: "[| a contl f x) & - (ALL x. a < x & x 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 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 = b))" - -lemma division: "division (a, b) D = -(D 0 = a & (EX 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 N)" - -lemma dsize: "dsize D = (SOME 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 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 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 = 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 EX x>a. x 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 bool) xb ==> EX n 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 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 - diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/HOL4Vec.thy --- 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 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 - 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 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 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 '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 (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 - (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 - (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 - 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 - diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/HOL4Word32.thy --- 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 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 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 - diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/arithmetic.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/bits.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/bool.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/boolean_sequence.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/bword_arith.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/bword_bitop.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/bword_num.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/combin.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/divides.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/hrat.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/hreal.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/ind_type.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/lim.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/list.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/marker.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/nets.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/num.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/numeral.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/one.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/operator.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/option.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/pair.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/poly.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/powser.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/pred_set.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/prim_rec.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/prime.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/prob.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/prob_algebra.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/prob_canon.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/prob_extra.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/prob_indep.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/prob_pseudo.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/prob_uniform.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/real.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/realax.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/relation.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/res_quan.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/rich_list.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/seq.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/state_transformer.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/sum.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/topology.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/transc.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/word32.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/word_base.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/word_bitop.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Generated/word_num.imp --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Imported.thy --- 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 - diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Importer.thy --- 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 \ P \ Q" - by auto - -lemma HOLallI: "(!! bogus. P bogus) \ (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 \ 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 \ 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 \ (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) \ (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 \ EX x. x \ (Collect P)" - by simp - -use "proof_kernel.ML" -use "replay.ML" -use "import.ML" - -setup Import.setup - -end - diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/README --- 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. diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/ROOT.ML --- 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"; diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Template/GenHOL4Base.thy --- 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 \ nat \ 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 \ nat \ bool" - "+" > Groups.plus_class.plus :: "nat \ nat \ nat" - "*" > Groups.times_class.times :: "nat \ nat \ nat" - "-" > Groups.minus_class.minus :: "nat \ nat \ nat" - MIN > Orderings.ord_class.min :: "nat \ nat \ nat" - MAX > Orderings.ord_class.max :: "nat \ nat \ nat" - DIV > Divides.div_class.div :: "nat \ nat \ nat" - MOD > Divides.div_class.mod :: "nat \ nat \ nat" - EXP > Power.power_class.power :: "nat \ nat \ 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 \ nat \ 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Template/GenHOL4Prob.thy --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Template/GenHOL4Real.thy --- 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 \ real" - inv > Fields.inverse_class.inverse :: "real \ real" - real_add > Groups.plus_class.plus :: "real \ real \ real" - real_sub > Groups.minus_class.minus :: "real \ real \ real" - real_mul > Groups.times_class.times :: "real \ real \ real" - real_div > Fields.inverse_class.divide :: "real \ real \ real" - real_lt > Orderings.ord_class.less :: "real \ real \ 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 \ real \ bool" - real_sub > Groups.minus_class.minus :: "real \ real \ real" - "/" > Fields.inverse_class.divide :: "real \ real \ real" - pow > Power.power_class.power :: "real \ nat \ 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Template/GenHOL4Vec.thy --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/Template/GenHOL4Word32.thy --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/generate.ML --- 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"; diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/import.ML --- 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 - diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/import_rews.ML --- 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"; diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/imported.ML --- 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"; diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/proof_kernel.ML --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/replay.ML --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/Import/HOL4/shuffler.ML --- 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 diff -r 880e587eee9f -r 2d4ea84278da src/HOL/IsaMakefile --- 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 \